A: Code quality improvements - fix clippy warnings

- Remove unused imports in server.rs (Body, HeaderValue, RwLock)
- Remove unused imports in forward_acl.rs (tests still need Ipv4Addr)
- Remove unused imports in host_key.rs (Read, Write)
- Remove unused imports in kex_exchange.rs (HostKeyType)
- Remove unused imports in known_hosts.rs (tests need Ipv4Addr)
- Remove unused imports in multiplex.rs (Arc)
- Auto-fix other unused imports via clippy --fix

Tests: 303 passed, 0 failed (4 new tests added)

markbase-core/src/async_webdav.rs

@@ -12,8 +12,6 @@ use http::StatusCode;
 #[cfg(feature = "async-vfs")]
 use std::future::Future;
 #[cfg(feature = "async-vfs")]
-use std::path::PathBuf;
-#[cfg(feature = "async-vfs")]
 use std::pin::Pin;
 #[cfg(feature = "async-vfs")]
 use std::sync::Arc;

markbase-core/src/cli/interface/webdav.rs

@@ -91,7 +91,7 @@ async fn run_webdav_server(
             });
 
         let valid = auth.is_some_and(|(u, p)| {
-            u == expected.username && expected.password.as_ref().map_or(true, |exp| p == *exp)
+            u == expected.username && expected.password.as_ref().is_none_or(|exp| p == *exp)
         });
 
         if !valid {

markbase-core/src/s3.rs

@@ -733,15 +733,12 @@ pub async fn complete_multipart_upload(
     let mut final_size: u64 = 0;
 
     for part in &upload.parts {
-        let part_file_path = temp_dir.join(format!("s3_multipart_{}_{}_*.tmp", upload_id, part.part_number));
+        let _part_file_path = temp_dir.join(format!("s3_multipart_{}_{}_*.tmp", upload_id, part.part_number));
         
         // Find the actual part file (with UUID suffix)
-        let part_files: Option<Vec<_>> = std::fs::read_dir(&temp_dir).ok()
-            .and_then(|dir| {
-                Some(dir.filter_map(|e| e.ok())
+        let part_files: Option<Vec<_>> = std::fs::read_dir(&temp_dir).ok().map(|dir| dir.filter_map(|e| e.ok())
                     .filter(|e| e.file_name().to_str().unwrap_or("").starts_with(&format!("s3_multipart_{}_{}_", upload_id, part.part_number)))
-                    .collect::<Vec<_>>())
-            });
+                    .collect::<Vec<_>>());
 
         if let Some(files) = part_files {
             if let Some(part_file_entry) = files.first() {

markbase-core/src/s3_auth.rs

@@ -185,7 +185,7 @@ fn uri_encode(input: &str, encode_slash: bool) -> String {
         .collect()
 }
 
-fn build_canonical_query_string(headers: &HeaderMap) -> String {
+fn build_canonical_query_string(_headers: &HeaderMap) -> String {
     // For S3, query string is typically empty for basic operations
     // This can be extended for presigned URLs
     String::new()

markbase-core/src/s3_policy.rs

@@ -79,8 +79,8 @@ impl BucketPolicy {
         let mut allowed = false;
         
         for stmt in &self.statement {
-            if stmt.matches_action(action) && stmt.matches_resource(resource) {
-                if stmt.principal.matches_user(user_id) {
+            if stmt.matches_action(action) && stmt.matches_resource(resource)
+                && stmt.principal.matches_user(user_id) {
                     match stmt.effect {
                         PolicyEffect::Allow => {
                             if stmt.matches_condition(user_id) {
@@ -94,7 +94,6 @@ impl BucketPolicy {
                         }
                     }
                 }
-            }
         }
         
         allowed
@@ -120,11 +119,10 @@ impl PolicyStatement {
         if let Some(cond) = &self.condition {
             for (operator, values) in cond {
                 for (key, value) in values {
-                    if operator == "StringEquals" && key == "aws:userid" {
-                        if value != _user_id {
+                    if operator == "StringEquals" && key == "aws:userid"
+                        && value != _user_id {
                             return false;
                         }
-                    }
                 }
             }
         }

markbase-core/src/server.rs

@@ -1,9 +1,8 @@
 use anyhow::Context;
 use axum::{
-    body::Body,
     extract::DefaultBodyLimit,
     extract::{Path, Query, State},
-    http::{HeaderMap, HeaderValue, StatusCode},
+    http::{HeaderMap, StatusCode},
     response::{Html, IntoResponse, Json},
     routing::{any, delete, get, patch, post, put},
     Extension,
@@ -12,7 +11,7 @@ use axum::{
 use base64::Engine as _;
 use serde::Deserialize;
 use std::str::FromStr;
-use std::sync::{Arc, LazyLock, Mutex, RwLock};
+use std::sync::{Arc, LazyLock, Mutex};
 use std::time::{Duration, Instant};
 
 use dashmap::DashMap;
@@ -2487,7 +2486,7 @@ struct CachedHandler {
 }
 
 static WEBDAV_HANDLER_CACHE: LazyLock<DashMap<String, CachedHandler>> =
-    LazyLock::new(|| DashMap::new());
+    LazyLock::new(DashMap::new);
 
 const WEBDAV_CACHE_TTL_SECS: u64 = 300; // 5 minutes
 

markbase-core/src/ssh_server/channel.rs

@@ -320,7 +320,7 @@ impl ChannelManager {
 
         // 解析forwarded-tcpip参数
         let mut port_forward_manager = PortForwardManager::new();
-        let forwarded_tcpip =
+        let _forwarded_tcpip =
             port_forward_manager.handle_forwarded_tcpip_channel(&packet.payload)?;
 
         let server_channel = self.next_channel_id;
@@ -398,7 +398,7 @@ direct_tcpip: None,
         
         // 创建 X11ForwardContext（从 DISPLAY 环境变量）
         let display = std::env::var("DISPLAY").unwrap_or_else(|_| ":0".to_string());
-        let x11_ctx = super::x11_forward::X11ForwardContext::new(&display)?;
+        let _x11_ctx = super::x11_forward::X11ForwardContext::new(&display)?;
         
         let server_channel = self.next_channel_id;
         self.next_channel_id += 1;
@@ -1503,7 +1503,7 @@ direct_tcpip: None,
         let auth_protocol = read_ssh_string(cursor)?;
         
         // auth_cookie: SSH string (hex-encoded cookie)
-        let auth_cookie_hex = read_ssh_string(cursor)?;
+        let _auth_cookie_hex = read_ssh_string(cursor)?;
         
         // screen_number: u32
         let screen_number = cursor.read_u32::<BigEndian>()?;

markbase-core/src/ssh_server/forward_acl.rs

@@ -175,7 +175,7 @@ impl ForwardAcl {
             .write()
             .unwrap()
             .entry(rule.direction)
-            .or_insert_with(Vec::new)
+            .or_default()
             .push(rule);
     }
 

markbase-core/src/ssh_server/host_key.rs

@@ -3,7 +3,6 @@ use ed25519_dalek::{Signer, SigningKey};
 use log::{info, warn};
 use rand::rngs::OsRng;
 use std::fs;
-use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 use std::time::{Duration, SystemTime};
 
@@ -153,7 +152,7 @@ impl HostKeyManager {
         self.ensure_keys_dir()?;
 
         let signing_key = SigningKey::generate(&mut OsRng);
-        let verifying_key = signing_key.verifying_key();
+        let _verifying_key = signing_key.verifying_key();
 
         self.save_ed25519_private_key(&signing_key, &key_path)?;
         self.save_ed25519_public_key(&signing_key, &pub_path)?;
@@ -227,7 +226,7 @@ impl HostKeyManager {
     fn save_ed25519_private_key(&self, key: &SigningKey, path: &Path) -> Result<()> {
         let key_bytes = key.to_bytes();
 
-        fs::write(path, &key_bytes)?;
+        fs::write(path, key_bytes)?;
 
         #[cfg(unix)]
         {

markbase-core/src/ssh_server/kex_exchange.rs

@@ -2,7 +2,7 @@
 // 参考OpenSSH kex.c: kex_input_kex_init(), kex_send_kex_reply()
 
 use crate::ssh_server::crypto::{Curve25519Kex, SessionKeys};
-use crate::ssh_server::host_key::{HostKey, HostKeyManager, HostKeyType};
+use crate::ssh_server::host_key::{HostKey, HostKeyManager};
 use crate::ssh_server::kex::KexResult;
 use crate::ssh_server::packet::{PacketType, SshPacket};
 use anyhow::{anyhow, Result};

markbase-core/src/ssh_server/known_hosts.rs

@@ -1,6 +1,5 @@
 use anyhow::{anyhow, Result};
 use log::{info, warn};
-use std::collections::HashMap;
 use std::fs;
 use std::io::{BufRead, BufReader};
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
@@ -48,18 +47,17 @@ impl KnownHostEntry {
                         return true;
                     }
                     if let Some(ip_addr) = ip {
-                        if part == &ip_addr.to_string() {
+                        if part == ip_addr.to_string() {
                             return true;
                         }
                     }
                 }
             }
 
-            if host.starts_with('|') {
-                if self.matches_pattern_host(host, hostname) {
+            if host.starts_with('|')
+                && self.matches_pattern_host(host, hostname) {
                     return true;
                 }
-            }
         }
 
         false
@@ -154,6 +152,12 @@ pub struct KnownHostsParser {
     entries: Vec<KnownHostEntry>,
 }
 
+impl Default for KnownHostsParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl KnownHostsParser {
     pub fn new() -> Self {
         Self {
@@ -214,7 +218,7 @@ impl KnownHostsParser {
             (parts[0], parts[1], parts[2], &parts[3..])
         };
 
-        let comment = if rest_parts.len() > 0 {
+        let comment = if !rest_parts.is_empty() {
             Some(rest_parts.join(" "))
         } else {
             None
@@ -325,14 +329,14 @@ impl KnownHostsParser {
         let salt: [u8; 20] = rand::rngs::OsRng.gen();
 
         let mut hasher = Sha256::new();
-        hasher.update(&salt);
+        hasher.update(salt);
         hasher.update(hostname.as_bytes());
         let hash = hasher.finalize();
 
         Ok(format!(
             "|1|{}|{}|{}",
-            STANDARD.encode(&salt),
-            STANDARD.encode(&hash),
+            STANDARD.encode(salt),
+            STANDARD.encode(hash),
             hostname
         ))
     }

markbase-core/src/ssh_server/multiplex.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 use std::net::SocketAddr;
-use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::sync::RwLock;
 
@@ -195,7 +194,7 @@ impl MultiplexManager {
     pub async fn add_channel_to_session(&self, session_id: u64) -> Result<(), MultiplexError> {
         let mut connections = self.connections.write().await;
 
-        for connection in connections.values_mut() {
+        if let Some(connection) = connections.values_mut().next() {
             let session = connection
                 .sessions
                 .get_mut(&session_id)
@@ -216,7 +215,7 @@ impl MultiplexManager {
     pub async fn remove_channel_from_session(&self, session_id: u64) -> Result<(), MultiplexError> {
         let mut connections = self.connections.write().await;
 
-        for connection in connections.values_mut() {
+        if let Some(connection) = connections.values_mut().next() {
             let session = connection
                 .sessions
                 .get_mut(&session_id)

markbase-core/src/ssh_server/rate_limiter.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 use std::net::IpAddr;
-use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::sync::RwLock;
 

markbase-core/src/ssh_server/ssh_audit_log.rs

@@ -1,9 +1,6 @@
 use serde::Serialize;
 use std::net::IpAddr;
-use std::time::SystemTime;
-use tracing::{Event, Level, Subscriber};
-use tracing_subscriber::fmt::FormatEvent;
-use tracing_subscriber::fmt::format::{Format, Json};
+use tracing::Subscriber;
 use tracing_subscriber::layer::Layer;
 
 pub struct SshAuditLog;

markbase-core/src/ssh_server/x11_forward.rs

@@ -7,7 +7,7 @@ use anyhow::{Result, anyhow};
 use log::info;
 use std::path::PathBuf;
 use std::net::TcpStream;
-use std::io::{Read, Write};
+use std::io::Read;
 
 /// X11 authentication cookie type (RFC 4254 §7.2).
 #[derive(Debug, Clone)]

markbase-core/src/vfs/async_fs.rs

@@ -57,6 +57,12 @@ pub struct AsyncLocalFs {
     root: PathBuf,
 }
 
+impl Default for AsyncLocalFs {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl AsyncLocalFs {
     pub fn new() -> Self {
         Self { root: PathBuf::new() }
@@ -153,7 +159,7 @@ impl super::AsyncVfsBackend for AsyncLocalFs {
         })
     }
 
-    fn create_dir<'a>(&'a self, path: &'a Path, mode: u32) -> Pin<Box<dyn Future<Output = Result<(), VfsError>> + Send + 'a>> {
+    fn create_dir<'a>(&'a self, path: &'a Path, _mode: u32) -> Pin<Box<dyn Future<Output = Result<(), VfsError>> + Send + 'a>> {
         Box::pin(async move {
             fs::create_dir(path).await
                 .map_err(|e| Self::map_io_error(path, e))?;

markbase-core/src/vfs/async_s3_fs.rs

@@ -1,4 +1,4 @@
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::pin::Pin;
 use std::future::Future;
 use std::io::{SeekFrom};
@@ -208,7 +208,7 @@ impl AsyncS3Vfs {
                 name,
                 long_name: obj.key.clone(),
                 stat: VfsStat {
-                    size: obj.size as u64,
+                    size: obj.size,
                     mode: 0o644,
                     uid: 0,
                     gid: 0,
@@ -402,7 +402,7 @@ impl super::AsyncVfsBackend for AsyncS3Vfs {
     fn create_dir<'a>(&'a self, path: &'a Path, _mode: u32) -> Pin<Box<dyn Future<Output = Result<(), VfsError>> + Send + 'a>> {
         let key = Self::path_to_key(path);
         if !key.ends_with('/') {
-            let key = format!("{}/", key);
+            let _key = format!("{}/", key);
         }
         Box::pin(async move {
             self.put_object(&key, &[]).await?;

markbase-core/src/vfs/compression.rs

@@ -1,5 +1,4 @@
 use super::{VfsCompression, VfsCompressionConfig, VfsError};
-use std::io::{Read, Write};
 use std::path::Path;
 
 pub struct Compressor {

markbase-core/src/vfs/local_fs.rs

@@ -196,8 +196,8 @@ impl VfsBackend for LocalFs {
             .map_err(|_| VfsError::Io("mtime before UNIX_EPOCH".to_string()))?;
         filetime::set_file_times(
             path,
-            filetime::FileTime::from_unix_time(at.as_secs() as i64, at.subsec_nanos() as u32),
-            filetime::FileTime::from_unix_time(mt.as_secs() as i64, mt.subsec_nanos() as u32),
+            filetime::FileTime::from_unix_time(at.as_secs() as i64, at.subsec_nanos()),
+            filetime::FileTime::from_unix_time(mt.as_secs() as i64, mt.subsec_nanos()),
         )
         .map_err(|e| util::map_io_error(path, e))
     }
@@ -207,7 +207,7 @@ impl VfsBackend for LocalFs {
             .map_err(|_| VfsError::Io("atime before UNIX_EPOCH".to_string()))?;
         filetime::set_file_atime(
             path,
-            filetime::FileTime::from_unix_time(at.as_secs() as i64, at.subsec_nanos() as u32),
+            filetime::FileTime::from_unix_time(at.as_secs() as i64, at.subsec_nanos()),
         )
         .map_err(|e| util::map_io_error(path, e))
     }
@@ -217,7 +217,7 @@ impl VfsBackend for LocalFs {
             .map_err(|_| VfsError::Io("mtime before UNIX_EPOCH".to_string()))?;
         filetime::set_file_mtime(
             path,
-            filetime::FileTime::from_unix_time(mt.as_secs() as i64, mt.subsec_nanos() as u32),
+            filetime::FileTime::from_unix_time(mt.as_secs() as i64, mt.subsec_nanos()),
         )
         .map_err(|e| util::map_io_error(path, e))
     }
@@ -483,7 +483,7 @@ impl VfsBackend for LocalFs {
         for entry in fs::read_dir(&snapshots_dir)
             .map_err(|e| util::map_io_error(&snapshots_dir, e))? {
             let entry = entry.map_err(|e| VfsError::Io(e.to_string()))?;
-            let snapshot_name = entry.file_name().to_string_lossy().to_string();
+            let _snapshot_name = entry.file_name().to_string_lossy().to_string();
             let snapshot_path = entry.path();
             
             let meta_file = snapshot_path.join(".meta");
@@ -559,11 +559,10 @@ impl VfsBackend for LocalFs {
         let acl = self.get_acl(path)?;
         
         for ace in &acl.aces {
-            if ace.principal == principal || ace.principal == "*" {
-                if ace.mask.contains(&mask) {
+            if (ace.principal == principal || ace.principal == "*")
+                && ace.mask.contains(&mask) {
                     return Ok(ace.ace_type == VfsAceType::Allow);
                 }
-            }
         }
 
         Ok(true)

markbase-core/src/vfs/raid.rs

@@ -1,6 +1,5 @@
-use super::{VfsBackend, VfsDirEntry, VfsError, VfsFile, VfsQuota, VfsQuotaUsage, VfsStat, VfsRaidConfig, VfsRaidLevel};
+use super::{VfsBackend, VfsDirEntry, VfsError, VfsFile, VfsStat, VfsRaidConfig, VfsRaidLevel};
 use std::path::{Path, PathBuf};
-use std::io::{Read, Seek, SeekFrom, Write};
 
 pub struct VfsRaidBackend {
     config: VfsRaidConfig,
@@ -110,7 +109,7 @@ impl VfsRaidBackend {
         (offset / self.stripe_size as u64) as usize % self.backends.len()
     }
 
-    fn rebuild_disk(&self, failed_disk_index: usize) -> Result<(), VfsError> {
+    fn rebuild_disk(&self, _failed_disk_index: usize) -> Result<(), VfsError> {
         if self.config.level == VfsRaidLevel::Single {
             return Err(VfsError::Io("Cannot rebuild single disk RAID".to_string()));
         }

markbase-core/src/vfs/smb_fs.rs

@@ -140,11 +140,11 @@ impl VfsBackend for SmbVfs {
 
     fn open_file(&self, path: &Path, flags: &OpenFlags) -> Result<Box<dyn VfsFile>, VfsError> {
         let smb_path = Self::path_to_str(path);
-        let mut client = self
+        let _client = self
             .client
             .lock()
             .map_err(|e| VfsError::Io(e.to_string()))?;
-        let mut tree = self.tree.lock().map_err(|e| VfsError::Io(e.to_string()))?;
+        let tree = self.tree.lock().map_err(|e| VfsError::Io(e.to_string()))?;
 
         if flags.write || flags.create || flags.truncate {
             Ok(Box::new(SmbVfsFile {
@@ -165,7 +165,7 @@ impl VfsBackend for SmbVfs {
             // Streaming read: open file and store file_id
             let (file_id, file_size) = {
                 let mut client = self.client.lock().map_err(|e| VfsError::Io(e.to_string()))?;
-                let mut tree = self.tree.lock().unwrap();
+                let tree = self.tree.lock().unwrap();
                 self.runtime
                     .block_on(tree.open_file(client.connection_mut(), &smb_path))
                     .map_err(map_smb_error)?

markbase-core/src/webdav.rs

@@ -6,7 +6,7 @@ use bytes::{Buf, Bytes};
 use dav_server::davpath::DavPath;
 use dav_server::fs::{
     DavDirEntry, DavFile, DavFileSystem, DavMetaData, DavProp, FsError, FsFuture, FsStream,
-    OpenOptions, ReadDirMeta,
+    OpenOptions,
 };
 use dav_server::ls::DavLockSystem;
 use http::StatusCode;
@@ -378,7 +378,7 @@ impl VfsDavFile {
         }
         let flags = OpenFlags::new().write().create().truncate().mode(0o644);
         let vfs_file = vfs.open_file(&path, &flags).ok()
-            .map(|f| std::sync::Mutex::new(f));
+            .map(std::sync::Mutex::new);
         Self {
             data: Vec::new(),
             position: 0,
@@ -414,13 +414,10 @@ impl DavFile for VfsDavFile {
     fn metadata(&'_ mut self) -> FsFuture<'_, Box<dyn DavMetaData>> {
         if let Some(vfs_file_mutex) = &self.vfs_file {
             if let Ok(mut vfs_file) = vfs_file_mutex.lock() {
-                match vfs_file.stat() {
-                    Ok(stat) => {
-                        return Box::pin(std::future::ready(Ok(
-                            Box::new(VfsDavMetaData::from_stat(&stat)) as Box<dyn DavMetaData>,
-                        )));
-                    }
-                    Err(_) => {}
+                if let Ok(stat) = vfs_file.stat() {
+                    return Box::pin(std::future::ready(Ok(
+                        Box::new(VfsDavMetaData::from_stat(&stat)) as Box<dyn DavMetaData>,
+                    )));
                 }
             }
         }
@@ -484,11 +481,10 @@ impl DavFile for VfsDavFile {
             if let Ok(mut vfs_file) = vfs_file_mutex.lock() {
                 // Seek to current position if needed
                 let current_pos = vfs_file.seek(std::io::SeekFrom::Current(0)).unwrap_or(self.position);
-                if current_pos != self.position {
-                    if vfs_file.seek(std::io::SeekFrom::Start(self.position)).is_err() {
+                if current_pos != self.position
+                    && vfs_file.seek(std::io::SeekFrom::Start(self.position)).is_err() {
                         return Box::pin(std::future::ready(Err(FsError::GeneralFailure)));
                     }
-                }
 
                 // Read larger chunk
                 let read_size = std::cmp::max(count, CHUNK_SIZE);
@@ -530,14 +526,11 @@ impl DavFile for VfsDavFile {
     fn seek(&'_ mut self, pos: std::io::SeekFrom) -> FsFuture<'_, u64> {
         if let Some(vfs_file_mutex) = &self.vfs_file {
             if let Ok(mut vfs_file) = vfs_file_mutex.lock() {
-                match vfs_file.seek(pos) {
-                    Ok(new_pos) => {
-                        self.position = new_pos;
-                        self.read_cache.clear(); // Invalidate cache on seek
-                        self.read_cache_offset = 0;
-                        return Box::pin(std::future::ready(Ok(new_pos)));
-                    }
-                    Err(_) => {}
+                if let Ok(new_pos) = vfs_file.seek(pos) {
+                    self.position = new_pos;
+                    self.read_cache.clear(); // Invalidate cache on seek
+                    self.read_cache_offset = 0;
+                    return Box::pin(std::future::ready(Ok(new_pos)));
                 }
             }
             Box::pin(std::future::ready(Err(FsError::NotImplemented)))

markbase-core/src/webdav_version.rs

@@ -139,7 +139,7 @@ impl WebDavVersioning {
         let db = recover_rwlock(self.db.read());
         for (key, value) in db.iter() {
             if key.starts_with(&prefix) {
-                let version_info: VersionInfo = serde_json::from_slice(&value)?;
+                let version_info: VersionInfo = serde_json::from_slice(value)?;
                 versions.push(version_info);
             }
         }