replace option

Author: dcodesdev

src/cli.rs

@@ -12,19 +12,22 @@ pub struct Cli {
 pub enum Commands {
     #[command(about = "Copy a file to a remote host")]
     Receive {
-        #[arg(help = "Remote source to copy from")]
+        #[clap(help = "Remote source to copy from")]
         source: String,
 
-        #[arg(help = "Local destination to copy to")]
+        #[clap(help = "Local destination to copy to")]
         destination: String,
 
-        #[arg(long, help = "Remote host to connect to")]
+        #[clap(long, help = "Remote host to connect to")]
         host: String,
 
-        #[arg(short, long, help = "Remote username to connect as")]
+        #[clap(short, long, help = "Remote username to connect as")]
         user: String,
 
-        #[arg(short, long, help = "Path to private key")]
+        #[clap(short, long, help = "Path to private key")]
         private_key: Option<PathBuf>,
+
+        #[clap(help = "Replace the file if it exists", long, default_value = "false")]
+        replace: bool,
     },
 }

src/run.rs

@@ -1,6 +1,6 @@
 use crate::cli::{Cli, Commands};
 use crate::error::ScpError;
-use crate::scp::{Connect, SshOpts};
+use crate::scp::{Connect, Mode, SshOpts};
 use crate::utils::get_private_key_path;
 use clap::Parser;
 use std::path::PathBuf;
@@ -15,6 +15,7 @@ pub async fn run() -> anyhow::Result<(), ScpError> {
             host,
             user: username,
             private_key,
+            replace,
         } => {
             let private_key = get_private_key_path(&private_key)?;
 
@@ -24,7 +25,9 @@ pub async fn run() -> anyhow::Result<(), ScpError> {
                 username,
             };
 
-            return Connect::new(scp_opts)?
+            let mode = if replace { Mode::Replace } else { Mode::Ignore };
+
+            return Connect::new(scp_opts, mode)?
                 .receive(&PathBuf::from(source), &PathBuf::from(destination))
                 .await;
         }

src/scp.rs

@@ -13,13 +13,18 @@ use crate::{error::ScpError, utils::with_retry};
 pub struct Connect {
     session: Session,
     ssh_opts: SshOpts,
+    mode: Mode,
 }
 
 impl Connect {
-    pub fn new(ssh_opts: SshOpts) -> anyhow::Result<Self, ScpError> {
+    pub fn new(ssh_opts: SshOpts, mode: Mode) -> anyhow::Result<Self, ScpError> {
         let session = create_session(&ssh_opts)?;
 
-        Ok(Self { session, ssh_opts })
+        Ok(Self {
+            session,
+            ssh_opts,
+            mode,
+        })
     }
 
     pub async fn receive(&self, from: &PathBuf, to: &PathBuf) -> anyhow::Result<(), ScpError> {
@@ -34,8 +39,10 @@ impl Connect {
             let item_clone = item.clone();
             let ssh_opts = self.ssh_opts.clone();
             let pb = pb.clone();
+            let mode = self.mode.clone();
             let handle = tokio::task::spawn(async move {
-                let result = copy_file_from_remote(&ssh_opts, item_clone.clone(), to_path).await;
+                let result =
+                    copy_file_from_remote(&ssh_opts, item_clone.clone(), to_path, &mode).await;
                 pb.inc(1);
                 result
             });
@@ -110,10 +117,20 @@ pub struct SshOpts {
     pub private_key: PathBuf,
 }
 
+/// Mode to use when copying files
+/// Replace will overwrite the file if it exists
+/// Ignore will skip the file if it exists
+#[derive(Clone)]
+pub enum Mode {
+    Replace,
+    Ignore,
+}
+
 async fn copy_file_from_remote(
     ssh_opts: &SshOpts,
     remote_file_path: PathBuf,
     local_file_path: PathBuf,
+    mode: &Mode,
 ) -> anyhow::Result<(), ScpError> {
     let create_session = || create_session(ssh_opts);
     let session = with_retry(create_session, 10)?;
@@ -126,9 +143,21 @@ async fn copy_file_from_remote(
     // make the dir if not exists
     fs::create_dir_all(local_file_path.parent().unwrap())?;
 
-    // Create local file and write to it
-    let mut local_file = File::create(local_file_path)?;
-    local_file.write_all(&contents)?;
+    match mode {
+        Mode::Replace => {
+            let mut local_file = File::create(&local_file_path)?;
+            local_file.write_all(&contents)?;
+        }
+        Mode::Ignore => {
+            if local_file_path.exists() {
+                return Ok(());
+            }
+
+            let mut local_file = File::create(local_file_path)?;
+            local_file.write_all(&contents)?;
+        }
+    }
+
     session.disconnect(None, "Bye", None)?;
 
     Ok(())