connexa 0.3.1

High level abtraction of rust-libp2p
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

use crate::behaviour;
use crate::behaviour::peer_store::store::Store;
use crate::task::ConnexaTask;
use crate::types::AutonatCommand;
use libp2p::Swarm;
use libp2p::autonat::v1::Event as AutonatV1Event;
use libp2p::autonat::v2::client::Event as AutonatV2ClientEvent;
use libp2p::autonat::v2::server::Event as AutonatV2ServerEvent;
use libp2p::swarm::NetworkBehaviour;
use std::fmt::Debug;
use std::io;

impl<X, C: NetworkBehaviour, S, T> ConnexaTask<X, C, S, T>
where
    X: Default + Send + 'static,
    C: Send,
    C::ToSwarm: Debug,
    S: Store,
{
    pub fn process_autonat_v1_command(&mut self, command: AutonatCommand) {
        let Some(swarm) = self.swarm.as_mut() else {
            return;
        };
        match command {
            AutonatCommand::PublicAddress { resp } => {
                let Some(autonat) = swarm.behaviour_mut().autonat_v1.as_mut() else {
                    let _ = resp.send(Err(io::Error::other("autonat v1 not enabled")));
                    return;
                };

                let addr = autonat.public_address().cloned();

                let _ = resp.send(Ok(addr));
            }
            AutonatCommand::NatStatus { resp } => {
                let Some(autonat) = swarm.behaviour_mut().autonat_v1.as_mut() else {
                    let _ = resp.send(Err(io::Error::other("autonat v1 not enabled")));
                    return;
                };

                let status = autonat.nat_status();

                let _ = resp.send(Ok(status));
            }
            AutonatCommand::AddServer {
                peer,
                address,
                resp,
            } => {
                let Some(autonat) = swarm.behaviour_mut().autonat_v1.as_mut() else {
                    let _ = resp.send(Err(io::Error::other("autonat v1 not enabled")));
                    return;
                };

                autonat.add_server(peer, address);
                let _ = resp.send(Ok(()));
            }
            AutonatCommand::RemoveServer { peer, resp } => {
                let Some(autonat) = swarm.behaviour_mut().autonat_v1.as_mut() else {
                    let _ = resp.send(Err(io::Error::other("autonat v1 not enabled")));
                    return;
                };

                autonat.remove_server(&peer);

                let _ = resp.send(Ok(()));
            }
            AutonatCommand::Probe { address, resp } => {
                let Some(autonat) = swarm.behaviour_mut().autonat_v1.as_mut() else {
                    let _ = resp.send(Err(io::Error::other("autonat v1 not enabled")));
                    return;
                };

                autonat.probe_address(address);

                let _ = resp.send(Ok(()));
            }
        }
    }
    pub fn process_autonat_v1_event(&mut self, event: AutonatV1Event) {
        match event {
            AutonatV1Event::InboundProbe(_) => {}
            AutonatV1Event::OutboundProbe(_) => {}
            AutonatV1Event::StatusChanged { old, new } => {
                tracing::info!(old = ?old, new = ?new, "nat status changed");
            }
        }
    }

    pub fn process_autonat_v2_client_event(&mut self, event: AutonatV2ClientEvent) {
        let AutonatV2ClientEvent {
            tested_addr,
            bytes_sent,
            server,
            result,
        } = event;
        match result {
            Ok(_) => {
                tracing::info!(%tested_addr, %bytes_sent, %server, "autonat v2 response succeed");
            }
            Err(e) => {
                tracing::info!(%tested_addr, %bytes_sent, %server, error=%e, "autonat v2 response error");
            }
        }
    }

    pub fn process_autonat_v2_server_event(&mut self, event: AutonatV2ServerEvent) {
        let AutonatV2ServerEvent {
            all_addrs,
            tested_addr,
            client,
            data_amount,
            result,
        } = event;
        match result {
            Ok(_) => {
                tracing::info!(%tested_addr, ?all_addrs, %client, %data_amount, "autonat v2 response succeed");
            }
            Err(e) => {
                tracing::info!(%tested_addr, ?all_addrs, %client, %data_amount, error=%e, "autonat v2 response error");
            }
        }
    }
}