node/debug: Use derived serializers — heartwood

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.

  "amplify",
  "base32",
  "cyphergraphy",
  "serde",
  "sha3",
 ]

  "bloomy",
  "bytes",
  "crossbeam-channel",
  "cyphernet",
  "cypheraddr",
  "fastrand",
  "log",
  "nonempty",

 chrono = { version = "0.4.26", default-features = false }
 colored = "2.1.0"
 crossbeam-channel = "0.5.6"
 cypheraddr = "0.4.0"
 cyphernet = "0.5.2"
 dunce = "1.0.5"
 fastrand = { version = "2.0.0", default-features = false }

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

 bloomy = "1.2"
 bytes = { workspace = true }
 crossbeam-channel = { workspace = true }
 cyphernet = { workspace = true, features = ["tor"] }
 cypheraddr = { workspace = true, features = ["serde", "tor"] }
 fastrand = { workspace = true }
 log = { workspace = true, features = ["std"] }
 nonempty = { workspace = true, features = ["serialize"] }

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

 /// 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>,

 }
 /// 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,

 }
 /// 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,

 }
 /// 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,

 ///
 /// 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 {

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

 /// 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>,

 use bytes::{Buf, BufMut};
 use cyphernet::addr::tor;
 use cypheraddr::tor;
 use radicle::crypto::{PublicKey, Signature, Unverified};
 use radicle::git;

     }
 }
 impl Encode for cyphernet::addr::tor::OnionAddrV3 {
 impl Encode for cypheraddr::tor::OnionAddrV3 {
     fn encode(&self, buf: &mut impl BufMut) {
         self.into_raw_bytes().encode(buf)
     }

 use bytes::Buf;
 use bytes::BufMut;
 use cyphernet::addr::{tor, HostName, NetAddr};
 use cypheraddr::{tor, HostName, NetAddr};
 use radicle::crypto::Signature;
 use radicle::git::Oid;
 use radicle::identity::RepoId;