working_init

Author: ranfdev

Cargo.lock

@@ -56,7 +56,8 @@
             {
               "type": "git",
               "url": "https://gitlab.gnome.org/jwestman/blueprint-compiler",
-              "tag": "v0.14.0"
+              "tag": "v0.14.0",
+              "commit": "8e10fcf8692108b9d4ab78f41086c5d7773ef864"
             }
           ]
         },

build-aux/com.ranfdev.Notify.Devel.json

@@ -19,13 +19,15 @@ tokio = { version = "1.0.0", features = ["net", "rt", "macros", "parking_lot"]}
 tokio-util = { version = "0.7.4", features = ["compat", "io"] }
 clap = { version = "4.3.11", features = ["derive"] }
 anyhow = "1.0.71"
-tokio-stream = { version = "0.1.14", features = ["io-util", "time"] }
+tokio-stream = { version = "0.1.14", features = ["io-util", "time", "sync"] }
 rusqlite = "0.29.0"
 rand = "0.8.5"
-reqwest = { version = "0.11.18", features = ["stream", "rustls-tls-native-roots"]}
-url = "2.4.0"
+reqwest = { version = "0.12.9", features = ["stream", "rustls-tls-native-roots"]}
+url = { version = "2.4.0", features = ["serde"] }
 generational-arena = "0.2.9"
 tracing = "0.1.37"
 thiserror = "1.0.49"
 regex = "1.9.6"
 oo7 = "0.2.1"
+async-trait = "0.1.83"
+http = "1.1.0"

ntfy-daemon/Cargo.toml

@@ -2,26 +2,159 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 
+use async_trait::async_trait;
+
+#[derive(Clone)]
+pub struct KeyringItem {
+    attributes: HashMap<String, String>,
+    // we could zero-out this region of memory
+    secret: Vec<u8> 
+}
+
+impl KeyringItem {
+    async fn attributes(&self) -> HashMap<String, String> {
+        self.attributes.clone()
+    }
+    async fn secret(&self) -> &[u8] {
+        &self.secret[..]
+    }
+}
+
+#[async_trait]
+trait LightKeyring {
+    async fn search_items(
+        &self,
+        attributes: HashMap<&str, &str>,
+    ) -> anyhow::Result<Vec<KeyringItem>>;
+    async fn create_item(
+        &self,
+        label: &str,
+        attributes: HashMap<&str, &str>,
+        secret: &str,
+        replace: bool,
+    ) -> anyhow::Result<()>;
+    async fn delete(&self, attributes: HashMap<&str, &str>) -> anyhow::Result<()>;
+}
+
+struct RealKeyring {
+    keyring: oo7::Keyring,
+}
+
+#[async_trait]
+impl LightKeyring for RealKeyring {
+    async fn search_items(
+        &self,
+        attributes: HashMap<&str, &str>,
+    ) -> anyhow::Result<Vec<KeyringItem>> {
+        let items = self.keyring.search_items(attributes).await?;
+
+        let mut out_items = vec![];
+        for item in items {
+            out_items.push(KeyringItem {
+                attributes: item.attributes().await?,
+                secret: item.secret().await?.to_vec(),
+            });
+        }
+        Ok(out_items)
+    }
+
+    async fn create_item(
+        &self,
+        label: &str,
+        attributes: HashMap<&str, &str>,
+        secret: &str,
+        replace: bool,
+    ) -> anyhow::Result<()> {
+        self.keyring
+            .create_item(label, attributes, secret, replace)
+            .await?;
+        Ok(())
+    }
+
+    async fn delete(&self, attributes: HashMap<&str, &str>) -> anyhow::Result<()> {
+        self.keyring.delete(attributes).await?;
+        Ok(())
+    }
+}
+
+struct NullableKeyring {
+    search_response: Vec<KeyringItem>,
+}
+
+impl NullableKeyring {
+    pub fn new(search_response: Vec<KeyringItem>) -> Self {
+        Self { search_response }
+    }
+}
+
+#[async_trait]
+impl LightKeyring for NullableKeyring {
+    async fn search_items(
+        &self,
+        _attributes: HashMap<&str, &str>,
+    ) -> anyhow::Result<Vec<KeyringItem>> {
+        Ok(self.search_response.clone())
+    }
+
+    async fn create_item(
+        &self,
+        _label: &str,
+        _attributes: HashMap<&str, &str>,
+        _secret: &str,
+        _replace: bool,
+    ) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    async fn delete(&self, _attributes: HashMap<&str, &str>) -> anyhow::Result<()> {
+        Ok(())
+    }
+}
+impl NullableKeyring {
+    pub fn with_credentials(credentials: Vec<Credential>) -> Self {
+        let mut search_response = vec![];
+
+        for cred in credentials {
+            let attributes = HashMap::from([
+                ("type".to_string(), "password".to_string()),
+                ("username".to_string(), cred.username.clone()),
+                ("server".to_string(), cred.password.clone()),
+            ]);
+            search_response.push(KeyringItem { attributes, secret: cred.password.into_bytes() });
+        }
+
+        Self { search_response }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct Credential {
     pub username: String,
     pub password: String,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct Credentials {
-    keyring: Rc<oo7::Keyring>,
+    keyring: Rc<dyn LightKeyring>,
     creds: Rc<RefCell<HashMap<String, Credential>>>,
 }
 
 impl Credentials {
     pub async fn new() -> anyhow::Result<Self> {
         let mut this = Self {
-            keyring: Rc::new(
-                oo7::Keyring::new()
+            keyring: Rc::new(RealKeyring {
+                keyring: oo7::Keyring::new()
                     .await
                     .expect("Failed to start Secret Service"),
-            ),
+            }),
+            creds: Default::default(),
+        };
+        this.load().await?;
+        Ok(this)
+    }
+    pub async fn new_nullable(credentials: Vec<Credential>) -> anyhow::Result<Self> {
+        let mut this = Self {
+            keyring: Rc::new(NullableKeyring::with_credentials(credentials)),
             creds: Default::default(),
         };
         this.load().await?;
@@ -39,13 +172,12 @@ impl Credentials {
         for item in values {
             let attrs = item
                 .attributes()
-                .await
-                .map_err(|e| capnp::Error::failed(e.to_string()))?;
+                .await;
             self.creds.borrow_mut().insert(
                 attrs["server"].to_string(),
                 Credential {
                     username: attrs["username"].to_string(),
-                    password: std::str::from_utf8(&item.secret().await?)?.to_string(),
+                    password: std::str::from_utf8(&item.secret().await)?.to_string(),
                 },
             );
         }