relay-man 0.2.5

Peer to peer library
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

use bytes_kman::TBytes;

use crate::common::packets::{NewRequestFinal, Packets, RequestFinal};

use super::{ClientStage, Connecting, RelayServer};

impl RelayServer {
    pub(crate) fn on_request_final(&mut self, index: usize, request_final: RequestFinal) {
        let mut to = None;
        for client in self.clients.iter() {
            if let ClientStage::Registered(rclient) = &client.stage {
                if rclient.adress == request_final.to {
                    if rclient
                        .to_connect
                        .contains(&Connecting::Start(request_final.session))
                    {
                        to = Some(client.session)
                    }
                    break;
                }
            } else {
                return;
            }
        }

        let mut from = None;
        if let Some(client) = self.clients.get(index) {
            if let ClientStage::Registered(rclient) = &client.stage {
                from = Some(rclient.adress.clone())
            } else {
                return;
            }
        }

        let Some(from) = from else{return};
        let Some(_) = to else{return};

        let mut session = None;
        for client in self.clients.iter_mut() {
            if let ClientStage::Registered(rclient) = &mut client.stage {
                if rclient.adress == request_final.to {
                    let pak = NewRequestFinal {
                        session: client.session,
                        from,
                        accepted: request_final.accepted,
                    };
                    let mut bytes = Packets::NewRequestFinal(pak).to_bytes();
                    bytes.reverse();
                    let _ = client.conn.send(&bytes);
                    session = Some(client.session);
                    if request_final.accepted {
                        for to_conn in rclient.to_connect.iter_mut() {
                            if to_conn.session() == request_final.session {
                                *to_conn = Connecting::Finishing(
                                    to_conn.session(),
                                    request_final.time_offset,
                                );
                                break;
                            }
                        }
                    } else {
                        rclient
                            .to_connect
                            .retain(|to_conn| to_conn.session() != request_final.session);
                    }
                    break;
                }
            } else {
                return;
            }
        }

        let Some(session) = session else{return};
        if let Some(client) = self.clients.get_mut(index) {
            if let ClientStage::Registered(rclient) = &mut client.stage {
                if request_final.accepted {
                    for to_conn in rclient.to_connect.iter_mut() {
                        if to_conn.session() == session {
                            *to_conn =
                                Connecting::Finishing(to_conn.session(), request_final.time_offset);
                            break;
                        }
                    }
                } else {
                    rclient
                        .to_connect
                        .retain(|to_conn| to_conn.session() != session);
                }
            }
        }
    }
}