Struct App 

pub struct App { /* private fields */ }

An assembled, immutable, cheaply-cloneable application.

Produced by AppBuilder::build. Internally reference-counted, so cloning is cheap and clones share the same router, middleware, state, and config. Serve it with start (or start_with_shutdown), drive a single request in-process with process, or hand it to a TestClient for testing.

use churust_core::{Churust, Call, TestClient};
let app = Churust::server()
    .routing(|r| { r.get("/", |_c: Call| async { "ok" }); })
    .build();
let clone = app.clone(); // cheap; shares the same inner app
let res = TestClient::new(clone).get("/").send().await;
assert_eq!(res.status().as_u16(), 200);

Implementations

impl App

pub fn config(&self) -> &ServerConfig

The resolved ServerConfig this app was built with.

pub async fn process( &self, method: Method, uri: Uri, headers: HeaderMap, body: Bytes, ) -> Response

The single request entry point: run one request through the full pipeline (middleware then routed handler) and return the Response.

Both the hyper engine and the TestClient call this. It is panic-isolated — a panicking handler is caught and turned into 500 Internal Server Error rather than crashing the task.

use churust_core::{Churust, Call};
use http::{HeaderMap, Method};
use bytes::Bytes;
let app = Churust::server()
    .routing(|r| { r.get("/", |_c: Call| async { "ok" }); })
    .build();
let res = app.process(Method::GET, "/".parse().unwrap(), HeaderMap::new(), Bytes::new()).await;
assert_eq!(res.status.as_u16(), 200);

THE single request entry point used by the engine and TestClient. Panic-isolated: a panicking handler yields 500.

pub async fn process_with_extensions( &self, method: Method, uri: Uri, headers: HeaderMap, body: Bytes, extensions: Extensions, ) -> Response

Like App::process, but seeds the Call with pre-built extensions (e.g. a captured WebSocket upgrade handle). Advanced/engine use.

pub async fn start(self) -> Result<()>

Bind the configured address and serve until Ctrl-C (SIGINT), then drain in-flight connections gracefully. Does not return until shutdown.

Errors

Returns an std::io::Error if the configured host:port is invalid or the socket cannot be bound (e.g. the port is in use).

use churust_core::{Churust, Call};
let app = Churust::server()
    .routing(|r| { r.get("/", |_c: Call| async { "hi" }); })
    .build();
app.start().await

pub async fn start_with_shutdown<F>(self, shutdown: F) -> Result<()>

where F: Future<Output = ()> + Send + 'static,

Bind and serve until the provided shutdown future resolves, then drain gracefully. Use this to wire a custom shutdown signal (e.g. in tests, or to combine SIGTERM with SIGINT).

Errors

Returns an std::io::Error if the configured host:port is invalid or the socket cannot be bound.

use churust_core::{Churust, Call};
let app = Churust::server()
    .routing(|r| { r.get("/", |_c: Call| async { "hi" }); })
    .build();
let (tx, rx) = tokio::sync::oneshot::channel::<()>();
// ... later: tx.send(()) to trigger shutdown ...
app.start_with_shutdown(async { let _ = rx.await; }).await

Trait Implementations

impl Clone for App

fn clone(&self) -> App

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.