feat: trait for module request context

Introduce RequestContext trait for managing request-specific context data:
- Provides create, remove, get, get_mut, and exists methods
- Uses pool allocation with cleanup handlers for memory management
- Add get_module_ctx_mut method to Request for mutable context access
- Update ngx_log_debug_http macro to use request.log() method

Author: ensh63

src/http/mod.rs

@@ -1,10 +1,12 @@
 mod conf;
 mod module;
 mod request;
+mod request_context;
 mod status;
 mod upstream;
 
 pub use conf::*;
 pub use module::*;
 pub use request::*;
+pub use request_context::*;
 pub use status::*;

src/http/request.rs

@@ -249,6 +249,14 @@ impl Request {
         unsafe { ctx.as_ref() }
     }
 
+    /// Get mutable Module context
+    pub fn get_module_ctx_mut<T>(&mut self, module: &ngx_module_t) -> Option<&mut T> {
+        let ctx = self.get_module_ctx_ptr(module).cast::<T>();
+        // SAFETY: ctx is either NULL or allocated with ngx_p(c)alloc and
+        // explicitly initialized by the module
+        unsafe { ctx.as_mut() }
+    }
+
     /// Sets the value as the module's context.
     ///
     /// See <https://nginx.org/en/docs/dev/development_guide.html#http_request>

src/http/request_context.rs

@@ -0,0 +1,40 @@
+use crate::http::{HttpModule, Request};
+use crate::ngx_log_debug_http;
+
+/// A trait for managing request-specific context data.
+pub trait RequestContext<Module: HttpModule>: Sized {
+    /// Creates a new context and associates it with the given request.
+    /// No check is performed to see if a context already exists.
+    fn create<F>(request: &mut Request, f: F) -> Option<&mut Self>
+    where
+        F: FnOnce() -> Self,
+    {
+        let ctx_ref = unsafe { request.pool().allocate_with_cleanup(f)?.as_mut() };
+        request.set_module_ctx(ctx_ref as *mut _ as _, Module::module());
+        Some(ctx_ref)
+    }
+
+    /// Removes the context associated with the given request.
+    fn remove(request: &mut Request) {
+        if let Some(ctx_ptr) = request.get_module_ctx::<Self>(Module::module()) {
+            unsafe { request.pool().remove(ctx_ptr as *const Self) };
+            request.set_module_ctx(core::ptr::null_mut(), Module::module());
+            ngx_log_debug_http!(request, "RequestContext removed from request");
+        }
+    }
+
+    /// Retrieves an immutable reference to the context associated with the given request.
+    fn get(request: &Request) -> Option<&Self> {
+        request.get_module_ctx::<Self>(Module::module())
+    }
+
+    /// Retrieves a mutable reference to the context associated with the given request.
+    fn get_mut(request: &mut Request) -> Option<&mut Self> {
+        request.get_module_ctx_mut::<Self>(Module::module())
+    }
+
+    /// Checks if a context is associated with the given request.
+    fn exists(request: &Request) -> bool {
+        request.get_module_ctx::<Self>(Module::module()).is_some()
+    }
+}

src/log.rs

@@ -153,7 +153,7 @@ macro_rules! ngx_log_debug {
 #[macro_export]
 macro_rules! ngx_log_debug_http {
     ( $request:expr, $($arg:tt)+ ) => {
-        let log = unsafe { (*$request.connection()).log };
+        let log = $request.log();
         $crate::ngx_log_debug!(mask: $crate::log::DebugMask::Http, log, $($arg)+);
     }
 }