node: New relay configuration for nodes — heartwood

Relay now has three values: “always”, “never” and “auto”.

The first two operate like the previous true/false. The new (default) value turns relaying on for nodes with public (external) addresses and off for nodes without. This should reduce redundant traffic on the network, that was causing the rate limiters to trigger.

   export SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)
   if ! command -v rad > /dev/null; then
     echo "fatal: rad is not installed" ; exit 1
     echo "fatal: rad is not installed" >&2 ; exit 1
   fi
   if ! command -v podman > /dev/null; then
     echo "fatal: podman is not installed" ; exit 1
     echo "fatal: podman is not installed" >&2 ; exit 1
   fi
   if ! command -v sha256sum > /dev/null; then
     echo "fatal: sha256sum is not installed" ; exit 1
     echo "fatal: sha256sum is not installed" >&2 ; exit 1
   fi
   rev="$(git rev-parse --short HEAD)"

   image=radicle-build-$version
   if [ ! -f "$keypath" ]; then
     echo "fatal: no key found at $keypath" ; exit 1
     echo "fatal: no key found at $keypath" >&2 ; exit 1
   fi
   # Authenticate user for signing
   rad auth

   echo "Building image ($image).."
   podman --cgroup-manager=cgroupfs build \
     --env SOURCE_DATE_EPOCH \
     --env TZ \
     --env LC_ALL \
     --env GIT_COMMIT_TIME=$SOURCE_DATE_EPOCH \
     --env GIT_HEAD=$rev \
     --env RADICLE_VERSION=$version \

 build/checksums
 echo
 echo "Build ran successfully."
 echo "Build successful."

     "tor": null,
     "network": "main",
     "log": "INFO",
     "relay": true,
     "relay": "auto",
     "limits": {
       "routingMaxSize": 1000,
       "routingMaxAge": 604800,

 ```
 $ rad sync status --sort-by alias
 ╭──────────────────────────────────────────────────────────────────────────────────────────╮
 │ ●   Node                      Address                  Status        Tip       Timestamp │
 ├──────────────────────────────────────────────────────────────────────────────────────────┤
 │ ●   alice   (you)             alice.radicle.xyz:8776                 f209c9f   [  ...  ] │
 │ ●   bob     z6Mkt67…v4N1tRk   bob.radicle.xyz:8776     out-of-sync   f209c9f   [  ...  ] │
 │ ●   eve     z6Mkux1…nVhib7Z   eve.radicle.xyz:8776     out-of-sync   f209c9f   [  ...  ] │
 ╰──────────────────────────────────────────────────────────────────────────────────────────╯
 ╭──────────────────────────────────────────────────────────────────────────────────────────────╮
 │ ●   Node                      Address                      Status        Tip       Timestamp │
 ├──────────────────────────────────────────────────────────────────────────────────────────────┤
 │ ●   alice   (you)             alice.radicle.example:8776                 f209c9f   [  ...  ] │
 │ ●   bob     z6Mkt67…v4N1tRk   bob.radicle.example:8776     out-of-sync   f209c9f   [  ...  ] │
 │ ●   eve     z6Mkux1…nVhib7Z   eve.radicle.example:8776     out-of-sync   f209c9f   [  ...  ] │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────╯
 ```
 Now let's run `rad sync`. This will announce the issue refs to the network and

 ```
 $ rad sync status --sort-by alias
 ╭─────────────────────────────────────────────────────────────────────────────────────╮
 │ ●   Node                      Address                  Status   Tip       Timestamp │
 ├─────────────────────────────────────────────────────────────────────────────────────┤
 │ ●   alice   (you)             alice.radicle.xyz:8776            a9ce0d1   [  ...  ] │
 │ ●   bob     z6Mkt67…v4N1tRk   bob.radicle.xyz:8776     synced   a9ce0d1   [  ...  ] │
 │ ●   eve     z6Mkux1…nVhib7Z   eve.radicle.xyz:8776     synced   a9ce0d1   [  ...  ] │
 ╰─────────────────────────────────────────────────────────────────────────────────────╯
 ╭─────────────────────────────────────────────────────────────────────────────────────────╮
 │ ●   Node                      Address                      Status   Tip       Timestamp │
 ├─────────────────────────────────────────────────────────────────────────────────────────┤
 │ ●   alice   (you)             alice.radicle.example:8776            a9ce0d1   [  ...  ] │
 │ ●   bob     z6Mkt67…v4N1tRk   bob.radicle.example:8776     synced   a9ce0d1   [  ...  ] │
 │ ●   eve     z6Mkux1…nVhib7Z   eve.radicle.example:8776     synced   a9ce0d1   [  ...  ] │
 ╰─────────────────────────────────────────────────────────────────────────────────────────╯
 ```
 If we try to sync again after the nodes have synced, we will already

     pub fn seed(alias: &'static str) -> Config {
         Config {
             network: Network::Test,
             relay: node::config::Relay::Always,
             limits: Limits {
                 rate: RateLimits {
                     inbound: RateLimit {

                 },
                 ..Limits::default()
             },
             external_addresses: vec![node::Address::from_str(&format!(
                 "{alias}.radicle.example:8776"
             ))
             .unwrap()],
             ..node(alias)
         }
     }
     /// Test node config.
     pub fn node(alias: &'static str) -> Config {
     /// Relay node config.
     pub fn relay(alias: &'static str) -> Config {
         Config {
             external_addresses: vec![
                 node::Address::from_str(&format!("{alias}.radicle.xyz:8776")).unwrap(),
             ],
             ..Config::test(Alias::new(alias))
             relay: node::config::Relay::Always,
             ..node(alias)
         }
     }
     /// Test node config.
     pub fn node(alias: &'static str) -> Config {
         Config::test(Alias::new(alias))
     }
     /// Test profile config.
     pub fn profile(alias: &'static str) -> profile::Config {
         Environment::config(Alias::new(alias))

 #[test]
 fn rad_patch_delete() {
     let mut environment = Environment::new();
     let alice = environment.node(Config::test(Alias::new("alice")));
     let bob = environment.node(Config::test(Alias::new("bob")));
     let seed = environment.node(Config::test(Alias::new("seed")));
     let alice = environment.node(config::relay("alice"));
     let bob = environment.node(config::relay("bob"));
     let seed = environment.node(config::relay("seed"));
     let working = environment.tmp().join("working");
     let acme = RepoId::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

 #[test]
 fn rad_sync_without_node() {
     let mut environment = Environment::new();
     let alice = environment.node(Config::test(Alias::new("alice")));
     let bob = environment.node(Config::test(Alias::new("bob")));
     let mut eve = environment.node(Config::test(Alias::new("eve")));
     let alice = environment.node(config::seed("alice"));
     let bob = environment.node(config::seed("bob"));
     let mut eve = environment.node(config::seed("eve"));
     let rid = RepoId::from_urn("rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5").unwrap();
     eve.policies.seed(&rid, Scope::All).unwrap();

 fn rad_sync() {
     let mut environment = Environment::new();
     let working = environment.tmp().join("working");
     let alice = environment.node(config::node("alice"));
     let bob = environment.node(config::node("bob"));
     let eve = environment.node(config::node("eve"));
     let alice = environment.node(config::seed("alice"));
     let bob = environment.node(config::seed("bob"));
     let eve = environment.node(config::seed("eve"));
     let acme = RepoId::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();
     fixtures::repository(working.join("acme"));

 //
 fn test_replication_via_seed() {
     let mut environment = Environment::new();
     let alice = environment.node(Config::test(Alias::new("alice")));
     let bob = environment.node(Config::test(Alias::new("bob")));
     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,
         ..Config::test(Alias::new("seed"))
         ..config::relay("seed")
     });
     let working = environment.tmp().join("working");
     let rid = RepoId::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

 use radicle::node::address;
 use radicle::node::address::Store as _;
 use radicle::node::address::{AddressBook, KnownAddress};
 use radicle::node::config::PeerConfig;
 use radicle::node::config::{PeerConfig, Relay};
 use radicle::node::refs::Store as _;
 use radicle::node::routing::Store as _;
 use radicle::node::seed;

         &mut self,
         relayer_addr: &Address,
         announcement: &Announcement,
     ) -> Result<bool, session::Error> {
     ) -> Result<Relay, session::Error> {
         if !announcement.verify() {
             return Err(session::Error::Misbehavior);
         }

         // Ignore our own announcements, in case the relayer sent one by mistake.
         if announcer == self.nid() {
             return Ok(false);
             return Ok(Relay::Never);
         }
         let now = self.clock;
         let timestamp = message.timestamp();

         {
             self.config.relay
         } else {
             false
             Relay::Never
         };
         // Don't allow messages from too far in the future.

                 Ok(node) => {
                     if node.is_none() {
                         debug!(target: "service", "Ignoring announcement from unknown node {announcer} (t={timestamp})");
                         return Ok(false);
                         return Ok(Relay::Never);
                     }
                 }
                 Err(e) => {
                     error!(target: "service", "Error looking up node in address book: {e}");
                     return Ok(false);
                     return Ok(Relay::Never);
                 }
             }
         }

                 // Empty announcements can be safely ignored.
                 let Some(refs) = NonEmpty::from_vec(message.refs.to_vec()) else {
                     debug!(target: "service", "Skipping fetch, no refs in announcement for {} (t={timestamp})", message.rid);
                     return Ok(false);
                     return Ok(Relay::Never);
                 };
                 // We update inventories when receiving ref announcements, as these could come
                 // from a new repository being initialized.

                 let relayer_addr = peer.addr.clone();
                 let announcer = ann.node;
                 // Returning true here means that the message should be relayed.
                 if self.handle_announcement(&relayer_addr, &ann)? {
                 let relay = match self.handle_announcement(&relayer_addr, &ann)? {
                     // In "auto" mode, we only relay if we're a public seed node.
                     // This reduces traffic for private nodes, as well as message redundancy.
                     Relay::Auto => !self.config.external_addresses.is_empty(),
                     Relay::Never => false,
                     Relay::Always => true,
                 };
                 if relay {
                     // Choose peers we should relay this message to.
                     // 1. Don't relay to the peer who sent us this message.
                     // 2. Don't relay to the peer who signed this announcement.

 use crate::test::environment::{converge, Environment, Node};
 use crate::test::logger;
 mod config {
     use super::*;
     use radicle::node::config::{Config, Relay};
     /// Relay node config.
     pub fn relay(alias: &'static str) -> Config {
         Config {
             relay: Relay::Always,
             ..Config::test(Alias::new(alias))
         }
     }
 }
 #[test]
 //
 //     alice -- bob

     let tmp = tempfile::tempdir().unwrap();
     let mut alice = Node::init(tmp.path(), Config::test(Alias::new("alice")));
     let mut bob = Node::init(tmp.path(), Config::test(Alias::new("bob")));
     let mut alice = Node::init(tmp.path(), config::relay("alice"));
     let mut bob = Node::init(tmp.path(), config::relay("bob"));
     alice.project("alice", "");
     bob.project("bob", "");

     logger::init(log::Level::Debug);
     let tmp = tempfile::tempdir().unwrap();
     let alice = Node::init(tmp.path(), Config::test(Alias::new("alice")));
     let mut bob = Node::init(tmp.path(), Config::test(Alias::new("bob")));
     let alice = Node::init(tmp.path(), config::relay("alice"));
     let mut bob = Node::init(tmp.path(), config::relay("bob"));
     let acme = bob.project("acme", "");
     let mut alice = alice.spawn();

     let env = Environment::new();
     let scale = env.scale();
     let mut alice = Node::init(&env.tmp(), Config::test(Alias::new("alice")));
     let bob = Node::init(&env.tmp(), Config::test(Alias::new("bob")));
     let mut alice = Node::init(&env.tmp(), config::relay("alice"));
     let bob = Node::init(&env.tmp(), config::relay("bob"));
     let tmp = tempfile::tempdir().unwrap();
     let (repo, _) = fixtures::repository(tmp.path());

         &env.tmp(),
         service::Config {
             limits: limits.clone(),
             ..service::Config::test(Alias::new("alice"))
             relay: radicle::node::config::Relay::Always,
             ..config::relay("alice")
         },
     );
     let mut bob = Node::init(
         &env.tmp(),
         service::Config {
             limits,
             ..service::Config::test(Alias::new("bob"))
             relay: radicle::node::config::Relay::Always,
             ..config::relay("bob")
         },
     );

     let tmp = tempfile::tempdir().unwrap();
     let mut alice = Node::init(tmp.path(), Config::test(Alias::new("alice")));
     let bob = Node::init(tmp.path(), Config::test(Alias::new("bob")));
     let eve = Node::init(tmp.path(), Config::test(Alias::new("eve")));
     let mut alice = Node::init(tmp.path(), config::relay("alice"));
     let bob = Node::init(tmp.path(), config::relay("bob"));
     let eve = Node::init(tmp.path(), config::relay("eve"));
     let rid = alice.project("acme", "");

     }
 }
 /// Relay configuration.
 #[derive(Debug, Copy, Clone, Default, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum Relay {
     /// Always relay messages.
     Always,
     /// Never relay messages.
     Never,
     /// Relay messages when applicable.
     #[default]
     Auto,
 }
 /// Tor configuration.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase", tag = "mode")]

     #[serde(default = "defaults::log")]
     #[serde(with = "crate::serde_ext::string")]
     pub log: log::Level,
     /// Whether or not our node should relay inventories.
     #[serde(default = "crate::serde_ext::bool::yes")]
     pub relay: bool,
     /// Whether or not our node should relay messages.
     #[serde(default, deserialize_with = "crate::serde_ext::ok_or_default")]
     pub relay: Relay,
     /// Configured service limits.
     #[serde(default)]
     pub limits: Limits,

             external_addresses: vec![],
             network: Network::default(),
             tor: None,
             relay: true,
             relay: Relay::default(),
             limits: Limits::default(),
             workers: DEFAULT_WORKERS,
             log: defaults::log(),

     t == &T::default()
 }
 /// Deserialize a value, but if it fails, return the default value.
 pub fn ok_or_default<'de, T, D>(deserializer: D) -> Result<T, D::Error>
 where
     T: serde::Deserialize<'de> + Default,
     D: serde::Deserializer<'de>,
 {
     let v: serde_json::Value = serde::Deserialize::deserialize(deserializer)?;
     Ok(T::deserialize(v).unwrap_or_default())
 }
 #[cfg(test)]
 mod test {
     use super::*;