Merge pull request #138 from wa5i/main

refactor: optimize code, remove Core's RwLock, and add entry structure RustyVault

Author: wa5i

Cargo.toml

@@ -79,6 +79,7 @@ priority-queue = "2.1"
 crossbeam-channel = "0.5"
 maybe-async = { version = "0.2", optional = false }
 lockfile = "0.4.0"
+arc-swap = "1"
 
 # optional dependencies
 openssl = { version = "*", optional = true }

build.rs

@@ -67,7 +67,7 @@ fn main() {
                 if let Some(bin_entry_table) = bin_entry.as_table() {
                     if let Some(name_value) = bin_entry_table.get("name") {
                         if let Some(name_str) = name_value.as_str() {
-                            println!("cargo:rustc-env=CARGO_BIN_NAME={}", name_str);
+                            println!("cargo:rustc-env=CARGO_BIN_NAME={name_str}");
                         }
                     }
                 }

src/api/auth_token.rs

@@ -59,7 +59,7 @@ impl TokenAuth<'_> {
 
     pub fn create_with_role(&self, input: &TokenInput, role_name: &str) -> Result<HttpResponse, RvError> {
         let data = serde_json::to_value(input)?;
-        self.request_write(format!("/v1/auth/token/create/{}", role_name), data.as_object().cloned())
+        self.request_write(format!("/v1/auth/token/create/{role_name}"), data.as_object().cloned())
     }
 
     pub fn lookup(&self, token: &str) -> Result<HttpResponse, RvError> {

src/api/client.rs

@@ -168,7 +168,7 @@ impl Client {
         } else {
             format!("{}/{}", self.address, path)
         };
-        log::debug!("request url: {}, method: {}", url, method);
+        log::debug!("request url: {url}, method: {method}");
 
         let mut req = self.http_client.request(&method.to_uppercase(), &url);
 
@@ -199,7 +199,7 @@ impl Client {
                 Ok(ret.clone())
             }
             Err(e) => {
-                log::error!("Request failed: {}", e);
+                log::error!("Request failed: {e}");
                 Err(RvError::UreqError { source: e })
             }
         }

src/api/logical.rs

@@ -18,15 +18,15 @@ impl Client {
 
 impl Logical<'_> {
     pub fn read(&self, path: &str) -> Result<HttpResponse, RvError> {
-        self.request_read(format!("/v1/{}", path))
+        self.request_read(format!("/v1/{path}"))
     }
 
     pub fn write(&self, path: &str, data: Option<Map<String, Value>>) -> Result<HttpResponse, RvError> {
-        self.request_write(format!("/v1/{}", path), data)
+        self.request_write(format!("/v1/{path}"), data)
     }
 
     pub fn list(&self, path: &str) -> Result<HttpResponse, RvError> {
-        let mut ret = self.request_list(format!("/v1/{}", path))?;
+        let mut ret = self.request_list(format!("/v1/{path}"))?;
         if ret.response_status != 200 || ret.response_data.is_none() {
             return Ok(ret);
         }
@@ -38,6 +38,6 @@ impl Logical<'_> {
     }
 
     pub fn delete(&self, path: &str, data: Option<Map<String, Value>>) -> Result<HttpResponse, RvError> {
-        self.request_delete(format!("/v1/{}", path), data)
+        self.request_delete(format!("/v1/{path}"), data)
     }
 }

src/api/mod.rs

@@ -28,7 +28,7 @@ impl HttpResponse {
         }
 
         if let Some(response_data) = &self.response_data {
-            println!("{:?}", response_data);
+            println!("{response_data:?}");
         }
     }
 }

src/api/sys.rs

@@ -111,20 +111,20 @@ impl Sys<'_> {
 
     pub fn enable_auth(&self, path: &str, input: &AuthInput) -> Result<HttpResponse, RvError> {
         let data = serde_json::to_value(input)?;
-        self.request_write(format!("/v1/sys/auth/{}", path), data.as_object().cloned())
+        self.request_write(format!("/v1/sys/auth/{path}"), data.as_object().cloned())
     }
 
     pub fn disable_auth(&self, path: &str) -> Result<HttpResponse, RvError> {
-        self.request_delete(format!("/v1/sys/auth/{}", path), None)
+        self.request_delete(format!("/v1/sys/auth/{path}"), None)
     }
 
     pub fn mount(&self, path: &str, input: &MountInput) -> Result<HttpResponse, RvError> {
         let data = serde_json::to_value(input)?;
-        self.request_write(format!("/v1/sys/mounts/{}", path), data.as_object().cloned())
+        self.request_write(format!("/v1/sys/mounts/{path}"), data.as_object().cloned())
     }
 
     pub fn unmount(&self, path: &str) -> Result<HttpResponse, RvError> {
-        self.request_delete(format!("/v1/sys/mounts/{}", path), None)
+        self.request_delete(format!("/v1/sys/mounts/{path}"), None)
     }
 
     pub fn remount(&self, from: &str, to: &str) -> Result<HttpResponse, RvError> {
@@ -145,18 +145,18 @@ impl Sys<'_> {
     }
 
     pub fn read_policy(&self, name: &str) -> Result<HttpResponse, RvError> {
-        self.request_read(format!("/v1/sys/policies/acl/{}", name))
+        self.request_read(format!("/v1/sys/policies/acl/{name}"))
     }
 
     pub fn write_policy(&self, name: &str, policy: &str) -> Result<HttpResponse, RvError> {
         let data = json!({
             "policy": policy,
         });
 
-        self.request_write(format!("/v1/sys/policies/acl/{}", name), data.as_object().cloned())
+        self.request_write(format!("/v1/sys/policies/acl/{name}"), data.as_object().cloned())
     }
 
     pub fn delete_policy(&self, name: &str) -> Result<HttpResponse, RvError> {
-        self.request_delete(format!("/v1/sys/policies/acl/{}", name), None)
+        self.request_delete(format!("/v1/sys/policies/acl/{name}"), None)
     }
 }

src/cli/command/auth_disable.rs

@@ -48,11 +48,11 @@ impl CommandExecutor for Disable {
         match sys.disable_auth(&path) {
             Ok(ret) => match ret.response_status {
                 200 | 204 | 404 => {
-                    println!("Success! Disabled the auth method (if it existed) at: {}", path);
+                    println!("Success! Disabled the auth method (if it existed) at: {path}");
                 }
                 _ => ret.print_debug_info(),
             },
-            Err(e) => eprintln!("Error disabling auth method at {}: {}", path, e),
+            Err(e) => eprintln!("Error disabling auth method at {path}: {e}"),
         }
         Ok(())
     }

src/cli/command/auth_enable.rs

@@ -92,7 +92,7 @@ impl CommandExecutor for Enable {
                 }
                 _ => ret.print_debug_info(),
             },
-            Err(e) => eprintln!("Error: {}", e),
+            Err(e) => eprintln!("Error: {e}"),
         }
         Ok(())
     }

src/cli/command/auth_help.rs

@@ -53,15 +53,15 @@ impl CommandExecutor for Help {
             let path = util::ensure_trailing_slash(&util::sanitize_path(&self.auth_type));
             let auth_list: crate::api::HttpResponse = sys.list_auth()?;
             if auth_list.response_status != 200 || auth_list.response_data.is_none() {
-                println!("Error listing auth methods at: {}", path);
+                println!("Error listing auth methods at: {path}");
                 std::process::exit(2);
             }
 
             let auth_list_value = auth_list.response_data.unwrap();
             let auth_list_map = auth_list_value.as_object().unwrap();
             let auth = auth_list_map.get(&path);
             if auth.is_none() {
-                println!("No auth method available on the server at: {}", path);
+                println!("No auth method available on the server at: {path}");
                 std::process::exit(1);
             }