Struct ServerBuilder 

pub struct ServerBuilder { /* private fields */ }

ServerBuilder constructs and configures a NWEP server before binding.

Use the builder pattern to attach callbacks, override Settings, and register optional sub-servers. Call build when configuration is complete.

Implementations

impl ServerBuilder

pub fn new(addr: impl Into<String>, keypair: Keypair) -> Self

new creates a builder that will bind the server to addr and authenticate with keypair.

addr is any string accepted by std::net::UdpSocket::bind (e.g. "0.0.0.0:4433"). The keypair provides the Ed25519 identity used in the mutual-authentication handshake.

Examples found in repository

examples/server.rs (line 60)

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 settings(self, s: Settings) -> Self

settings overrides the default transport settings for this server.

pub fn on_connect<F: Fn(ConnInfo) + Send + 'static>(self, f: F) -> Self

on_connect registers a callback invoked each time a peer completes the handshake.

The callback receives a ConnInfo describing the new peer. It runs on the event loop thread, so it should be fast and non-blocking.

Examples found in repository

examples/server.rs (line 61)

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 on_disconnect<F: Fn(ConnInfo, i32) + Send + 'static>(self, f: F) -> Self

on_disconnect registers a callback invoked each time a peer disconnects.

The second argument is an error code: 0 means a clean shutdown, non-zero indicates a transport error. The callback runs on the event loop thread.

Examples found in repository

examples/server.rs (line 62)

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 log_server(self, ls: Arc<Mutex<LogServer>>) -> Self

Register a LogServer to automatically handle requests to /log and /log/*. The Arc<Mutex<LogServer>> is shared with the returned Server so callers can still access it via Server::log_server() after starting.

pub fn anchor_server(self, as_: Arc<Mutex<AnchorServer>>) -> Self

Register an AnchorServer to automatically handle requests to /checkpoint and /checkpoint/*.

pub fn build<H: Handler>(self, handler: H) -> Result<(Server, EventLoop), Error>

Examples found in repository

examples/server.rs (line 63)

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);
    }
}