Skip to content
Prev Previous commit
Next Next commit
fix(node): complete federation review follow-ups
Register the bounded peer-query fixture in the writer ledger, name federation bounds, and share the state-owned limiter across routers and the cleanup sweep. Cover exhausted-bucket rejection before database access.
  • Loading branch information
euxarist committed Sep 9, 2026
commit 050dd4f82958e4b9db8049ea9d815073e3dec426
60 changes: 49 additions & 11 deletions crates/gitlawb-node/src/api/repos.rs
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,8 @@ const ZERO_SHA: &str = "0000000000000000000000000000000000000000";

const FEDERATED_PEER_CONCURRENCY: usize = 4;
const FEDERATED_PEER_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
const FEDERATED_AGGREGATE_DEADLINE: std::time::Duration = std::time::Duration::from_secs(10);
pub(crate) const MAX_FEDERATED_PEERS: usize = 200;
const MAX_FEDERATED_PEER_BYTES: usize = 512 * 1024;
const MAX_FEDERATED_PEER_REPOS: usize = 200;
const MAX_FEDERATED_REPOS: usize = 1_000;
Expand Down Expand Up @@ -3380,7 +3382,7 @@ where
let mut responses = stream::iter(fetches).buffer_unordered(FEDERATED_PEER_CONCURRENCY);
let mut nodes_queried = 0;

let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(10);
let deadline = tokio::time::Instant::now() + FEDERATED_AGGREGATE_DEADLINE;
loop {
let response = match tokio::time::timeout_at(deadline, responses.next()).await {
Ok(Some(response)) => response,
Expand Down Expand Up @@ -3417,7 +3419,8 @@ where
///
/// Query all known peers for their public repos and return a merged view of
/// the network. Each repo includes a `node_url` and `node_did` indicating
/// which node hosts it. Peer work stops after ten seconds or 200 peers; omitted
/// which node hosts it. Peer work is bounded by `FEDERATED_AGGREGATE_DEADLINE`
/// and `MAX_FEDERATED_PEERS`; omitted
/// results set `truncated`. The route admits 12 requests per minute per client IP.
pub async fn list_federated_repos(
State(state): State<AppState>,
Expand Down Expand Up @@ -3468,9 +3471,12 @@ pub async fn list_federated_repos(
// Dropping the buffered stream at the aggregate ceiling cancels its in-flight
// request futures and leaves the remaining iterator entries unpolled.
// One extra row detects omitted peers without materializing the full table.
let mut peers = state.db.list_federation_peers(201).await?;
aggregate.truncated |= peers.len() > 200;
peers.truncate(200);
let mut peers = state
.db
.list_federation_peers(MAX_FEDERATED_PEERS as i64 + 1)
.await?;
aggregate.truncated |= peers.len() > MAX_FEDERATED_PEERS;
peers.truncate(MAX_FEDERATED_PEERS);
let fetches: Vec<_> = peers
.into_iter()
.filter(|p| p.last_ping_ok && !p.http_url.is_empty())
Expand Down Expand Up @@ -4468,10 +4474,11 @@ mod tests {
#[sqlx::test]
async fn federated_peer_query_is_bounded(pool: sqlx::PgPool) {
let state = crate::test_support::test_state(pool.clone()).await;
sqlx::query("INSERT INTO peers (did, http_url, last_ping_ok, announced_at) SELECT 'peer-' || n, 'https://example.com', TRUE, '2026-01-01T00:00:00Z' FROM generate_series(1, 205) n")
sqlx::query("INSERT INTO peers (did, http_url, last_ping_ok, announced_at) SELECT 'peer-' || n, 'https://example.com', TRUE, '2026-01-01T00:00:00Z' FROM generate_series(1, $1) n")
.bind(MAX_FEDERATED_PEERS as i64 + 5)
.execute(&pool).await.unwrap();
let peers = state.db.list_federation_peers(1000).await.unwrap();
assert_eq!(peers.len(), 201);
let peers = state.db.list_federation_peers(i64::MAX).await.unwrap();
assert_eq!(peers.len(), MAX_FEDERATED_PEERS + 1);
assert_eq!(state.db.list_federation_peers(2).await.unwrap().len(), 2);
assert!(state.db.list_federation_peers(0).await.unwrap().is_empty());
}
Expand All @@ -4481,8 +4488,10 @@ mod tests {
use tower::ServiceExt;
let mut state = crate::test_support::test_state(pool).await;
state.push_limiter_trust = crate::rate_limit::TrustedProxy::None;
state.federated_rate_limiter =
crate::rate_limit::RateLimiter::new_bounded(1, std::time::Duration::from_secs(60), 10);
let router = crate::server::build_router(state);
for n in 0..13 {
for n in 0..2 {
let mut request = axum::http::Request::builder()
.uri("/api/v1/repos/federated")
.body(axum::body::Body::empty())
Expand All @@ -4493,7 +4502,7 @@ mod tests {
let response = router.clone().oneshot(request).await.unwrap();
assert_eq!(
response.status(),
if n < 12 {
if n == 0 {
StatusCode::OK
} else {
StatusCode::TOO_MANY_REQUESTS
Expand Down Expand Up @@ -4549,13 +4558,42 @@ mod tests {
);
}

#[tokio::test]
async fn federated_route_uses_the_state_owned_bucket_before_database_access() {
use tower::ServiceExt;
let mut state = crate::test_support::test_state_lazy();
state.push_limiter_trust = crate::rate_limit::TrustedProxy::None;
state.federated_rate_limiter =
crate::rate_limit::RateLimiter::new_bounded(1, std::time::Duration::from_secs(60), 10);
assert!(state.federated_rate_limiter.check("203.0.113.42").await);
// Both routers must use the same exhausted bucket from AppState.
for router in [
crate::server::build_router(state.clone()),
crate::server::build_router(state),
] {
let mut request = axum::http::Request::builder()
.uri("/api/v1/repos/federated")
.body(axum::body::Body::empty())
.unwrap();
request.extensions_mut().insert(axum::extract::ConnectInfo(
"203.0.113.42:5000".parse::<std::net::SocketAddr>().unwrap(),
));
let response =
tokio::time::timeout(std::time::Duration::from_secs(1), router.oneshot(request))
.await
.expect("the exhausted bucket must reject before accessing the lazy database")
.unwrap();
assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
}
}

#[tokio::test]
async fn federated_aggregate_deadline_returns_partial_results() {
let mut budget = FederatedRepoBudget::new(0, 1000, MAX_FEDERATED_REPO_JSON_BYTES);
let fetches =
(0..8).map(|_| async { std::future::pending::<Option<FederatedPeerRepos>>().await });
let nodes = tokio::time::timeout(
std::time::Duration::from_secs(12),
FEDERATED_AGGREGATE_DEADLINE + std::time::Duration::from_secs(2),
collect_federated_fetches(fetches, &mut budget),
)
.await
Expand Down
1 change: 1 addition & 0 deletions crates/gitlawb-node/src/auth/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -668,6 +668,7 @@ mod tests {
push_limiter_trust: crate::rate_limit::TrustedProxy::None,
sync_trigger_rate_limiter: RateLimiter::new(60, Duration::from_secs(3600)),
peer_write_rate_limiter: RateLimiter::new(600, Duration::from_secs(3600)),
federated_rate_limiter: RateLimiter::new_bounded(12, Duration::from_secs(60), 10_000),
shutdown_tx: tokio::sync::watch::channel(false).0,
git_read_semaphore: Arc::new(tokio::sync::Semaphore::new(64)),
git_write_semaphore: Arc::new(tokio::sync::Semaphore::new(64)),
Expand Down
4 changes: 3 additions & 1 deletion crates/gitlawb-node/src/db/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -3032,7 +3032,7 @@ impl Db {
"SELECT did, http_url, last_seen, last_ping_ok, announced_at
FROM peers WHERE last_ping_ok = TRUE AND http_url <> '' ORDER BY last_seen DESC NULLS LAST, did LIMIT $1",
)
.bind(limit.clamp(0, 201))
.bind(limit.clamp(0, crate::api::repos::MAX_FEDERATED_PEERS as i64 + 1))
.fetch_all(&self.pool)
.await?;
Ok(rows
Expand Down Expand Up @@ -9303,6 +9303,7 @@ mod peer_authority_tests {
/// | `gossip_ping_round_requires_two_failures_before_persisting_unreachable` (main.rs) | test-only fixture seed. Raw SQL because the test drives the readiness HYSTERESIS, which needs a row already at `last_ping_ok = TRUE` before the round runs; it never exercises the announce gate |
/// | `manual_ping_uses_readiness_without_mutating_federation_gate` (api/peers.rs) | test-only fixture seed, same shape and same reason: the row under test must pre-exist so the assertion is about what the ping does NOT rewrite |
/// | `seed_peer` (p2p/mod.rs) | test-only fixture seed. Raw SQL so the gossip ingest tests can drive the known-peer gate directly, including the did:web case `upsert_peer` would refuse |
/// | `federated_peer_query_is_bounded` (api/repos.rs) | test-only fixture seed for the bounded federation query; inserts reachable rows without exercising peer admission |
///
/// And the `upsert_peer` CALL-SITE authority table, which the ledger above
/// structurally cannot hold, because the bootstrap site issues no SQL of its own
Expand Down Expand Up @@ -9388,6 +9389,7 @@ mod peers_table_writer_guard {
/// listed function that no longer has one.
const LEDGER: &[(&str, usize)] = &[
("a_legacy_row_can_still_refresh_its_liveness", 1),
("federated_peer_query_is_bounded", 1),
(
"gossip_ping_round_requires_two_failures_before_persisting_unreachable",
1,
Expand Down
5 changes: 5 additions & 0 deletions crates/gitlawb-node/src/main.rs
Original file line number Diff line number Diff line change
Expand Up @@ -429,6 +429,8 @@ async fn main() -> Result<()> {
std::time::Duration::from_secs(3600),
200_000,
);
let federated_rate_limiter =
rate_limit::RateLimiter::new_bounded(12, std::time::Duration::from_secs(60), 10_000);
if config.sync_trigger_rate_limit == 0 {
tracing::warn!(
"GITLAWB_SYNC_TRIGGER_RATE_LIMIT=0 — /sync/trigger IP rate limiting disabled"
Expand Down Expand Up @@ -467,6 +469,7 @@ async fn main() -> Result<()> {
push_limiter_trust,
sync_trigger_rate_limiter,
peer_write_rate_limiter,
federated_rate_limiter,
shutdown_tx: shutdown_tx.clone(),
git_read_semaphore: Arc::new(tokio::sync::Semaphore::new(config.max_concurrent_git_ops)),
git_write_semaphore: Arc::new(tokio::sync::Semaphore::new(
Expand Down Expand Up @@ -1171,6 +1174,7 @@ mod rate_limiter_sweep_tests {
state.close_issue_rate_limiter = RateLimiter::new(10, window);
state.sync_trigger_rate_limiter = RateLimiter::new(10, window);
state.peer_write_rate_limiter = RateLimiter::new(10, window);
state.federated_rate_limiter = RateLimiter::new(10, window);
state.ipfs_rate_limiter = RateLimiter::new(10, window);

let limiters = |s: &crate::state::AppState| {
Expand All @@ -1181,6 +1185,7 @@ mod rate_limiter_sweep_tests {
s.close_issue_rate_limiter.clone(),
s.sync_trigger_rate_limiter.clone(),
s.peer_write_rate_limiter.clone(),
s.federated_rate_limiter.clone(),
s.ipfs_rate_limiter.clone(),
]
};
Expand Down
6 changes: 1 addition & 5 deletions crates/gitlawb-node/src/server.rs
Original file line number Diff line number Diff line change
Expand Up @@ -390,11 +390,7 @@ pub fn build_router(state: AppState) -> Router {
get(repos::list_federated_repos)
.route_layer(middleware::from_fn(rate_limit::rate_limit_by_ip))
.route_layer(axum::Extension(rate_limit::IpRateLimiter {
limiter: rate_limit::RateLimiter::new_bounded(
12,
std::time::Duration::from_secs(60),
10_000,
),
limiter: state.federated_rate_limiter.clone(),
trust: state.push_limiter_trust,
})),
)
Expand Down
4 changes: 4 additions & 0 deletions crates/gitlawb-node/src/state.rs
Original file line number Diff line number Diff line change
Expand Up @@ -190,6 +190,9 @@ pub struct AppState {
/// sink as trigger and accepts unsigned requests from known peers, so it is
/// braked too; each peer's distinct IP gets its own bucket.
pub peer_write_rate_limiter: RateLimiter,
/// Per-client-IP federation budget: 12 requests per minute, with at most
/// 10,000 tracked source keys. Shared by router instances and swept below.
pub federated_rate_limiter: RateLimiter,
/// Process-wide graceful-shutdown signal. Sending `true` causes every
/// task that holds a `watch::Receiver` to exit at its next await point.
/// Used by:
Expand Down Expand Up @@ -351,6 +354,7 @@ impl AppState {
self.ipfs_work_rate_limiter.cleanup().await;
self.sync_trigger_rate_limiter.cleanup().await;
self.peer_write_rate_limiter.cleanup().await;
self.federated_rate_limiter.cleanup().await;
}

/// Trigger graceful shutdown. Idempotent — calling more than once
Expand Down
1 change: 1 addition & 0 deletions crates/gitlawb-node/src/test_support.rs
Original file line number Diff line number Diff line change
Expand Up @@ -116,6 +116,7 @@ fn build_state(db: Arc<crate::db::Db>, pool: PgPool) -> AppState {
push_limiter_trust: crate::rate_limit::TrustedProxy::None,
sync_trigger_rate_limiter: RateLimiter::new(60, Duration::from_secs(3600)),
peer_write_rate_limiter: RateLimiter::new(600, Duration::from_secs(3600)),
federated_rate_limiter: RateLimiter::new_bounded(12, Duration::from_secs(60), 10_000),
shutdown_tx: tokio::sync::watch::channel(false).0,
// Generous — no test drives the handler-level shed (git_permit is unit-tested).
git_read_semaphore: Arc::new(tokio::sync::Semaphore::new(64)),
Expand Down