Struct Server 

pub struct Server { /* private fields */ }

Server is the thread-safe handle to a running NWEP server.

Server is obtained from ServerBuilder::build alongside an EventLoop. It can be cloned and sent across threads freely; all mutating operations are communicated to the event loop via an internal channel.

Implementations

impl Server

pub fn node_id(&self) -> NodeId

node_id returns the server’s own 32-byte NWEP node identifier.

pub fn addr(&self) -> SocketAddr

addr returns the local UDP socket address the server is listening on.

Examples found in repository

examples/server.rs (line 70)

fn main() {
    nwep::init().unwrap_or_else(|e| {
        eprintln!("init: {e}");
        process::exit(1);
    });

    let key_file = std::env::var("NWEP_KEY_FILE").unwrap_or_else(|_| DEFAULT_KEY_FILE.into());
    let keypair = load_or_generate_keypair(&key_file).unwrap_or_else(|e| {
        eprintln!("keypair: {e}");
        process::exit(1);
    });

    let node_id = keypair.node_id().unwrap_or_else(|e| {
        eprintln!("node_id: {e}");
        process::exit(1);
    });
    eprintln!("node id: {node_id}");

    let mut router = Router::new();
    router.handle_func("/hello", |w: &mut ResponseWriter, _r: &Request| {
        let _ = w.respond("ok", b"hello from nwep-rust");
    });

    let addr = std::env::args().nth(1).unwrap_or_else(|| DEFAULT_ADDR.into());

    let (server, event_loop) = ServerBuilder::new(&addr, keypair)
        .on_connect(|info| eprintln!("connected: {}", info.node_id))
        .on_disconnect(|info, code| eprintln!("disconnected: {} (code {code})", info.node_id))
        .build(router)
        .unwrap_or_else(|e| {
            eprintln!("server: {e}");
            process::exit(1);
        });

    let url = server.url("/hello");
    eprintln!("listening on {}", server.addr());
    println!("{url}"); // URL printed to stdout for the client to read

    if let Err(e) = event_loop.run() {
        eprintln!("server run: {e}");
        process::exit(1);
    }
}

pub fn url(&self, path: &str) -> String

url formats a web:// URL for the given path on this server.

If the server was bound to an unspecified address (0.0.0.0 or ::), the URL uses the loopback address instead, matching Go’s server.URL() behaviour.

Example

println!("{}", server.url("/hello")); // e.g. "web://127.0.0.1:<node_id>:8080/hello"

Examples found in repository

examples/server.rs (line 69)

fn main() {
    nwep::init().unwrap_or_else(|e| {
        eprintln!("init: {e}");
        process::exit(1);
    });

    let key_file = std::env::var("NWEP_KEY_FILE").unwrap_or_else(|_| DEFAULT_KEY_FILE.into());
    let keypair = load_or_generate_keypair(&key_file).unwrap_or_else(|e| {
        eprintln!("keypair: {e}");
        process::exit(1);
    });

    let node_id = keypair.node_id().unwrap_or_else(|e| {
        eprintln!("node_id: {e}");
        process::exit(1);
    });
    eprintln!("node id: {node_id}");

    let mut router = Router::new();
    router.handle_func("/hello", |w: &mut ResponseWriter, _r: &Request| {
        let _ = w.respond("ok", b"hello from nwep-rust");
    });

    let addr = std::env::args().nth(1).unwrap_or_else(|| DEFAULT_ADDR.into());

    let (server, event_loop) = ServerBuilder::new(&addr, keypair)
        .on_connect(|info| eprintln!("connected: {}", info.node_id))
        .on_disconnect(|info, code| eprintln!("disconnected: {} (code {code})", info.node_id))
        .build(router)
        .unwrap_or_else(|e| {
            eprintln!("server: {e}");
            process::exit(1);
        });

    let url = server.url("/hello");
    eprintln!("listening on {}", server.addr());
    println!("{url}"); // URL printed to stdout for the client to read

    if let Err(e) = event_loop.run() {
        eprintln!("server run: {e}");
        process::exit(1);
    }
}

pub fn connection_count(&self) -> usize

connection_count returns the number of currently authenticated, connected peers.

The count is updated synchronously on the event loop thread when a peer connects or disconnects, so it may lag slightly behind the network state.

pub fn connected_peers(&self) -> Vec<NodeId>

connected_peers returns a snapshot of the node IDs of all currently connected peers.

pub fn shutdown(&self)

shutdown signals the event loop to stop accepting new connections and exit.

This call returns immediately; wait for EventLoop::run to return to confirm the server has fully stopped.

pub fn notify( &self, peer_node_id: NodeId, event: &str, path: &str, body: Vec<u8>, ) -> Result<(), Error>

notify sends a server-initiated push message to a single connected peer.

The peer receives the notification in its on_notify callback. event is a free-form event type string; path is the resource path; body is the payload.

Errors

Returns an error if the internal channel has been closed (i.e. the event loop has already stopped).

pub fn notify_with_options( &self, peer_node_id: NodeId, event: &str, path: &str, body: Vec<u8>, options: NotifyOptions, ) -> Result<(), Error>

notify_with_options sends a server-initiated push message with additional metadata.

Like notify but also accepts a NotifyOptions to attach custom headers or a stable notification identifier to the wire message.

Errors

Returns an error if the internal channel has been closed.

pub fn notify_all( &self, event: &str, path: &str, body: Vec<u8>, ) -> Result<(), Error>

notify_all broadcasts a push notification to every currently connected peer.

The message is sent to the snapshot of connections held by the event loop at the time it processes the event; peers that disconnect between the call and processing are silently skipped.

Errors

Returns an error if the internal channel has been closed.

pub fn close_connection( &self, peer_node_id: NodeId, error: i32, ) -> Result<(), Error>

close_connection forcefully closes the connection to the identified peer.

The peer is removed from internal state immediately and the on_disconnect callback fires before the QUIC CONNECTION_CLOSE is sent. This is intentional: the C library’s QUIC CLOSING state is asynchronous and the disconnect callback would otherwise be delayed until the peer sends a packet.

Errors

Returns an error if the internal channel has been closed.

pub fn log_server(&self) -> Option<Arc<Mutex<LogServer>>>

log_server returns the shared LogServer registered during build, if any.

The returned Arc<Mutex<LogServer>> is the same instance intercepting /log/* requests, so callers can inspect or modify log state without additional coordination.

pub fn anchor_server(&self) -> Option<Arc<Mutex<AnchorServer>>>

anchor_server returns the shared AnchorServer registered during build, if any.

The returned Arc<Mutex<AnchorServer>> is the same instance intercepting /checkpoint/* requests.