Crate kvarn

An extensible and efficient forward-thinking web server for the future.

Kvarn is a rethought web server tailored for the current needs from web application developers.

It handles several things for you, including

• Content-Type
• Compression of body
• Correct and performant HTTP/1 and HTTP/2
• Common API across HTTP/1 and HTTP/2
• Easy integration with HTTP/2 push promises
• Five types of extensions, all backed with intuitive macros
• Optional encryption with rustls
• Several checks for illegal requests
• cache-control and kvarn-cache-control header limits server cache lifetimes

Getting started

To get started, configure a RunConfig. See the example at RunConfig::execute on how to get a simple web server running.

A battle-tested reference implementation can be found at GitHub. It powers my two websites with minimal resource requirements.

Future plans

See the README @ GitHub and kvarn.org.

Re-exports

pub use error::default as default_error;

pub use error::default_response as default_error_response;

pub use extensions::Extensions;

pub use extensions::Id;

pub use read::file as read_file;

pub use read::file_cached as read_file_cached;

Modules

application

Abstractions for the application layer, providing a common interface for all HTTP versions supported.

comprash

Compress and cache.

cors

CORS implementation for Kvarn.

csp

CSP implementation for Kvarn.

encryption

Encryption for incoming and outgoing traffic, implemented through streams.

error

Utility functions to generate error responses.

extensions

Here, all extensions code is housed.

host

Handling of multiple Hosts on one instance of Kvarn.

limiting

Limits traffic from a IP address to partially mitigate attacks.

prelude

The Kvarn Prelude

read

Utilities for reading files with or without a FileCache.

shutdown

Graceful shutdown for Kvarn.

vary

Vary header handling in Kvarn.

Macros

box_fut

Makes a pinned future, compatible with crate::RetFut and crate::RetSyncFut

extension

The ultimate extension-creation macro.

package

Will make a Package extension.

post

Will make a Post extension.

prepare

Will make a Prepare extension.

present

Will make a Present extension.

prime

Will make a Prime extension.

response_pipe_fut

Creates a ResponsePipeFuture.

run_config

Creates a RunConfig from PortDescriptors. This allows you to configure the RunConfig and then RunConfig::execute the server.

Structs

FatResponse

A Response returned by handle_request().

PortDescriptor

Describes port, certificate, and host data for a single port to bind.

RunConfig

Configuration for Self::execute. This mainly consists of an array of PortDescriptors.

Enums

BindIpVersion

Which version of the Internet Protocol to bind to.

SendKind

How to send data to the client.

Constants

SERVER

The Kvarn server header. Can also be used for identifying the client when using Kvarn as a reverse-proxy.

Functions

handle_cache

Will handle a single request, check the cache, process if needed, and caches it. This is where the response is sent.

handle_connection

Handles a single connection. This includes encrypting it, extracting the HTTP header information, optionally (HTTP/2 & HTTP/3) decompressing them, and passing the request to handle_cache(). It will also recognise which host should handle the connection.

handle_request

Handles a single request and returns response with cache and compress preference.

Type Definitions

FatRequest

The Request used within Kvarn.