asimov-protocol 25.3.4

ASIMOV Software Development Kit (SDK) for Rust
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

// This is free and unencumbered software released into the public domain.

use crate::{
    BindError, ConnectError, DefaultPreset, GOSSIP_ALPN, GossipProtocol, NODE_ALPN, NodeProtocol,
    PeerConnect, PeerConnection, PingError, StartError, SubscribeError, TerminateError, Topic,
    TopicSubscription, node_state::*,
};
use alloc::vec::Vec;
use asimov_id::PublicKey;
use core::{result::Result, time::Duration};
use iroh::{Endpoint, EndpointAddr, EndpointId, endpoint::EndpointClosed, protocol::Router};

#[derive(Debug)]
pub struct Node<State = Building>(State);

impl Default for Node {
    fn default() -> Self {
        Self(Building {
            endpoint: Endpoint::builder(DefaultPreset),
        })
    }
}

impl Node<Building> {
    pub async fn bind(self) -> Result<Node<Bound>, BindError> {
        Ok(Node(Bound {
            endpoint: self.0.endpoint.bind().await?,
        }))
    }
}

impl Node<Bound> {
    pub fn public_key(&self) -> PublicKey {
        self.endpoint().id().into()
    }

    pub fn endpoint_addr(&self) -> EndpointAddr {
        self.endpoint().addr()
    }

    pub fn endpoint(&self) -> &Endpoint {
        &self.0.endpoint
    }

    pub async fn start(self) -> Result<Node<Running>, StartError> {
        let endpoint = self.0.endpoint;
        endpoint.online().await;
        let node = NodeProtocol::new();
        let gossip = GossipProtocol::new(endpoint.clone());
        let router = Router::builder(endpoint)
            .accept(NODE_ALPN, node.clone())
            .accept(GOSSIP_ALPN, gossip.0.clone())
            .spawn();
        Ok(Node(Running {
            router,
            node,
            gossip,
            peers: Vec::new(),
        }))
    }
}

impl Node<Running> {
    pub fn public_key(&self) -> PublicKey {
        self.endpoint().id().into()
    }

    pub fn endpoint_addr(&self) -> EndpointAddr {
        self.endpoint().addr()
    }

    pub fn endpoint(&self) -> &Endpoint {
        self.0.router.endpoint()
    }

    pub fn is_closed(&self) -> bool {
        self.endpoint().is_closed()
    }

    pub fn closed(&self) -> EndpointClosed {
        self.endpoint().closed()
    }

    pub async fn terminate(self) -> Result<Node<Terminating>, TerminateError> {
        let router = self.0.router;
        router.shutdown().await?;
        Ok(Node(Terminating { router }))
    }

    pub async fn online(&self) {
        self.endpoint().online().await
    }

    pub fn add_peer(&mut self, endpoint: impl Into<EndpointId>) {
        self.0.peers.push(endpoint.into());
    }

    pub async fn ping(&self, peer_addr: impl Into<EndpointAddr>) -> Result<Duration, PingError> {
        let mut connection = self.connect(peer_addr).await?;
        let rtt = connection.ping().await?;
        Ok(rtt)
    }

    pub async fn connect(
        &self,
        peer_addr: impl Into<EndpointAddr>,
    ) -> Result<PeerConnection, ConnectError> {
        let endpoint = self.0.router.endpoint();

        let state: PeerConnect = endpoint.connect(peer_addr, NODE_ALPN).await?.into();
        let state = state.send_hello().await?;
        let state = state.recv_hello().await?;

        Ok(state.into_connection())
    }

    pub async fn subscribe(
        &self,
        topic: impl Into<Topic>,
    ) -> Result<TopicSubscription, SubscribeError> {
        let topic_id = topic.into().id();
        let gossip = &self.0.gossip;
        Ok(gossip
            .0
            .subscribe(topic_id, self.0.peers.clone())
            .await?
            .into())
    }

    pub async fn subscribe_and_join(
        &self,
        topic: impl Into<Topic>,
    ) -> Result<TopicSubscription, SubscribeError> {
        let topic_id = topic.into().id();
        let gossip = &self.0.gossip;
        Ok(gossip
            .0
            .subscribe_and_join(topic_id, self.0.peers.clone())
            .await?
            .into())
    }
}

impl Node<Terminating> {}