Added function to attach key to litterbox

Author: Gerharddc

litterbox/src/errors.rs

@@ -22,6 +22,9 @@ pub enum LitterboxError {
     DockerfileAlreadyExists(PathBuf),
     PromptError(InquireError),
     FailedToSerialise(&'static str),
+    KeyAlreadyExists(String),
+    KeyDoesNotExist(String),
+    AlreadyAttachedToKey(String, String),
 }
 
 impl LitterboxError {
@@ -91,7 +94,18 @@ impl LitterboxError {
                 println!("Failed to retrieve valid input from user.");
             }
             LitterboxError::FailedToSerialise(name) => {
-                println!("Failed to serialise {name}");
+                println!("Failed to serialise {name}.");
+            }
+            LitterboxError::KeyAlreadyExists(name) => {
+                println!("Key named {name} already exists.")
+            }
+            LitterboxError::KeyDoesNotExist(name) => {
+                println!("Key named {name} does not exist.")
+            }
+            LitterboxError::AlreadyAttachedToKey(key_name, litterbox_name) => {
+                println!(
+                    "Litterbox named {litterbox_name} already attached to key named {key_name}."
+                )
             }
         }
     }

litterbox/src/keys.rs

@@ -150,8 +150,14 @@ impl Keys {
         }
     }
 
+    fn key_mut(&mut self, key_name: &str) -> Option<&mut Key> {
+        self.keys.iter_mut().find(|key| key.name == key_name)
+    }
+
     pub fn generate(&mut self, key_name: &str) -> Result<(), LitterboxError> {
-        // FIXME: make sure a key with this name does not exist yet
+        if self.key_mut(key_name).is_some() {
+            return Err(LitterboxError::KeyAlreadyExists(key_name.to_owned()));
+        }
 
         let password = self.prompt_password()?;
         self.keys.push(Key::new(key_name, &password));
@@ -170,15 +176,39 @@ impl Keys {
             }
         });
 
-        if found {
-            self.save_to_file()?;
-            println!("Deleted key named {key_name}");
-        } else {
-            println!("Could not find key named {key_name}. Nothing deleted.")
+        if !found {
+            return Err(LitterboxError::KeyDoesNotExist(key_name.to_owned()));
         }
 
+        self.save_to_file()?;
+        println!("Deleted key named {key_name}");
         Ok(())
     }
+
+    pub fn attach(&mut self, key_name: &str, litterbox_name: &str) -> Result<(), LitterboxError> {
+        match self.key_mut(key_name) {
+            Some(key) => {
+                if key
+                    .attached_litterboxes
+                    .iter()
+                    .find(|name| **name == litterbox_name)
+                    .is_some()
+                {
+                    return Err(LitterboxError::AlreadyAttachedToKey(
+                        key_name.to_owned(),
+                        litterbox_name.to_owned(),
+                    ));
+                }
+
+                key.attached_litterboxes.push(litterbox_name.to_owned());
+                self.save_to_file()?;
+
+                println!("Attached {litterbox_name} to {key_name}!");
+                Ok(())
+            }
+            None => Err(LitterboxError::KeyDoesNotExist(key_name.to_owned())),
+        }
+    }
 }
 
 #[cfg(test)]

litterbox/src/main.rs

@@ -169,9 +169,18 @@ enum KeyCommands {
         /// The name of the key
         name: String,
     },
+
+    /// Attach an existing key to a Litterbox
+    Attach {
+        /// The name of the key
+        key_name: String,
+
+        /// The name of the Litterbox
+        litterbox_name: String,
+    },
 }
 
-fn try_run() -> Result<(), LitterboxError> {
+fn run_menu() -> Result<(), LitterboxError> {
     let args = Args::parse();
     match args.command {
         Commands::Prepare { name } => {
@@ -185,7 +194,7 @@ fn try_run() -> Result<(), LitterboxError> {
             println!("Litterbox created!");
         }
         Commands::Enter { name } => {
-            enter_distrobox(&name)?;
+            enter_litterbox(&name)?;
             println!("Exited Litterbox...")
         }
         Commands::List => {
@@ -196,7 +205,7 @@ fn try_run() -> Result<(), LitterboxError> {
             println!("{table}");
         }
         Commands::Delete { name } => {
-            delete_distrobox(&name)?;
+            delete_litterbox(&name)?;
         }
         Commands::Keys(cmd) => process_key_cmd(cmd)?,
     }
@@ -215,14 +224,20 @@ fn process_key_cmd(cmd: KeyCommands) -> Result<(), LitterboxError> {
         KeyCommands::Delete { name } => {
             keys.delete(&name)?;
         }
+        KeyCommands::Attach {
+            key_name,
+            litterbox_name,
+        } => {
+            keys.attach(&key_name, &litterbox_name)?;
+        }
     }
     Ok(())
 }
 
 fn main() {
     env_logger::init();
 
-    if let Err(e) = try_run() {
+    if let Err(e) = run_menu() {
         e.print();
     }
 }

litterbox/src/podman.rs

@@ -208,7 +208,7 @@ pub fn create_litterbox(lbx_name: &str, user: &str) -> Result<(), LitterboxError
     Ok(())
 }
 
-pub fn enter_distrobox(name: &str) -> Result<(), LitterboxError> {
+pub fn enter_litterbox(name: &str) -> Result<(), LitterboxError> {
     let mut child = Command::new("podman")
         .args([
             "start",
@@ -220,11 +220,11 @@ pub fn enter_distrobox(name: &str) -> Result<(), LitterboxError> {
         .map_err(LitterboxError::RunPodman)?;
 
     child.wait().map_err(LitterboxError::RunPodman)?;
-    debug!("Distrobox finished.");
+    debug!("Litterbox finished.");
     Ok(())
 }
 
-pub fn delete_distrobox(lbx_name: &str) -> Result<(), LitterboxError> {
+pub fn delete_litterbox(lbx_name: &str) -> Result<(), LitterboxError> {
     // We check if it exists before promting the user
     let container_id = get_container_id(lbx_name)?;