Struct Client 

pub struct Client { /* private fields */ }

Client is a handle to an established NWEP connection.

Client is cheap to clone; all clones share the same underlying QUIC connection and event loop. Use fetch, get, or post to make requests, and close when done.

Implementations

impl Client

pub fn node_id(&self) -> NodeId

node_id returns the local node’s identifier derived from the connecting keypair.

pub fn peer_identity(&self) -> Identity

peer_identity returns the verified identity of the remote server as established during the NWEP mutual-authentication handshake.

pub fn peer_node_id(&self) -> NodeId

peer_node_id returns the remote server’s node identifier.

This is a convenience shorthand for client.peer_identity().node_id.

pub fn fetch( &self, method: &str, path: &str, body: &[u8], ) -> Result<Response, Error>

fetch sends a request with the given method, path, and body, blocking until the complete response is received or the request timeout elapses.

Errors

Returns Err if the connection is closed, the timeout elapses, or the server returns an error response. Use is_ok on the returned Response to distinguish application-level errors from transport errors.

pub fn fetch_with_headers( &self, method: &str, path: &str, body: &[u8], headers: &[Header], ) -> Result<Response, Error>

fetch_with_headers sends a request with the given method, path, body, and additional request headers, blocking until the complete response is received.

Errors

Returns Err if the connection is closed, the timeout elapses, or the C layer fails to open a stream.

pub fn get(&self, path: &str) -> Result<Response, Error>

get sends a read request to path with no body.

This is a convenience wrapper around fetch using the NWEP read method.

Examples found in repository

examples/client.rs (line 36)

fn main() {
    let url = std::env::args().nth(1).unwrap_or_else(|| {
        eprintln!("usage: client <web://url/path>");
        process::exit(1);
    });

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

    nwep::log::set_level(nwep::log::LogLevel::Warn);
    nwep::log::set_stderr(true);

    let parsed = Url::parse(&url).unwrap_or_else(|e| {
        eprintln!("parse url: {e}");
        process::exit(1);
    });
    let path = if parsed.path.is_empty() { "/".to_string() } else { parsed.path.clone() };

    let keypair = Keypair::generate().unwrap_or_else(|e| {
        eprintln!("keygen: {e}");
        process::exit(1);
    });

    let client = ClientBuilder::new()
        .connect(keypair, &url)
        .unwrap_or_else(|e| {
            eprintln!("connect: {e}");
            process::exit(1);
        });

    let resp = client.get(&path).unwrap_or_else(|e| {
        eprintln!("get: {e}");
        process::exit(1);
    });

    println!("{}", resp.status);
    println!("{}", String::from_utf8_lossy(&resp.body));

    client.close();
}

pub fn post(&self, path: &str, body: &[u8]) -> Result<Response, Error>

post sends a write request to path with the given body bytes.

This is a convenience wrapper around fetch using the NWEP write method.

pub fn close(&self)

Sends the shutdown signal and blocks until the event loop thread has exited and all resources (C client, state, pending requests) have been freed.

Examples found in repository

examples/client.rs (line 44)

fn main() {
    let url = std::env::args().nth(1).unwrap_or_else(|| {
        eprintln!("usage: client <web://url/path>");
        process::exit(1);
    });

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

    nwep::log::set_level(nwep::log::LogLevel::Warn);
    nwep::log::set_stderr(true);

    let parsed = Url::parse(&url).unwrap_or_else(|e| {
        eprintln!("parse url: {e}");
        process::exit(1);
    });
    let path = if parsed.path.is_empty() { "/".to_string() } else { parsed.path.clone() };

    let keypair = Keypair::generate().unwrap_or_else(|e| {
        eprintln!("keygen: {e}");
        process::exit(1);
    });

    let client = ClientBuilder::new()
        .connect(keypair, &url)
        .unwrap_or_else(|e| {
            eprintln!("connect: {e}");
            process::exit(1);
        });

    let resp = client.get(&path).unwrap_or_else(|e| {
        eprintln!("get: {e}");
        process::exit(1);
    });

    println!("{}", resp.status);
    println!("{}", String::from_utf8_lossy(&resp.body));

    client.close();
}