node: Simplify configuration — heartwood

This is a change to the config.json file which removes certain options that are best not touched and changes some options to make them easier to work with.

We change the default journaling mode to “wal” and remove the config option.
We remove the option to set the peer connection “target”, as it’s not a good idea to set this to a different value, as it affects the network.
We combine seeding policy & scope, since there’s no need to set the scope when the policy is “block”. In that case, we always want to block “all” remotes. The new policy configuration has the following schema:

{ seedingPolicy: { default: “block” | “allow”, scope?: “all” | “followed” } }

The “scope” key is not used when “default” is set to “block”.
We add an extra field to the node config for options that are not recognized. We use this to warn the user.

 ```
 $ rad seed
 ╭──────────────────────────────────────────────────────────────╮
 │ Repository                          Name   Policy   Scope    │
 ├──────────────────────────────────────────────────────────────┤
 │ rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji          block    followed │
 ╰──────────────────────────────────────────────────────────────╯
 ╭───────────────────────────────────────────────────────────╮
 │ Repository                          Name   Policy   Scope │
 ├───────────────────────────────────────────────────────────┤
 │ rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji          block    all   │
 ╰───────────────────────────────────────────────────────────╯
 ```

     "alias": "alice",
     "listen": [],
     "peers": {
       "type": "dynamic",
       "target": 8
       "type": "dynamic"
     },
     "connect": [],
     "externalAddresses": [],
     "db": {
       "journalMode": "rollback"
     },
     "network": "main",
     "log": "INFO",
     "relay": "auto",

       }
     },
     "workers": 8,
     "policy": "block",
     "scope": "all"
     "seedingPolicy": {
       "default": "block"
     }
   }
 }
 ```

         term::success!("Authenticated as {}", term::format::tertiary(profile.id()));
         return Ok(());
     }
     for (key, _) in &profile.config.node.extra {
         term::warning(format!(
             "unused or deprecated configuration attribute {:?}",
             key
         ));
     }
     // If our key is encrypted, we try to authenticate with SSH Agent and
     // register it; only if it is running.

 use radicle::identity::RepoId;
 use radicle::identity::{DocAt, Identity};
 use radicle::node::policy::Policy;
 use radicle::node::policy::SeedingPolicy;
 use radicle::node::AliasStore as _;
 use radicle::storage::git::{Repository, Storage};
 use radicle::storage::refs::RefsAt;

             let policies = profile.policies()?;
             let seed = policies.seed_policy(&rid)?;
             match seed.policy {
                 Policy::Allow => {
                 SeedingPolicy::Allow { scope } => {
                     println!(
                         "Repository {} is {} with scope {}",
                         term::format::tertiary(&rid),
                         term::format::positive("being seeded"),
                         term::format::dim(format!("`{}`", seed.scope))
                         term::format::dim(format!("`{scope}`"))
                     );
                 }
                 Policy::Block => {
                 SeedingPolicy::Block => {
                     println!(
                         "Repository {} is {}",
                         term::format::tertiary(&rid),

 use anyhow::anyhow;
 use radicle::node::policy;
 use radicle::node::policy::Scope;
 use radicle::node::policy::{Policy, Scope};
 use radicle::node::Handle;
 use radicle::{prelude::*, storage, Node};
 use radicle_term::Element as _;

     ]);
     t.divider();
     for policy::SeedPolicy { rid, scope, policy } in store.seed_policies()? {
     for policy::SeedPolicy { rid, policy } in store.seed_policies()? {
         let id = rid.to_string();
         let name = storage
             .repository(rid)
             .map_err(storage::RepositoryError::from)
             .and_then(|repo| repo.project().map(|proj| proj.name().to_string()))
             .unwrap_or_default();
         let scope = scope.to_string();
         let policy = term::format::policy(&policy);
         let scope = policy.scope().unwrap_or_default().to_string();
         let policy = term::format::policy(&Policy::from(policy));
         t.push([
             term::format::tertiary(id),

 use radicle::test::fixtures;
 use radicle_cli_test::TestFormula;
 use radicle_node::service::policy::{Policy, Scope};
 use radicle_node::service::policy::{Scope, SeedingPolicy};
 use radicle_node::service::Event;
 use radicle_node::test::environment::{Config, Environment, Node};
 #[allow(unused_imports)]

 fn rad_block() {
     let mut environment = Environment::new();
     let alice = environment.node(Config {
         policy: Policy::Allow,
         seeding_policy: SeedingPolicy::Allow { scope: Scope::All },
         ..Config::test(Alias::new("alice"))
     });
     let working = tempfile::tempdir().unwrap();

     let mut environment = Environment::new();
     let mut alice = environment
         .node(Config {
             policy: Policy::Block,
             seeding_policy: SeedingPolicy::Block,
             ..Config::test(Alias::new("alice"))
         })
         .spawn();

     let alice = environment.node(config::relay("alice"));
     let bob = environment.node(config::relay("bob"));
     let seed = environment.node(Config {
         policy: Policy::Allow,
         scope: Scope::All,
         seeding_policy: SeedingPolicy::Allow { scope: Scope::All },
         ..config::relay("seed")
     });
     let working = environment.tmp().join("working");

 use radicle::node::policy::store::Read;
 use radicle::prelude::RepoId;
 pub use radicle::node::policy::{Policy, Scope};
 pub use radicle::node::policy::{Policy, Scope, SeedingPolicy};
 #[derive(Clone, Debug)]
 pub enum Allowed {

             .seed_policy(&rid)
             .map_err(|err| error::Policy::FailedPolicy { rid, err })?;
         match entry.policy {
             Policy::Block => {
             SeedingPolicy::Block => {
                 log::error!(target: "fetch", "Attempted to fetch non-seeded repo {rid}");
                 Err(error::Policy::BlockedPolicy { rid })
             }
             Policy::Allow => match entry.scope {
                 Scope::All => Ok(Self::All),
                 Scope::Followed => {
                     let nodes = config
                         .follow_policies()
                         .map_err(|err| error::Policy::FailedNodes { rid, err })?;
                     let followed: HashSet<_> = nodes
                         .filter_map(|node| (node.policy == Policy::Allow).then_some(node.nid))
                         .collect();
                     Ok(Allowed::Followed { remotes: followed })
                 }
             },
             SeedingPolicy::Allow { scope: Scope::All } => Ok(Self::All),
             SeedingPolicy::Allow {
                 scope: Scope::Followed,
             } => {
                 let nodes = config
                     .follow_policies()
                     .map_err(|err| error::Policy::FailedNodes { rid, err })?;
                 let followed: HashSet<_> = nodes
                     .filter_map(|node| (node.policy == Policy::Allow).then_some(node.nid))
                     .collect();
                 Ok(Allowed::Followed { remotes: followed })
             }
         }
     }
 }

 use radicle::identity::RepoId;
 use radicle::node::routing::Store;
 use radicle::node::{policy, AliasStore, Handle, NodeId, DEFAULT_TIMEOUT};
 use radicle::node::{
     policy::{Policy, SeedPolicy},
     AliasStore, Handle, NodeId, DEFAULT_TIMEOUT,
 };
 use radicle::Node;
 use crate::api::error::Error;

     let policies = ctx.profile.policies()?;
     let mut repos = Vec::new();
     for policy::SeedPolicy {
         rid: id,
         scope,
         policy,
     } in policies.seed_policies()?
     {
     for SeedPolicy { rid: id, policy } in policies.seed_policies()? {
         repos.push(json!({
             "id": id,
             "scope": scope,
             "policy": policy,
             "scope": policy.scope().unwrap_or_default(),
             "policy": Policy::from(policy),
         }));
     }

         let clock = LocalTime::now();
         let timestamp = clock.into();
         let storage = Storage::open(home.storage(), git::UserInfo { alias, key: id })?;
         let scope = config.scope;
         let policy = config.policy;
         let policy = config.seeding_policy;
         for (key, _) in &config.extra {
             log::warn!(target: "node", "Unused or deprecated configuration attribute {:?}", key);
         }
         log::info!(target: "node", "Opening node database..");
         let db = home.database_mut()?.journal_mode(config.db.journal_mode)?;
         let db = home
             .database_mut()?
             .journal_mode(node::db::JournalMode::default())?;
         let mut stores: service::Stores<_> = db.clone().into();
         log::info!(target: "node", "Opening policy database..");
         let policies = home.policies_mut()?;
         let policies = policy::Config::new(policy, scope, policies);
         let policies = policy::Config::new(policy, policies);
         let notifications = home.notifications_mut()?;
         let cobs_cache = cob::cache::Store::open(home.cobs().join(cob::cache::COBS_DB_FILE))?;

                 storage: storage.clone(),
                 fetch,
                 policy,
                 scope,
                 policies_db: home.node().join(node::POLICIES_DB_FILE),
             },
         )?;

 use radicle::node::{ConnectOptions, Penalty, Severity};
 use radicle::storage::refs::SIGREFS_BRANCH;
 use radicle::storage::RepositoryError;
 use radicle_fetch::policy::SeedingPolicy;
 use crate::crypto;
 use crate::crypto::{Signer, Verified};

 use crate::service::message::{
     Announcement, AnnouncementMessage, Info, NodeAnnouncement, Ping, RefsAnnouncement, RefsStatus,
 };
 use crate::service::policy::{store::Write, Policy, Scope};
 use crate::service::policy::{store::Write, Scope};
 use crate::storage;
 use crate::storage::{refs::RefsAt, Namespaces, ReadStorage};
 use crate::worker::fetch;

 pub const CONNECTION_RETRY_DELTA: LocalDuration = LocalDuration::from_mins(10);
 /// How long to wait for a fetch to stall before aborting, default is 3s.
 pub const FETCH_TIMEOUT: time::Duration = time::Duration::from_secs(3);
 /// Target number of peers to maintain connections to.
 pub const TARGET_OUTBOUND_PEERS: usize = 8;
 /// Maximum external address limit imposed by message size limits.
 pub use message::ADDRESS_LIMIT;

         self.filter = Filter::new(
             self.policies
                 .seed_policies()?
                 .filter_map(|t| (t.policy == Policy::Allow).then_some(t.rid)),
                 .filter_map(|t| (t.policy.is_allow()).then_some(t.rid)),
         );
         Ok(updated)
     }

                     .policies
                     .seed_policy(&rid)
                     .expect("Service::dequeue_fetch: error accessing repo seeding configuration");
                 let SeedingPolicy::Allow { scope } = repo_entry.policy else {
                     debug!(target: "service", "Repository {rid} is no longer seeded, skipping..");
                     continue;
                 };
                 // Keep dequeueing if there was nothing to fetch, otherwise break.
                 if self.fetch_refs_at(rid, from, refs, repo_entry.scope, timeout, channel) {
                 if self.fetch_refs_at(rid, from, refs, scope, timeout, channel) {
                     break;
                 }
             } else {

                 let repo_entry = self.policies.seed_policy(&message.rid).expect(
                     "Service::handle_announcement: error accessing repo seeding configuration",
                 );
                 if repo_entry.policy != Policy::Allow {
                 let SeedingPolicy::Allow { scope } = repo_entry.policy else {
                     debug!(
                         target: "service",
                         "Ignoring refs announcement from {announcer}: repository {} isn't seeded (t={timestamp})",
                         message.rid
                     );
                     return Ok(None);
                 }
                 };
                 // Refs can be relayed by peers who don't have the data in storage,
                 // therefore we only check whether we are connected to the *announcer*,
                 // which is required by the protocol to only announce refs it has.

                     return Ok(relay);
                 };
                 // Finally, start the fetch.
                 self.fetch_refs_at(
                     message.rid,
                     remote.id,
                     refs,
                     repo_entry.scope,
                     FETCH_TIMEOUT,
                     None,
                 );
                 self.fetch_refs_at(message.rid, remote.id, refs, scope, FETCH_TIMEOUT, None);
                 return Ok(relay);
             }
             AnnouncementMessage::Node(

     /// Return a new filter object, based on our seeding policy.
     fn filter(&self) -> Filter {
         if self.config.policy == Policy::Allow {
         if self.config.seeding_policy.is_allow() {
             // TODO: Remove bits for blocked repos.
             Filter::default()
         } else {

     /// Try to maintain a target number of connections.
     fn maintain_connections(&mut self) {
         let PeerConfig::Dynamic { target } = self.config.peers else {
         let PeerConfig::Dynamic = self.config.peers else {
             return;
         };
         trace!(target: "service", "Maintaining connections..");
         let target = TARGET_OUTBOUND_PEERS;
         let now = self.clock;
         let outbound = self
             .sessions

 use crate::service;
 use crate::service::io::Io;
 use crate::service::message::*;
 use crate::service::policy::{Policy, Scope};
 use crate::service::policy::{Scope, SeedingPolicy};
 use crate::service::*;
 use crate::storage::git::transport::remote;
 use crate::storage::Inventory;

     pub config: service::Config,
     pub db: Stores<node::Database>,
     pub local_time: LocalTime,
     pub policy: Policy,
     pub scope: Scope,
     pub policy: SeedingPolicy,
     pub signer: G,
     pub rng: fastrand::Rng,
     pub tmp: tempfile::TempDir,

             config: service::Config::test(Alias::from_str("mocky").unwrap()),
             db,
             local_time: LocalTime::now(),
             policy: Policy::default(),
             scope: Scope::default(),
             policy: SeedingPolicy::default(),
             signer,
             rng,
             tmp,

         mut config: Config<G>,
     ) -> Self {
         let policies = policy::Store::<policy::store::Write>::memory().unwrap();
         let mut policies = policy::Config::new(config.policy, config.scope, policies);
         let mut policies = policy::Config::new(config.policy, policies);
         let id = *config.signer.public_key();
         let ip = ip.into();
         let local_addr = net::SocketAddr::new(ip, config.rng.u16(..));

 use crate::runtime::{thread, Emitter, Handle};
 use crate::service::policy;
 use crate::service::policy::Policy;
 use crate::service::policy::SeedingPolicy;
 use crate::wire::StreamId;
 pub use channels::{ChannelEvent, Channels};

     /// Configuration for performing fetched.
     pub fetch: FetchConfig,
     /// Default policy, if a policy for a specific node or repository was not found.
     pub policy: Policy,
     /// Default scope, if a scope for a specific repository was not found.
     pub scope: policy::Scope,
     pub policy: SeedingPolicy,
     /// Path to the policies database.
     pub policies_db: PathBuf,
 }

         let policy = self.policies.seed_policy(&rid)?.policy;
         let repo = self.storage.repository(rid)?;
         let doc = repo.identity_doc()?;
         if !doc.is_visible_to(&remote) || policy == Policy::Block {
         if !doc.is_visible_to(&remote) || policy.is_block() {
             Err(UploadError::Unauthorized(remote, rid))
         } else {
             Ok(())

     ) -> Result<Self, policy::Error> {
         let mut pool = Vec::with_capacity(config.capacity);
         for i in 0..config.capacity {
             let policies = policy::Config::new(
                 config.policy,
                 config.scope,
                 policy::Store::reader(&config.policies_db)?,
             );
             let policies =
                 policy::Config::new(config.policy, policy::Store::reader(&config.policies_db)?);
             let worker = Worker {
                 nid,
                 tasks: tasks.clone(),