2 releases

Uses new Rust 2021

0.1.1 May 4, 2022
0.1.0 Apr 28, 2022

#2191 in Network programming

MIT license

110KB
2.5K SLoC

Robust, ergonomic CoAP server in Rust

Build Status Coverage Status Crates.io MIT licensed

An asynchronous CoAP server with a modern and ergonomic API for larger scale applications, inspired by warp and actix. CoAP offers an excellent alternative to HTTP for resource constrained environments like IoT devices.

  • Ergonomic: Fluent app-builder API makes it easy to compose rich applications, including those that use more advanced CoAP features.
  • Concurrent: High concurrency is supported by using a separate spawned task for each request, allowing long running requests to not interfere with shorter running ones at scale.
  • Feature-rich: Conveniently supports a wide range of CoAP server features including Observe, and Block-wise Transfer.
  • Flexible: Supports pluggable transport backends with goals of supporting alternative async runtimes like embassy.

Example

use coap_server::app::{CoapError, Request, Response};
use coap_server::{app, CoapServer, FatalServerError, UdpTransport};

#[tokio::main]
async fn main() -> Result<(), FatalServerError> {
    let server = CoapServer::bind(UdpTransport::new("0.0.0.0:5683")).await?;
    server.serve(
        app::new().resource(
            app::resource("/hello").get(handle_get_hello))
    ).await
}

async fn handle_get_hello(request: Request<SocketAddr>) -> Result<Response, CoapError> {
    let whom = request
        .unmatched_path
        .first()
        .cloned()
        .unwrap_or_else(|| "world".to_string());

    let mut response = request.new_response();
    response.message.payload = format!("Hello, {whom}").into_bytes();
    Ok(response)
}

To experiment, I recommend using the excellent coap-client command-line tool, as with:

$ coap-client -m get coap://localhost/hello
Hello, world

See examples for more.

Features

This project aims to be a robust and complete CoAP server, and in particular a more convenient alternative to MQTT for Rust-based projects:

  • Correct and convenient Observe support (RFC 7641)
  • Block-wise transfer support (RFC 7959)
  • Resource discovery and filtering via /.well-known/core (RFC 6690)
  • Multicast UDP
  • Fully concurrent request handling (no head-of-line blocking or scaling surprises!)
  • Ping/Pong keep-alive messages

Desired but not implemented:

Dependencies

~6–12MB
~217K SLoC