geiserx_ts_python 0.7.2

pyo3-based python bindings for tailscale
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

//! Python marshaling for `status()`, `whois()`, and netmap snapshots.
//!
//! Mirrors `node_info.rs`: each returned struct derives [`IntoPyObject`] and exposes plain,
//! Python-friendly fields (`IpAddr`/`SocketAddr` become strings, `online` becomes `None`/`bool`,
//! routes become a list of CIDR strings, capabilities become a list of `(str, list[str])` tuples).

use pyo3::IntoPyObject;

use crate::node_info::NodeInfo;

/// A single node entry in a [`Status`] snapshot (mirrors `tailscale::StatusNode`).
///
/// Turned into a `dict` on the Python side via `IntoPyObject`.
#[derive(Debug, IntoPyObject)]
pub struct StatusNode {
    /// The node's stable id (stable across re-registration).
    pub stable_id: String,
    /// Display name: fqdn if a tailnet component is known, else the bare hostname.
    pub display_name: String,
    /// The node's tailnet IPv4 address, as a string.
    pub ipv4: String,
    /// The node's tailnet IPv6 address, as a string.
    pub ipv6: String,
    /// Whether the node is online, if known (always `None` in this fork — see
    /// `ts_runtime::status` docs).
    pub online: Option<bool>,
    /// The routes this node accepts traffic for, as a list of CIDR strings.
    pub allowed_routes: Vec<String>,
    /// Whether this node advertises a default route, making it eligible as an exit node.
    pub is_exit_node: bool,
}

impl From<&tailscale::StatusNode> for StatusNode {
    fn from(value: &tailscale::StatusNode) -> Self {
        Self {
            stable_id: value.stable_id.0.clone(),
            display_name: value.display_name.clone(),
            ipv4: value.ipv4.to_string(),
            ipv6: value.ipv6.to_string(),
            online: value.online,
            allowed_routes: value.allowed_routes.iter().map(|r| r.to_string()).collect(),
            is_exit_node: value.is_exit_node,
        }
    }
}

/// A snapshot of the local netmap: this node plus every known peer (mirrors `tailscale::Status`).
///
/// Turned into a `dict` on the Python side via `IntoPyObject`.
#[derive(Debug, IntoPyObject)]
pub struct Status {
    /// This node, if a netmap has been received from control yet.
    pub self_node: Option<StatusNode>,
    /// Every peer currently known in the netmap.
    pub peers: Vec<StatusNode>,
}

impl From<&tailscale::Status> for Status {
    fn from(value: &tailscale::Status) -> Self {
        Self {
            self_node: value.self_node.as_ref().map(StatusNode::from),
            peers: value.peers.iter().map(StatusNode::from).collect(),
        }
    }
}

/// The result of a `whois()` lookup (mirrors `tailscale::WhoIs`).
///
/// Turned into a `dict` on the Python side via `IntoPyObject`.
#[derive(Debug, IntoPyObject)]
pub struct WhoIs {
    /// The node that owns the queried source IP.
    pub node: NodeInfo,
    /// The login/email of the user that owns the node, if known (always `None` in this fork).
    pub user: Option<String>,
    /// The node's capability map, as a list of `(capability, args)` tuples (always empty in this
    /// fork).
    pub capabilities: Vec<(String, Vec<String>)>,
}

impl From<&tailscale::WhoIs> for WhoIs {
    fn from(value: &tailscale::WhoIs) -> Self {
        Self {
            node: NodeInfo::from(&value.node),
            user: value.user.clone(),
            capabilities: value.capabilities.clone(),
        }
    }
}