Rayhaan JaufeerallyandClaude Fable 5.1
630c175918
The work of the speaker-cleanup branch as one commit; the branch keeps the step-by-step history. Sessions - The state machine is a pure function from events to actions, driven by one task per connection. Idle, Connect and Active belong to a dialer that keeps configured peers up with backoff. - Capabilities are negotiated: address families, four-octet AS numbers with AS_TRANS and AS4_PATH, route refresh, ADD-PATH per family and direction. - Collision detection per RFC 4271 section 6.8, by address and identifier. - Connections are taken only from configured peers, a few per address. - A panic in a session is contained and answered with a Cease; a core task that stops shuts the server down with a Cease to every peer. - Writes that make no progress are given up (RFC 9687). Codec - Malformed UPDATEs are handled as RFC 7606 says: treat-as-withdraw, attribute discard, or session reset, with the NOTIFICATION to send. - Address families are open types; any can be named and ignored. - Prefixes are fixed-size values, normalised, with path identifiers. - Lengths are filled in after writing; one definition of each type code. - Property tests and fuzz targets for every decoder. Routing table - Adj-RIBs-In and Loc-RIB in one sharded table that sessions write to directly. Routes are sixteen bytes; attribute sets are interned in wire form. Best-path selection per RFC 4271 section 9.1.2.2 with deterministic MED. - A journal per shard lets followers read changes at their own pace; one that falls behind is resynchronised. - On a RIPE RIS dump of 148 peers and 39.3M routes: loaded in 2.0 s on 12 cores, about 52 bytes a route. Announcing - Originated routes come from the configuration. Each session has its own exporter with an Adj-RIB-Out, so a slow peer delays only itself. - Routes to a peer in our own AS have an empty path and a LOCAL_PREF. Operations - HTTP status page, JSON API, event stream and Prometheus metrics. - Benchmarks on synthetic and real tables. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
88 lines
2.9 KiB
Rust
88 lines
2.9 KiB
Rust
//! What the server does when a part of it that it cannot do without fails.
|
|
//!
|
|
//! The local RIB's actor stops only by panicking. Before, nothing noticed:
|
|
//! sessions stayed up, nothing was announced any more, and the status page
|
|
//! showed an empty table. Now the server tells its peers it is going and
|
|
//! stops with an error, for whatever supervises it to restart it.
|
|
|
|
use std::net::Ipv4Addr;
|
|
use std::time::Duration;
|
|
|
|
use bgp_integration_tests::test_peer::TestPeer;
|
|
use bgp_integration_tests::test_server::TestServer;
|
|
use bgp_packet::errors::{BgpError, CeaseSubcode};
|
|
use bgp_packet::message::Message;
|
|
use bgp_rib::RibStopped;
|
|
use bgp_server::error::ServerError;
|
|
use eyre::{Result, bail};
|
|
|
|
const LOCAL_ASN: u32 = 65000;
|
|
const PEER_ASN: u32 = 65001;
|
|
const TIMEOUT: Duration = Duration::from_secs(5);
|
|
|
|
async fn established(server: &TestServer) -> Result<TestPeer> {
|
|
let mut peer = TestPeer::connect(server.addr).await?;
|
|
peer.handshake(PEER_ASN, Ipv4Addr::new(10, 0, 0, 1), 90)
|
|
.await?;
|
|
tokio::time::timeout(TIMEOUT, async {
|
|
while server.registry.list().is_empty() {
|
|
tokio::time::sleep(Duration::from_millis(10)).await;
|
|
}
|
|
})
|
|
.await?;
|
|
Ok(peer)
|
|
}
|
|
|
|
/// Reads until the server's NOTIFICATION, skipping KEEPALIVEs.
|
|
async fn farewell(peer: &mut TestPeer) -> Result<BgpError> {
|
|
tokio::time::timeout(TIMEOUT, async {
|
|
loop {
|
|
match peer.recv().await? {
|
|
Message::KeepAlive => {}
|
|
Message::Notification(n) => return Ok(n.error),
|
|
other => bail!("expected NOTIFICATION, got {other:?}"),
|
|
}
|
|
}
|
|
})
|
|
.await?
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_losing_the_local_rib_stops_the_server_and_tells_the_peers() -> Result<()> {
|
|
let mut server = TestServer::start(LOCAL_ASN).await?;
|
|
let (base, _http) = server.serve_http().await?;
|
|
let mut peer = established(&server).await?;
|
|
|
|
server.local_rib.stop_for_testing();
|
|
|
|
let outcome = tokio::time::timeout(TIMEOUT, server.stopped()).await?;
|
|
assert!(
|
|
matches!(outcome, Err(ServerError::RibStopped(RibStopped { rib })) if rib == "local RIB"),
|
|
"{outcome:?}"
|
|
);
|
|
assert_eq!(
|
|
farewell(&mut peer).await?,
|
|
BgpError::Cease(CeaseSubcode::AdminShutdown)
|
|
);
|
|
|
|
// The status interface says the table cannot be read, where it used to
|
|
// show an empty one.
|
|
let client = reqwest::Client::new();
|
|
for path in ["/api/status", "/api/routes/local", "/metricz"] {
|
|
let response = client.get(format!("{base}{path}")).send().await?;
|
|
assert_eq!(response.status(), 503, "{path}");
|
|
assert_eq!(
|
|
response.text().await?,
|
|
"the local RIB has stopped",
|
|
"{path}"
|
|
);
|
|
}
|
|
// What does not need that table still answers.
|
|
let response = client
|
|
.get(format!("{base}/api/routes/received"))
|
|
.send()
|
|
.await?;
|
|
assert_eq!(response.status(), 200);
|
|
Ok(())
|
|
}
|