Struct SessionMiddleware 

pub struct SessionMiddleware { /* private fields */ }

Session middleware

Examples

use std::sync::Arc;
use std::time::Duration;
use reinhardt_middleware::session::{SessionMiddleware, SessionConfig};
use reinhardt_http::{Handler, Middleware, Request, Response};
use hyper::{StatusCode, Method, Version, HeaderMap};
use bytes::Bytes;

struct TestHandler;

#[async_trait::async_trait]
impl Handler for TestHandler {
    async fn handle(&self, _request: Request) -> reinhardt_core::exception::Result<Response> {
        Ok(Response::new(StatusCode::OK).with_body(Bytes::from("OK")))
    }
}

let config = SessionConfig::new("sessionid".to_string(), Duration::from_secs(3600));
let middleware = SessionMiddleware::new(config);
let handler = Arc::new(TestHandler);

let request = Request::builder()
    .method(Method::GET)
    .uri("/api/data")
    .version(Version::HTTP_11)
    .headers(HeaderMap::new())
    .body(Bytes::new())
    .build()
    .unwrap();

let response = middleware.process(request, handler).await.unwrap();
assert_eq!(response.status, StatusCode::OK);

Implementations

impl SessionMiddleware

pub fn new(config: SessionConfig) -> Self

Create a new session middleware

Examples

use std::time::Duration;
use reinhardt_middleware::session::{SessionMiddleware, SessionConfig};

let config = SessionConfig::new("sessionid".to_string(), Duration::from_secs(3600));
let middleware = SessionMiddleware::new(config);

pub fn from_settings(settings: &Settings) -> Self

Create a SessionMiddleware from application Settings

Examples

use reinhardt_conf::Settings;
use reinhardt_middleware::session::SessionMiddleware;

#[allow(deprecated)]
let settings = Settings::default();
#[allow(deprecated)]
let middleware = SessionMiddleware::from_settings(&settings);

pub fn with_defaults() -> Self

Create with default configuration

pub fn from_arc(config: SessionConfig, store: Arc<SessionStore>) -> Self

Create from an existing Arc-wrapped session store

This is provided for cases where you already have an Arc<SessionStore>. In most cases, you should use new() instead, which creates the store internally.

pub fn store(&self) -> &SessionStore

Get a reference to the session store

Examples

use std::time::Duration;
use reinhardt_middleware::session::{SessionMiddleware, SessionConfig};

let middleware = SessionMiddleware::new(
    SessionConfig::new("sessionid".to_string(), Duration::from_secs(3600))
);

// Access the store
let store = middleware.store();
assert_eq!(store.len(), 0);

pub fn store_arc(&self) -> Arc<SessionStore>

Get a cloned Arc of the store (for cases where you need ownership)

In most cases, you should use store() instead to get a reference.

Trait Implementations

impl Default for SessionMiddleware

fn default() -> Self

Returns the “default value” for a type.

impl Middleware for SessionMiddleware

fn process<'life0, 'async_trait>( &'life0 self, request: Request, handler: Arc<dyn Handler>, ) -> Pin<Box<dyn Future<Output = Result<Response>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Processes a request through this middleware.

fn should_continue(&self, _request: &Request) -> bool

Determines whether this middleware should be executed for the given request.