node/debug: Use derived serializers

The construction of the debug object is unwieldy, and error prone
(for example, renamed struct members have to be manually renamed
in the serialization code, see "refs" vs. "refsAt").

Use derived serializers where possible to make this easier to maintain.

Author: lorenzleutgeb

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(),

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 {

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

@@ -2,14 +2,15 @@ use std::collections::{HashMap, HashSet};
 
 use localtime::LocalTime;
 use radicle::node::{address, config, HostName, NodeId};
+use serde::Serialize;
 
 /// Peer rate limiter.
 ///
 /// Uses a token bucket algorithm, where each address starts with a certain amount of tokens,
 /// 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>,