RubyGems - spikard - Versions diffs - 0.8.3 → 0.10.2 - Mend

spikard 0.8.3 → 0.10.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (106) hide show

data/vendor/crates/spikard-http/src/server/fast_router.rs ADDED Viewed

@@ -0,0 +1,186 @@
+//! Fast-path HashMap router for static responses.
+//!
+//! Routes registered with `StaticResponse` and without path parameters are
+//! placed into a two-level `AHashMap` keyed by `Method` then `path`. An axum
+//! middleware layer checks this map first — on a hit the pre-built response is
+//! returned immediately, avoiding the full Axum routing + middleware pipeline.
+use ahash::AHashMap;
+use axum::body::Body;
+use axum::http::Method;
+use crate::handler_trait::StaticResponse;
+/// HashMap-based router for static-response routes without path parameters.
+///
+/// Uses a two-level map (`Method` → `path` → `StaticResponse`) so that
+/// lookups only require a `&str` borrow — no heap allocation per request.
+///
+/// Inserted as the outermost middleware layer so that matching requests
+/// never reach the Axum router at all.
+#[derive(Clone)]
+pub struct FastRouter {
+    routes: AHashMap<Method, AHashMap<String, StaticResponse>>,
+}
+impl FastRouter {
+    /// Create an empty fast router.
+    pub fn new() -> Self {
+        Self {
+            routes: AHashMap::new(),
+        }
+    }
+    /// Register a static response for an exact method + path pair.
+    pub fn insert(&mut self, method: Method, path: &str, resp: &StaticResponse) {
+        self.routes
+            .entry(method)
+            .or_default()
+            .insert(path.to_owned(), resp.clone());
+    }
+    /// Returns `true` when at least one route has been registered.
+    pub fn has_routes(&self) -> bool {
+        !self.routes.is_empty()
+    }
+    /// Try to serve a request from the fast router.
+    /// Returns `None` if the method + path pair is not registered.
+    ///
+    /// `Bytes::clone()` inside `to_response()` is reference-counted (not a
+    /// deep copy), so this is cheap even for large response bodies.
+    pub fn lookup(&self, method: &Method, path: &str) -> Option<axum::response::Response<Body>> {
+        let by_path = self.routes.get(method)?;
+        let resp = by_path.get(path)?;
+        Some(resp.to_response())
+    }
+}
+impl Default for FastRouter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::http::{HeaderValue, StatusCode};
+    use bytes::Bytes;
+    use http_body_util::BodyExt;
+    fn make_static_response(status: u16, body: &str) -> StaticResponse {
+        StaticResponse {
+            status,
+            headers: vec![],
+            body: Bytes::from(body.to_owned()),
+            content_type: HeaderValue::from_static("text/plain"),
+        }
+    }
+    #[test]
+    fn test_fast_router_miss_returns_none() {
+        let router = FastRouter::new();
+        assert!(router.lookup(&Method::GET, "/health").is_none());
+    }
+    #[test]
+    fn test_fast_router_hit_returns_response() {
+        let mut router = FastRouter::new();
+        router.insert(Method::GET, "/health", &make_static_response(200, "OK"));
+        let resp = router.lookup(&Method::GET, "/health");
+        assert!(resp.is_some());
+        let resp = resp.unwrap();
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+    #[test]
+    fn test_fast_router_method_mismatch() {
+        let mut router = FastRouter::new();
+        router.insert(Method::GET, "/health", &make_static_response(200, "OK"));
+        assert!(router.lookup(&Method::POST, "/health").is_none());
+    }
+    #[test]
+    fn test_fast_router_path_mismatch() {
+        let mut router = FastRouter::new();
+        router.insert(Method::GET, "/health", &make_static_response(200, "OK"));
+        assert!(router.lookup(&Method::GET, "/ready").is_none());
+    }
+    #[test]
+    fn test_fast_router_has_routes() {
+        let mut router = FastRouter::new();
+        assert!(!router.has_routes());
+        router.insert(Method::GET, "/health", &make_static_response(200, "OK"));
+        assert!(router.has_routes());
+    }
+    #[test]
+    fn test_fast_router_multiple_routes() {
+        let mut router = FastRouter::new();
+        router.insert(Method::GET, "/health", &make_static_response(200, "OK"));
+        router.insert(Method::GET, "/ready", &make_static_response(200, "ready"));
+        router.insert(Method::POST, "/health", &make_static_response(201, "created"));
+        assert!(router.lookup(&Method::GET, "/health").is_some());
+        assert!(router.lookup(&Method::GET, "/ready").is_some());
+        assert!(router.lookup(&Method::POST, "/health").is_some());
+        assert!(router.lookup(&Method::DELETE, "/health").is_none());
+    }
+    #[test]
+    fn test_fast_router_custom_headers() {
+        use axum::http::header::HeaderName;
+        let resp = StaticResponse {
+            status: 200,
+            headers: vec![(HeaderName::from_static("x-custom"), HeaderValue::from_static("value"))],
+            body: Bytes::from_static(b"OK"),
+            content_type: HeaderValue::from_static("application/json"),
+        };
+        let mut router = FastRouter::new();
+        router.insert(Method::GET, "/test", &resp);
+        let response = router.lookup(&Method::GET, "/test").unwrap();
+        assert_eq!(response.headers().get("x-custom").unwrap(), "value");
+        assert_eq!(response.headers().get("content-type").unwrap(), "application/json");
+    }
+    #[tokio::test]
+    async fn test_fast_router_response_body_content() {
+        let mut router = FastRouter::new();
+        router.insert(Method::GET, "/health", &make_static_response(200, "OK"));
+        router.insert(Method::GET, "/ready", &make_static_response(200, "ready"));
+        let resp = router.lookup(&Method::GET, "/health").unwrap();
+        let body = resp.into_body().collect().await.unwrap().to_bytes();
+        assert_eq!(body.as_ref(), b"OK");
+        let resp = router.lookup(&Method::GET, "/ready").unwrap();
+        let body = resp.into_body().collect().await.unwrap().to_bytes();
+        assert_eq!(body.as_ref(), b"ready");
+    }
+    #[tokio::test]
+    async fn test_fast_router_custom_status_code() {
+        let mut router = FastRouter::new();
+        router.insert(Method::POST, "/items", &make_static_response(201, "created"));
+        let resp = router.lookup(&Method::POST, "/items").unwrap();
+        assert_eq!(resp.status(), StatusCode::CREATED);
+        let body = resp.into_body().collect().await.unwrap().to_bytes();
+        assert_eq!(body.as_ref(), b"created");
+    }
+    #[test]
+    fn test_fast_router_default() {
+        let router = FastRouter::default();
+        assert!(!router.has_routes());
+    }
+}

data/vendor/crates/spikard-http/src/server/grpc_routing.rs CHANGED Viewed

@@ -3,7 +3,7 @@
 //! This module handles routing gRPC requests to the appropriate handlers
 //! and multiplexing between HTTP/1.1 REST and HTTP/2 gRPC traffic.
-use crate::grpc::{GrpcRegistry, parse_grpc_path};
+use crate::grpc::{GrpcConfig, GrpcRegistry, RpcMode, parse_grpc_path};
 use axum::body::Body;
 use axum::http::{Request, Response, StatusCode};
 use std::sync::Arc;
@@ -42,6 +42,7 @@ fn grpc_status_to_http(code: tonic::Code) -> StatusCode {
 /// # Arguments
 ///
 /// * `registry` - gRPC handler registry
+/// * `config` - gRPC configuration with size limits
 /// * `request` - The incoming gRPC request
 ///
 /// # Returns
@@ -49,6 +50,7 @@ fn grpc_status_to_http(code: tonic::Code) -> StatusCode {
 /// A future that resolves to a gRPC response or error
 pub async fn route_grpc_request(
     registry: Arc<GrpcRegistry>,
+    config: &GrpcConfig,
     request: Request<Body>,
 ) -> Result<Response<Body>, (StatusCode, String)> {
     // Extract the request path
@@ -66,18 +68,55 @@ pub async fn route_grpc_request(
     };
     // Look up the handler for this service
-    let handler = match registry.get(&service_name) {
-        Some(h) => h,
+    let (handler, rpc_mode) = match registry.get(&service_name) {
+        Some((h, mode)) => (h, mode),
         None => {
             return Err((StatusCode::NOT_FOUND, format!("Service not found: {}", service_name)));
         }
     };
-    // Convert the Axum request to bytes
+    // Create the service bridge
+    let service = crate::grpc::GenericGrpcService::new(handler);
+    // Dispatch based on RPC mode
+    match rpc_mode {
+        RpcMode::Unary => {
+            handle_unary_request(service, service_name, method_name, config.max_message_size, request).await
+        }
+        RpcMode::ServerStreaming => {
+            handle_server_streaming_request(service, service_name, method_name, config.max_message_size, request).await
+        }
+        RpcMode::ClientStreaming => {
+            handle_client_streaming_request(service, service_name, method_name, config.max_message_size, request).await
+        }
+        RpcMode::BidirectionalStreaming => {
+            handle_bidirectional_streaming_request(service, service_name, method_name, config.max_message_size, request)
+                .await
+        }
+    }
+}
+/// Handle a unary RPC request
+async fn handle_unary_request(
+    service: crate::grpc::GenericGrpcService,
+    service_name: String,
+    method_name: String,
+    max_message_size: usize,
+    request: Request<Body>,
+) -> Result<Response<Body>, (StatusCode, String)> {
+    // Convert the Axum request to bytes with the configured size limit
     let (parts, body) = request.into_parts();
-    let body_bytes = match axum::body::to_bytes(body, usize::MAX).await {
+    let body_bytes = match axum::body::to_bytes(body, max_message_size).await {
         Ok(bytes) => bytes,
         Err(e) => {
+            // Check if error is due to size limit (axum returns "body size exceeded" or similar)
+            let error_msg = e.to_string();
+            if error_msg.contains("body") || error_msg.contains("size") || error_msg.contains("exceeded") {
+                return Err((
+                    StatusCode::PAYLOAD_TOO_LARGE,
+                    format!("Message exceeds maximum size of {} bytes", max_message_size),
+                ));
+            }
             return Err((StatusCode::BAD_REQUEST, format!("Failed to read request body: {}", e)));
         }
     };
@@ -87,22 +126,17 @@ pub async fn route_grpc_request(
     // Copy headers to Tonic metadata
     for (key, value) in parts.headers.iter() {
-        if let Ok(value_str) = value.to_str() {
-            // Try to parse as ASCII metadata
-            if let Ok(metadata_value) = value_str.parse::<tonic::metadata::MetadataValue<tonic::metadata::Ascii>>() {
-                // Use key.as_str() directly instead of creating String
-                if let Ok(metadata_key) = key
-                    .as_str()
-                    .parse::<tonic::metadata::MetadataKey<tonic::metadata::Ascii>>()
-                {
-                    tonic_request.metadata_mut().insert(metadata_key, metadata_value);
-                }
-            }
+        if let Ok(value_str) = value.to_str()
+            && let Ok(metadata_value) = value_str.parse::<tonic::metadata::MetadataValue<tonic::metadata::Ascii>>()
+            && let Ok(metadata_key) = key
+                .as_str()
+                .parse::<tonic::metadata::MetadataKey<tonic::metadata::Ascii>>()
+        {
+            tonic_request.metadata_mut().insert(metadata_key, metadata_value);
         }
     }
     // Use the service bridge to handle the request
-    let service = crate::grpc::GenericGrpcService::new(handler);
     let tonic_response = match service.handle_unary(service_name, method_name, tonic_request).await {
         Ok(resp) => resp,
         Err(status) => {
@@ -142,6 +176,225 @@ pub async fn route_grpc_request(
     Ok(response)
 }
+/// Handle a server streaming RPC request
+async fn handle_server_streaming_request(
+    service: crate::grpc::GenericGrpcService,
+    service_name: String,
+    method_name: String,
+    max_message_size: usize,
+    request: Request<Body>,
+) -> Result<Response<Body>, (StatusCode, String)> {
+    // Convert the Axum request to bytes with the configured size limit
+    let (parts, body) = request.into_parts();
+    let body_bytes = match axum::body::to_bytes(body, max_message_size).await {
+        Ok(bytes) => bytes,
+        Err(e) => {
+            // Check if error is due to size limit (axum returns "body size exceeded" or similar)
+            let error_msg = e.to_string();
+            if error_msg.contains("body") || error_msg.contains("size") || error_msg.contains("exceeded") {
+                return Err((
+                    StatusCode::PAYLOAD_TOO_LARGE,
+                    format!("Message exceeds maximum size of {} bytes", max_message_size),
+                ));
+            }
+            return Err((StatusCode::BAD_REQUEST, format!("Failed to read request body: {}", e)));
+        }
+    };
+    // Create a Tonic request
+    let mut tonic_request = tonic::Request::new(body_bytes);
+    // Copy headers to Tonic metadata
+    for (key, value) in parts.headers.iter() {
+        if let Ok(value_str) = value.to_str()
+            && let Ok(metadata_value) = value_str.parse::<tonic::metadata::MetadataValue<tonic::metadata::Ascii>>()
+            && let Ok(metadata_key) = key
+                .as_str()
+                .parse::<tonic::metadata::MetadataKey<tonic::metadata::Ascii>>()
+        {
+            tonic_request.metadata_mut().insert(metadata_key, metadata_value);
+        }
+    }
+    // Use the service bridge to handle the streaming request
+    let tonic_response = match service
+        .handle_server_stream(service_name, method_name, tonic_request)
+        .await
+    {
+        Ok(resp) => resp,
+        Err(status) => {
+            let status_code = grpc_status_to_http(status.code());
+            return Err((status_code, status.message().to_string()));
+        }
+    };
+    // Convert Tonic response to Axum response
+    let body = tonic_response.into_inner();
+    let mut response = Response::builder()
+        .status(StatusCode::OK)
+        .header("content-type", "application/grpc+proto");
+    // Add gRPC status trailer (success)
+    response = response.header("grpc-status", "0");
+    let response = response.body(body).map_err(|e| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Failed to build response: {}", e),
+        )
+    })?;
+    Ok(response)
+}
+/// Handle a client streaming RPC request
+async fn handle_client_streaming_request(
+    service: crate::grpc::GenericGrpcService,
+    service_name: String,
+    method_name: String,
+    max_message_size: usize,
+    request: Request<Body>,
+) -> Result<Response<Body>, (StatusCode, String)> {
+    // Extract request parts - keep body as stream for frame parsing
+    let (parts, body) = request.into_parts();
+    // Create a Tonic request with streaming body
+    // Body will be parsed by service.handle_client_stream using frame parser
+    let mut tonic_request = tonic::Request::new(body);
+    // Copy headers to Tonic metadata
+    for (key, value) in parts.headers.iter() {
+        if let Ok(value_str) = value.to_str()
+            && let Ok(metadata_value) = value_str.parse::<tonic::metadata::MetadataValue<tonic::metadata::Ascii>>()
+            && let Ok(metadata_key) = key
+                .as_str()
+                .parse::<tonic::metadata::MetadataKey<tonic::metadata::Ascii>>()
+        {
+            tonic_request.metadata_mut().insert(metadata_key, metadata_value);
+        }
+    }
+    // Use the service bridge to handle the client streaming request
+    // Frame parsing and size validation happens in handle_client_stream
+    let tonic_response = match service
+        .handle_client_stream(service_name, method_name, tonic_request, max_message_size)
+        .await
+    {
+        Ok(resp) => resp,
+        Err(status) => {
+            let status_code = grpc_status_to_http(status.code());
+            return Err((status_code, status.message().to_string()));
+        }
+    };
+    // Convert Tonic response to Axum response
+    let payload = tonic_response.get_ref().clone();
+    let metadata = tonic_response.metadata();
+    let mut response = Response::builder()
+        .status(StatusCode::OK)
+        .header("content-type", "application/grpc+proto");
+    // Copy metadata to response headers
+    for key_value in metadata.iter() {
+        if let tonic::metadata::KeyAndValueRef::Ascii(key, value) = key_value
+            && let Ok(header_value) = axum::http::HeaderValue::from_str(value.to_str().unwrap_or(""))
+        {
+            response = response.header(key.as_str(), header_value);
+        }
+    }
+    // Add gRPC status trailer (success)
+    response = response.header("grpc-status", "0");
+    // Convert bytes::Bytes to Body
+    let response = response.body(Body::from(payload)).map_err(|e| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Failed to build response: {}", e),
+        )
+    })?;
+    Ok(response)
+}
+/// Handle a bidirectional streaming RPC request
+///
+/// Bidirectional streaming allows both client and server to send multiple messages.
+/// This function:
+/// 1. Keeps the request body as a stream (not converting to bytes)
+/// 2. Copies HTTP headers to gRPC metadata
+/// 3. Passes the streaming body to the service for frame parsing
+/// 4. Returns the response stream from the handler
+///
+/// # Arguments
+///
+/// * `service` - The GenericGrpcService containing the handler
+/// * `service_name` - Fully qualified service name (e.g., "mypackage.ChatService")
+/// * `method_name` - Method name (e.g., "Chat")
+/// * `max_message_size` - Maximum size per message in bytes
+/// * `request` - Axum HTTP request with streaming body
+///
+/// # Returns
+///
+/// Response with streaming body containing response messages, or error with status code
+async fn handle_bidirectional_streaming_request(
+    service: crate::grpc::GenericGrpcService,
+    service_name: String,
+    method_name: String,
+    max_message_size: usize,
+    request: Request<Body>,
+) -> Result<Response<Body>, (StatusCode, String)> {
+    // Extract request parts - keep body as stream for frame parsing
+    let (parts, body) = request.into_parts();
+    // Create a Tonic request with streaming body
+    // Body will be parsed by service.handle_bidi_stream using frame parser
+    let mut tonic_request = tonic::Request::new(body);
+    // Copy HTTP headers to gRPC metadata
+    for (key, value) in parts.headers.iter() {
+        if let Ok(value_str) = value.to_str()
+            && let Ok(metadata_value) = value_str.parse::<tonic::metadata::MetadataValue<tonic::metadata::Ascii>>()
+            && let Ok(metadata_key) = key
+                .as_str()
+                .parse::<tonic::metadata::MetadataKey<tonic::metadata::Ascii>>()
+        {
+            tonic_request.metadata_mut().insert(metadata_key, metadata_value);
+        }
+    }
+    // Call service handler - frame parsing and size validation happens inside
+    let tonic_response = match service
+        .handle_bidi_stream(service_name, method_name, tonic_request, max_message_size)
+        .await
+    {
+        Ok(response) => response,
+        Err(status) => {
+            let status_code = grpc_status_to_http(status.code());
+            return Err((status_code, status.message().to_string()));
+        }
+    };
+    // Convert Tonic response to Axum response with streaming body
+    let body = tonic_response.into_inner();
+    let mut response = Response::builder()
+        .status(StatusCode::OK)
+        .header("content-type", "application/grpc+proto");
+    // Add gRPC status trailer (success)
+    response = response.header("grpc-status", "0");
+    let response = response.body(body).map_err(|e| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Failed to build response: {}", e),
+        )
+    })?;
+    Ok(response)
+}
 /// Check if an incoming request is a gRPC request
 ///
 /// Returns true if the request has a content-type starting with "application/grpc"
@@ -157,7 +410,7 @@ pub fn is_grpc_request(request: &Request<Body>) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::grpc::handler::{GrpcHandler, GrpcHandlerResult, GrpcRequestData, GrpcResponseData};
+    use crate::grpc::handler::{GrpcHandler, GrpcHandlerResult, GrpcRequestData, GrpcResponseData, RpcMode};
     use bytes::Bytes;
     use std::future::Future;
     use std::pin::Pin;
@@ -174,7 +427,7 @@ mod tests {
             })
         }
-        fn service_name(&self) -> &'static str {
+        fn service_name(&self) -> &str {
             "test.EchoService"
         }
     }
@@ -182,8 +435,9 @@ mod tests {
     #[tokio::test]
     async fn test_route_grpc_request_success() {
         let mut registry = GrpcRegistry::new();
-        registry.register("test.EchoService", Arc::new(EchoHandler));
+        registry.register("test.EchoService", Arc::new(EchoHandler), RpcMode::Unary);
         let registry = Arc::new(registry);
+        let config = GrpcConfig::default();
         let request = Request::builder()
             .uri("/test.EchoService/Echo")
@@ -191,13 +445,14 @@ mod tests {
             .body(Body::from(Bytes::from("test payload")))
             .unwrap();
-        let result = route_grpc_request(registry, request).await;
+        let result = route_grpc_request(registry, &config, request).await;
         assert!(result.is_ok());
     }
     #[tokio::test]
     async fn test_route_grpc_request_service_not_found() {
         let registry = Arc::new(GrpcRegistry::new());
+        let config = GrpcConfig::default();
         let request = Request::builder()
             .uri("/nonexistent.Service/Method")
@@ -205,7 +460,7 @@ mod tests {
             .body(Body::from(Bytes::new()))
             .unwrap();
-        let result = route_grpc_request(registry, request).await;
+        let result = route_grpc_request(registry, &config, request).await;
         assert!(result.is_err());
         let (status, message) = result.unwrap_err();
@@ -216,6 +471,7 @@ mod tests {
     #[tokio::test]
     async fn test_route_grpc_request_invalid_path() {
         let registry = Arc::new(GrpcRegistry::new());
+        let config = GrpcConfig::default();
         let request = Request::builder()
             .uri("/invalid")
@@ -223,7 +479,7 @@ mod tests {
             .body(Body::from(Bytes::new()))
             .unwrap();
-        let result = route_grpc_request(registry, request).await;
+        let result = route_grpc_request(registry, &config, request).await;
         assert!(result.is_err());
         let (status, _message) = result.unwrap_err();
@@ -324,4 +580,49 @@ mod tests {
             StatusCode::UNAUTHORIZED
         );
     }
+    #[tokio::test]
+    async fn test_route_grpc_request_with_custom_max_message_size() {
+        let mut registry = GrpcRegistry::new();
+        registry.register("test.EchoService", Arc::new(EchoHandler), RpcMode::Unary);
+        let registry = Arc::new(registry);
+        let mut config = GrpcConfig::default();
+        config.max_message_size = 100; // Set small limit
+        let request = Request::builder()
+            .uri("/test.EchoService/Echo")
+            .header("content-type", "application/grpc")
+            .body(Body::from(Bytes::from("test payload")))
+            .unwrap();
+        // This should succeed since payload is small
+        let result = route_grpc_request(registry.clone(), &config, request).await;
+        assert!(result.is_ok());
+    }
+    #[tokio::test]
+    async fn test_route_grpc_request_exceeds_max_message_size() {
+        let mut registry = GrpcRegistry::new();
+        registry.register("test.EchoService", Arc::new(EchoHandler), RpcMode::Unary);
+        let registry = Arc::new(registry);
+        let mut config = GrpcConfig::default();
+        config.max_message_size = 10; // Set very small limit
+        // Create a large payload that exceeds the limit
+        let large_payload = vec![b'x'; 1000];
+        let request = Request::builder()
+            .uri("/test.EchoService/Echo")
+            .header("content-type", "application/grpc")
+            .body(Body::from(Bytes::from(large_payload)))
+            .unwrap();
+        let result = route_grpc_request(registry, &config, request).await;
+        assert!(result.is_err());
+        let (status, message) = result.unwrap_err();
+        assert_eq!(status, StatusCode::PAYLOAD_TOO_LARGE);
+        assert!(message.contains("Message exceeds maximum size"));
+    }
 }