pulseengine_mcp_server/
middleware.rs

1//! Middleware stack for request/response processing
2
3use crate::context::RequestContext;
4use pulseengine_mcp_auth::AuthenticationManager;
5use pulseengine_mcp_monitoring::MetricsCollector;
6use pulseengine_mcp_protocol::*;
7use pulseengine_mcp_security::SecurityMiddleware;
8
9use async_trait::async_trait;
10use std::sync::Arc;
11use tracing::debug;
12
13/// Trait for middleware components
14#[async_trait]
15pub trait Middleware: Send + Sync {
16    /// Process incoming request
17    async fn process_request(
18        &self,
19        request: Request,
20        context: &RequestContext,
21    ) -> std::result::Result<Request, Error>;
22
23    /// Process outgoing response
24    async fn process_response(
25        &self,
26        response: Response,
27        context: &RequestContext,
28    ) -> std::result::Result<Response, Error>;
29}
30
31/// Stack of middleware components
32#[derive(Clone)]
33pub struct MiddlewareStack {
34    security: Option<SecurityMiddleware>,
35    auth: Option<Arc<AuthenticationManager>>,
36    monitoring: Option<Arc<MetricsCollector>>,
37}
38
39impl MiddlewareStack {
40    /// Create a new middleware stack
41    pub fn new() -> Self {
42        Self {
43            security: None,
44            auth: None,
45            monitoring: None,
46        }
47    }
48
49    /// Add security middleware
50    pub fn with_security(mut self, security: SecurityMiddleware) -> Self {
51        self.security = Some(security);
52        self
53    }
54
55    /// Add authentication middleware
56    pub fn with_auth(mut self, auth: Arc<AuthenticationManager>) -> Self {
57        self.auth = Some(auth);
58        self
59    }
60
61    /// Add monitoring middleware
62    pub fn with_monitoring(mut self, monitoring: Arc<MetricsCollector>) -> Self {
63        self.monitoring = Some(monitoring);
64        self
65    }
66
67    /// Process request through middleware stack
68    pub async fn process_request(
69        &self,
70        mut request: Request,
71        context: &RequestContext,
72    ) -> std::result::Result<Request, crate::handler::HandlerError> {
73        debug!("Processing request through middleware stack");
74
75        // Security middleware (first)
76        if let Some(security) = &self.security {
77            let sec_context = pulseengine_mcp_security::middleware::RequestContext {
78                request_id: context.request_id,
79            };
80            request = security.process_request(request, &sec_context)?;
81        }
82
83        // Authentication middleware
84        if let Some(auth) = &self.auth {
85            let auth_context = pulseengine_mcp_auth::manager::RequestContext {
86                user_id: context.authenticated_user.clone(),
87                roles: context
88                    .roles
89                    .iter()
90                    .map(|_r| pulseengine_mcp_auth::models::Role::Admin)
91                    .collect(), // TODO: proper role mapping
92            };
93            request = auth
94                .process_request(request, &auth_context)
95                .await
96                .map_err(|e| crate::handler::HandlerError::Authentication(e.to_string()))?;
97        }
98
99        // Monitoring middleware (last)
100        if let Some(monitoring) = &self.monitoring {
101            let mon_context = pulseengine_mcp_monitoring::collector::RequestContext {
102                request_id: context.request_id,
103            };
104            request = monitoring.process_request(request, &mon_context)?;
105        }
106
107        Ok(request)
108    }
109
110    /// Process response through middleware stack (reverse order)
111    pub async fn process_response(
112        &self,
113        mut response: Response,
114        context: &RequestContext,
115    ) -> std::result::Result<Response, crate::handler::HandlerError> {
116        debug!("Processing response through middleware stack");
117
118        // Monitoring middleware (first on response)
119        if let Some(monitoring) = &self.monitoring {
120            let mon_context = pulseengine_mcp_monitoring::collector::RequestContext {
121                request_id: context.request_id,
122            };
123            response = monitoring.process_response(response, &mon_context)?;
124        }
125
126        // Authentication middleware
127        if let Some(auth) = &self.auth {
128            let auth_context = pulseengine_mcp_auth::manager::RequestContext {
129                user_id: context.authenticated_user.clone(),
130                roles: context
131                    .roles
132                    .iter()
133                    .map(|_r| pulseengine_mcp_auth::models::Role::Admin)
134                    .collect(), // TODO: proper role mapping
135            };
136            response = auth
137                .process_response(response, &auth_context)
138                .await
139                .map_err(|e| crate::handler::HandlerError::Authentication(e.to_string()))?;
140        }
141
142        // Security middleware (last on response)
143        if let Some(security) = &self.security {
144            let sec_context = pulseengine_mcp_security::middleware::RequestContext {
145                request_id: context.request_id,
146            };
147            response = security.process_response(response, &sec_context)?;
148        }
149
150        Ok(response)
151    }
152}
153
154impl Default for MiddlewareStack {
155    fn default() -> Self {
156        Self::new()
157    }
158}
pulseengine_mcp_server/middleware.rs

pulseengine_mcp_server/
middleware.rs
