itsi-scheduler 0.2.15 → 0.2.17

data/ext/itsi_server/src/services/rate_limiter.rs

@@ -1,4 +1,5 @@
 use async_trait::async_trait;
+use parking_lot::{Mutex, RwLock};
 use rand::Rng;
 use redis::aio::ConnectionManager;
 use redis::{Client, RedisError, Script};
@@ -6,9 +7,9 @@ use serde::Deserialize;
 use std::any::Any;
 use std::collections::{HashMap, HashSet};
 use std::result::Result;
-use std::sync::{Arc, LazyLock, Mutex};
+use std::sync::{Arc, LazyLock};
 use std::time::{Duration, Instant};
-use tokio::sync::{Mutex as AsyncMutex, RwLock};
+use tokio::sync::Mutex as AsyncMutex;
 use tokio::time::timeout;
 use tracing::warn;
 use url::Url;
@@ -242,10 +243,10 @@ impl InMemoryRateLimiter {
     /// Cleans up expired entries
     async fn cleanup(&self) {
         // Try to get the write lock, but fail open if we can't
-        if let Ok(mut entries) = self.entries.try_write() {
-            let now = Instant::now();
-            entries.retain(|_, entry| entry.expires_at > now);
-        }
+        let now = Instant::now();
+        self.entries
+            .write()
+            .retain(|_, entry| entry.expires_at > now);
     }
 
     /// Bans an IP address for the specified duration
@@ -258,12 +259,7 @@ impl InMemoryRateLimiter {
         let now = Instant::now();
         let ban_key = format!("ban:ip:{}", ip);
 
-        let mut entries = self.entries.try_write().map_err(|e| {
-            tracing::error!("Failed to acquire write lock: {}", e);
-            RateLimitError::LockError
-        })?;
-
-        entries.insert(
+        self.entries.write().insert(
             ban_key,
             RateLimitEntry {
                 count: 1, // Use count=1 to indicate banned
@@ -279,12 +275,7 @@ impl InMemoryRateLimiter {
         let now = Instant::now();
         let ban_key = format!("ban:ip:{}", ip);
 
-        let entries = self.entries.try_read().map_err(|e| {
-            tracing::error!("Failed to acquire read lock: {}", e);
-            RateLimitError::LockError
-        })?;
-
-        if let Some(entry) = entries.get(&ban_key) {
+        if let Some(entry) = self.entries.read().get(&ban_key) {
             if entry.expires_at > now {
                 // IP is banned, return a generic reason since we don't store reasons
                 return Ok(Some("IP address banned".to_string()));
@@ -310,7 +301,7 @@ impl RateLimiter for InMemoryRateLimiter {
 
         let now = Instant::now();
 
-        let mut entries = self.entries.write().await;
+        let mut entries = self.entries.write();
 
         let entry = entries
             .entry(key.to_string())
@@ -436,7 +427,7 @@ impl RateLimiterStore {
     ) -> Result<Arc<RedisRateLimiter>, RateLimitError> {
         // First check if this URL is known to fail
         {
-            let failed_urls = self.failed_urls.lock().unwrap_or_else(|e| e.into_inner());
+            let failed_urls = self.failed_urls.lock();
             if failed_urls.contains(connection_url) {
                 return Err(RateLimitError::ConnectionTimeout);
             }
@@ -444,10 +435,7 @@ impl RateLimiterStore {
 
         // Then check if we already have a limiter for this URL
         {
-            let limiters = self
-                .redis_limiters
-                .lock()
-                .unwrap_or_else(|e| e.into_inner());
+            let limiters = self.redis_limiters.lock();
             if let Some(limiter) = limiters.get(connection_url) {
                 return Ok(limiter.clone());
             }
@@ -455,7 +443,7 @@ impl RateLimiterStore {
 
         // Get a dedicated mutex for this URL or create a new one if it doesn't exist
         let url_mutex = {
-            let mut locks = CONNECTION_LOCKS.lock().unwrap_or_else(|e| e.into_inner());
+            let mut locks = CONNECTION_LOCKS.lock();
 
             // Get or create the mutex for this URL
             locks
@@ -476,10 +464,7 @@ impl RateLimiterStore {
 
         // Check again if another thread created the limiter while we were waiting
         {
-            let limiters = self
-                .redis_limiters
-                .lock()
-                .unwrap_or_else(|e| e.into_inner());
+            let limiters = self.redis_limiters.lock();
             if let Some(limiter) = limiters.get(connection_url) {
                 return Ok(limiter.clone());
             }
@@ -492,10 +477,7 @@ impl RateLimiterStore {
                 let limiter = Arc::new(limiter);
 
                 // Store it for future use
-                let mut limiters = self
-                    .redis_limiters
-                    .lock()
-                    .unwrap_or_else(|e| e.into_inner());
+                let mut limiters = self.redis_limiters.lock();
                 limiters.insert(connection_url.to_string(), limiter.clone());
 
                 Ok(limiter)
@@ -503,7 +485,7 @@ impl RateLimiterStore {
             Err(e) => {
                 tracing::error!("Failed to initialize Redis rate limiter: {}", e);
                 // Cache the failure
-                let mut failed_urls = self.failed_urls.lock().unwrap_or_else(|e| e.into_inner());
+                let mut failed_urls = self.failed_urls.lock();
                 failed_urls.insert(connection_url.to_string());
                 Err(e)
             }

data/ext/itsi_server/src/services/static_file_server.rs

@@ -2,7 +2,7 @@ use crate::{
     default_responses::NOT_FOUND_RESPONSE,
     prelude::*,
     server::{
-        http_message_types::{HttpRequest, HttpResponse, RequestExt, ResponseFormat},
+        http_message_types::{HttpBody, HttpRequest, HttpResponse, RequestExt, ResponseFormat},
         middleware_stack::ErrorResponse,
         redirect_type::RedirectType,
     },
@@ -16,10 +16,9 @@ use http::{
     },
     HeaderName, HeaderValue, Response, StatusCode,
 };
-use http_body_util::{combinators::BoxBody, Full};
 use itsi_error::Result;
 use parking_lot::{Mutex, RwLock};
-use percent_encoding::{percent_decode_str, utf8_percent_encode, NON_ALPHANUMERIC};
+use percent_encoding::percent_decode_str;
 use quick_cache::sync::Cache;
 use serde::Deserialize;
 use serde_json::json;
@@ -28,7 +27,6 @@ use std::{
     borrow::Cow,
     cmp::Ordering,
     collections::HashMap,
-    convert::Infallible,
     fs::Metadata,
     ops::Deref,
     path::{Path, PathBuf},
@@ -175,7 +173,7 @@ impl CacheEntry {
             let mut hasher = Sha256::new();
             hasher.update(&bytes);
             let result = hasher.finalize();
-            general_purpose::STANDARD.encode(result)
+            general_purpose::STANDARD.encode(&result[..16])
         };
         let headers_ct = get_mime_type(&path);
         let headers_etag = format!(r#"W/"{etag}""#).parse().unwrap();
@@ -279,7 +277,7 @@ impl StaticFileServer {
         supported_encodings: &[HeaderValue],
     ) -> Option<HttpResponse> {
         let accept: ResponseFormat = request.accept().into();
-        let resolved = self.resolve(path, abs_path, accept.clone()).await;
+        let resolved = self.resolve(path, abs_path, accept).await;
 
         Some(match resolved {
             Ok(ResolvedAsset {
@@ -324,7 +322,7 @@ impl StaticFileServer {
             }) => Response::builder()
                 .status(StatusCode::MOVED_PERMANENTLY)
                 .header(header::LOCATION, redirect_to)
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap(),
             Err(not_found_behavior) => match not_found_behavior {
                 NotFoundBehavior::Error(error_response) => {
@@ -340,7 +338,7 @@ impl StaticFileServer {
                 NotFoundBehavior::Redirect(redirect) => Response::builder()
                     .status(redirect.r#type.status_code())
                     .header(header::LOCATION, redirect.to)
-                    .body(BoxBody::new(Full::new(Bytes::new())))
+                    .body(HttpBody::empty())
                     .unwrap(),
             },
         })
@@ -407,7 +405,7 @@ impl StaticFileServer {
 
         Response::builder()
             .status(StatusCode::NOT_FOUND)
-            .body(BoxBody::new(Full::new(Bytes::new())))
+            .body(HttpBody::empty())
             .unwrap()
     }
 
@@ -648,15 +646,8 @@ impl StaticFileServer {
         Err(nf)
     }
 
-    async fn stream_file_range(
-        &self,
-        path: PathBuf,
-        start: u64,
-        end: u64,
-    ) -> Option<BoxBody<Bytes, Infallible>> {
+    async fn stream_file_range(&self, path: PathBuf, start: u64, end: u64) -> Option<HttpBody> {
         use futures::TryStreamExt;
-        use http_body_util::StreamBody;
-        use hyper::body::Frame;
         use tokio::io::AsyncSeekExt;
         use tokio_util::io::ReaderStream;
 
@@ -687,32 +678,25 @@ impl StaticFileServer {
         let range_length = end - start + 1;
         let limited_reader = tokio::io::AsyncReadExt::take(file, range_length);
         let path_clone = path.clone();
-        let stream = ReaderStream::with_capacity(limited_reader, 64 * 1024)
-            .map_ok(Frame::data)
-            .map_err(move |e| {
-                warn!("Error streaming file {}: {}", path_clone.display(), e);
-                unreachable!("We handle IO errors above")
-            });
-
-        Some(BoxBody::new(StreamBody::new(stream)))
+        let stream = ReaderStream::with_capacity(limited_reader, 64 * 1024).map_err(move |e| {
+            warn!("Error streaming file {}: {}", path_clone.display(), e);
+            unreachable!("We handle IO errors above")
+        });
+        Some(HttpBody::stream(stream))
     }
 
-    async fn stream_file(&self, path: PathBuf) -> Option<BoxBody<Bytes, Infallible>> {
+    async fn stream_file(&self, path: PathBuf) -> Option<HttpBody> {
         use futures::TryStreamExt;
-        use http_body_util::StreamBody;
-        use hyper::body::Frame;
         use tokio_util::io::ReaderStream;
 
         match File::open(&path).await {
             Ok(file) => {
                 let path_clone = path.clone();
-                let stream = ReaderStream::with_capacity(file, 64 * 1024)
-                    .map_ok(Frame::data)
-                    .map_err(move |e| {
-                        warn!("Error streaming file {}: {}", path_clone.display(), e);
-                        unreachable!("We handle IO errors above")
-                    });
-                Some(BoxBody::new(StreamBody::new(stream)))
+                let stream = ReaderStream::with_capacity(file, 64 * 1024).map_err(move |e| {
+                    warn!("Error streaming file {}: {}", path_clone.display(), e);
+                    unreachable!("We handle IO errors above")
+                });
+                Some(HttpBody::stream(stream))
             }
             Err(e) => {
                 warn!(
@@ -749,7 +733,7 @@ impl StaticFileServer {
             return Response::builder()
                 .status(StatusCode::RANGE_NOT_SATISFIABLE)
                 .header("Content-Range", format!("bytes */{}", content_length))
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap();
         }
 
@@ -795,7 +779,7 @@ impl StaticFileServer {
                 builder = builder.header("Content-Range", range);
             }
 
-            return builder.body(BoxBody::new(Full::new(Bytes::new()))).unwrap();
+            return builder.body(HttpBody::empty()).unwrap();
         }
 
         // For GET requests, prepare the actual content
@@ -829,10 +813,7 @@ impl StaticFileServer {
         }
     }
 
-    fn serve_cached_content(
-        &self,
-        serve_cache_args: ServeCacheArgs,
-    ) -> http::Response<BoxBody<Bytes, Infallible>> {
+    fn serve_cached_content(&self, serve_cache_args: ServeCacheArgs) -> HttpResponse {
         let ServeCacheArgs(
             cache_entry,
             start,
@@ -855,7 +836,7 @@ impl StaticFileServer {
             return Response::builder()
                 .status(StatusCode::RANGE_NOT_SATISFIABLE)
                 .header("Content-Range", format!("bytes */{}", content_length))
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap();
         }
 
@@ -904,7 +885,7 @@ impl StaticFileServer {
                 builder = builder.header("Content-Range", range);
             }
 
-            return builder.body(BoxBody::new(Full::new(Bytes::new()))).unwrap();
+            return builder.body(HttpBody::empty()).unwrap();
         }
 
         if is_range_request {
@@ -920,7 +901,7 @@ impl StaticFileServer {
                 cache_entry.last_modified_http_date.clone(),
                 content_range,
                 &self.headers,
-                BoxBody::new(Full::new(range_bytes)),
+                HttpBody::full(range_bytes),
             )
         } else {
             // Return the full content
@@ -987,15 +968,15 @@ fn format_http_date_header(time: SystemTime) -> HeaderValue {
         .unwrap()
 }
 
-fn build_ok_body(bytes: Arc<Bytes>) -> BoxBody<Bytes, Infallible> {
-    BoxBody::new(Full::new(bytes.as_ref().clone()))
+fn build_ok_body(bytes: Arc<Bytes>) -> HttpBody {
+    HttpBody::full(bytes.as_ref().clone())
 }
 
 // Helper function to handle not modified responses
-fn build_not_modified_response() -> http::Response<BoxBody<Bytes, Infallible>> {
+fn build_not_modified_response() -> HttpResponse {
     Response::builder()
         .status(StatusCode::NOT_MODIFIED)
-        .body(BoxBody::new(Full::new(Bytes::new())))
+        .body(HttpBody::empty())
         .unwrap()
 }
 
@@ -1009,8 +990,8 @@ fn build_file_response(
     last_modified_http_date: HeaderValue,
     range_header: Option<String>,
     headers: &Option<HashMap<String, String>>,
-    body: BoxBody<Bytes, Infallible>,
-) -> http::Response<BoxBody<Bytes, Infallible>> {
+    body: HttpBody,
+) -> HttpResponse {
     let mut response = Response::new(body);
 
     *response.status_mut() = status;
@@ -1188,7 +1169,6 @@ async fn generate_directory_listing(
 
             // Generate JSON entries for directories.
             for (name, metadata) in dirs {
-                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
                 let modified = metadata
                     .modified()
                     .ok()
@@ -1201,7 +1181,7 @@ async fn generate_directory_listing(
 
                 items.push(json!({
                     "name": format!("{}/", name),
-                    "path": format!("{}/", encoded),
+                    "path": format!("{}/", name),
                     "is_dir": true,
                     "size": null,
                     "modified": modified,
@@ -1210,7 +1190,6 @@ async fn generate_directory_listing(
 
             // Generate JSON entries for files.
             for (name, metadata) in files {
-                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
                 let file_size = metadata.len();
                 let formatted_size = if file_size < 1024 {
                     format!("{} B", file_size)
@@ -1234,7 +1213,7 @@ async fn generate_directory_listing(
 
                 items.push(json!({
                     "name": name,
-                    "path": encoded,
+                    "path": name,
                     "is_dir": false,
                     "size": formatted_size,
                     "modified": modified_str,
@@ -1341,11 +1320,9 @@ async fn generate_directory_listing(
 
             // Generate rows for directories.
             for (name, metadata) in dirs {
-                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
-
                 rows.push_str(&format!(
             r#"<tr><td><a href="{0}/">{1}/</a></td><td class="size">-</td><td class="date">{2}</td></tr>"#,
-            encoded,
+            name,
             name,
             metadata.modified().ok().map(|m| DateTime::<Utc>::from(m).format("%Y-%m-%d %H:%M:%S").to_string())
                 .unwrap_or_else(|| "-".to_string())
@@ -1355,8 +1332,6 @@ async fn generate_directory_listing(
 
             // Generate rows for files.
             for (name, metadata) in files {
-                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
-
                 let file_size = metadata.len();
                 let formatted_size = if file_size < 1024 {
                     format!("{} B", file_size)
@@ -1380,7 +1355,7 @@ async fn generate_directory_listing(
 
                 rows.push_str(&format!(
             r#"<tr><td><a href="{0}">{1}</a></td><td class="size">{2}</td><td class="date">{3}</td></tr>"#,
-            encoded, name, formatted_size, modified_str
+            name, name, formatted_size, modified_str
         ));
                 rows.push('\n');
             }

data/lib/itsi/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Scheduler
-    VERSION = "0.2.15"
+    VERSION = "0.2.17"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: itsi-scheduler
 version: !ruby/object:Gem::Version
-  version: 0.2.15
+  version: 0.2.17
 platform: ruby
 authors:
 - Wouter Coppieters
@@ -120,6 +120,7 @@ files:
 - ext/itsi_server/src/server/binds/tls.rs
 - ext/itsi_server/src/server/binds/tls/locked_dir_cache.rs
 - ext/itsi_server/src/server/byte_frame.rs
+- ext/itsi_server/src/server/frame_stream.rs
 - ext/itsi_server/src/server/http_message_types.rs
 - ext/itsi_server/src/server/io_stream.rs
 - ext/itsi_server/src/server/lifecycle_event.rs
@@ -156,6 +157,7 @@ files:
 - ext/itsi_server/src/server/process_worker.rs
 - ext/itsi_server/src/server/redirect_type.rs
 - ext/itsi_server/src/server/request_job.rs
+- ext/itsi_server/src/server/serve_strategy/acceptor.rs
 - ext/itsi_server/src/server/serve_strategy/cluster_mode.rs
 - ext/itsi_server/src/server/serve_strategy/mod.rs
 - ext/itsi_server/src/server/serve_strategy/single_mode.rs