added new s3 params

src/filetransfer/builder.rs

@@ -73,10 +73,16 @@ impl Builder {
 
     /// Build aws s3 client from parameters
     fn aws_s3_client(params: AwsS3Params) -> AwsS3Fs {
-        let mut client = AwsS3Fs::new(params.bucket_name, params.region);
+        let mut client = AwsS3Fs::new(params.bucket_name).new_path_style(params.new_path_style);
+        if let Some(region) = params.region {
+            client = client.region(region);
+        }
         if let Some(profile) = params.profile {
             client = client.profile(profile);
         }
+        if let Some(endpoint) = params.endpoint {
+            client = client.endpoint(endpoint);
+        }
         if let Some(access_key) = params.access_key {
             client = client.access_key(access_key);
         }
@@ -151,7 +157,9 @@ mod test {
     #[test]
     fn should_build_aws_s3_fs() {
         let params = ProtocolParams::AwsS3(
-            AwsS3Params::new("omar", "eu-west-1", Some("test"))
+            AwsS3Params::new("omar", Some("eu-west-1"), Some("test"))
+                .endpoint(Some("http://localhost:9000"))
+                .new_path_style(true)
                 .access_key(Some("pippo"))
                 .secret_access_key(Some("pluto"))
                 .security_token(Some("omar"))

src/filetransfer/params.rs

@@ -59,12 +59,14 @@ pub struct GenericProtocolParams {
 #[derive(Debug, Clone)]
 pub struct AwsS3Params {
     pub bucket_name: String,
-    pub region: String,
+    pub region: Option<String>,
+    pub endpoint: Option<String>,
     pub profile: Option<String>,
     pub access_key: Option<String>,
     pub secret_access_key: Option<String>,
     pub security_token: Option<String>,
     pub session_token: Option<String>,
+    pub new_path_style: bool,
 }
 
 impl FileTransferParams {
@@ -167,18 +169,26 @@ impl GenericProtocolParams {
 
 impl AwsS3Params {
     /// Instantiates a new `AwsS3Params` struct
-    pub fn new<S: AsRef<str>>(bucket: S, region: S, profile: Option<S>) -> Self {
+    pub fn new<S: AsRef<str>>(bucket: S, region: Option<S>, profile: Option<S>) -> Self {
         Self {
             bucket_name: bucket.as_ref().to_string(),
-            region: region.as_ref().to_string(),
+            region: region.map(|x| x.as_ref().to_string()),
             profile: profile.map(|x| x.as_ref().to_string()),
+            endpoint: None,
             access_key: None,
             secret_access_key: None,
             security_token: None,
             session_token: None,
+            new_path_style: false,
         }
     }
 
+    /// Construct aws s3 params with specified endpoint
+    pub fn endpoint<S: AsRef<str>>(mut self, endpoint: Option<S>) -> Self {
+        self.endpoint = endpoint.map(|x| x.as_ref().to_string());
+        self
+    }
+
     /// Construct aws s3 params with provided access key
     pub fn access_key<S: AsRef<str>>(mut self, key: Option<S>) -> Self {
         self.access_key = key.map(|x| x.as_ref().to_string());
@@ -202,6 +212,12 @@ impl AwsS3Params {
         self.session_token = key.map(|x| x.as_ref().to_string());
         self
     }
+
+    /// Specify new path style when constructing aws s3 params
+    pub fn new_path_style(mut self, new_path_style: bool) -> Self {
+        self.new_path_style = new_path_style;
+        self
+    }
 }
 
 #[cfg(test)]
@@ -240,35 +256,42 @@ mod test {
 
     #[test]
     fn should_init_aws_s3_params() {
-        let params: AwsS3Params = AwsS3Params::new("omar", "eu-west-1", Some("test"));
+        let params: AwsS3Params = AwsS3Params::new("omar", Some("eu-west-1"), Some("test"));
         assert_eq!(params.bucket_name.as_str(), "omar");
-        assert_eq!(params.region.as_str(), "eu-west-1");
+        assert_eq!(params.region.as_deref().unwrap(), "eu-west-1");
         assert_eq!(params.profile.as_deref().unwrap(), "test");
+        assert!(params.endpoint.is_none());
         assert!(params.access_key.is_none());
         assert!(params.secret_access_key.is_none());
         assert!(params.security_token.is_none());
         assert!(params.session_token.is_none());
+        assert_eq!(params.new_path_style, false);
     }
 
     #[test]
     fn should_init_aws_s3_params_with_optionals() {
-        let params: AwsS3Params = AwsS3Params::new("omar", "eu-west-1", Some("test"))
+        let params: AwsS3Params = AwsS3Params::new("omar", Some("eu-west-1"), Some("test"))
+            .endpoint(Some("http://omar.it"))
             .access_key(Some("pippo"))
             .secret_access_key(Some("pluto"))
             .security_token(Some("omar"))
-            .session_token(Some("gerry-scotti"));
+            .session_token(Some("gerry-scotti"))
+            .new_path_style(true);
         assert_eq!(params.bucket_name.as_str(), "omar");
-        assert_eq!(params.region.as_str(), "eu-west-1");
+        assert_eq!(params.region.as_deref().unwrap(), "eu-west-1");
         assert_eq!(params.profile.as_deref().unwrap(), "test");
+        assert_eq!(params.endpoint.as_deref().unwrap(), "http://omar.it");
         assert_eq!(params.access_key.as_deref().unwrap(), "pippo");
         assert_eq!(params.secret_access_key.as_deref().unwrap(), "pluto");
         assert_eq!(params.security_token.as_deref().unwrap(), "omar");
         assert_eq!(params.session_token.as_deref().unwrap(), "gerry-scotti");
+        assert_eq!(params.new_path_style, true);
     }
 
     #[test]
     fn references() {
-        let mut params = ProtocolParams::AwsS3(AwsS3Params::new("omar", "eu-west-1", Some("test")));
+        let mut params =
+            ProtocolParams::AwsS3(AwsS3Params::new("omar", Some("eu-west-1"), Some("test")));
         assert!(params.s3_params().is_some());
         assert!(params.generic_params().is_none());
         assert!(params.mut_generic_params().is_none());