Struct direkuta::Direkuta

pub struct Direkuta { /* private fields */ }

The Direkuta web server itself.

Implementations

impl Direkuta

pub fn new() -> Self

Constructs a new Direkuta.

Examples

Direkuta::new();

pub fn config(c: impl Fn(&mut Config) + Send + Sync + 'static) -> Self

Set the configuration of the server.

This is an alternative to Direkuta::new() and allows you to set custom paths.

Examples

Direkuta::config(|c| {
    c.template_path("html/templates");
});

pub fn state<T: Any + Send + Sync + 'static>(self, state: T) -> Self

Insert a state into server.

Examples

Direkuta::new()
    .state(String::from("Hello World!"));

Panics

Do not use this from anywhere else but the main constructor. Using this from any else will cause a thread panic.

pub fn middle<T: Middle + Send + Sync + 'static>(self, middle: T) -> Self

Insert a middleware into server.

Middleware is anything that implements the trait Middle.

Examples

Direkuta::new()
    .middle(Logger::new());

Panics

Do not use this from anywhere else but the main constructor. Using this from any else will cause a thread panic.

pub fn route(self, route: impl Fn(&mut Router) + Send + Sync + 'static) -> Self

Create new router as a closure.

Examples

Direkuta::new()
    .route(|r| {
        // handlers here
    });

pub fn run(self, addr: &str)

Run server as a Hyper server.

Examples

// Not tested due to the fact that its a web server.
Direkuta::new()
    .run("0.0.0.0:3000");

Errors

If any errors come from the server they will be printed to the console.

Trait Implementations

impl Default for Direkuta

fn default() -> Self

Returns the “default value” for a type.

impl NewService for Direkuta

type ReqBody = Body

The Payload body of the http::Request.

type ResBody = Body

The Payload body of the http::Response.

type Error = DireError

The error type that can be returned by Services.

type InitError = DireError

The error type that can be returned when creating a new Service.

type Service = Direkuta

The resolved Service from new_service().

type Future = Box<dyn Future<Item = <Direkuta as NewService>::Service, Error = <Direkuta as NewService>::InitError> + Send + 'static, Global>

The future returned from new_service of a Service.

fn new_service(&self) -> Self::Future

Create a new Service.

impl Service for Direkuta

type ReqBody = Body

The Payload body of the http::Request.

type ResBody = Body

The Payload body of the http::Response.

type Error = DireError

The error type that can occur within this Service.

type Future = Box<dyn Future<Item = Response<<Direkuta as Service>::ResBody>, Error = <Direkuta as Service>::Error> + Send + 'static, Global>

The Future returned by this Service.

fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future

Calls this Service with a request, returning a Future of the response.

fn poll_ready(&mut self) -> Result<Async<()>, Self::Error>

Returns Ready when the service is able to process requests.