haply 1.3.1

Haply Robotics Client Library for the Inverse Service
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

use haply::events::{ EventChannel, TimestampedEvent };
use std::env;
use std::time::{ Duration, UNIX_EPOCH };
use tokio;

/// Example showing how to poll for events from the WebSocket channel.
/// This is useful for applications that need to process events at regular intervals
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // Read polling interval (in seconds) from env var or default to 5s
    let poll_secs: u64 = env
        ::var("POLL_RATE")
        .ok()
        .and_then(|v| v.parse().ok())
        .unwrap_or(5);
    let mut interval = tokio::time::interval(Duration::from_secs(poll_secs));

    let ws_url = "ws://localhost:10020";
    let channel = EventChannel::new(ws_url).await;
    let channel = match channel {
        Ok(c) => c,
        Err(e) => {
            eprintln!("Failed to connect to WebSocket: {}", e);
            return Err(e);
        }
    };
    println!("Polling every {}s for new events…", poll_secs);

    loop {
        interval.tick().await;
        let events = channel.read_events().await;
        if events.is_empty() {
            continue;
        }
        for ts_evt in events {
            let TimestampedEvent { timestamp, event } = ts_evt;
            let secs = timestamp.duration_since(UNIX_EPOCH)?.as_secs();
            println!("--- [{}] {} ({:?}/{:?})", secs, event.name(), event.category, event.level);
            println!("Data   : {:?}", event.data);
            if let Some(msg) = event.message {
                println!("Message: {}", msg);
            }
        }
    }
}