impl linux credential storage

Signed-off-by: kernelkind <kernelkind@gmail.com>

src/key_storage.rs

@@ -1,67 +1,88 @@
 use enostr::Keypair;
 
+#[cfg(target_os = "linux")]
+use crate::linux_key_storage::LinuxKeyStorage;
 #[cfg(target_os = "macos")]
 use crate::macos_key_storage::MacOSKeyStorage;
 
 #[cfg(target_os = "macos")]
 pub const SERVICE_NAME: &str = "Notedeck";
 
-pub enum KeyStorage {
+#[derive(Debug, PartialEq)]
+pub enum KeyStorageType {
     None,
     #[cfg(target_os = "macos")]
     MacOS,
+    #[cfg(target_os = "linux")]
+    Linux,
     // TODO:
-    // Linux,
     // Windows,
     // Android,
 }
 
-impl KeyStorage {
-    pub fn get_keys(&self) -> Result<Vec<Keypair>, KeyStorageError> {
+#[allow(dead_code)]
+#[derive(Debug, PartialEq)]
+pub enum KeyStorageResponse<R> {
+    Waiting,
+    ReceivedResult(Result<R, KeyStorageError>),
+}
+
+pub trait KeyStorage {
+    fn get_keys(&self) -> KeyStorageResponse<Vec<Keypair>>;
+    fn add_key(&self, key: &Keypair) -> KeyStorageResponse<()>;
+    fn remove_key(&self, key: &Keypair) -> KeyStorageResponse<()>;
+}
+
+impl KeyStorage for KeyStorageType {
+    fn get_keys(&self) -> KeyStorageResponse<Vec<Keypair>> {
         match self {
-            Self::None => Ok(Vec::new()),
+            Self::None => KeyStorageResponse::ReceivedResult(Ok(Vec::new())),
             #[cfg(target_os = "macos")]
-            Self::MacOS => Ok(MacOSKeyStorage::new(SERVICE_NAME).get_all_keypairs()),
+            Self::MacOS => MacOSKeyStorage::new(SERVICE_NAME).get_keys(),
+            #[cfg(target_os = "linux")]
+            Self::Linux => LinuxKeyStorage::new().get_keys(),
         }
     }
 
-    pub fn add_key(&self, key: &Keypair) -> Result<(), KeyStorageError> {
+    fn add_key(&self, key: &Keypair) -> KeyStorageResponse<()> {
         let _ = key;
         match self {
-            Self::None => Ok(()),
+            Self::None => KeyStorageResponse::ReceivedResult(Ok(())),
             #[cfg(target_os = "macos")]
             Self::MacOS => MacOSKeyStorage::new(SERVICE_NAME).add_key(key),
+            #[cfg(target_os = "linux")]
+            Self::Linux => LinuxKeyStorage::new().add_key(key),
         }
     }
 
-    pub fn remove_key(&self, key: &Keypair) -> Result<(), KeyStorageError> {
+    fn remove_key(&self, key: &Keypair) -> KeyStorageResponse<()> {
         let _ = key;
         match self {
-            Self::None => Ok(()),
+            Self::None => KeyStorageResponse::ReceivedResult(Ok(())),
             #[cfg(target_os = "macos")]
-            Self::MacOS => MacOSKeyStorage::new(SERVICE_NAME).delete_key(&key.pubkey),
+            Self::MacOS => MacOSKeyStorage::new(SERVICE_NAME).remove_key(key),
+            #[cfg(target_os = "linux")]
+            Self::Linux => LinuxKeyStorage::new().remove_key(key),
         }
     }
 }
 
+#[allow(dead_code)]
 #[derive(Debug, PartialEq)]
 pub enum KeyStorageError {
-    Retrieval,
+    Retrieval(String),
     Addition(String),
     Removal(String),
-    UnsupportedPlatform,
+    OSError(String),
 }
 
 impl std::fmt::Display for KeyStorageError {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
-            Self::Retrieval => write!(f, "Failed to retrieve keys."),
+            Self::Retrieval(e) => write!(f, "Failed to retrieve keys: {:?}", e),
             Self::Addition(key) => write!(f, "Failed to add key: {:?}", key),
             Self::Removal(key) => write!(f, "Failed to remove key: {:?}", key),
-            Self::UnsupportedPlatform => write!(
-                f,
-                "Attempted to use a key storage impl from an unsupported platform."
-            ),
+            Self::OSError(e) => write!(f, "OS had an error: {:?}", e),
         }
     }
 }