dink-sdk 0.3.1

Rust SDK for Dink edge mesh platform — JSON-over-NATS RPC for IoT and edge computing
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

use async_nats::Client;
use bytes::Bytes;
use std::time::Duration;

use crate::error::{DinkError, Result};

/// Send an authenticated request-reply to a NATS subject.
///
/// Uses `send_request` with a [`async_nats::Request`] to attach both
/// authorization headers and a per-request timeout.
pub async fn request_with_auth(
    client: &Client,
    subject: &str,
    data: &[u8],
    api_key: &str,
    timeout: Duration,
) -> Result<async_nats::Message> {
    let mut headers = async_nats::HeaderMap::new();
    headers.insert("Authorization", format!("Bearer {}", api_key).as_str());

    let request = async_nats::Request::new()
        .headers(headers)
        .payload(Bytes::copy_from_slice(data))
        .timeout(Some(timeout));

    client
        .send_request(subject.to_string(), request)
        .await
        .map_err(|e| DinkError::Nats(e.to_string()))
}

/// Send a plain (unauthenticated) request-reply.
pub async fn request(
    client: &Client,
    subject: &str,
    data: &[u8],
    timeout: Duration,
) -> Result<async_nats::Message> {
    let request = async_nats::Request::new()
        .payload(Bytes::copy_from_slice(data))
        .timeout(Some(timeout));

    client
        .send_request(subject.to_string(), request)
        .await
        .map_err(|e| DinkError::Nats(e.to_string()))
}

// ---------------------------------------------------------------------------
// Subject builders
// ---------------------------------------------------------------------------

/// `edge.{appId}.{edgeId}.services.{svc}.{method}`
pub fn edge_service_subject(app_id: &str, edge_id: &str, service: &str, method: &str) -> String {
    format!(
        "edge.{}.{}.services.{}.{}",
        app_id, edge_id, service, method
    )
}

/// `edge.{appId}.{edgeId}.services.{svc}.{method}.stream`
pub fn edge_service_stream_subject(
    app_id: &str,
    edge_id: &str,
    service: &str,
    method: &str,
) -> String {
    format!(
        "edge.{}.{}.services.{}.{}.stream",
        app_id, edge_id, service, method
    )
}

/// `edge.{appId}.{edgeId}.services.{svc}.>`
pub fn edge_service_wildcard(app_id: &str, edge_id: &str, service: &str) -> String {
    format!("edge.{}.{}.services.{}.>", app_id, edge_id, service)
}

/// `edge.{appId}.group.{groupId}.{edgeId}.services.{svc}.{method}`
pub fn peer_directed_subject(
    app_id: &str,
    group_id: &str,
    edge_id: &str,
    service: &str,
    method: &str,
) -> String {
    format!(
        "edge.{}.group.{}.{}.services.{}.{}",
        app_id, group_id, edge_id, service, method
    )
}

/// `edge.{appId}.group.{groupId}.services.{svc}.{method}`
pub fn peer_broadcast_subject(app_id: &str, group_id: &str, service: &str, method: &str) -> String {
    format!(
        "edge.{}.group.{}.services.{}.{}",
        app_id, group_id, service, method
    )
}

/// `edge.{appId}.group.{groupId}.{edgeId}.services.{svc}.>`
pub fn peer_directed_wildcard(
    app_id: &str,
    group_id: &str,
    edge_id: &str,
    service: &str,
) -> String {
    format!(
        "edge.{}.group.{}.{}.services.{}.>",
        app_id, group_id, edge_id, service
    )
}

/// `edge.{appId}.group.{groupId}.services.{svc}.>`
pub fn peer_broadcast_wildcard(app_id: &str, group_id: &str, service: &str) -> String {
    format!("edge.{}.group.{}.services.{}.>", app_id, group_id, service)
}

/// `center.{appId}.group.{groupId}.services.{svc}.{method}`
pub fn center_group_subject(app_id: &str, group_id: &str, service: &str, method: &str) -> String {
    format!(
        "center.{}.group.{}.services.{}.{}",
        app_id, group_id, service, method
    )
}