feat: WebDAV support (#235)

src/filetransfer/builder.rs

@@ -12,7 +12,9 @@ use remotefs_smb::SmbOptions;
 #[cfg(smb)]
 use remotefs_smb::{SmbCredentials, SmbFs};
 use remotefs_ssh::{ScpFs, SftpFs, SshConfigParseRule, SshOpts};
+use remotefs_webdav::WebDAVFs;
 
+use super::params::WebDAVProtocolParams;
 #[cfg(not(smb))]
 use super::params::{AwsS3Params, GenericProtocolParams};
 #[cfg(smb)]
@@ -51,6 +53,9 @@ impl Builder {
             (FileTransferProtocol::Smb, ProtocolParams::Smb(params)) => {
                 Box::new(Self::smb_client(params))
             }
+            (FileTransferProtocol::WebDAV, ProtocolParams::WebDAV(params)) => {
+                Box::new(Self::webdav_client(params))
+            }
             (protocol, params) => {
                 error!("Invalid params for protocol '{:?}'", protocol);
                 panic!("Invalid protocol '{protocol:?}' with parameters of type {params:?}")
@@ -154,6 +159,10 @@ impl Builder {
         SmbFs::new(credentials)
     }
 
+    fn webdav_client(params: WebDAVProtocolParams) -> WebDAVFs {
+        WebDAVFs::new(&params.username, &params.password, &params.uri)
+    }
+
     /// Build ssh options from generic protocol params and client configuration
     fn build_ssh_opts(params: GenericProtocolParams, config_client: &ConfigClient) -> SshOpts {
         let mut opts = SshOpts::new(params.address.clone())

src/filetransfer/mod.rs

@@ -18,6 +18,7 @@ pub enum FileTransferProtocol {
     Scp,
     Sftp,
     Smb,
+    WebDAV,
 }
 
 // Traits
@@ -33,6 +34,7 @@ impl std::string::ToString for FileTransferProtocol {
             FileTransferProtocol::Scp => "SCP",
             FileTransferProtocol::Sftp => "SFTP",
             FileTransferProtocol::Smb => "SMB",
+            FileTransferProtocol::WebDAV => "WEBDAV",
         })
     }
 }
@@ -47,6 +49,7 @@ impl std::str::FromStr for FileTransferProtocol {
             "SCP" => Ok(FileTransferProtocol::Scp),
             "SFTP" => Ok(FileTransferProtocol::Sftp),
             "SMB" => Ok(FileTransferProtocol::Smb),
+            "WEBDAV" | "HTTP" | "HTTPS" => Ok(FileTransferProtocol::WebDAV),
             _ => Err(s.to_string()),
         }
     }
@@ -134,9 +137,17 @@ mod tests {
             FileTransferProtocol::Ftp(false).to_string(),
             String::from("FTP")
         );
+        assert_eq!(
+            FileTransferProtocol::WebDAV.to_string(),
+            String::from("WEBDAV")
+        );
         assert_eq!(FileTransferProtocol::Scp.to_string(), String::from("SCP"));
         assert_eq!(FileTransferProtocol::Sftp.to_string(), String::from("SFTP"));
         assert_eq!(FileTransferProtocol::AwsS3.to_string(), String::from("S3"));
         assert_eq!(FileTransferProtocol::Smb.to_string(), String::from("SMB"));
+        assert_eq!(
+            FileTransferProtocol::WebDAV.to_string(),
+            String::from("WEBDAV")
+        );
     }
 }

src/filetransfer/params.rs

@@ -21,6 +21,7 @@ pub enum ProtocolParams {
     Generic(GenericProtocolParams),
     AwsS3(AwsS3Params),
     Smb(SmbParams),
+    WebDAV(WebDAVProtocolParams),
 }
 
 /// Protocol params used by most common protocols
@@ -89,6 +90,7 @@ impl FileTransferParams {
             ProtocolParams::AwsS3(params) => params.password_missing(),
             ProtocolParams::Generic(params) => params.password_missing(),
             ProtocolParams::Smb(params) => params.password_missing(),
+            ProtocolParams::WebDAV(params) => params.password_missing(),
         }
     }
 
@@ -98,10 +100,29 @@ impl FileTransferParams {
             ProtocolParams::AwsS3(params) => params.set_default_secret(secret),
             ProtocolParams::Generic(params) => params.set_default_secret(secret),
             ProtocolParams::Smb(params) => params.set_default_secret(secret),
+            ProtocolParams::WebDAV(params) => params.set_default_secret(secret),
         }
     }
 }
 
+/// Protocol params used by WebDAV
+#[derive(Debug, Clone)]
+pub struct WebDAVProtocolParams {
+    pub uri: String,
+    pub username: String,
+    pub password: String,
+}
+
+impl WebDAVProtocolParams {
+    fn set_default_secret(&mut self, secret: String) {
+        self.password = secret;
+    }
+
+    fn password_missing(&self) -> bool {
+        self.password.is_empty()
+    }
+}
+
 impl Default for FileTransferParams {
     fn default() -> Self {
         Self::new(FileTransferProtocol::Sftp, ProtocolParams::default())
@@ -149,6 +170,15 @@ impl ProtocolParams {
             _ => None,
         }
     }
+
+    #[cfg(test)]
+    /// Retrieve WebDAV parameters if any
+    pub fn webdav_params(&self) -> Option<&WebDAVProtocolParams> {
+        match self {
+            ProtocolParams::WebDAV(params) => Some(params),
+            _ => None,
+        }
+    }
 }
 
 // -- Generic protocol params
@@ -512,6 +542,40 @@ mod test {
         );
     }
 
+    #[test]
+    #[cfg(linux)]
+    fn set_default_secret_smb() {
+        let mut params = FileTransferParams::new(
+            FileTransferProtocol::Scp,
+            ProtocolParams::Smb(SmbParams::new("localhost", "temp")),
+        );
+        params.set_default_secret(String::from("secret"));
+        assert_eq!(
+            params
+                .params
+                .smb_params()
+                .unwrap()
+                .password
+                .as_deref()
+                .unwrap(),
+            "secret"
+        );
+    }
+
+    #[test]
+    fn set_default_secret_webdav() {
+        let mut params = FileTransferParams::new(
+            FileTransferProtocol::Scp,
+            ProtocolParams::WebDAV(WebDAVProtocolParams {
+                uri: "http://localhost".to_string(),
+                username: "user".to_string(),
+                password: "pass".to_string(),
+            }),
+        );
+        params.set_default_secret(String::from("secret"));
+        assert_eq!(params.params.webdav_params().unwrap().password, "secret");
+    }
+
     #[test]
     fn set_default_secret_generic() {
         let mut params =