Struct Unit

pub struct Unit { /* private fields */ }

The Unit application context.

This object wraps the libunit library, which talks to the Unit server over shared memory and a unix socket in order to receive data about requests.

This object is not Send nor Sync, and cannot be sent to other threads.

However, multiple objects of this type may be created; additional Unit objects will automatically be linked to the first through a global mutex, and will be able to receive and process requests in other threads.

The first context is internally wrapped in an Arc, shared among all instances Unit and will be deallocated when the last Unit object is dropped.

Implementations

impl Unit

pub fn new() -> Result<Self, UnitInitError>

Create a new Unit context capable of receiving and handling requests on the current thread.

If called after a previous Unit was constructed but already received a QUIT event from the Unit server, this will return a no-op Unit instance whose Unit::run method will immediately return.

If called after a previous Unit failed to initialize, this will return the same initialization failure.

Examples found in repository

examples/request_info.rs (line 9)

fn main() {
    let mut unit = Unit::new().unwrap();

    unit.set_request_handler(request_handler);

    unit.run();
}

examples/hello_world.rs (line 6)

fn main() {
    let mut unit = Unit::new().unwrap();

    unit.set_request_handler(|req: Request| {
        let headers = &[("Content-Type", "text/plain")];
        let body = "Hello world!\n";
        req.send_response(200, headers, body)?;

        Ok(())
    });

    unit.run();
}

examples/http_adapter.rs (line 8)

fn main() {
    let mut unit = Unit::new().unwrap();

    unit.set_request_handler(HttpHandler::new(|req: Request<Vec<u8>>| {
        let body = format!("Hello world!\n\nBody length: {}\n", req.body().len());

        // The Unit server redirects stdout/stderr to the server log.
        eprintln!("Received reqest for: {}", req.uri().path());

        if req.uri().path() == "/panic" {
            // The HttpHandler converts panics into 501 errors. This imposes an
            // UnwindSafe restriction on the request handler.
            panic!("The /panic path panics!")
        }

        let response = Response::builder()
            .header("Content-Type", "text/plain")
            .body(body.into_bytes())
            .unwrap();

        Ok(response)
    }));

    unit.run();
}

examples/multi_threaded.rs (line 30)

fn worker(thread_id: i32, global_visits: Arc<AtomicI32>) {
    let mut unit = Unit::new().unwrap();

    // Thread state, available through a mutable, unique reference.
    let mut thread_visits = 0;

    unit.set_request_handler(move |req: Request| {
        if req.path() == "/panic" {
            // This library supports safely forwarding panics through the FFI.
            panic!("The /panic path panics!")
        }

        let headers = &[("Content-Type", "text/plain")];
        let body = "Hello world!\n";
        req.send_response(200, headers, body)?;
        thread_visits += 1;
        global_visits.fetch_add(1, Ordering::Release);

        req.send_chunk_with_buffer(4096, |buf| {
            writeln!(
                buf,
                "Thread {} visits: {} (global visits: {})",
                thread_id,
                thread_visits,
                global_visits.load(Ordering::Acquire),
            )
            .unwrap();
            Ok(())
        })?;

        Ok(())
    });

    unit.run();
}

pub fn set_request_handler(&mut self, f: impl UnitService + 'static)

Set a request handler for the Unit application.

The handler must be an object that implements the UnitService trait.

This trait is automatically implemented for functions or lambda functions that take a Request object and return a UnitResult<()>.

Examples found in repository

examples/request_info.rs (line 11)

fn main() {
    let mut unit = Unit::new().unwrap();

    unit.set_request_handler(request_handler);

    unit.run();
}

examples/hello_world.rs (lines 8-14)

fn main() {
    let mut unit = Unit::new().unwrap();

    unit.set_request_handler(|req: Request| {
        let headers = &[("Content-Type", "text/plain")];
        let body = "Hello world!\n";
        req.send_response(200, headers, body)?;

        Ok(())
    });

    unit.run();
}

examples/http_adapter.rs (lines 10-28)

fn main() {
    let mut unit = Unit::new().unwrap();

    unit.set_request_handler(HttpHandler::new(|req: Request<Vec<u8>>| {
        let body = format!("Hello world!\n\nBody length: {}\n", req.body().len());

        // The Unit server redirects stdout/stderr to the server log.
        eprintln!("Received reqest for: {}", req.uri().path());

        if req.uri().path() == "/panic" {
            // The HttpHandler converts panics into 501 errors. This imposes an
            // UnwindSafe restriction on the request handler.
            panic!("The /panic path panics!")
        }

        let response = Response::builder()
            .header("Content-Type", "text/plain")
            .body(body.into_bytes())
            .unwrap();

        Ok(response)
    }));

    unit.run();
}

examples/multi_threaded.rs (lines 35-60)

fn worker(thread_id: i32, global_visits: Arc<AtomicI32>) {
    let mut unit = Unit::new().unwrap();

    // Thread state, available through a mutable, unique reference.
    let mut thread_visits = 0;

    unit.set_request_handler(move |req: Request| {
        if req.path() == "/panic" {
            // This library supports safely forwarding panics through the FFI.
            panic!("The /panic path panics!")
        }

        let headers = &[("Content-Type", "text/plain")];
        let body = "Hello world!\n";
        req.send_response(200, headers, body)?;
        thread_visits += 1;
        global_visits.fetch_add(1, Ordering::Release);

        req.send_chunk_with_buffer(4096, |buf| {
            writeln!(
                buf,
                "Thread {} visits: {} (global visits: {})",
                thread_id,
                thread_visits,
                global_visits.load(Ordering::Acquire),
            )
            .unwrap();
            Ok(())
        })?;

        Ok(())
    });

    unit.run();
}

pub fn run(&mut self)

Enter the main event loop, handling requests on this thread until the Unit server exits or requests a restart.

This may be executed in parallel with other threads that call Unit::run()

Examples found in repository

examples/request_info.rs (line 13)

fn main() {
    let mut unit = Unit::new().unwrap();

    unit.set_request_handler(request_handler);

    unit.run();
}

examples/hello_world.rs (line 16)

fn main() {
    let mut unit = Unit::new().unwrap();

    unit.set_request_handler(|req: Request| {
        let headers = &[("Content-Type", "text/plain")];
        let body = "Hello world!\n";
        req.send_response(200, headers, body)?;

        Ok(())
    });

    unit.run();
}

examples/http_adapter.rs (line 30)

fn main() {
    let mut unit = Unit::new().unwrap();

    unit.set_request_handler(HttpHandler::new(|req: Request<Vec<u8>>| {
        let body = format!("Hello world!\n\nBody length: {}\n", req.body().len());

        // The Unit server redirects stdout/stderr to the server log.
        eprintln!("Received reqest for: {}", req.uri().path());

        if req.uri().path() == "/panic" {
            // The HttpHandler converts panics into 501 errors. This imposes an
            // UnwindSafe restriction on the request handler.
            panic!("The /panic path panics!")
        }

        let response = Response::builder()
            .header("Content-Type", "text/plain")
            .body(body.into_bytes())
            .unwrap();

        Ok(response)
    }));

    unit.run();
}

examples/multi_threaded.rs (line 62)

fn worker(thread_id: i32, global_visits: Arc<AtomicI32>) {
    let mut unit = Unit::new().unwrap();

    // Thread state, available through a mutable, unique reference.
    let mut thread_visits = 0;

    unit.set_request_handler(move |req: Request| {
        if req.path() == "/panic" {
            // This library supports safely forwarding panics through the FFI.
            panic!("The /panic path panics!")
        }

        let headers = &[("Content-Type", "text/plain")];
        let body = "Hello world!\n";
        req.send_response(200, headers, body)?;
        thread_visits += 1;
        global_visits.fetch_add(1, Ordering::Release);

        req.send_chunk_with_buffer(4096, |buf| {
            writeln!(
                buf,
                "Thread {} visits: {} (global visits: {})",
                thread_id,
                thread_visits,
                global_visits.load(Ordering::Acquire),
            )
            .unwrap();
            Ok(())
        })?;

        Ok(())
    });

    unit.run();
}

Trait Implementations

impl Drop for Unit

fn drop(&mut self)

Executes the destructor for this type.