Struct Handle 

pub struct Handle { /* private fields */ }

A server running in the background, from Server::spawn. Stopping it (or dropping it) stops accepting connections and ends every session.

Implementations

impl Handle

pub fn local_addr(&self) -> SocketAddr

The address the server listens on.

pub fn url(&self) -> &str

The address to open in a browser, with the token.

Examples found in repository

examples/session_probe.rs (line 98)

fn main() -> std::io::Result<()> {
    let mut args = std::env::args().skip(1);
    let mut addr = "127.0.0.1:8080".to_string();
    let mut token = None;
    let mut startup = None;
    let mut stdin_stop = false;
    let mut nested = false;
    while let Some(arg) = args.next() {
        let mut value = || args.next().expect("a value after the option");
        match arg.as_str() {
            "--token" => token = Some(value()),
            "--startup-sleep" => startup = Some(value().parse::<u64>().expect("ms")),
            "--stdin-stop" => stdin_stop = true,
            "--nested" => nested = true,
            _ => addr = arg,
        }
    }
    if nested {
        // An unrelated program that serves an app: it should get the
        // address it asked for.
        let server = rich_web::Server::bind(addr.as_str(), app)?;
        println!("BOUND {}", server.local_addr());
        return Ok(());
    }
    if let (Some(ms), true) = (startup, std::env::var_os(rich_web::SESSION_ENV).is_some()) {
        std::thread::sleep(Duration::from_millis(ms));
    }
    let mut server = rich_web::Server::bind(addr.as_str(), app)?.title("session probe");
    if let Some(token) = token {
        server = server.token(token);
    }
    if stdin_stop {
        let handle = server.spawn()?;
        println!("Serving session probe at {}", handle.url());
        let mut line = String::new();
        std::io::stdin().lock().read_line(&mut line)?;
        let started = Instant::now();
        handle.stop();
        println!("STOPPED {}", started.elapsed().as_millis());
        return Ok(());
    }
    server.run()
}

pub fn sessions(&self) -> usize

The sessions running now.

pub fn stop(self)

Stop: no more connections, and every session ends (within one turn of its loop, at most 50 ms). A program’s session ends its program: it is hung up on, and a LocalPty’s is killed, with its process group, if it is still running a second later. This returns once every program has ended; a connection still sending its request is not served.

Examples found in repository

examples/session_probe.rs (line 102)

fn main() -> std::io::Result<()> {
    let mut args = std::env::args().skip(1);
    let mut addr = "127.0.0.1:8080".to_string();
    let mut token = None;
    let mut startup = None;
    let mut stdin_stop = false;
    let mut nested = false;
    while let Some(arg) = args.next() {
        let mut value = || args.next().expect("a value after the option");
        match arg.as_str() {
            "--token" => token = Some(value()),
            "--startup-sleep" => startup = Some(value().parse::<u64>().expect("ms")),
            "--stdin-stop" => stdin_stop = true,
            "--nested" => nested = true,
            _ => addr = arg,
        }
    }
    if nested {
        // An unrelated program that serves an app: it should get the
        // address it asked for.
        let server = rich_web::Server::bind(addr.as_str(), app)?;
        println!("BOUND {}", server.local_addr());
        return Ok(());
    }
    if let (Some(ms), true) = (startup, std::env::var_os(rich_web::SESSION_ENV).is_some()) {
        std::thread::sleep(Duration::from_millis(ms));
    }
    let mut server = rich_web::Server::bind(addr.as_str(), app)?.title("session probe");
    if let Some(token) = token {
        server = server.token(token);
    }
    if stdin_stop {
        let handle = server.spawn()?;
        println!("Serving session probe at {}", handle.url());
        let mut line = String::new();
        std::io::stdin().lock().read_line(&mut line)?;
        let started = Instant::now();
        handle.stop();
        println!("STOPPED {}", started.elapsed().as_millis());
        return Ok(());
    }
    server.run()
}

Trait Implementations

impl Drop for Handle

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.