Struct SessionManager 

pub struct SessionManager { /* private fields */ }

Multi-client session manager

Manages multiple concurrent OpenIGTLink client connections with automatic message routing and broadcasting capabilities.

Implementations

impl SessionManager

pub async fn new(addr: &str) -> Result<Self>

Create a new session manager bound to the specified address

Arguments

• addr - Address to bind (e.g., “127.0.0.1:18944”)

Examples

use openigtlink_rust::io::SessionManager;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let manager = SessionManager::new("0.0.0.0:18944").await?;
    Ok(())
}

pub fn local_addr(&self) -> Result<SocketAddr>

Get the local address this manager is bound to

pub async fn client_count(&self) -> usize

Get the number of active client connections

Examples

println!("Active clients: {}", manager.client_count().await);

pub async fn client_ids(&self) -> Vec<ClientId>

Get a list of all active client IDs

pub async fn client_info(&self, client_id: ClientId) -> Option<ClientInfo>

Get information about a specific client

pub async fn add_handler(&self, handler: Box<dyn MessageHandler>)

Register a message handler

Handlers are called in the order they were registered.

Examples

use openigtlink_rust::io::{SessionManager, MessageHandler, ClientId};

struct MyHandler;

impl MessageHandler for MyHandler {
    fn handle_message(&self, client_id: ClientId, type_name: &str, data: &[u8]) {
        println!("Client {} sent {}", client_id, type_name);
    }
}

manager.add_handler(Box::new(MyHandler)).await;

pub async fn accept_clients(&self)

Accept new client connections in a loop

This method runs forever, accepting new clients and spawning handler tasks. It should be run in a separate task.

Examples

use openigtlink_rust::io::SessionManager;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let manager = Arc::new(SessionManager::new("127.0.0.1:18944").await?);

    // Spawn acceptor in background
    let mgr = manager.clone();
    tokio::spawn(async move {
        mgr.accept_clients().await;
    });

    // Do other work...
    Ok(())
}

pub async fn broadcast<T: Message + Clone>(&self, message: &T) -> Result<()>

Broadcast a message to all connected clients

Examples

use openigtlink_rust::io::SessionManager;
use openigtlink_rust::protocol::types::StatusMessage;

let status = StatusMessage::ok("System ready");
manager.broadcast(&status).await?;

pub async fn send_to<T: Message + Clone>( &self, client_id: ClientId, message: &T, ) -> Result<()>

Send a message to a specific client

Examples

use openigtlink_rust::io::SessionManager;
use openigtlink_rust::protocol::types::StatusMessage;

let status = StatusMessage::ok("Personal message");
manager.send_to(42, &status).await?;

pub async fn disconnect(&self, client_id: ClientId) -> Result<()>

Disconnect a specific client

pub async fn shutdown(&self)

Disconnect all clients and shut down