Struct ClientSession 

pub struct ClientSession { /* private fields */ }

Represents an active client session

Implementations

impl ClientSession

pub async fn handle_per_command_routing( &self, client_stream: TcpStream, ) -> Result<(u64, u64)>

Handle a client connection with per-command routing Each command is routed independently to potentially different backends

impl ClientSession

pub async fn handle_with_pooled_backend<T>( &self, client_stream: TcpStream, backend_conn: T, ) -> Result<(u64, u64)>

where T: AsyncRead + AsyncWrite + Unpin,

Handle a client connection with a dedicated backend connection (standard 1:1 mode)

impl ClientSession

pub fn new( client_addr: SocketAddr, buffer_pool: BufferPool, auth_handler: Arc<AuthHandler>, ) -> Self

Create a new client session for 1:1 backend mapping

pub fn new_with_router( client_addr: SocketAddr, buffer_pool: BufferPool, router: Arc<BackendSelector>, routing_mode: RoutingMode, auth_handler: Arc<AuthHandler>, ) -> Self

Create a new client session for per-command routing mode

pub fn builder( client_addr: SocketAddr, buffer_pool: BufferPool, auth_handler: Arc<AuthHandler>, ) -> ClientSessionBuilder

Create a builder for constructing a client session

Examples

use std::net::SocketAddr;
use std::sync::Arc;
use nntp_proxy::session::ClientSession;
use nntp_proxy::pool::BufferPool;
use nntp_proxy::types::BufferSize;
use nntp_proxy::auth::AuthHandler;

let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
let buffer_pool = BufferPool::new(BufferSize::DEFAULT, 10);
let auth_handler = Arc::new(AuthHandler::new(None, None));

// Standard 1:1 routing mode
let session = ClientSession::builder(addr, buffer_pool.clone(), auth_handler)
    .build();

assert!(!session.is_per_command_routing());

pub fn client_id(&self) -> ClientId

Get the unique client ID

pub fn is_per_command_routing(&self) -> bool

Check if this session is using per-command routing

pub fn mode(&self) -> SessionMode

Get the current session mode