Allow multiple calls to dbus combinator

Before this change, additional calls to the dbus combinator would add
multiple `xdg-dbus-proxy` instances, but only the latest call would be
forwarded into the jail.

With this change, all permissions are saved in state, then, in a
deferred `add-runtime` we add a single `xdg-dbus-proxy` exposing the
union of all previous dbus calls.

This should allow writing combinators that expose dbus permissions like
notifications, or reading light/dark mode changes which can be composed
just like the other non-dbus combinators.
This commit is contained in:
Alex David 2025-09-28 15:44:36 -07:00
commit 3610987241
3 changed files with 113 additions and 37 deletions

View file

@ -980,6 +980,11 @@ rec {
]; ];
} }
``` ```
Multiple calls to `dbus` will only run a single xdg-dbus-proxy with a
union of all passed own/talk/see/call/broadcast permissions. This makes
it possible to write wrapper combinators for specific dbus permissions
and use them in conjunction with each other.
''; '';
__functor = __functor =
_: _:
@ -990,19 +995,51 @@ rec {
call ? [ ], call ? [ ],
broadcast ? [ ], broadcast ? [ ],
}: }:
compose [
# Just set the options on state so dbus can be called multiple times
(
state:
state
// {
dbusPermissions = state.dbusPermissions ++ [
{
inherit
own
talk
see
call
broadcast
;
}
];
}
)
# Then add deferred runtime logic to spin up xdg-dbus-proxy:
(include-once "dbus" (
defer (
state:
let let
proxy = jail "xdg-dbus-proxy" pkgs.xdg-dbus-proxy [ proxy = jail "xdg-dbus-proxy" pkgs.xdg-dbus-proxy [
unsafe-dbus unsafe-dbus
(readwrite (noescape "\"$PROXIED_DBUS_SOCKET_DIR\"")) (readwrite (noescape "\"$PROXIED_DBUS_SOCKET_DIR\""))
]; ];
getFlags =
type:
lib.pipe state.dbusPermissions [
(map (p: p.${type}))
lib.flatten
lib.unique
(map (id: "--${type}=${lib.escapeShellArg id}"))
];
args = args =
[ "--filter" ] [ "--filter" ]
++ map (id: "--own=${lib.escapeShellArg id}") own ++ getFlags "own"
++ map (id: "--talk=${lib.escapeShellArg id}") talk ++ getFlags "talk"
++ map (id: "--see=${lib.escapeShellArg id}") see ++ getFlags "see"
++ map (id: "--call=${lib.escapeShellArg id}") call ++ getFlags "call"
++ map (id: "--broadcast=${lib.escapeShellArg id}") broadcast; ++ getFlags "broadcast";
in in
compose [ compose [
(add-runtime '' (add-runtime ''
@ -1028,6 +1065,9 @@ rec {
'') '')
(readwrite (noescape "\"$PROXIED_DBUS_SOCKET_DIR\"")) (readwrite (noescape "\"$PROXIED_DBUS_SOCKET_DIR\""))
(set-env "DBUS_SESSION_BUS_ADDRESS" (noescape "\"unix:path=$PROXIED_DBUS_SOCKET\"")) (set-env "DBUS_SESSION_BUS_ADDRESS" (noescape "\"unix:path=$PROXIED_DBUS_SOCKET\""))
] state
)
))
]; ];
}; };

View file

@ -43,6 +43,7 @@ let
cleanup = [ ]; # See cleanup combinator cleanup = [ ]; # See cleanup combinator
deferredPermissions = [ ]; # See defer combinator deferredPermissions = [ ]; # See defer combinator
additionalRuntimeClosures = [ ]; # See bind-nix-store-runtime-closure additionalRuntimeClosures = [ ]; # See bind-nix-store-runtime-closure
dbusPermissions = [ ]; # See dbus combinator
}; };
in in
lib.pipe initialState ( lib.pipe initialState (

View file

@ -145,6 +145,41 @@ spec = inTestM $ do
sendDBusOutput `shouldBe` "Failed to call dbus method\n" sendDBusOutput `shouldBe` "Failed to call dbus method\n"
methodCalls `shouldBe` [] methodCalls `shouldBe` []
describe "multiple calls to the dbus combinator" $ do
it "exposes a union of all of the specified permissions" $ do
let mockMethod1 =
MockDBusMethod
{ objPath = "/foo/object1",
ifaceName = "foo.iface1.Iface",
methodName = "method1"
}
let mockMethod2 =
MockDBusMethod
{ objPath = "/foo/object2",
ifaceName = "foo.iface2.Iface",
methodName = "method2"
}
((sendDBusOutput, method2Calls), method1Calls) <- withDBusClient $ \mockBusName client -> do
withMockDBusMethodHandler client mockMethod1 "return value 1" $ do
withMockDBusMethodHandler client mockMethod2 "return value 2" $ do
runNixDrv
[i|
jail
"send-multiple"
(sh ''
${lib.getExe (#{callDBusMethodNixDrv mockBusName mockMethod1 "arg1"})}
${lib.getExe (#{callDBusMethodNixDrv mockBusName mockMethod2 "arg2"})}
'')
(c: [
(c.dbus { call = [ #{toNixString $ toProxyRule mockBusName mockMethod1} ]; })
(c.dbus { call = [ #{toNixString $ toProxyRule mockBusName mockMethod2} ]; })
])
|]
liftIO $ do
sendDBusOutput `shouldBe` " return value 1 return value 2"
method1Calls `shouldBe` ["arg1"]
method2Calls `shouldBe` ["arg2"]
-- * DBus test helpers -- * DBus test helpers
withDBusClient :: (DBus.BusName -> DBus.Client -> TestM a) -> TestM a withDBusClient :: (DBus.BusName -> DBus.Client -> TestM a) -> TestM a