Refactor error handling and response structures

- Changed several methods in `KodeBridgeError` to `const fn` for improved performance.
- Updated `Response` struct methods in `http_client.rs` to `const fn`.
- Modified `HttpResponse` and `StreamResponse` constructors to `const fn`.
- Enhanced IPC client and server code for better clarity and performance.
- Refactored connection pool methods to use `Arc::clone` for thread safety.
- Improved retry logic with `const fn` where applicable.
- Adjusted parser cache to use boxed slices for headers.
- General code cleanup and consistency improvements across multiple files.

Author: Tunglies

CHANGELOG.md

@@ -6,6 +6,23 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [0.3.5] - 2025-12-15
+
+### Fixed
+- Avoid large stack arrays in `ipc_http_server` by allocating HTTP header storage on the heap (fixes Clippy `large-stack-arrays`).
+- Replace `.clone()` on `Arc<T>` with `Arc::clone(&...)` across tests and examples to satisfy Clippy `clone_on_ref_ptr`.
+- Address explicit auto-deref and other small Clippy warnings in `ipc_http_server` and related modules.
+- Improve benches/examples error handling to address `unwrap_used`/`expect_used` lints; where appropriate, replace `unwrap()` with `expect()` and add targeted `#[allow(...)]` for benign bench/example code.
+- Minor example fixes (e.g., replace `vec!` with array in `examples/stream_server.rs`) and other cleanup.
+
+### Changed
+- Code hygiene and small refactors to satisfy clippy and improve robustness across tests, benches, and examples.
+
+### Internal
+- Updated examples and benches: `examples/stream_server.rs`, `examples/traffic_monitor.rs`, `examples/metrics_demo.rs`, `examples/concurrent_proxy_test.rs`, and `benches/bench_version.rs`.
+- Re-ran `cargo clippy` and iterated until the workspace was clean of the reported lints.
+
+
 ## [0.3.4] - 2025-10-11
 
 ### Changed

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "kode-bridge"
 authors = ["Tunglies"]
-version = "0.3.4"
+version = "0.3.5"
 edition = "2021"
 description = "Modern HTTP Over IPC library for Rust with both client and server support (Unix sockets, Windows named pipes)."
 license = "Apache-2.0"

Cargo.toml

@@ -25,8 +25,14 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use kode_bridge::http_client::Response;
 use kode_bridge::IpcHttpClient;
 
+#[allow(clippy::expect_used, clippy::unwrap_used)]
 async fn bench_version_once(client: &IpcHttpClient) -> Response {
-    client.get("/version").send().await.unwrap().into_inner()
+    client
+        .get("/version")
+        .send()
+        .await
+        .expect("Request failed")
+        .into_inner()
 }
 
 fn get_ipc_path() -> String {
@@ -48,8 +54,9 @@ fn get_ipc_path() -> String {
     }
 }
 
+#[allow(clippy::expect_used, clippy::unwrap_used)]
 fn bench_version(c: &mut Criterion) {
-    let rt = Runtime::new().unwrap();
+    let rt = Runtime::new().expect("Failed to create runtime");
     let ipc_path = get_ipc_path();
 
     let mut group = c.benchmark_group("ipc_http_version");
@@ -60,15 +67,15 @@ fn bench_version(c: &mut Criterion) {
 
     // Create client once for Unix, or per-iteration for Windows
     #[cfg(unix)]
-    let client = IpcHttpClient::new(&ipc_path).unwrap();
+    let client = IpcHttpClient::new(&ipc_path).expect("Failed to create IpcHttpClient");
 
     group.bench_function("version_once", |b| {
         b.iter(|| {
             rt.block_on(async {
                 // Create client for each iteration on Windows to avoid connection issues
                 #[cfg(windows)]
                 {
-                    let client = IpcHttpClient::new(&ipc_path).unwrap();
+                    let client = IpcHttpClient::new(&ipc_path).expect("Failed to create IpcHttpClient");
                     let _ = bench_version_once(&client).await;
                 }
 
@@ -81,7 +88,7 @@ fn bench_version(c: &mut Criterion) {
                 // Default behavior for other platforms
                 #[cfg(not(any(unix, windows)))]
                 {
-                    let client = IpcHttpClient::new(&ipc_path).unwrap();
+                    let client = IpcHttpClient::new(&ipc_path).expect("Failed to create IpcHttpClient");
                     let _ = bench_version_once(&client).await;
                 }
             });

benches/bench_version.rs

@@ -27,7 +27,7 @@ async fn concurrent_proxy_test(
 
     // 创建并发任务
     for (index, proxy_name) in proxies.iter().enumerate() {
-        let client = client.clone();
+        let client = Arc::clone(&client);
         let proxy_group = proxy_group.to_string();
         let proxy_name = proxy_name.to_string();
 
@@ -118,8 +118,8 @@ async fn concurrent_proxy_test(
     durations.sort();
 
     if !durations.is_empty() {
-        let min_duration = durations.first().unwrap();
-        let max_duration = durations.last().unwrap();
+        let min_duration = durations[0];
+        let max_duration = durations[durations.len() - 1];
         let median_duration = durations[durations.len() / 2];
 
         println!("   📊 Latency Analysis:");
@@ -264,7 +264,7 @@ async fn main() -> Result<()> {
 
                         // 执行并发测试
                         if let Err(e) =
-                            concurrent_proxy_test(client.clone(), group_name, proxy_names).await
+                            concurrent_proxy_test(Arc::clone(&client), group_name, proxy_names).await
                         {
                             println!("❌ Concurrent test failed: {}", e);
                         }

examples/concurrent_proxy_test.rs

@@ -260,7 +260,7 @@ async fn main() -> Result<()> {
 
 // Helper function to demonstrate server statistics
 #[allow(dead_code)]
-async fn print_server_stats() {
+fn print_server_stats() {
     // This would be called periodically to show server stats
     // For now, it's just a placeholder
     info!("Server statistics would be displayed here");

examples/http_server.rs

@@ -3,6 +3,7 @@ use kode_bridge::{
     MetricsSnapshot, ParserCacheStats,
 };
 use std::time::Duration;
+use std::sync::Arc;
 use tokio::time::sleep;
 
 #[tokio::main]
@@ -18,7 +19,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("✅ Metrics system initialized");
 
     // Create health checker
-    let health_checker = HealthChecker::new(metrics.clone());
+    let health_checker = HealthChecker::new(Arc::clone(&metrics));
     println!("✅ Health checker created");
 
     // Create a test configuration
@@ -84,12 +85,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Demonstrate buffer pool integration
     println!("\n💾 Buffer Pool Statistics:");
     println!("==========================");
-    demonstrate_buffer_pools().await;
+    demonstrate_buffer_pools();
 
     // Demonstrate parser cache
     println!("\n🧠 Parser Cache Statistics:");
     println!("===========================");
-    demonstrate_parser_cache().await;
+    demonstrate_parser_cache();
 
     println!("\n✨ Demo completed successfully!");
     println!("📝 In a real application, you would:");
@@ -198,7 +199,7 @@ fn print_health_report(report: &kode_bridge::HealthReport) {
     }
 }
 
-async fn demonstrate_buffer_pools() {
+fn demonstrate_buffer_pools() {
     use kode_bridge::buffer_pool::global_pools;
 
     let pools = global_pools();
@@ -225,7 +226,7 @@ async fn demonstrate_buffer_pools() {
     println!("Buffer efficiency: 75% reuse rate");
 }
 
-async fn demonstrate_parser_cache() {
+fn demonstrate_parser_cache() {
     use kode_bridge::parser_cache::global_parser_cache;
 
     let cache = global_parser_cache();

examples/metrics_demo.rs

@@ -3,8 +3,10 @@
 //! This example demonstrates how to create a streaming IPC server that
 //! broadcasts real-time data to multiple connected clients.
 
+#![allow(clippy::expect_used, clippy::useless_vec)]
+
 use kode_bridge::{IpcStreamServer, JsonDataSource, Result, StreamMessage, StreamServerConfig};
-use rand::Rng;
+use rand::Rng as _;
 use serde_json::json;
 use std::env;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
@@ -40,7 +42,7 @@ struct EventLog {
 fn generate_traffic_data() -> Result<serde_json::Value> {
     let timestamp = SystemTime::now()
         .duration_since(UNIX_EPOCH)
-        .unwrap()
+        .expect("SystemTime before UNIX_EPOCH")
         .as_secs();
 
     let mut rng = rand::rng();
@@ -57,7 +59,7 @@ fn generate_traffic_data() -> Result<serde_json::Value> {
 fn generate_system_metrics() -> Result<serde_json::Value> {
     let timestamp = SystemTime::now()
         .duration_since(UNIX_EPOCH)
-        .unwrap()
+        .expect("SystemTime before UNIX_EPOCH")
         .as_secs();
 
     let mut rng = rand::rng();
@@ -76,10 +78,10 @@ fn generate_system_metrics() -> Result<serde_json::Value> {
 fn generate_event_log() -> Result<serde_json::Value> {
     let timestamp = SystemTime::now()
         .duration_since(UNIX_EPOCH)
-        .unwrap()
+        .expect("SystemTime before UNIX_EPOCH")
         .as_secs();
 
-    let events = vec![
+    let events = [
         ("INFO", "User logged in successfully", "auth"),
         ("WARN", "High memory usage detected", "system"),
         ("ERROR", "Failed to connect to database", "database"),
@@ -270,17 +272,16 @@ async fn main() -> Result<()> {
 
 // Example of manual broadcasting (for demonstration)
 #[allow(dead_code)]
-async fn manual_broadcast_example() -> Result<()> {
+fn manual_broadcast_example() {
     // This shows how you might manually broadcast messages
     let _data = json!({
         "type": "notification",
         "message": "Manual broadcast message",
-        "timestamp": SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()
+        "timestamp": SystemTime::now().duration_since(UNIX_EPOCH).expect("SystemTime before UNIX_EPOCH").as_secs()
     });
 
     // server.broadcast(StreamMessage::Json(data))?;
     info!("Manual broadcast sent");
-    Ok(())
 }
 
 // Example of different message types

examples/stream_server.rs

@@ -37,7 +37,7 @@ pub struct TrafficMonitor(Arc<RwLock<CurrentTraffic>>);
 impl TrafficMonitor {
     pub fn new(client: IpcStreamClient) -> Self {
         let current = Arc::new(RwLock::new(CurrentTraffic::default()));
-        let monitor_current = current.clone();
+        let monitor_current = Arc::clone(&current);
 
         tokio::spawn(async move {
             let mut last: Option<TrafficData> = None;
@@ -58,7 +58,7 @@ impl TrafficMonitor {
                                 .unwrap_or((0, 0));
 
                             tokio::spawn({
-                                let current = monitor_current.clone();
+                                let current = Arc::clone(&monitor_current);
                                 async move {
                                     *current.write().await = CurrentTraffic {
                                         up_rate,
@@ -104,7 +104,7 @@ async fn main() -> Result<()> {
     dotenv().ok();
 
     let client =
-        IpcStreamClient::new(env::var("CUSTOM_SOCK").unwrap_or("/tmp/example.sock".into()))?;
+        IpcStreamClient::new(env::var("CUSTOM_SOCK").unwrap_or_else(|_| "/tmp/example.sock".into()))?;
 
     // Test connection
     if client

examples/traffic_monitor.rs

@@ -51,13 +51,18 @@ impl BufferPool {
 
     /// Pre-warm the pool with buffers
     pub fn warm_up(&self, count: usize) {
-        let mut buffers = self.buffers.lock();
-        let current_size = buffers.len();
-        let to_create = (count.saturating_sub(current_size)).min(self.max_pool_size - current_size);
+        let to_create = {
+            let mut buffers = self.buffers.lock();
+            let current_size = buffers.len();
+            let to_create =
+                (count.saturating_sub(current_size)).min(self.max_pool_size - current_size);
 
-        for _ in 0..to_create {
-            buffers.push_back(Vec::with_capacity(self.buffer_size));
-        }
+            for _ in 0..to_create {
+                buffers.push_back(Vec::with_capacity(self.buffer_size));
+            }
+
+            to_create
+        };
 
         debug!("Buffer pool warmed up with {} buffers", to_create);
     }
@@ -78,12 +83,12 @@ pub struct PooledBuffer {
 
 impl PooledBuffer {
     /// Get mutable reference to the underlying buffer
-    pub fn as_mut_vec(&mut self) -> &mut Vec<u8> {
+    pub const fn as_mut_vec(&mut self) -> &mut Vec<u8> {
         &mut self.buffer
     }
 
     /// Get reference to the underlying buffer
-    pub fn as_vec(&self) -> &Vec<u8> {
+    pub const fn as_vec(&self) -> &Vec<u8> {
         &self.buffer
     }
 
@@ -131,12 +136,20 @@ impl PooledBuffer {
 impl Drop for PooledBuffer {
     fn drop(&mut self) {
         if let Some(pool) = self.pool.upgrade() {
-            let mut buffers = pool.lock();
-            if buffers.len() < self.max_pool_size && self.buffer.capacity() >= 1024 {
-                // Only return buffer to pool if it's reasonably sized and pool has space
-                let mut returned_buffer = std::mem::take(&mut self.buffer);
-                returned_buffer.clear();
-                buffers.push_back(returned_buffer);
+            let returned = {
+                let mut buffers = pool.lock();
+                if buffers.len() < self.max_pool_size && self.buffer.capacity() >= 1024 {
+                    // Only return buffer to pool if it's reasonably sized and pool has space
+                    let mut returned_buffer = std::mem::take(&mut self.buffer);
+                    returned_buffer.clear();
+                    buffers.push_back(returned_buffer);
+                    true
+                } else {
+                    false
+                }
+            };
+
+            if returned {
                 debug!("Buffer returned to pool");
             }
         }