Struct kwap::blocking::client::Client

pub struct Client<Cfg: Platform> { /* private fields */ }

A blocking CoAP request client

Implementations

impl Client<StdSecure>

pub fn try_new_secure(port: u16) -> Result<Self>

Create a new Client secured by DTLS

use kwap::blocking::Client;
use kwap::req::ReqBuilder;
use kwap::ContentFormat;

let mut client = Client::try_new_secure(1234).unwrap();
let req = ReqBuilder::get("127.0.0.1:5683".parse().unwrap(), "hello").accept(ContentFormat::Text)
                                                                     .build()
                                                                     .unwrap();

let rep = client.send(req).unwrap();

println!("Hello, {}!", rep.payload_string().unwrap());

pub fn try_new_secure_config(port: u16, config: Config) -> Result<Self>

Create a new std client with a specific runtime config

impl Client<Std>

pub fn new_std() -> Self

Create a new Client for a platform supporting Rust’s standard library.

use kwap::blocking::Client;
use kwap::req::ReqBuilder;
use kwap::ContentFormat;

let mut client = Client::new_std();
let req = ReqBuilder::get("127.0.0.1:5683".parse().unwrap(), "hello").accept(ContentFormat::Text)
                                                                     .build()
                                                                     .unwrap();

let rep = client.send(req).unwrap();

println!("Hello, {}!", rep.payload_string().unwrap());

pub fn new_std_config(config: Config) -> Self

Create a new std client with a specific runtime config

impl<P: Platform> Client<P>

pub fn new(_: ClientConfig<P>) -> Self

Create a new request client

pub fn new_config(config: Config, _: ClientConfig<P>) -> Self

Create a new request client with a specific runtime config

pub fn ping(&mut self, host: impl AsRef<str>, port: u16) -> Result<(), Error<P>>

Ping an endpoint

Note: this will eventually not require Client to be borrowed mutably.

pub fn send(&mut self, req: Req<P>) -> Result<Resp<P>, Error<P>>

Send a request

Note: this will eventually not require Client to be borrowed mutably.

pub fn listen_multicast(
    clock: P::Clock,
    port: u16
) -> Result<Addrd<Req<P>>, Error<P>>

Listen on a multicast address for a broadcast from a Server

This will time out if nothing has been received after 1 second.

pub fn get(host: SocketAddr, path: impl AsRef<str>) -> ReqBuilder<P>

Send a GET request