Module sessions 

Session management for ordered message processing.

This module provides a generic framework for session key generation that enables ordered message processing for any domain. Session keys group related messages to ensure they are processed in FIFO order.

Design Philosophy

This module is intentionally domain-agnostic. It provides the infrastructure for session-based ordering without assuming any specific message structure or business domain (GitHub events, e-commerce orders, IoT telemetry, etc.).

Core Concepts

• SessionKeyGenerator: Trait for extracting session keys from messages
• Session Keys: Strings that group related messages for ordered processing
• Message Metadata: Messages provide metadata via the SessionKeyExtractor trait

Usage Pattern

1. Implement SessionKeyExtractor for your message type
2. Implement SessionKeyGenerator for your domain-specific strategy
3. Use the generator to produce session IDs when sending messages to queues

Example

use queue_runtime::sessions::{SessionKeyGenerator, SessionKeyExtractor};
use queue_runtime::message::SessionId;
use std::collections::HashMap;

// Your domain message type
struct OrderEvent {
    order_id: String,
    customer_id: String,
}

// Implement metadata extraction
impl SessionKeyExtractor for OrderEvent {
    fn get_metadata(&self, key: &str) -> Option<String> {
        match key {
            "order_id" => Some(self.order_id.clone()),
            "customer_id" => Some(self.customer_id.clone()),
            _ => None,
        }
    }
}

// Implement your session strategy
struct OrderSessionStrategy;

impl SessionKeyGenerator for OrderSessionStrategy {
    fn generate_key(&self, extractor: &dyn SessionKeyExtractor) -> Option<SessionId> {
        extractor.get_metadata("order_id")
            .and_then(|id| SessionId::new(format!("order-{}", id)).ok())
    }
}

Structs

CompositeKeyStrategy

Generates session keys by composing multiple metadata fields.

FallbackStrategy

Strategy that tries multiple generators in order, using the first success.

NoOrderingStrategy

Strategy that disables session-based ordering.

SessionAffinity

Mapping of a session to its assigned consumer.

SessionAffinityTracker

Tracks session-to-consumer affinity mappings for ordered processing.

SessionInfo

Information about an active session’s lifecycle state.

SessionLifecycleConfig

Configuration for session lifecycle management.

SessionLifecycleManager

Manages session lifecycles with automatic cleanup and recovery.

SessionLock

Represents a lock on a session for exclusive message processing.

SessionLockManager

Manages session locks for concurrent message processing.

SingleFieldStrategy

Generates session keys from a single metadata field.

Traits

SessionKeyExtractor

Trait for extracting metadata from messages for session key generation.

SessionKeyGenerator

Strategy trait for generating session keys from messages.