use std::net::IpAddr;
use std::str::FromStr;
use std::time::Duration;
use anyhow::{anyhow, Result};
use bgpkit_parser::parser::filter::Filterable;
use bgpkit_parser::{parse_ris_live_message_raw, BgpElem, RisSubscribe, RisSubscribeType};
use ipnet::IpNet;
use serde::{Deserialize, Serialize};
pub const RIS_LIVE_URL: &str = "wss://ris-live.ripe.net/v1/ws/?client=monocle";
pub const RECONNECT_BACKOFF: Duration = Duration::from_secs(5);
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[cfg_attr(feature = "cli", derive(clap::Args))]
pub struct WatchFilters {
#[cfg_attr(feature = "cli", clap(short = 'o', long, value_delimiter = ','))]
#[serde(default)]
pub origin_asn: Vec<String>,
#[cfg_attr(feature = "cli", clap(short = 'p', long, value_delimiter = ','))]
#[serde(default)]
pub prefix: Vec<String>,
#[cfg_attr(feature = "cli", clap(short = 's', long))]
#[serde(default)]
pub include_super: bool,
#[cfg_attr(feature = "cli", clap(short = 'S', long))]
#[serde(default)]
pub include_sub: bool,
#[cfg_attr(feature = "cli", clap(short = 'j', long))]
#[serde(default)]
pub peer_ip: Vec<IpAddr>,
#[cfg_attr(feature = "cli", clap(short = 'J', long, value_delimiter = ','))]
#[serde(default)]
pub peer_asn: Vec<String>,
#[cfg_attr(
feature = "cli",
clap(
short = 'C',
long = "community",
visible_alias = "communities",
value_delimiter = ','
)
)]
#[serde(default)]
pub communities: Vec<String>,
#[cfg_attr(feature = "cli", clap(short = 'm', long, value_enum))]
#[serde(default)]
pub elem_type: Option<crate::lens::parse::ParseElemType>,
#[cfg_attr(feature = "cli", clap(short = 'a', long))]
#[serde(default)]
pub as_path: Option<String>,
}
#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct PushdownReport {
pub host: Option<String>,
pub prefixes: Vec<String>,
pub peers: Vec<String>,
pub require: Option<String>,
}
#[derive(Debug)]
pub struct SubscriptionPlan {
pub subscriptions: Vec<RisSubscribe>,
pub report: PushdownReport,
}
impl WatchFilters {
pub fn is_empty(&self) -> bool {
self.origin_asn.is_empty()
&& self.prefix.is_empty()
&& self.peer_ip.is_empty()
&& self.peer_asn.is_empty()
&& self.communities.is_empty()
&& self.elem_type.is_none()
&& self.as_path.is_none()
}
pub fn to_subscription_plan(&self, host: Option<&str>) -> Result<SubscriptionPlan> {
let mut report = PushdownReport::default();
if let Some(h) = host {
report.host = Some(h.to_string());
}
let positive_prefixes: Vec<&String> = self
.prefix
.iter()
.filter(|p| !p.trim_start().starts_with('!'))
.collect();
let mut prefix_nets = Vec::new();
for value in &positive_prefixes {
let net = IpNet::from_str(value.trim())
.map_err(|e| anyhow!("invalid prefix '{}': {e}", value.trim()))?;
prefix_nets.push(net);
report.prefixes.push(value.trim().to_string());
}
for peer in &self.peer_ip {
report.peers.push(peer.to_string());
}
if let Some(t) = &self.elem_type {
report.require = Some(match t {
crate::lens::parse::ParseElemType::A => "announcements".to_string(),
crate::lens::parse::ParseElemType::W => "withdrawals".to_string(),
});
}
let prefixes: Vec<Option<IpNet>> = if prefix_nets.is_empty() {
vec![None]
} else {
prefix_nets.into_iter().map(Some).collect()
};
let peers: Vec<Option<IpAddr>> = if self.peer_ip.is_empty() {
vec![None]
} else {
self.peer_ip.iter().copied().map(Some).collect()
};
let mut subscriptions = Vec::new();
for pfx in &prefixes {
for peer in &peers {
let mut sub = RisSubscribe::new().data_type(RisSubscribeType::UPDATE);
if let Some(h) = host {
sub = sub.host(h);
}
if let Some(net) = pfx {
sub = sub
.prefix(*net)
.more_specific(self.include_sub)
.less_specific(self.include_super);
}
if let Some(ip) = peer {
sub = sub.peer(*ip);
}
if let Some(req) = &report.require {
sub = sub.require(req);
}
subscriptions.push(sub);
}
}
Ok(SubscriptionPlan {
subscriptions,
report,
})
}
pub fn compile_client_filters(&self) -> Result<Vec<bgpkit_parser::parser::filter::Filter>> {
self.to_parse_filters()?.to_filters()
}
pub fn to_parse_filters(&self) -> Result<crate::lens::parse::ParseFilters> {
let filters = crate::lens::parse::ParseFilters {
origin_asn: self.origin_asn.clone(),
prefix: self.prefix.clone(),
include_super: self.include_super,
include_sub: self.include_sub,
peer_ip: self.peer_ip.clone(),
peer_asn: self.peer_asn.clone(),
communities: self.communities.clone(),
elem_type: self.elem_type.clone(),
as_path: self.as_path.clone(),
..Default::default()
};
filters.validate()?;
Ok(filters)
}
pub fn matches(
&self,
elem: &BgpElem,
filters: &[bgpkit_parser::parser::filter::Filter],
) -> bool {
elem.match_filters(filters)
}
}
#[derive(Debug)]
pub enum LiveFrame {
Data(LiveMessage),
SubscribeOk,
Error(String),
Other,
}
#[derive(Debug)]
pub struct LiveMessage {
pub host: Option<String>,
pub elems: Vec<BgpElem>,
}
pub fn parse_live_frame(msg_str: &str) -> Result<LiveFrame> {
match extract_string_field(msg_str, "type").as_deref() {
Some("ris_subscribe_ok") => return Ok(LiveFrame::SubscribeOk),
Some("ris_error") => {
return Ok(LiveFrame::Error(
extract_string_field(msg_str, "message").unwrap_or_else(|| "unknown error".into()),
))
}
Some("ris_message") => {}
Some(_) => return Ok(LiveFrame::Other),
None => {}
}
let host = extract_host(msg_str);
match parse_ris_live_message_raw(msg_str) {
Ok(elems) => Ok(LiveFrame::Data(LiveMessage { host, elems })),
Err(e) => Err(anyhow!("failed to parse RIS Live message: {e}")),
}
}
fn extract_string_field(msg_str: &str, field: &str) -> Option<String> {
let marker = format!("\"{field}\"");
let idx = msg_str.find(&marker)?;
let rest = &msg_str[idx + marker.len()..];
let colon = rest.find(':')?;
let after = rest[colon + 1..].trim_start();
let quote = after.find('"')?;
let value = &after[quote + 1..];
let end = value.find('"')?;
Some(value[..end].to_string())
}
fn extract_host(msg_str: &str) -> Option<String> {
extract_string_field(msg_str, "host")
}
#[cfg(test)]
mod tests {
use super::*;
use bgpkit_parser::RisLiveClientMessage;
#[test]
fn test_empty_filters_report_full_feed() {
let filters = WatchFilters::default();
assert!(filters.is_empty());
}
#[test]
fn test_origin_not_pushed_down() {
let filters = WatchFilters {
origin_asn: vec!["2906".to_string()],
..Default::default()
};
let plan = filters.to_subscription_plan(None).unwrap();
assert_eq!(plan.subscriptions.len(), 1);
assert!(!plan.subscriptions[0].to_json_string().contains("path"));
let client = filters.compile_client_filters().unwrap();
assert!(!client.is_empty());
}
#[test]
fn test_pushdown_prefix_and_host() {
let filters = WatchFilters {
prefix: vec!["1.1.1.0/24".to_string()],
include_sub: true,
..Default::default()
};
let plan = filters.to_subscription_plan(Some("rrc00")).unwrap();
assert_eq!(plan.report.host.as_deref(), Some("rrc00"));
assert_eq!(plan.report.prefixes, vec!["1.1.1.0/24".to_string()]);
let json = plan.subscriptions[0].to_json_string();
assert!(json.contains("rrc00"));
assert!(json.contains("1.1.1.0/24"));
assert!(json.contains("\"moreSpecific\":true"));
}
#[test]
fn test_prefix_specificity_set_explicitly() {
let filters = WatchFilters {
prefix: vec!["1.1.1.0/24".to_string()],
..Default::default()
};
let plan = filters.to_subscription_plan(None).unwrap();
let json = plan.subscriptions[0].to_json_string();
assert!(json.contains("\"moreSpecific\":false"));
assert!(json.contains("\"lessSpecific\":false"));
}
#[test]
fn test_multi_prefix_multi_peer_expands_subscriptions() {
let filters = WatchFilters {
prefix: vec!["1.1.1.0/24".to_string(), "8.8.8.0/24".to_string()],
peer_ip: vec!["192.0.2.1".parse().unwrap(), "192.0.2.2".parse().unwrap()],
..Default::default()
};
let plan = filters.to_subscription_plan(None).unwrap();
assert_eq!(plan.subscriptions.len(), 4);
assert_eq!(plan.report.prefixes.len(), 2);
assert_eq!(plan.report.peers.len(), 2);
let jsons: Vec<String> = plan
.subscriptions
.iter()
.map(|s| s.to_json_string())
.collect();
assert!(jsons
.iter()
.any(|j| j.contains("1.1.1.0/24") && j.contains("192.0.2.1")));
assert!(jsons
.iter()
.any(|j| j.contains("8.8.8.0/24") && j.contains("192.0.2.2")));
}
#[test]
fn test_negative_prefix_client_side_only() {
let filters = WatchFilters {
prefix: vec!["!1.1.1.0/24".to_string()],
..Default::default()
};
let plan = filters.to_subscription_plan(None).unwrap();
assert!(plan.report.prefixes.is_empty());
assert!(!filters.compile_client_filters().unwrap().is_empty());
}
#[test]
fn test_elem_type_pushdown_and_client_filter() {
let filters = WatchFilters {
elem_type: Some(crate::lens::parse::ParseElemType::A),
..Default::default()
};
let plan = filters.to_subscription_plan(None).unwrap();
assert_eq!(plan.report.require.as_deref(), Some("announcements"));
assert!(!filters.compile_client_filters().unwrap().is_empty());
}
#[test]
fn test_invalid_origin_rejected_at_compile() {
let filters = WatchFilters {
origin_asn: vec!["bogus".to_string()],
..Default::default()
};
assert!(filters.compile_client_filters().is_err());
}
#[test]
fn test_invalid_prefix_rejected_at_compile() {
let filters = WatchFilters {
prefix: vec!["not-a-prefix".to_string()],
..Default::default()
};
assert!(filters.compile_client_filters().is_err());
}
#[test]
fn test_mixed_positive_negative_origin_rejected() {
let filters = WatchFilters {
origin_asn: vec!["13335".to_string(), "!15169".to_string()],
..Default::default()
};
assert!(filters.compile_client_filters().is_err());
}
#[test]
fn test_community_spec_or_semantics() {
let filters = WatchFilters {
communities: vec!["13335:100".to_string(), "15169:*".to_string()],
..Default::default()
};
let compiled = filters.compile_client_filters().unwrap();
assert_eq!(compiled.len(), 1);
}
#[test]
fn test_mixed_community_negation_rejected() {
let filters = WatchFilters {
communities: vec!["13335:100".to_string(), "!15169:1".to_string()],
..Default::default()
};
assert!(filters.compile_client_filters().is_err());
}
#[test]
fn test_extract_host() {
let frame = r#"{"type":"ris_message","data":{"timestamp":1700000000,"peer":"1.1.1.1","host":"rrc10","path":[1,2,3],"announcements":[]}}"#;
assert_eq!(extract_host(frame).as_deref(), Some("rrc10"));
assert!(extract_host("garbage").is_none());
}
#[test]
fn test_data_frame_parses_elements_and_host() {
let frame = r#"{"type":"ris_message","data":{"timestamp":1636245154.8,"peer":"2001:7f8:b:100:1d1:a520:1333:74","peer_asn":"201333","id":"10-183678-175313836","host":"rrc10","type":"UPDATE","raw":"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0086020000006F4001010040021202040003127500001A6A000000AE00004FF980040400000000C008081A6A001E1A6A3840800E4100020120200107F8000B010001D1A52013330074FE800000000000000217A3FFFEFE290500302A0E97C70000302A0E97C600FE302A10CC4217B7302A10CC421FEB"}}"#;
match parse_live_frame(frame).unwrap() {
LiveFrame::Data(msg) => {
assert_eq!(msg.host.as_deref(), Some("rrc10"));
assert!(!msg.elems.is_empty());
let elem = &msg.elems[0];
assert_eq!(elem.peer_asn.to_u32(), 201333);
assert!(elem.prefix.prefix.addr().is_ipv6());
}
other => panic!("expected data frame, got {other:?}"),
}
}
#[test]
fn test_control_frames_classified() {
let ok = parse_live_frame(r#"{"type":"ris_subscribe_ok","data":{}}"#).unwrap();
assert!(matches!(ok, LiveFrame::SubscribeOk));
let err = parse_live_frame(r#"{"type":"ris_error","data":{"message":"bad subscription"}}"#)
.unwrap();
match err {
LiveFrame::Error(msg) => assert_eq!(msg, "bad subscription"),
other => panic!("expected error frame, got {other:?}"),
}
let other = parse_live_frame(r#"{"type":"pong","data":null}"#).unwrap();
assert!(matches!(other, LiveFrame::Other));
}
}