coap 0.25.0

A CoAP library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

extern crate coap;

use coap::client::ObserveMessage;
use coap::UdpCoAPClient;
use std::io;
use std::io::ErrorKind;

#[tokio::main]
async fn main() {
    println!("GET url:");
    example_get().await;

    println!("POST data to url:");
    example_post().await;

    println!("PUT data to url:");
    example_put().await;

    println!("DELETE url:");
    example_delete().await;

    println!("Observing:");
    example_observe().await;
}

async fn example_get() {
    let url = "coap://127.0.0.1:5683/hello/get";
    println!("Client request: {}", url);

    match UdpCoAPClient::get(url).await {
        Ok(response) => {
            println!(
                "Server reply: {}",
                String::from_utf8(response.message.payload).unwrap()
            );
        }
        Err(e) => {
            match e.kind() {
                ErrorKind::WouldBlock => println!("Request timeout"), // Unix
                ErrorKind::TimedOut => println!("Request timeout"),   // Windows
                _ => println!("Request error: {:?}", e),
            }
        }
    }
}

async fn example_post() {
    let url = "coap://127.0.0.1:5683/hello/post";
    let data = b"data".to_vec();
    println!("Client request: {}", url);

    match UdpCoAPClient::post(url, data).await {
        Ok(response) => {
            println!(
                "Server reply: {}",
                String::from_utf8(response.message.payload).unwrap()
            );
        }
        Err(e) => {
            match e.kind() {
                ErrorKind::WouldBlock => println!("Request timeout"), // Unix
                ErrorKind::TimedOut => println!("Request timeout"),   // Windows
                _ => println!("Request error: {:?}", e),
            }
        }
    }
}

async fn example_put() {
    let url = "coap://127.0.0.1:5683/hello/put";
    let data = b"data".to_vec();
    println!("Client request: {}", url);

    match UdpCoAPClient::put(url, data).await {
        Ok(response) => {
            println!(
                "Server reply: {}",
                String::from_utf8(response.message.payload).unwrap()
            );
        }
        Err(e) => {
            match e.kind() {
                ErrorKind::WouldBlock => println!("Request timeout"), // Unix
                ErrorKind::TimedOut => println!("Request timeout"),   // Windows
                _ => println!("Request error: {:?}", e),
            }
        }
    }
}

async fn example_delete() {
    let url = "coap://127.0.0.1:5683/hello/delete";
    println!("Client request: {}", url);

    match UdpCoAPClient::delete(url).await {
        Ok(response) => {
            println!(
                "Server reply: {}",
                String::from_utf8(response.message.payload).unwrap()
            );
        }
        Err(e) => {
            match e.kind() {
                ErrorKind::WouldBlock => println!("Request timeout"), // Unix
                ErrorKind::TimedOut => println!("Request timeout"),   // Windows
                _ => println!("Request error: {:?}", e),
            }
        }
    }
}

async fn example_observe() {
    let client = UdpCoAPClient::new("127.0.0.1:5683").await.unwrap();
    let observe_channel = client
        .observe("/hello/put", |msg| {
            println!(
                "resource changed {}",
                String::from_utf8(msg.payload).unwrap()
            );
        })
        .await
        .unwrap();

    println!("Enter any key to stop...");

    io::stdin().read_line(&mut String::new()).unwrap();
    observe_channel.send(ObserveMessage::Terminate).unwrap();
}