server: tokio/zbus/etc

.envrc

@@ -0,0 +1 @@
+use flake

.github/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: "CI"
+on:
+  pull_request:
+  push:
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: cachix/install-nix-action@v20
+      - uses: icewind1991/attic-action@v1
+        with:
+          name: ci
+          instance: https://cache.icewind.me
+          authToken: '${{ secrets.ATTIC_TOKEN }}'
+      - run: nix build .#check
+
+  clippy:
+    runs-on: ubuntu-latest
+    needs: check
+    steps:
+      - uses: actions/checkout@v3
+      - uses: cachix/install-nix-action@v20
+      - uses: icewind1991/attic-action@v1
+        with:
+          name: ci
+          instance: https://cache.icewind.me
+          authToken: '${{ secrets.ATTIC_TOKEN }}'
+      - run: nix build .#clippy
+
+  test:
+    runs-on: ubuntu-latest
+    needs: check
+    steps:
+      - uses: actions/checkout@v3
+      - uses: cachix/install-nix-action@v20
+      - uses: icewind1991/attic-action@v1
+        with:
+          name: ci
+          instance: https://cache.icewind.me
+          authToken: '${{ secrets.ATTIC_TOKEN }}'
+      - run: nix build .#test

.gitignore

@@ -1 +1,3 @@
 /target
+result
+.direnv

client/Cargo.toml

@@ -9,8 +9,8 @@ name = "shortcutd"
 path = "src/lib.rs"
 
 [dependencies]
-dbus = { version = "0.8.2", path = "../../dbus-rs/dbus" }
+dbus = { version = "0.8.4" }
-evdev-shortcut = { version = "0.1", path = "../../evdev-shortcut", default_features = false }
+evdev-shortcut = { version = "0.1.1", default_features = false }
 
 [dev-dependencies]
-test-case = "1.0.0"
+test-case = "3.1.0"

client/src/lib.rs

@@ -1,6 +1,6 @@
 use dbus::arg;
 use dbus::blocking;
-use evdev_shortcut::Shortcut;
+pub use evdev_shortcut::Shortcut;
 
 const INTERFACE: &'static str = "nl.icewind.shortcutd";
 

flake.lock

@@ -0,0 +1,88 @@
+{
+  "nodes": {
+    "naersk": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1686242667,
+        "narHash": "sha256-I7Kwp06WX/9E+rEND1i1wjdKQQm3XiDxYOyNK9fuJu0=",
+        "owner": "icewind1991",
+        "repo": "naersk",
+        "rev": "6d245a3bbb2ee31ec726bb57b9a8b206302e7110",
+        "type": "github"
+      },
+      "original": {
+        "owner": "icewind1991",
+        "repo": "naersk",
+        "rev": "6d245a3bbb2ee31ec726bb57b9a8b206302e7110",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1686059680,
+        "narHash": "sha256-sp0WlCIeVczzB0G8f8iyRg3IYW7KG31mI66z7HIZwrI=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "a558f7ac29f50c4b937fb5c102f587678ae1c9fb",
+        "type": "github"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "ref": "nixos-23.05",
+        "type": "indirect"
+      }
+    },
+    "root": {
+      "inputs": {
+        "naersk": "naersk",
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay",
+        "utils": "utils"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "flake-utils": [
+          "utils"
+        ],
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1686191569,
+        "narHash": "sha256-8ey5FOXNms9piFGTn6vJeAQmSKk+NL7GTMSoVttsNTs=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "b4b71458b92294e8f1c3a112d972e3cff8a2ab71",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    },
+    "utils": {
+      "locked": {
+        "lastModified": 1667395993,
+        "narHash": "sha256-nuEHfE/LcWyuSWnS8t12N1wc105Qtau+/OdUAjtQ0rA=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "5aed5285a952e0b949eb3ba02c12fa4fcfef535f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,83 @@
+{
+  inputs = {
+    nixpkgs.url = "nixpkgs/nixos-23.05";
+    utils.url = "github:numtide/flake-utils";
+    naersk.url = "github:icewind1991/naersk?rev=6d245a3bbb2ee31ec726bb57b9a8b206302e7110";
+    naersk.inputs.nixpkgs.follows = "nixpkgs";
+    rust-overlay.url = "github:oxalica/rust-overlay";
+    rust-overlay.inputs.nixpkgs.follows = "nixpkgs";
+    rust-overlay.inputs.flake-utils.follows = "utils";
+  };
+
+  outputs = {
+    self,
+    nixpkgs,
+    utils,
+    naersk,
+    rust-overlay,
+  }:
+    utils.lib.eachDefaultSystem (system: let
+      overlays = [ (import rust-overlay) ];
+      pkgs = (import nixpkgs) {
+        inherit system overlays;
+      };
+      lib = pkgs.lib;
+      naerskForTarget = target: let
+        toolchain = pkgs.rust-bin.stable.latest.default.override { targets = [target]; };
+      in pkgs.callPackage naersk {
+        cargo = toolchain;
+        rustc = toolchain;
+      };
+      hostTarget = pkgs.hostPlatform.config;
+      targets = ["x86_64-pc-windows-gnu" hostTarget];
+      hostNaersk = naerskForTarget hostTarget;
+      src = lib.sources.sourceByRegex (lib.cleanSource ./.) ["Cargo.*" "(src)(/.*)?"];
+      nearskOpt = {
+        pname = "vbspview";
+        root = src;
+        nativeBuildInputs = buildDependencies;
+      };
+      crossArgs = {
+        "x86_64-pc-windows-gnu" = {
+          nativeBuildInputs = [ pkgs.pkgsCross.mingwW64.stdenv.cc ];
+          overrideMain = args: args // { buildInputs = [ pkgs.pkgsCross.mingwW64.windows.pthreads ]; };
+        };
+      };
+      crossArgsFor = target: if (hostTarget != target) then (crossArgs.${target} or {}) else {};
+      buildDependencies = with pkgs; [
+        freetype
+        pkgconfig
+        dbus
+        libGL
+      ];
+    in rec {
+      packages = (lib.attrsets.genAttrs targets (target: (naerskForTarget target).buildPackage (nearskOpt // {
+        CARGO_BUILD_TARGET = target;
+      } // (crossArgsFor target)))) // rec {
+        vbspview = packages.${hostTarget};
+        check = hostNaersk.buildPackage (nearskOpt // {
+          mode = "check";
+        });
+        clippy = hostNaersk.buildPackage (nearskOpt // {
+          mode = "clippy";
+        });
+        default = vbspview;
+      };
+
+      inherit targets;
+
+      devShells.default = pkgs.mkShell {
+        nativeBuildInputs = with pkgs; [
+          pkgs.rust-bin.stable.latest.default
+          bacon
+          cargo-edit
+          cargo-outdated
+          clippy
+          cargo-audit
+          cargo-msrv
+        ] ++ buildDependencies;
+
+        LD_LIBRARY_PATH = with pkgs; "/run/opengl-driver/lib/:${lib.makeLibraryPath ([libGL libGLU])}";
+      };
+    });
+}

server/Cargo.toml

@@ -10,9 +10,13 @@ path = "src/server.rs"
 
 [dependencies]
 main_error = "0.1.0"
-dbus = { version = "0.8.2", path = "../../dbus-rs/dbus" }
 glob = "0.3.0"
-evdev-shortcut = { version = "0.1", path = "../../evdev-shortcut" }
+evdev-shortcut = "0.1.1"
+tokio = { version = "1.28.2", features = ["macros", "rt-multi-thread"] }
+futures = "0.3.28"
+zbus = { version = "3.13.1", features = ["tokio"], default-features = false }
+tracing = "0.1.37"
+tracing-subscriber = "0.3.17"
 
 [dev-dependencies]
-test-case = "1.0.0"
+test-case = "3.1.0"

server/src/server.rs

@@ -1,110 +1,71 @@
 use main_error::MainError;
-
+use evdev_shortcut::{Shortcut, ShortcutEvent, ShortcutListener, ShortcutState};
-use dbus::blocking::LocalConnection;
-use dbus::channel::Sender;
-
-use dbus::tree::{Factory, MethodErr, Signal};
-use std::collections::HashMap;
-
-use evdev_shortcut::{Shortcut, ShortcutListener};
 use glob::GlobError;
 use std::path::PathBuf;
-use std::sync::mpsc::{channel, TryRecvError};
+use futures::stream::StreamExt;
-use std::sync::Arc;
+use zbus::{ConnectionBuilder, dbus_interface, fdo, SignalContext, ObjectServer};
-use std::time::Duration;
+use zbus::export::futures_util::pin_mut;
 
-const INTERFACE: &'static str = "nl.icewind.shortcutd";
+struct Register {
+    listener: ShortcutListener,
+}
 
-fn main() {
+#[dbus_interface(name = "nl.icewind.shortcutd")]
-    loop {
+impl Register {
-        let _ = std::panic::catch_unwind(|| {
+    async fn register(&mut self, shortcut: &str, #[zbus(object_server)] server: &ObjectServer) -> Result<String, fdo::Error> {
-            let _ = run();
+        match shortcut.parse::<Shortcut>() {
-        });
+            Ok(shortcut) => {
+                self.listener.add(shortcut.clone());
+                let path = format!("/{}", shortcut.identifier());
+                if let Err(e) = server.at(path.as_str(), ShortcutSignal).await {
+                    eprintln!("{e:#}");
+                }
 
-        eprintln!("crashed, restarting");
+                Ok(path)
-
+            }
-        std::thread::sleep(Duration::from_secs(15));
+            Err(_) => Err(fdo::Error::InvalidArgs("Malformed shortcut".into())),
+        }
     }
 }
 
-fn run() -> Result<(), MainError> {
+struct ShortcutSignal;
+
+#[dbus_interface(name = "nl.icewind.shortcutd")]
+impl ShortcutSignal {
+    #[dbus_interface(signal)]
+    async fn triggered(signal_ctxt: &SignalContext<'_>, pressed: bool) -> zbus::Result<()>;
+}
+
+#[tokio::main]
+async fn main() -> Result<(), MainError> {
+    tracing_subscriber::fmt::init();
     let devices =
         glob::glob("/dev/input/by-id/*-kbd")?.collect::<Result<Vec<PathBuf>, GlobError>>()?;
 
-    let listener = Arc::new(ShortcutListener::new());
+    let listener = ShortcutListener::new();
+    let shortcut_events = listener.listen(&devices)?;
 
-    let mut signals: HashMap<String, Arc<Signal<()>>> = HashMap::default();
+    let bus = Register {
+        listener,
+    };
+    let conn = ConnectionBuilder::system()?
+        .name("nl.icewind.shortcutd")?
+        .serve_at("/register", bus)?
+        .build()
+        .await?;
 
-    let shortcut_trigger_rx = listener.listen(&devices)?;
+    let server = conn.object_server();
 
-    let mut connection = LocalConnection::new_system()?;
+    pin_mut!(shortcut_events);
-    connection.request_name(INTERFACE, false, true, false)?;
+    while let Some(event) = shortcut_events.next().await {
-
+        let event: ShortcutEvent = event;
-    let (shortcut_register_tx, shortcut_register_rx) = channel();
+        let identifier = format!("/{}", event.shortcut.identifier());
-
+        if let Ok(signal_interface) = server.interface::<_, ShortcutSignal>(identifier).await {
-    let factory = Factory::new_fn::<()>();
+            if let Err(e) = ShortcutSignal::triggered(signal_interface.signal_context(), event.state == ShortcutState::Pressed).await {
-    let mut tree = factory
+                eprintln!("{e:#}");
-        .tree(())
-        .add(
-            factory.object_path("/register", ()).introspectable().add(
-                factory.interface(INTERFACE, ()).add_m(
-                    factory
-                        .method("Register", (), move |m| {
-                            let shortcut_str: &str = m.msg.read1()?;
-
-                            match shortcut_str.parse::<Shortcut>() {
-                                Ok(shortcut) => {
-                                    let path = shortcut.identifier();
-                                    shortcut_register_tx.send(shortcut).unwrap();
-
-                                    Ok(vec![m.msg.method_return().append1(format!("/{}", path))])
-                                }
-                                Err(_) => Err(MethodErr::invalid_arg("Malformed shortcut")),
-                            }
-                        })
-                        .outarg::<&str, _>("path")
-                        .inarg::<&str, _>("shortcut"),
-                ),
-            ),
-        )
-        .add(factory.object_path("/", ()).introspectable());
-
-    // Serve clients forever.
-    loop {
-        connection.process_with_tree(&tree, Duration::from_millis(50))?;
-
-        while let Ok(shortcut) = shortcut_register_rx.try_recv() {
-            let identifier = format!("/{}", shortcut.identifier());
-
-            listener.add(shortcut);
-
-            let signal = Arc::new(factory.signal("Triggered", ()));
-            signals.insert(identifier.clone(), signal.clone());
-
-            tree = tree.add(
-                factory
-                    .object_path(identifier, ())
-                    .introspectable()
-                    .add(factory.interface(INTERFACE, ()).add_s(signal)),
-            );
-        }
-
-        match shortcut_trigger_rx.try_recv() {
-            Ok(shortcut) => {
-                let identifier = format!("/{}", shortcut.identifier());
-                if let Some(signal) = signals.get(&identifier) {
-                    connection
-                        .send(
-                            signal
-                                .clone()
-                                .msg(&identifier.into(), &INTERFACE.into())
-                                .append1(&format!("{}", shortcut)),
-                        )
-                        .unwrap();
-                }
-            }
-            Err(TryRecvError::Disconnected) => panic!("keyboard listener crashed"),
-            _ => {}
             }
         }
     }
+
+    Ok(())
+}