Struct CoapServer 

pub struct CoapServer { /* private fields */ }

A CoAP server that implements the core [Transport] and [Receive] traits.

It is the far end of a CoapTransport: a gateway that nodes send their readings to and observe their commands on. A PUT or POST to a path matching one of its subscribe filters is answered 2.04 Changed and delivered to recv, and one to any other path is answered 4.04 Not Found. send sets the state of a resource, which a GET reads and every observer of the path is notified of, as RFC 7641 describes.

Examples

use pamoja_coap::CoapServer;
use pamoja_core::{Receive, Transport};

let mut gateway = CoapServer::new("0.0.0.0:5683");
gateway.connect().await?;
gateway.subscribe("sensors/#").await?;
gateway.send_text("commands/valve", "closed").await?;

while let Some(reading) = gateway.recv().await? {
    println!("{}: {}", reading.topic, reading.text()?);
}

Implementations

impl CoapServer

pub fn new(bind: impl Into<String>) -> Self

Creates a server that will listen on a local address, without binding it.

Arguments

• bind - the local host:port, such as "0.0.0.0:5683" for the plaintext CoAP port on every interface, or port 0 for a free one.

Returns

A server ready for connect.

pub fn publisher(&self) -> CoapPublisher

Takes a handle that publishes resource states while a receive waits.

Returns

A publisher sharing this server’s resources and socket.

pub fn is_connected(&self) -> bool

Reports whether the server holds a bound socket.

Returns

true from a successful connect until disconnect.

pub fn local_addr(&self) -> Option<SocketAddr>

The address the server listens on, which names the port the system chose when it bound port 0.

Returns

The local address, or None before connect.

pub fn observers(&self, path: &str) -> usize

Counts the clients observing a resource.

Arguments

• path - the resource’s path.

Returns

How many observers the resource has.

pub async fn disconnect(&mut self) -> Result<()>

Closes the socket and stops the background task.

The resources and filters are kept for the next connect, and the observers are dropped, since their registrations were made to the socket that closed.

Returns

Ok(()) once the socket is released.

Errors

This call is best-effort and always returns Ok(()).

Trait Implementations

impl Receive for CoapServer

async fn recv(&mut self) -> Result<Option<Message>>

Awaits the next reading sent to a path the server takes.

Returns

Some(message) for the next reading, carrying the path it was sent to.

Errors

Returns [Error::Closed] if the server is not connected.

impl Transport for CoapServer

async fn connect(&mut self) -> Result<()>

Binds the server’s socket and starts answering requests.

Returns

Ok(()) once the socket is bound.

Errors

Returns [Error::Transport] if the address cannot be bound, such as a port another program holds.

async fn send(&mut self, topic: &str, payload: &[u8]) -> Result<()>

Sets the state of a resource and notifies every observer of it, as CoapPublisher::publish does.

Arguments

• topic - the resource’s path.
• payload - its new state, which a GET now reads.

Returns

Ok(()) once each observer’s notification has left.

Errors

Returns [Error::Closed] if the server is not connected.

async fn subscribe(&mut self, topic: &str) -> Result<()>

Takes the readings sent to the paths a filter matches.

Arguments

• topic - the filter, with + for one level and # for the rest, as [topic_matches] reads them.

Returns

Ok(()) once the filter is in place. A server takes readings for its filters whether or not it is connected.

fn send_text( &mut self, topic: &str, text: &str, ) -> impl Future<Output = Result<(), Error>> + Send

Publishes text to a topic: words, or a number written out.