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,44 +995,79 @@ rec {
call ? [ ], call ? [ ],
broadcast ? [ ], broadcast ? [ ],
}: }:
let
proxy = jail "xdg-dbus-proxy" pkgs.xdg-dbus-proxy [
unsafe-dbus
(readwrite (noescape "\"$PROXIED_DBUS_SOCKET_DIR\""))
];
args =
[ "--filter" ]
++ map (id: "--own=${lib.escapeShellArg id}") own
++ map (id: "--talk=${lib.escapeShellArg id}") talk
++ map (id: "--see=${lib.escapeShellArg id}") see
++ map (id: "--call=${lib.escapeShellArg id}") call
++ map (id: "--broadcast=${lib.escapeShellArg id}") broadcast;
in
compose [ compose [
(add-runtime '' # Just set the options on state so dbus can be called multiple times
PROXIED_DBUS_SOCKET_DIR=$(mktemp -d) (
export PROXIED_DBUS_SOCKET_DIR state:
PROXIED_DBUS_SOCKET="$PROXIED_DBUS_SOCKET_DIR/socket" state
mkfifo "$PROXIED_DBUS_SOCKET_DIR/ready" // {
exec {XDG_DBUS_PROXY_READY_FD}<>"$PROXIED_DBUS_SOCKET_DIR/ready" dbusPermissions = state.dbusPermissions ++ [
${lib.getExe proxy} \ {
"$DBUS_SESSION_BUS_ADDRESS" \ inherit
"$PROXIED_DBUS_SOCKET" \ own
--fd="$XDG_DBUS_PROXY_READY_FD" \ talk
${lib.concatStringsSep " " args} \ see
& call
PROXY_PID=$! broadcast
IFS= read -rn1 -u "$XDG_DBUS_PROXY_READY_FD" ;
'') }
(add-cleanup '' ];
kill "$PROXY_PID" }
if [ -e "''${PROXIED_DBUS_SOCKET_DIR-}" ]; then )
rm -rf "$PROXIED_DBUS_SOCKET_DIR" # Then add deferred runtime logic to spin up xdg-dbus-proxy:
fi (include-once "dbus" (
'') defer (
(readwrite (noescape "\"$PROXIED_DBUS_SOCKET_DIR\"")) state:
(set-env "DBUS_SESSION_BUS_ADDRESS" (noescape "\"unix:path=$PROXIED_DBUS_SOCKET\"")) let
proxy = jail "xdg-dbus-proxy" pkgs.xdg-dbus-proxy [
unsafe-dbus
(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 =
[ "--filter" ]
++ getFlags "own"
++ getFlags "talk"
++ getFlags "see"
++ getFlags "call"
++ getFlags "broadcast";
in
compose [
(add-runtime ''
PROXIED_DBUS_SOCKET_DIR=$(mktemp -d)
export PROXIED_DBUS_SOCKET_DIR
PROXIED_DBUS_SOCKET="$PROXIED_DBUS_SOCKET_DIR/socket"
mkfifo "$PROXIED_DBUS_SOCKET_DIR/ready"
exec {XDG_DBUS_PROXY_READY_FD}<>"$PROXIED_DBUS_SOCKET_DIR/ready"
${lib.getExe proxy} \
"$DBUS_SESSION_BUS_ADDRESS" \
"$PROXIED_DBUS_SOCKET" \
--fd="$XDG_DBUS_PROXY_READY_FD" \
${lib.concatStringsSep " " args} \
&
PROXY_PID=$!
IFS= read -rn1 -u "$XDG_DBUS_PROXY_READY_FD"
'')
(add-cleanup ''
kill "$PROXY_PID"
if [ -e "''${PROXIED_DBUS_SOCKET_DIR-}" ]; then
rm -rf "$PROXIED_DBUS_SOCKET_DIR"
fi
'')
(readwrite (noescape "\"$PROXIED_DBUS_SOCKET_DIR\""))
(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