openrtc 0.2.1

OpenRTC: a Rust-first P2P runtime for device discovery, signaling, and iroh/QUIC networking.
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

#![cfg(not(target_arch = "wasm32"))]

use crate::client::EndpointHandle;
use crate::connection_manager::{ConnectionManager, ConnectionRecord};
use crate::runtime_manager::RuntimeManager;
use anyhow::Result;
use iroh::Endpoint;
use std::sync::Arc;

#[derive(Clone)]
pub struct IrohNodeManagerAdapter {
    runtime_manager: Arc<RuntimeManager>,
}

impl IrohNodeManagerAdapter {
    pub fn new(runtime_manager: Arc<RuntimeManager>) -> Self {
        Self { runtime_manager }
    }

    pub async fn create(&self, secret_key: Option<Vec<u8>>) -> Result<String> {
        self.runtime_manager.init_runtime(secret_key).await
    }

    pub async fn adopt_endpoint(&self, endpoint: Endpoint) -> Result<String> {
        self.runtime_manager.adopt_endpoint(endpoint).await
    }

    pub async fn get_endpoint(&self) -> Result<Endpoint> {
        self.runtime_manager.get_endpoint().await
    }

    pub async fn get_node_id(&self) -> Option<String> {
        self.runtime_manager.current_node_id().await
    }

    pub async fn export_endpoint_handle(&self) -> Result<EndpointHandle> {
        self.runtime_manager.export_endpoint_handle().await
    }
}

#[derive(Clone, Default)]
pub struct ConnectionRepositoryAdapter {
    manager: Arc<ConnectionManager>,
}

impl ConnectionRepositoryAdapter {
    pub fn new(manager: Arc<ConnectionManager>) -> Self {
        Self { manager }
    }

    pub fn manager(&self) -> Arc<ConnectionManager> {
        self.manager.clone()
    }

    pub async fn upsert_pending(
        &self,
        connection_id: String,
        node_id: Option<String>,
        device_id: Option<String>,
        endpoint_id: Option<String>,
    ) -> ConnectionRecord {
        self.manager
            .upsert_pending(connection_id, node_id, device_id, endpoint_id)
            .await
    }

    pub async fn mark_connected(
        &self,
        connection_id: &str,
        endpoint_id: Option<String>,
    ) -> Option<ConnectionRecord> {
        self.manager.set_connected(connection_id, endpoint_id).await
    }

    pub async fn mark_disconnected(&self, connection_id: &str, reason: Option<String>) {
        self.manager.set_closed(connection_id, reason).await;
    }

    pub async fn get_by_connection_id(&self, connection_id: &str) -> Option<ConnectionRecord> {
        self.manager.get_by_connection_id(connection_id).await
    }

    pub async fn get_by_node_id(&self, node_id: &str) -> Vec<ConnectionRecord> {
        self.manager.get_by_node_id(node_id).await
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn connection_repository_adapter_matches_manager_index_queries() {
        let manager = Arc::new(ConnectionManager::new());
        let adapter = ConnectionRepositoryAdapter::new(manager.clone());

        adapter
            .upsert_pending(
                "conn-42".to_string(),
                Some("node-42".to_string()),
                Some("device-42".to_string()),
                None,
            )
            .await;

        adapter
            .mark_connected("conn-42", Some("endpoint-42".to_string()))
            .await;

        let from_adapter = adapter.get_by_node_id("node-42").await;
        let from_manager = manager.get_by_node_id("node-42").await;

        assert_eq!(from_adapter.len(), from_manager.len());
        assert_eq!(from_adapter[0].connection_id, "conn-42");

        adapter
            .mark_disconnected("conn-42", Some("done".to_string()))
            .await;
        assert_eq!(manager.list_active().await.len(), 0);
    }
}