rscale 0.1.0

Self-hosted Rust control plane for operating a single tailnet with Tailscale clients
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

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct AuditEvent {
    pub id: String,
    pub actor: AuditActor,
    pub kind: AuditEventKind,
    pub target: String,
    pub occurred_at_unix_secs: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct AuditActor {
    pub subject: String,
    pub mechanism: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum AuditEventKind {
    NodeRegistered,
    NodeUpdated,
    NodeDisabled,
    NodeDeleted,
    AuthKeyCreated,
    AuthKeyRevoked,
    PolicyUpdated,
    DnsUpdated,
    RouteCreated,
    RouteApproved,
    RouteRejected,
    AdminAuthenticated,
    BackupRestored,
    SshCheckApproved,
    SshCheckRejected,
}

impl AuditEventKind {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::NodeRegistered => "node_registered",
            Self::NodeUpdated => "node_updated",
            Self::NodeDisabled => "node_disabled",
            Self::NodeDeleted => "node_deleted",
            Self::AuthKeyCreated => "auth_key_created",
            Self::AuthKeyRevoked => "auth_key_revoked",
            Self::PolicyUpdated => "policy_updated",
            Self::DnsUpdated => "dns_updated",
            Self::RouteCreated => "route_created",
            Self::RouteApproved => "route_approved",
            Self::RouteRejected => "route_rejected",
            Self::AdminAuthenticated => "admin_authenticated",
            Self::BackupRestored => "backup_restored",
            Self::SshCheckApproved => "ssh_check_approved",
            Self::SshCheckRejected => "ssh_check_rejected",
        }
    }

    pub fn parse(value: &str) -> Option<Self> {
        match value {
            "node_registered" => Some(Self::NodeRegistered),
            "node_updated" => Some(Self::NodeUpdated),
            "node_disabled" => Some(Self::NodeDisabled),
            "node_deleted" => Some(Self::NodeDeleted),
            "auth_key_created" => Some(Self::AuthKeyCreated),
            "auth_key_revoked" => Some(Self::AuthKeyRevoked),
            "policy_updated" => Some(Self::PolicyUpdated),
            "dns_updated" => Some(Self::DnsUpdated),
            "route_created" => Some(Self::RouteCreated),
            "route_approved" => Some(Self::RouteApproved),
            "route_rejected" => Some(Self::RouteRejected),
            "admin_authenticated" => Some(Self::AdminAuthenticated),
            "backup_restored" => Some(Self::BackupRestored),
            "ssh_check_approved" => Some(Self::SshCheckApproved),
            "ssh_check_rejected" => Some(Self::SshCheckRejected),
            _ => None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn audit_event_kind_round_trips_to_strings() {
        let kinds = [
            AuditEventKind::NodeRegistered,
            AuditEventKind::NodeUpdated,
            AuditEventKind::NodeDisabled,
            AuditEventKind::NodeDeleted,
            AuditEventKind::AuthKeyCreated,
            AuditEventKind::AuthKeyRevoked,
            AuditEventKind::PolicyUpdated,
            AuditEventKind::DnsUpdated,
            AuditEventKind::RouteCreated,
            AuditEventKind::RouteApproved,
            AuditEventKind::RouteRejected,
            AuditEventKind::AdminAuthenticated,
            AuditEventKind::BackupRestored,
            AuditEventKind::SshCheckApproved,
            AuditEventKind::SshCheckRejected,
        ];

        for kind in kinds {
            let encoded = kind.as_str();
            assert_eq!(AuditEventKind::parse(encoded), Some(kind));
        }
        assert_eq!(AuditEventKind::parse("unknown"), None);
    }
}