adamo 0.1.71

Rust SDK for the Adamo Network — low-latency robotics pub/sub and video streaming.
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

//! End-to-end smoke test for the Rust SDK.
//!
//! Opens a session, declares a subscriber, publishes a payload on the
//! same key, and waits for the round-trip through the Adamo network.
//! Prints RTT and asserts the payload matches.
//!
//! Run with:
//!   ADAMO_API_KEY=<key> cargo run --example e2e

use std::time::{Duration, Instant};

use adamo::{Protocol, PublishOptions, Session};

const KEY: &str = "test/rust-sdk-e2e";

fn main() -> adamo::Result<()> {
    let api_key = std::env::var("ADAMO_API_KEY").expect("set ADAMO_API_KEY");

    println!("opening session (quic)…");
    let t0 = Instant::now();
    let session = Session::open(&api_key, Protocol::Quic)?;
    println!(
        "  connected to org `{}` in {:?}",
        session.org()?,
        t0.elapsed()
    );

    println!("declaring subscriber on `{KEY}`…");
    let sub = session.subscribe(KEY)?;

    // Let the subscription propagate through the fabric before publishing.
    std::thread::sleep(Duration::from_millis(250));

    let payload = format!("hello @ {}ms", now_ms()).into_bytes();
    println!("publishing {} bytes…", payload.len());
    let sent = Instant::now();
    session.put(
        KEY,
        &payload,
        PublishOptions {
            priority: 200,
            express: true,
        },
    )?;

    println!("waiting for round-trip (timeout 5s)…");
    let sample = sub.recv(Some(Duration::from_secs(5)))?;
    let rtt = sent.elapsed();

    assert_eq!(sample.payload, payload, "round-trip payload mismatch");
    println!(
        "  received {} bytes on `{}` — rtt {:?}",
        sample.payload.len(),
        sample.key,
        rtt
    );

    println!("OK");
    Ok(())
}

fn now_ms() -> u128 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_millis())
        .unwrap_or(0)
}