focl 0.1.0

focl/focld - lightweight Rust BGP speaker
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
112
113
114
115

use serde::{Deserialize, Serialize};
use serde_json::{json, Value};

use crate::types::ControlRequest;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CommandKind {
    Ping,
    DaemonStatus,
    Shutdown,
    Reload,
    PeerList,
    PeerShow,
    PeerReset,
    RibSummary,
    RibIn,
    RibOut,
    ArchiveStatus,
    ArchiveRollover,
    ArchiveSnapshotNow,
    ArchiveDestinations,
    ArchiveReplicatorRetry,
    Unsupported,
}

impl CommandKind {
    pub fn from_request(req: &ControlRequest) -> Self {
        match req.cmd.as_str() {
            "ping" => Self::Ping,
            "daemon_status" => Self::DaemonStatus,
            "shutdown" => Self::Shutdown,
            "reload" => Self::Reload,
            "peer_list" => Self::PeerList,
            "peer_show" => Self::PeerShow,
            "peer_reset" => Self::PeerReset,
            "rib_summary" => Self::RibSummary,
            "rib_in" => Self::RibIn,
            "rib_out" => Self::RibOut,
            "archive_status" => Self::ArchiveStatus,
            "archive_rollover" => Self::ArchiveRollover,
            "archive_snapshot_now" => Self::ArchiveSnapshotNow,
            "archive_destinations" => Self::ArchiveDestinations,
            "archive_replicator_retry" => Self::ArchiveReplicatorRetry,
            _ => Self::Unsupported,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PeerKeyArgs {
    pub peer: String,
}

impl PeerKeyArgs {
    pub fn from_json(value: &Value) -> Result<Self, serde_json::Error> {
        serde_json::from_value(value.clone())
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ArchiveStream {
    Updates,
    Ribs,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ArchiveRolloverArgs {
    pub stream: ArchiveStream,
}

impl ArchiveRolloverArgs {
    pub fn from_json(value: &Value) -> Result<Self, serde_json::Error> {
        serde_json::from_value(value.clone())
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ArchiveStatusResult {
    pub enabled: bool,
    pub collector_id: String,
    pub updates_interval_secs: u32,
    pub ribs_interval_secs: u32,
    pub updates_open_path: Option<String>,
    pub updates_record_count: u64,
    pub ribs_last_path: Option<String>,
    pub ribs_last_record_count: u64,
    pub queued_replication_jobs: usize,
    pub replication_failures: u64,
}

impl ArchiveStatusResult {
    pub fn as_value(&self) -> Value {
        json!(self)
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ArchiveDestinationResult {
    pub key: String,
    pub mode: String,
    #[serde(rename = "type")]
    pub destination_type: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ArchiveDestinationsResult {
    pub destinations: Vec<ArchiveDestinationResult>,
}

impl ArchiveDestinationsResult {
    pub fn as_value(&self) -> Value {
        json!(self)
    }
}