connexa 0.4.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

use crate::behaviour::peer_store::store::Store;
use crate::task::ConnexaTask;
use crate::types::RequestResponseCommand;
use libp2p::swarm::NetworkBehaviour;
use std::fmt::Debug;

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_request_response_command(&mut self, command: RequestResponseCommand) {
        let swarm = self.swarm.as_mut().unwrap();
        match command {
            RequestResponseCommand::SendRequests {
                protocol,
                peers,
                request,
                resp,
            } => {
                let Some(rr) = swarm.behaviour_mut().request_response(protocol) else {
                    let _ = resp.send(Err(std::io::Error::other(
                        "request response protocol is not enabled",
                    )));
                    return;
                };

                let st = rr.send_requests(peers, request);
                let _ = resp.send(Ok(st));
            }
            RequestResponseCommand::SendRequest {
                protocol,
                peer_id,
                request,
                resp,
            } => {
                let Some(rr) = swarm.behaviour_mut().request_response(protocol) else {
                    let _ = resp.send(Err(std::io::Error::other(
                        "request response protocol is not enabled",
                    )));
                    return;
                };

                let fut = rr.send_request(peer_id, request);
                let _ = resp.send(Ok(fut));
            }
            RequestResponseCommand::SendResponse {
                protocol,
                peer_id,
                request_id,
                response,
                resp,
            } => {
                let Some(rr) = swarm.behaviour_mut().request_response(protocol) else {
                    let _ = resp.send(Err(std::io::Error::other(
                        "request response protocol is not enabled",
                    )));
                    return;
                };

                let ret = rr.send_response(peer_id, request_id, response);

                let _ = resp.send(ret);
            }
            RequestResponseCommand::ListenForRequests { protocol, resp } => {
                let Some(rr) = swarm.behaviour_mut().request_response(protocol) else {
                    let _ = resp.send(Err(std::io::Error::other(
                        "request response protocol is not enabled",
                    )));
                    return;
                };
                let rx = rr.subscribe();
                let _ = resp.send(Ok(rx));
            }
        }
    }
}