Process by cargo clippy

Signed-off-by: Denys Fedoryshchenko <denys.f@collabora.com>

Author: nuclearcat

src/azure.rs

@@ -18,7 +18,6 @@ use azure_storage_blobs::prelude::{BlobBlockType, BlockId, BlockList, ClientBuil
 use chksum_hash_sha2_512 as sha2_512;
 use futures::stream::StreamExt;
 use headers::HeaderMap;
-use hex;
 use reqwest::Client;
 use serde::Deserialize;
 use std::fs::read_to_string;
@@ -47,12 +46,12 @@ fn get_azure_credentials(name: &str) -> AzureConfig {
     let container = azure_cfg.get("container").unwrap().as_str().unwrap();
     let sastoken = azure_cfg.get("sastoken").unwrap().as_str().unwrap();
     //println!("Azure account: {} key: {} sastoken: {} container: {}", account, key, sastoken, container);
-    return AzureConfig {
+    AzureConfig {
         account: account.to_string(),
         key: key.to_string(),
         container: container.to_string(),
         sastoken: sastoken.to_string(),
-    };
+    }
 }
 
 fn calculate_checksum(filename: &String, data: &[u8]) {
@@ -142,7 +141,7 @@ async fn write_file_to_blob(filename: String, data: Vec<u8>, cont_type: String)
             eprintln!("Error uploading block list: {:?}", e);
         }
     }
-    return "OK";
+    "OK"
 }
 
 /// Get headers from file (Maybe should be moved to a separate module, its not Azure specific)
@@ -158,7 +157,7 @@ fn get_headers_from_file(filename: String) -> HeaderMap {
             headers.insert(key, value);
         }
     }
-    return headers;
+    headers
 }
 
 /// Save headers(Azure) to file
@@ -306,7 +305,7 @@ async fn get_file_from_blob(filename: String) -> ReceivedFile {
             eprintln!("Error getting blob: {:?}", e);
         }
     }
-    return received_file;
+    received_file
 }
 
 // Implement set tags for Azure blob storage
@@ -332,10 +331,10 @@ async fn azure_set_filename_tags(
     let res = blob_client.set_tags(tags).await;
     match res {
         Ok(_) => {
-            return Ok(String::from("OK"));
+            Ok(String::from("OK"))
         }
         Err(e) => {
-            return Err(e.to_string());
+            Err(e.to_string())
         }
     }
 }
@@ -363,7 +362,7 @@ async fn azure_list_files(directory: String) -> Vec<String> {
         println!("Listing count: {}", listing.len());
     }
     //println!("Listing: {:?}", listing);
-    return listing;
+    listing
 }
 
 /// Implement Driver trait for AzureDriver
@@ -375,7 +374,7 @@ impl super::Driver for AzureDriver {
             let rt = tokio::runtime::Runtime::new().unwrap();
             rt.block_on(write_file_to_blob(filename, data, cont_type));
         });
-        return filenameret;
+        filenameret
     }
     fn tag_file(
         &self,
@@ -384,7 +383,7 @@ impl super::Driver for AzureDriver {
     ) -> Result<String, String> {
         let rt = tokio::runtime::Runtime::new().unwrap();
         let ret = rt.block_on(azure_set_filename_tags(filename, user_tags));
-        return ret;
+        ret
     }
     fn get_file(&self, filename: String) -> ReceivedFile {
         /* Call async get_file_from_blob use tokio::task::block_in_place */
@@ -398,14 +397,14 @@ impl super::Driver for AzureDriver {
             let rt = tokio::runtime::Runtime::new().unwrap();
             received_file = rt.block_on(get_file_from_blob(filename));
         });
-        return received_file;
+        received_file
     }
     fn list_files(&self, directory: String) -> Vec<String> {
         let mut ret = Vec::new();
         tokio::task::block_in_place(|| {
             let rt = tokio::runtime::Runtime::new().unwrap();
             ret = rt.block_on(azure_list_files(directory));
         });
-        return ret;
+        ret
     }
 }

src/main.rs

@@ -88,7 +88,7 @@ fn init_driver(driver_type: &str) -> Box<dyn Driver> {
             std::process::exit(1);
         }
     };
-    return driver;
+    driver
 }
 
 pub fn get_config_content() -> String {
@@ -97,8 +97,8 @@ pub fn get_config_content() -> String {
     if let Ok(cfg_file_env) = std::env::var("KCI_STORAGE_CONFIG") {
         cfg_file = PathBuf::from(&cfg_file_env);
     }
-    let cfg_content = std::fs::read_to_string(&cfg_file).unwrap();
-    cfg_content
+    
+    std::fs::read_to_string(&cfg_file).unwrap()
 }
 
 /// Initial variables configuration and checks
@@ -112,7 +112,7 @@ async fn initial_setup() -> Option<RustlsConfig> {
         std::process::exit(0);
     }
 
-    if args.generate_jwt_token != "" {
+    if !args.generate_jwt_token.is_empty() {
         let token_r = storjwt::generate_jwt_token(&args.generate_jwt_token);
         let token = match token_r {
             Ok(token) => token,
@@ -246,10 +246,7 @@ async fn ax_check_auth(headers: HeaderMap) -> (StatusCode, String) {
 // Guess content type based on filename (extension)
 fn heuristic_filetype(filename: String) -> String {
     let ext = filename.split(".").last();
-    let extension = match ext {
-        Some(ext) => ext,
-        None => "bin",
-    };
+    let extension = ext.unwrap_or("bin");
 
     match extension {
         "bin" => "application/octet-stream".to_string(),
@@ -296,7 +293,7 @@ fn verify_upload_permissions(owner: &str, path: &str) -> Result<(), String> {
         let user_prefixes_vec = user_prefixes.as_array().unwrap();
         for prefix_value in user_prefixes_vec {
             let prefix = prefix_value.as_str().unwrap();
-            if (path.starts_with(prefix) || prefix == "") && user_name == owner {
+            if (path.starts_with(prefix) || prefix.is_empty()) && user_name == owner {
                 return Ok(());
             }
         }
@@ -410,7 +407,7 @@ async fn ax_post_file(headers: HeaderMap, mut multipart: Multipart) -> (StatusCo
 
     // TBD
     let message = write_file_driver(full_path, file0, content_type.to_string());
-    if message != "" {
+    if !message.is_empty() {
         return (StatusCode::CONFLICT, Vec::new());
     }
     // write metadata file into cache directory
@@ -423,8 +420,8 @@ fn filename_from_fullpath(filepath: &str) -> String {
     let path = path::Path::new(filepath);
     let filename = path.file_name();
     match filename {
-        Some(filename) => return filename.to_str().unwrap().to_string(),
-        None => return filepath.to_string(),
+        Some(filename) => filename.to_str().unwrap().to_string(),
+        None => filepath.to_string(),
     }
 }
 
@@ -564,22 +561,22 @@ async fn ax_get_file(
                 "{:?} 404 0 {} {} {} {}",
                 remote_addr, human_time, method, filepath, user_agent_str
             );
-            return (StatusCode::NOT_FOUND, headers, Body::empty()).into_response();
+            (StatusCode::NOT_FOUND, headers, Body::empty()).into_response()
         }
-    };
+    }
 }
 
 fn driver_get_file(filepath: String) -> ReceivedFile {
     let driver_name = "azure";
     let driver = init_driver(driver_name);
-    return driver.get_file(filepath);
+    driver.get_file(filepath)
 }
 
 fn write_file_driver(filename: String, data: Vec<u8>, cont_type: String) -> String {
     let driver_name = "azure";
     let driver = init_driver(driver_name);
     driver.write_file(filename, data, cont_type);
-    return "".to_string();
+    "".to_string()
 }
 
 /// Parse range header
@@ -593,19 +590,16 @@ fn parse_range(range: &str) -> (u64, u64) {
     }
     let end = range_parts[1].parse::<u64>();
     match end {
-        Ok(end) => return (start, end),
-        Err(_) => return (start, 0),
+        Ok(end) => (start, end),
+        Err(_) => (start, 0),
     }
 }
 
 /// Verify the Authorization header
 /// Return error message + owner if the token is correct
 fn verify_auth_hdr(headers: &HeaderMap) -> Result<String, Option<String>> {
     let auth = headers.get("Authorization");
-    match auth {
-        None => return Err(None),
-        _ => (),
-    }
+    if auth == None { return Err(None) }
     let token = auth.unwrap().to_str().unwrap().split_whitespace();
     let token_parts: Vec<&str> = token.collect();
     if token_parts.len() != 2 {
@@ -632,9 +626,9 @@ fn verify_auth_hdr(headers: &HeaderMap) -> Result<String, Option<String>> {
         }
     };
     if let Some(email) = bmap.get("email") {
-        return Ok(email.to_string());
+        Ok(email.to_string())
     } else {
-        return Err(None);
+        Err(None)
     }
 }
 
@@ -644,5 +638,5 @@ async fn ax_list_files() -> (StatusCode, String) {
     let files = driver.list_files("/".to_string());
     // generate nice list of files, with one file per line
     let files_str = files.join("\n");
-    return (StatusCode::OK, files_str);
+    (StatusCode::OK, files_str)
 }

src/storcaching.rs

@@ -1,4 +1,3 @@
-use fs2;
 use std::fs;
 use std::time::SystemTime;
 use tokio::time::Duration;