Struct NomadServer 

pub struct NomadServer<S: SyncState> { /* private fields */ }

Available on crate feature server only.

A NOMAD protocol server.

Generic over state type S which must implement SyncState.

Example

use nomad_protocol::server::{NomadServer, NomadServerBuilder};

let config = NomadServerBuilder::new()
    .bind_addr("0.0.0.0:19999".parse()?)
    .private_key(server_privkey)
    .build();

let (server, mut events) = NomadServer::<MyState>::bind(config, initial_state_factory).await?;

// Handle events
while let Some(event) = events.recv().await {
    match event {
        ServerEvent::ClientConnected { session_id, .. } => {
            println!("Client connected: {:?}", session_id);
        }
        ServerEvent::StateUpdated { session_id, state } => {
            // Process client state, send response
            server.send_to(session_id, response_state).await?;
        }
        ServerEvent::ClientDisconnected { session_id } => {
            println!("Client disconnected: {:?}", session_id);
        }
    }
}

Implementations

impl<S: SyncState> NomadServer<S>

pub async fn bind<F>( config: ServerConfig, _state_factory: F, ) -> Result<(Self, Receiver<ServerEvent<S>>), ServerError>

where F: Fn() -> S + Send + Sync + 'static,

Bind to an address and start the server.

The state_factory is called for each new session to create the initial state.

pub fn local_addr(&self) -> SocketAddr

Get the local address the server is bound to.

pub async fn session_count(&self) -> usize

Get the number of active sessions.

pub async fn send_to( &self, session_id: ServerSessionId, state: S, ) -> Result<(), ServerError>

Send state to a specific session.

pub async fn broadcast(&self, state: S) -> Result<(), ServerError>

Broadcast state to all sessions.

pub fn session_sender(&self, session_id: ServerSessionId) -> SessionSender<S>

Get a sender handle for a specific session.

pub async fn disconnect( &self, session_id: ServerSessionId, ) -> Result<(), ServerError>

Disconnect a specific session.

pub async fn shutdown(self) -> Result<(), ServerError>

Gracefully shut down the server.

pub fn config(&self) -> &ServerConfig

Get the server configuration.

Trait Implementations

impl<S: SyncState> Drop for NomadServer<S>

fn drop(&mut self)

Executes the destructor for this type.