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.
• ctlhandover
  Control the Kvarn server from the outside.
• 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.
• websocketwebsocket
  Easy and fast WebSockets for Kvarn.

Macros

• box_fut
  Create a pinned future, compatible with crate::RetFut.
• extension
  The ultimate extension-creation macro.
• package
  Construct a Package extension like you write closures.
• pluginhandover
  Create a Plugin.
• post
  Construct a Post extension like you write closures.
• prepare
  Construct a Prepare extension like you write closures.
• present
  Construct a Present extension like you write closures.
• prime
  Construct a Prime extension like you write closures.
• response_pipe_fut
  Creates a super::ResponsePipeFuture.
• run_config
  Creates a RunConfig from PortDescriptors. This allows you to configure the RunConfig and then RunConfig::execute the server.

Structs

• CacheReply
  The returned data from handle_cache.
• 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.
• Incoming
  An incoming connection, before it’s wrapped with HTTP.
• SendKind
  How to send data to the client.

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 recognize which host should handle the connection.
• handle_request
  Handles a single request and returns response with cache and compress preference.
• spawn
  Spawn a task.

Type Aliases

• FatRequest
  The Request used within Kvarn.