5099c25 node/debug: Use derived serializers — heartwood

heartwood

rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5

Radicle Heartwood Protocol & Stack

node/debug: Use derived serializers

Lorenz Leutgeb committed 2 months ago

commit 5099c25df7b06f0cb800d1e1c3a354334a955d19
parent a1fa380

3 files changed +12 -34

modified crates/radicle-node/src/runtime/handle.rs

@@ -350,35 +350,10 @@ impl radicle::node::Handle for Handle {

     fn debug(&self) -> Result<serde_json::Value, Self::Error> {
         let (sender, receiver) = chan::bounded(1);
         let query: Arc<QueryState> = Arc::new(move |state| {
             let fetcher_state = state.fetching();
             let debug = serde_json::json!({
                 "outboxSize": state.outbox().len(),
                 "fetching": fetcher_state.active_fetches()
                     .iter()
                     .map(|(rid, active)| {
                         json!({
                             "rid": rid,
                             "from": active.from(),
                             "refsAt": active.refs(),
                         })
                     }).collect::<Vec<_>>(),
                 "queue": fetcher_state.queued_fetches().iter().map(|(node, queue)| {
                     json!({
                         "nid": node,
                         "queue": queue.iter().map(|fetch| {
                             json!({
                                 "rid": fetch.rid,
                                 "refsAt": fetch.refs,
                             })
                         }).collect::<Vec<_>>()
                     })
                 }).collect::<Vec<_>>(),
                 "rateLimiter": state.limiter().buckets.iter().map(|(host, bucket)| {
                     json!({
                         "host": host.to_string(),
                         "bucket": bucket
                     })
                 }).collect::<Vec<_>>(),
                 "fetching": state.fetching(),
                 "rateLimiter": state.limiter(),
                 "events": json!({
                     "subscribers": state.emitter().subscriptions(),
                     "pending": state.emitter().pending(),

modified crates/radicle-protocol/src/fetcher/state.rs

@@ -10,6 +10,7 @@ pub mod event;

 pub use command::Command;
 pub use event::Event;
 use serde::Serialize;
 use std::collections::{BTreeMap, VecDeque};
 use std::num::NonZeroUsize;

@@ -42,7 +43,7 @@ pub const MAX_CONCURRENCY: NonZeroUsize = NonZeroUsize::MIN;

 /// of fetches can happen with it concurrently. This does not guarantee that the
 /// node will actually allow this node to fetch from it – since it will maintain
 /// its own capacity for connections and load.
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct FetcherState {
     /// The active fetches that are occurring, ensuring only one fetch per repository.
     active: BTreeMap<RepoId, ActiveFetch>,

@@ -235,7 +236,7 @@ impl FetcherState {

 }
 /// Configuration for the [`FetcherState`].
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
 pub struct Config {
     /// Maximum number of concurrent fetches per peer connection.
     maximum_concurrency: NonZeroUsize,

@@ -271,7 +272,7 @@ impl Default for Config {

 }
 /// An active fetch represents a repository being fetched by a particular node.
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct ActiveFetch {
     pub from: NodeId,
     pub refs: RefsToFetch,

@@ -290,7 +291,7 @@ impl ActiveFetch {

 }
 /// A fetch that is waiting to be processed, in the fetch queue.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)]
 pub struct QueuedFetch {
     /// The repository that will be fetched.
     pub rid: RepoId,

@@ -304,14 +305,15 @@ pub struct QueuedFetch {

 ///
 /// It ensures that the queue contains unique items for fetching, and does not
 /// exceed the provided maximum capacity.
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct Queue {
     queue: VecDeque<QueuedFetch>,
     max_queue_size: MaxQueueSize,
 }
 /// The maximum number of fetches that can be queued for a single node.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
 #[serde(transparent)]
 pub struct MaxQueueSize(usize);
 impl MaxQueueSize {

modified crates/radicle-protocol/src/service/limiter.rs

@@ -2,6 +2,7 @@ use std::collections::{HashMap, HashSet};

 use localtime::LocalTime;
 use radicle::node::{address, config, HostName, NodeId};
 use serde::Serialize;
 /// Peer rate limiter.
 ///

@@ -9,7 +10,7 @@ use radicle::node::{address, config, HostName, NodeId};

 /// and every request from that address consumes one token. Tokens refill at a predefined
 /// rate. This mechanism allows for consistent request rates with potential bursts up to the
 /// bucket's capacity.
 #[derive(Debug, Default)]
 #[derive(Debug, Default, Serialize)]
 pub struct RateLimiter {
     pub buckets: HashMap<HostName, TokenBucket>,
     pub bypass: HashSet<NodeId>,