radicle/config/node: Granular Default Values — heartwood

Provide default values not only per struct, but for each individual struct member. This allows more granular configuration and fallback to defaults.

                     inbound: RateLimit {
                         fill_rate: 1.0,
                         capacity: usize::MAX,
                     },
                     }
                     .into(),
                     outbound: RateLimit {
                         fill_rate: 1.0,
                         capacity: usize::MAX,
                     },
                     }
                     .into(),
                 },
                 ..Limits::default()
             },

     let config = options.config.unwrap_or_else(|| home.config());
     let mut config = profile::Config::load(&config)?;
     let level = options.log.unwrap_or(config.node.log);
     let level = options.log.unwrap_or_else(|| config.node.log.into());
     let logger = {
         let journal = {

         config.node.listen.clone()
     };
     if let Err(e) = radicle::io::set_file_limit(config.node.limits.max_open_files) {
     if let Err(e) = radicle::io::set_file_limit::<usize>(config.node.limits.max_open_files.into()) {
         log::warn!(target: "node", "Unable to set process open file limit: {e}");
     }

             cobs_cache,
             db,
             worker::Config {
                 capacity: config.workers,
                 capacity: config.workers.into(),
                 storage: storage.clone(),
                 fetch,
                 policy,

         // All zero
         Test {
             limits: Limits {
                 routing_max_size: 0,
                 routing_max_age: LocalDuration::from_secs(0),
                 routing_max_size: 0.into(),
                 routing_max_age: LocalDuration::from_secs(0).into(),
                 ..Limits::default()
             },
             peer_projects: vec![10; 5],

         // All entries remain because the table is unconstrained.
         Test {
             limits: Limits {
                 routing_max_size: 50,
                 routing_max_age: LocalDuration::from_mins(0),
                 routing_max_size: 50.into(),
                 routing_max_age: LocalDuration::from_mins(0).into(),
                 ..Limits::default()
             },
             peer_projects: vec![10; 5],

         // Some entries are pruned because the table is constrained.
         Test {
             limits: Limits {
                 routing_max_size: 25,
                 routing_max_age: LocalDuration::from_mins(7 * 24 * 60),
                 routing_max_size: 25.into(),
                 routing_max_age: LocalDuration::from_mins(7 * 24 * 60).into(),
                 ..Limits::default()
             },
             peer_projects: vec![10; 5],

     let repos = scale.max(4);
     let limits = Limits {
         // Have one fetch be queued.
         fetch_concurrency: repos - 1,
         fetch_concurrency: (repos - 1).into(),
         ..Limits::default()
     };
     let mut bob_repos = HashSet::new();

 use radicle::node::address;
 use radicle::node::address::Store as _;
 use radicle::node::address::{AddressBook, AddressType, KnownAddress};
 use radicle::node::config::PeerConfig;
 use radicle::node::config::{PeerConfig, RateLimit};
 use radicle::node::device::Device;
 use radicle::node::refs::Store as _;
 use radicle::node::routing::Store as _;

             if let Err(err) = self
                 .db
                 .gossip_mut()
                 .prune((now - self.config.limits.gossip_max_age).into())
                 .prune((now - LocalDuration::from(self.config.limits.gossip_max_age)).into())
             {
                 error!(target: "service", "Error pruning gossip entries: {err}");
             }

             return true;
         }
         // Check for inbound connection limit.
         if self.sessions.inbound().count() >= self.config.limits.connection.inbound {
         if self.sessions.inbound().count() >= self.config.limits.connection.inbound.into() {
             return false;
         }
         match self.db.addresses().is_ip_banned(ip) {

             Err(e) => error!(target: "service", "Error querying ban status for {ip}: {e}"),
         }
         let host: HostName = ip.into();
         let tokens = RateLimit::from(self.config.limits.rate.inbound.clone());
         if self.limiter.limit(
             host.clone(),
             None,
             &self.config.limits.rate.inbound,
             self.clock,
         ) {
         if self.limiter.limit(host.clone(), None, &tokens, self.clock) {
             trace!(target: "service", "Rate limiting inbound connection from {host}..");
             return false;
         }

         };
         peer.last_active = self.clock;
         let limit = match peer.link {
             Link::Outbound => &self.config.limits.rate.outbound,
             Link::Inbound => &self.config.limits.rate.inbound,
         let limit: RateLimit = match peer.link {
             Link::Outbound => self.config.limits.rate.outbound.clone().into(),
             Link::Inbound => self.config.limits.rate.inbound.clone().into(),
         };
         if self
             .limiter
             .limit(peer.addr.clone().into(), Some(remote), limit, self.clock)
             .limit(peer.addr.clone().into(), Some(remote), &limit, self.clock)
         {
             debug!(target: "service", "Rate limiting message from {remote} ({})", peer.addr);
             return Ok(());

         if self.sessions.contains_key(&nid) {
             return Err(ConnectError::SessionExists { nid });
         }
         if self.sessions.outbound().count() >= self.config.limits.connection.outbound {
         if self.sessions.outbound().count() >= self.config.limits.connection.outbound.into() {
             return Err(ConnectError::LimitReached { nid, addr });
         }
         let persistent = self.config.is_persistent(&nid);

     fn prune_routing_entries(&mut self, now: &LocalTime) -> Result<(), routing::Error> {
         let count = self.db.routing().len()?;
         if count <= self.config.limits.routing_max_size {
         if count <= self.config.limits.routing_max_size.into() {
             return Ok(());
         }
         let delta = count - self.config.limits.routing_max_size;
         let delta = count - usize::from(self.config.limits.routing_max_size);
         let nid = self.node_id();
         self.db.routing_mut().prune(
             (*now - self.config.limits.routing_max_age).into(),
             (*now - LocalDuration::from(self.config.limits.routing_max_age)).into(),
             Some(delta),
             &nid,
         )?;

     pub fn is_at_capacity(&self) -> bool {
         if let State::Connected { fetching, .. } = &self.state {
             if fetching.len() >= self.limits.fetch_concurrency {
             if fetching.len() >= self.limits.fetch_concurrency.into() {
                 return true;
             }
         }

 /// Peer-to-peer protocol version.
 pub type ProtocolVersion = u8;
 /// Default number of workers to spawn.
 pub const DEFAULT_WORKERS: usize = 8;
 /// Configured public seeds.
 pub mod seeds {
     use std::{

 }
 /// Configuration parameters defining attributes of minima and maxima.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 #[serde(default, rename_all = "camelCase")]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Limits {
     /// Number of routing table entries before we start pruning.
     pub routing_max_size: usize,
     pub routing_max_size: LimitRoutingMaxSize,
     /// How long to keep a routing table entry before being pruned.
     #[serde(with = "crate::serde_ext::localtime::duration")]
     #[cfg_attr(
         feature = "schemars",
         schemars(with = "crate::schemars_ext::localtime::LocalDuration")
     )]
     pub routing_max_age: LocalDuration,
     pub routing_max_age: LimitRoutingMaxAge,
     /// How long to keep a gossip message entry before pruning it.
     #[serde(with = "crate::serde_ext::localtime::duration")]
     #[cfg_attr(
         feature = "schemars",
         schemars(with = "crate::schemars_ext::localtime::LocalDuration")
     )]
     pub gossip_max_age: LocalDuration,
     pub gossip_max_age: LimitGossipMaxAge,
     /// Maximum number of concurrent fetches per peer connection.
     pub fetch_concurrency: usize,
     pub fetch_concurrency: LimitFetchConcurrency,
     /// Maximum number of open files.
     pub max_open_files: usize,
     pub max_open_files: LimitMaxOpenFiles,
     /// Rate limitter settings.
     #[serde(default)]
     pub rate: RateLimits,
     /// Connection limits.
     #[serde(default)]
     pub connection: ConnectionLimits,
     /// Channel limits.
     #[serde(default)]
     pub fetch_pack_receive: FetchPackSizeLimit,
 }
 impl Default for Limits {
     fn default() -> Self {
         Self {
             routing_max_size: 1000,
             routing_max_age: LocalDuration::from_mins(7 * 24 * 60), // One week
             gossip_max_age: LocalDuration::from_mins(2 * 7 * 24 * 60), // Two weeks
             fetch_concurrency: 1,
             max_open_files: 4096,
             rate: RateLimits::default(),
             connection: ConnectionLimits::default(),
             fetch_pack_receive: FetchPackSizeLimit::default(),
         }
     }
 }
 /// Limiter for byte streams.
 ///
 /// Default: 500MiB

 }
 /// Connection limits.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 #[serde(default, rename_all = "camelCase")]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct ConnectionLimits {
     /// Max inbound connections.
     pub inbound: usize,
     /// Max outbound connections. Note that this can be higher than the *target* number.
     pub outbound: usize,
 }
     pub inbound: LimitConnectionsInbound,
 impl Default for ConnectionLimits {
     fn default() -> Self {
         Self {
             inbound: 128,
             outbound: 16,
         }
     }
     /// Max outbound connections. Note that this can be higher than the *target* number.
     pub outbound: LimitConnectionsOutbound,
 }
 /// Rate limts for a single connection.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[derive(Debug, Clone, Serialize, Deserialize, Display)]
 #[display("RateLimit(fill_rate={fill_rate}, capacity={capacity})")]
 #[serde(rename_all = "camelCase")]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct RateLimit {

 }
 /// Rate limits for inbound and outbound connections.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct RateLimits {
     pub inbound: RateLimit,
     pub outbound: RateLimit,
 }
     pub inbound: LimitRateInbound,
 impl Default for RateLimits {
     fn default() -> Self {
         Self {
             inbound: RateLimit {
                 fill_rate: 5.0,
                 capacity: 1024,
             },
             outbound: RateLimit {
                 fill_rate: 10.0,
                 capacity: 2048,
             },
         }
     }
     pub outbound: LimitRateOutbound,
 }
 /// Full address used to connect to a remote node.

 }
 /// Peer configuration.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 #[serde(rename_all = "camelCase", tag = "type")]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum PeerConfig {
     /// Static peer set. Connect to the configured peers and maintain the connections.
     Static,
     /// Dynamic peer set.
     #[default]
     Dynamic,
 }
 impl Default for PeerConfig {
     fn default() -> Self {
         Self::Dynamic
     }
 }
 /// Relay configuration.
 #[derive(Debug, Copy, Clone, Default, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]

     #[serde(default)]
     pub network: Network,
     /// Log level.
     #[serde(default = "defaults::log")]
     #[serde(with = "crate::serde_ext::string")]
     #[cfg_attr(
         feature = "schemars",
         schemars(with = "crate::schemars_ext::log::Level")
     )]
     pub log: log::Level,
     #[serde(default)]
     pub log: LogLevel,
     /// Whether or not our node should relay messages.
     #[serde(default, deserialize_with = "crate::serde_ext::ok_or_default")]
     pub relay: Relay,

     #[serde(default)]
     pub limits: Limits,
     /// Number of worker threads to spawn.
     #[serde(default = "defaults::workers")]
     pub workers: usize,
     #[serde(default)]
     pub workers: Workers,
     /// Default seeding policy.
     #[serde(default)]
     pub seeding_policy: DefaultSeedingPolicy,

             onion: None,
             relay: Relay::default(),
             limits: Limits::default(),
             workers: DEFAULT_WORKERS,
             log: defaults::log(),
             workers: Workers::default(),
             log: LogLevel::default(),
             seeding_policy: DefaultSeedingPolicy::default(),
             extra: json::Map::default(),
         }

     }
 }
 /// Defaults as functions, for serde.
 mod defaults {
     /// Worker count.
     pub fn workers() -> usize {
         super::DEFAULT_WORKERS
 #[derive(Clone, Copy, Debug, Display, Deserialize, Serialize, From)]
 #[serde(transparent)]
 #[display("{0}")]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct LogLevel(
     #[serde(with = "crate::serde_ext::string")]
     #[cfg_attr(
         feature = "schemars",
         schemars(with = "crate::schemars_ext::log::Level")
     )]
     log::Level,
 );
 impl Default for LogLevel {
     fn default() -> Self {
         Self(log::Level::Info)
     }
 }
     /// Log level.
     pub fn log() -> log::Level {
         log::Level::Info
 impl From<LogLevel> for log::Level {
     fn from(value: LogLevel) -> Self {
         value.0
     }
 }
 #[derive(Clone, Copy, Debug, Deserialize, Serialize, Eq, PartialEq)]
 #[serde(transparent)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct LimitRoutingMaxAge(
     #[serde(with = "crate::serde_ext::localtime::duration")]
     #[cfg_attr(
         feature = "schemars",
         schemars(with = "crate::schemars_ext::localtime::LocalDuration")
     )]
     localtime::LocalDuration,
 );
 impl Default for LimitRoutingMaxAge {
     fn default() -> Self {
         Self(localtime::LocalDuration::from_mins(7 * 24 * 60)) // One week
     }
 }
 impl From<LimitRoutingMaxAge> for LocalDuration {
     fn from(value: LimitRoutingMaxAge) -> Self {
         value.0
     }
 }
 impl From<LocalDuration> for LimitRoutingMaxAge {
     fn from(value: LocalDuration) -> Self {
         Self(value)
     }
 }
 #[derive(Clone, Copy, Debug, Deserialize, Serialize, Eq, PartialEq)]
 #[serde(transparent)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct LimitGossipMaxAge(
     #[serde(with = "crate::serde_ext::localtime::duration")]
     #[cfg_attr(
         feature = "schemars",
         schemars(with = "crate::schemars_ext::localtime::LocalDuration")
     )]
     localtime::LocalDuration,
 );
 impl Default for LimitGossipMaxAge {
     fn default() -> Self {
         Self(localtime::LocalDuration::from_mins(2 * 7 * 24 * 60)) // Two weeks
     }
 }
 impl From<LimitGossipMaxAge> for LocalDuration {
     fn from(value: LimitGossipMaxAge) -> Self {
         value.0
     }
 }
 macro_rules! wrapper {
     ($name:ident, $type:ty, $default:expr $(, $derive:ty)*) => {
         #[derive(Clone, Debug, Deserialize, Display, Serialize, From $(, $derive)*)]
         #[display("{0}")]
         #[serde(transparent)]
         #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
         pub struct $name($type);
         impl Default for $name {
             fn default() -> Self {
                 Self($default)
             }
         }
         impl From<$name> for $type {
             fn from(value: $name) -> Self {
                 value.0
             }
         }
     };
 }
 wrapper!(Workers, usize, 8, Copy);
 wrapper!(LimitConnectionsInbound, usize, 128, Copy);
 wrapper!(LimitConnectionsOutbound, usize, 16, Copy);
 wrapper!(LimitRoutingMaxSize, usize, 1000, Copy);
 wrapper!(LimitFetchConcurrency, usize, 1, Copy);
 wrapper!(
     LimitRateInbound,
     RateLimit,
     RateLimit {
         fill_rate: 5.0,
         capacity: 1024,
     }
 );
 wrapper!(LimitMaxOpenFiles, usize, 4096, Copy);
 wrapper!(
     LimitRateOutbound,
     RateLimit,
     RateLimit {
         fill_rate: 10.0,
         capacity: 2048,
     }
 );
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod test {
     #[test]
     fn partial() {
         use super::Config;
         use serde_json::json;
         let config: Config = serde_json::from_value(json!({
             "alias": "example",
             "limits": {
                 "connection": {
                     "inbound": 1337,
                 },
             },
         }
         ))
         .unwrap();
         assert_eq!(config.limits.connection.inbound.0, 1337);
         assert_eq!(
             config.limits.connection.outbound.0,
             super::LimitConnectionsOutbound::default().0,
         );
         let config: Config = serde_json::from_value(json!({
             "alias": "example",
             "limits": {
                 "connection": {
                     "outbound": 1337,
                 },
             },
         }
         ))
         .unwrap();
         assert_eq!(
             config.limits.connection.inbound.0,
             super::LimitConnectionsInbound::default().0,
         );
         assert_eq!(config.limits.connection.outbound.0, 1337);
     }
 }