risotto-lib 0.1.2

High performance BMP collector
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

pub mod processor;
pub mod state;
pub mod update;

use bgpkit_parser::parser::bmp::messages::BmpMessageBody;
use bytes::Bytes;
use core::net::IpAddr;
use std::sync::mpsc::Sender;
use tracing::{error, info, trace};

use crate::processor::{
    decode_bmp_message, peer_down_notification, peer_up_notification, route_monitoring,
};
use crate::state::AsyncState;
use crate::update::{new_metadata, Update};

pub async fn process_bmp_message(
    state: Option<AsyncState>,
    tx: Sender<Update>,
    router_addr: IpAddr,
    router_port: u16,
    bytes: &mut Bytes,
) {
    // Parse the BMP message
    let message = match decode_bmp_message(bytes) {
        Ok(message) => message,
        Err(e) => {
            error!("failed to decode BMP message: {}", e);
            return;
        }
    };

    // Extract header and peer information
    let metadata = match new_metadata(router_addr, router_port, message.clone()) {
        Some(m) => m,
        None => return,
    };

    match message.message_body {
        BmpMessageBody::InitiationMessage(_) => {
            info!(
                "InitiationMessage: {} - {}",
                metadata.router_addr, metadata.peer_addr
            )
            // No-Op
        }
        BmpMessageBody::PeerUpNotification(body) => {
            trace!("{:?}", body);
            info!(
                "PeerUpNotification: {} - {}",
                metadata.router_addr, metadata.peer_addr
            );
            peer_up_notification(state, tx, metadata, body).await;
        }
        BmpMessageBody::RouteMonitoring(body) => {
            trace!("{:?}", body);
            route_monitoring(state, tx, metadata, body).await;
        }
        BmpMessageBody::RouteMirroring(_) => {
            info!(
                "RouteMirroring: {} - {}",
                metadata.router_addr, metadata.peer_addr
            )
            // No-Op
        }
        BmpMessageBody::PeerDownNotification(body) => {
            trace!("{:?}", body);
            info!(
                "PeerDownNotification: {} - {}",
                metadata.router_addr, metadata.peer_addr
            );
            peer_down_notification(state, tx, metadata, body).await;
        }

        BmpMessageBody::TerminationMessage(_) => {
            info!(
                "TerminationMessage: {} - {}",
                metadata.router_addr, metadata.peer_addr
            )
            // No-Op
        }
        BmpMessageBody::StatsReport(_) => {
            info!(
                "StatsReport: {} - {}",
                metadata.router_addr, metadata.peer_addr
            )
            // No-Op
        }
    }
}