Rayhaan JaufeerallyandClaude Fable 5.1
31aa3a4563
The server now keeps what it learns in table::RibTable. The Adj-RIB-In actor is gone, and with it the queue every UPDATE from every session went through. - A session takes a number in the table when it is established and writes its UPDATEs into the table itself. Its routes are removed when it ends, on a blocking thread since that looks at every prefix; a session torn down without cleaning up still has them removed. - For every prefix the best route is chosen (RFC 4271 §9.1.2.2) as routes come and go. Nothing acts on the choice yet beyond showing it. - The UPDATE decoder hands over the bytes of the attributes it kept, so the table finds the attribute set from them without writing the attributes out again. On a session with two-octet AS numbers the bytes are not in the table's form, and the parsed attributes are used. - /api/routes/received marks the best route of each prefix and returns at most `limit` routes (default 1000): the table can hold hundreds of millions. /api/status has the totals, and the status page says how many it is showing. The time a route was received is no longer kept or shown. - The event stream reports changes of best route (best_changed, best_withdrawn) in place of every route received. Each client follows the table's journal with a reader of its own, from the moment it connects: table::RibTable::reader_from_now. - Metrics: bgp_rib_routes, bgp_rib_prefixes, bgp_rib_attribute_sets and bgp_rib_journal_entries replace bgp_adj_rib_in_routes. - A line is no longer logged at INFO for every UPDATE sent or received; a full table is a million of them. They are at DEBUG. - A table with no room for another peer ends the session with Cease / Out of Resources. Four peers sending a synthetic full table each over TCP, 4.9 million routes: 0.80 s, against 4.76 s before. One peer: 0.45 s against 0.69 s. 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(())
|
|
}
|