calimero-network 0.8.0

Core Calimero infrastructure and tools
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

use libp2p::rendezvous::client::Event;
use owo_colors::OwoColorize;
use tracing::{debug, error, info, warn};

use super::{EventHandler, NetworkManager};
use crate::discovery::state::{PeerDiscoveryMechanism, RendezvousRegistrationStatus};

impl EventHandler<Event> for NetworkManager {
    fn handle(&mut self, event: Event) {
        debug!("{}: {:?}", "rendezvous".yellow(), event);

        match event {
            Event::Discovered {
                rendezvous_node,
                registrations,
                cookie,
            } => {
                self.discovery
                    .state
                    .update_rendezvous_cookie(&rendezvous_node, &cookie);

                for registration in registrations {
                    let peer_id = registration.record.peer_id();

                    if peer_id == *self.swarm.local_peer_id() {
                        continue;
                    }

                    self.discovery
                        .state
                        .add_peer_discovery_mechanism(&peer_id, PeerDiscoveryMechanism::Rendezvous);

                    if self.swarm.is_connected(&peer_id)
                        || self
                            .discovery
                            .state
                            .is_peer_discovered_via(&peer_id, PeerDiscoveryMechanism::Mdns)
                    {
                        continue;
                    }

                    debug!(
                        %peer_id,
                        addrs=?(registration.record.addresses()),
                        "Discovered new unconnected peer via rendezvous, attempting to dial it"
                    );

                    for address in registration.record.addresses() {
                        debug!(%peer_id, %address, "Dialing peer discovered via rendezvous");
                        if let Err(err) = self.swarm.dial(address.clone()) {
                            error!("Failed to dial peer: {:?}", err);
                        }
                    }
                }
            }
            Event::Registered {
                rendezvous_node, ..
            } => {
                self.discovery.state.update_rendezvous_registration_status(
                    &rendezvous_node,
                    RendezvousRegistrationStatus::Registered,
                );

                if let Some(peer_info) = self.discovery.state.get_peer_info(&rendezvous_node) {
                    if peer_info
                        .rendezvous()
                        .and_then(|info| info.cookie())
                        .is_none()
                    {
                        debug!(%rendezvous_node, "Discovering peers via rendezvous after registration");
                        if let Err(err) = self.rendezvous_discover(&rendezvous_node) {
                            error!(%err, "Failed to run rendezvous discovery after registration");
                        }
                    }
                }
            }
            Event::DiscoverFailed {
                rendezvous_node,
                namespace,
                error,
            } => {
                warn!(?rendezvous_node, ?namespace, error_code=?error, "Rendezvous discovery failed");
            }
            Event::RegisterFailed {
                rendezvous_node,
                namespace,
                error,
            } => {
                error!(?rendezvous_node, ?namespace, error_code=?error, "Rendezvous registration failed");
            }
            Event::Expired { peer } => {
                self.discovery.state.update_rendezvous_registration_status(
                    &peer,
                    RendezvousRegistrationStatus::Expired,
                );

                if let Some(nominated_peer) = self.find_new_rendezvous_peer() {
                    if self.swarm.is_connected(&nominated_peer) {
                        if let Err(err) = self.rendezvous_register(&nominated_peer) {
                            error!(%err, "Failed to register with nominated rendezvous peer");
                        }
                    } else {
                        debug!(%nominated_peer, "Dialing nominated rendezvous peer");
                        if let Err(err) = self.swarm.dial(nominated_peer) {
                            error!(%err, "Failed to dial nominated rendezvous peer");
                        }
                    }
                } else {
                    info!("Couldn't find new peer to nominate for rendezvous registration.");
                }
            }
        }
    }
}