playit-agent-core 0.20.1

Contains the logic to create a playit.gg agent
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 std::{collections::HashMap, net::SocketAddr};

use playit_agent_proto::PortProto;
use playit_api_client::api::{AgentRunData, PortType, ProxyProtocol};
use tokio::sync::RwLock;

#[derive(Default)]
pub struct OriginLookup {
    map: RwLock<HashMap<Key, OriginResource>>,
}

impl OriginLookup {
    pub async fn update_from_run_data(&self, run_data: &AgentRunData) {
        self.update(run_data.tunnels.iter().map(|tunn| {
            OriginResource {
                tunnel_id: tunn.internal_id,
                proto: match tunn.proto {
                    PortType::Tcp => PortProto::Tcp,
                    PortType::Udp => PortProto::Udp,
                    PortType::Both => PortProto::Both,
                },
                local_addr: SocketAddr::new(tunn.local_ip, tunn.local_port),
                port_count: tunn.port.to - tunn.port.from,
                proxy_protocol: tunn.proxy_protocol,
            }
        })).await;
    }

    pub async fn update<I: Iterator<Item = OriginResource>>(&self, resources: I) {
        let mut lock = self.map.write().await;
        lock.clear();

        for res in resources {
            match res.proto {
                PortProto::Tcp => {
                    lock.insert(Key { tunnel_id: res.tunnel_id, is_tcp: true }, res);
                }
                PortProto::Udp => {
                    lock.insert(Key { tunnel_id: res.tunnel_id, is_tcp: false }, res);
                }
                PortProto::Both => {
                    lock.insert(Key { tunnel_id: res.tunnel_id, is_tcp: true }, res.clone());
                    lock.insert(Key { tunnel_id: res.tunnel_id, is_tcp: false }, res);
                }
            }
        }
    }

    pub async fn lookup(&self, tunnel_id: u64, is_tcp: bool) -> Option<OriginResource> {
        self.map.read().await.get(&Key { tunnel_id, is_tcp }).cloned()
    }
}

#[derive(Debug, PartialEq, Eq, Hash)]
struct Key {
    tunnel_id: u64,
    is_tcp: bool,
}

#[derive(Debug, Clone)]
pub struct OriginResource {
    pub tunnel_id: u64,
    pub proto: PortProto,
    pub local_addr: SocketAddr,
    pub port_count: u16,
    pub proxy_protocol: Option<ProxyProtocol>,
}

impl OriginResource {
    pub fn resolve_local(&self, port_offset: u16) -> Option<SocketAddr> {
        if port_offset == 0 {
            Some(self.local_addr)
        } else if port_offset < self.port_count {
            Some(SocketAddr::new(self.local_addr.ip(), self.local_addr.port() + port_offset))
        } else {
            None
        }
    }
}