11da344 node: Add `--tracking-policy` flag — heartwood

modified radicle-node/src/main.rs

@@ -1,5 +1,6 @@

 use std::{env, net, process};
 use anyhow::anyhow;
 use anyhow::Context as _;
 use crossbeam_channel as chan;
 use cyphernet::addr::PeerAddr;

@@ -8,6 +9,7 @@ use localtime::LocalDuration;

 use radicle::profile;
 use radicle_node::crypto::ssh::keystore::{Keystore, MemorySigner};
 use radicle_node::prelude::{Address, NodeId};
 use radicle_node::service::tracking::Policy;
 use radicle_node::Runtime;
 use radicle_node::{logger, service, signals};

@@ -21,6 +23,7 @@ Options

     --connect          <peer>        Connect to the given peer address on start
     --external-address <address>     Publicly accessible address (default 0.0.0.0:8776)
     --git-daemon       <address>     Address to bind git-daemon to (default 0.0.0.0:9418)
     --tracking-policy  (track|block) Default tracking policy
     --help                           Print help
     --listen           <address>     Address to listen on

@@ -33,6 +36,7 @@ struct Options {

     daemon: Option<net::SocketAddr>,
     limits: service::config::Limits,
     listen: Vec<net::SocketAddr>,
     tracking_policy: Policy,
 }
 impl Options {

@@ -45,6 +49,7 @@ impl Options {

         let mut limits = service::config::Limits::default();
         let mut listen = Vec::new();
         let mut daemon = None;
         let mut tracking_policy = Policy::default();
         while let Some(arg) = parser.next()? {
             match arg {

@@ -60,6 +65,13 @@ impl Options {

                     let addr = parser.value()?.parse()?;
                     daemon = Some(addr);
                 }
                 Long("tracking-policy") => {
                     let policy = parser
                         .value()?
                         .parse()
                         .map_err(|s| anyhow!("unknown tracking policy {:?}", s))?;
                     tracking_policy = policy;
                 }
                 Long("limit-routing-max-age") => {
                     let secs: u64 = parser.value()?.parse()?;
                     limits.routing_max_age = LocalDuration::from_secs(secs);

@@ -92,6 +104,7 @@ impl Options {

             external_addresses,
             limits,
             listen,
             tracking_policy,
         })
     }
 }

@@ -110,6 +123,7 @@ fn execute() -> anyhow::Result<()> {

         connect: options.connect.into_iter().collect(),
         external_addresses: options.external_addresses,
         limits: options.limits,
         policy: options.tracking_policy,
         ..service::Config::default()
     };
     let proxy = net::SocketAddr::new(net::Ipv4Addr::LOCALHOST.into(), 9050);

modified radicle-node/src/runtime.rs

@@ -118,6 +118,7 @@ impl<G: Signer + Ecdh + 'static> Runtime<G> {

         let tracking = tracking::Store::open(tracking_db)?;
         let tracking = tracking::Config::new(config.policy, tracking);
         log::info!(target: "node", "Default tracking policy set to '{}'", &config.policy);
         log::info!(target: "node", "Initializing service ({:?})..", network);
         let service = service::Service::new(
             config,

modified radicle-node/src/service/config.rs

@@ -57,7 +57,7 @@ impl Default for Config {

             network: Network::default(),
             relay: true,
             limits: Limits::default(),
             policy: Policy::Block,
             policy: Policy::default(),
         }
     }
 }

modified radicle-node/src/service/tracking.rs

@@ -1,7 +1,7 @@

 mod store;
 use std::ops;
 use std::str::FromStr;
 use std::{fmt, ops};
 use crate::prelude::Id;
 use crate::service::NodeId;

@@ -13,14 +13,36 @@ pub use store::Error;

 pub type Alias = String;
 /// Tracking policy.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Policy {
     /// The resource is tracked.
     Track,
     /// The resource is blocked.
     #[default]
     Block,
 }
 impl fmt::Display for Policy {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::Track => write!(f, "track"),
             Self::Block => write!(f, "block"),
         }
     }
 }
 impl FromStr for Policy {
     type Err = String;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "track" => Ok(Self::Track),
             "block" => Ok(Self::Block),
             _ => Err(s.to_owned()),
         }
     }
 }
 /// Tracking scope of a repository tracking policy.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Scope {