node: Add agent and version to node announcement — heartwood

Adds a user-agent string to the node announcement. This lets us keep track of what software version everyone is running. Especially useful to see what percentage of the network has upgraded to a new release.

For old nodes, this defaults to the string /radicle/.

The user agent format is roughly based on BIP 0014.

Advertize protocol version in node announcement.

By advertizing the protocol version, nodes can decide to only connect to peers with a compatible version. The default and current version is 1.

We bundle these two changes as they both modify the node announcement and node database.

 use radicle::node::config::seeds::{RADICLE_COMMUNITY_NODE, RADICLE_TEAM_NODE};
 use radicle::node::routing::Store as _;
 use radicle::node::Handle as _;
 use radicle::node::UserAgent;
 use radicle::node::{Address, Alias, DEFAULT_TIMEOUT};
 use radicle::prelude::{NodeId, RepoId};
 use radicle::profile;

 use radicle_node::test::environment::{Config, Environment, Node};
 #[allow(unused_imports)]
 use radicle_node::test::logger;
 use radicle_node::PROTOCOL_VERSION;
 /// Seed used in tests.
 const RAD_SEED: &str = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";

         .addresses_mut()
         .insert(
             &carol,
             PROTOCOL_VERSION,
             node::Features::SEED,
             Alias::new("carol"),
             &Alias::new("carol"),
 ,
             &UserAgent::default(),
             localtime::LocalTime::now().into(),
             [node::KnownAddress::new(
                 // Eve will fail to connect to this address.

     let bob = environment.node(Config::test(Alias::new("bob")));
     let mut eve = environment.node(Config::test(Alias::new("eve")));
     let acme = RepoId::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();
     let ua = UserAgent::default();
     let now = localtime::LocalTime::now().into();
     fixtures::repository(working.join("acme"));

         .addresses_mut()
         .insert(
             &alice.id,
             PROTOCOL_VERSION,
             node::Features::SEED,
             Alias::new("alice"),
             &Alias::new("alice"),
 ,
             &ua,
             now,
             [node::KnownAddress::new(
                 node::Address::from(alice.addr),

 pub mod wire;
 pub mod worker;
 use radicle::version::Version;
 pub use localtime::{LocalDuration, LocalTime};
 pub use netservices::Direction as Link;
 pub use radicle::node::PROTOCOL_VERSION;
 pub use radicle::prelude::Timestamp;
 pub use radicle::{collections, crypto, git, identity, node, profile, rad, storage};
 pub use runtime::Runtime;
 /// Node version.
 pub const VERSION: Version = Version {
     name: env!("CARGO_PKG_NAME"),
     commit: env!("GIT_HEAD"),
     version: env!("RADICLE_VERSION"),
     timestamp: env!("GIT_COMMIT_TIME"),
 };
 pub mod prelude {
     pub use crate::bounded::BoundedVec;
     pub use crate::crypto::{PublicKey, Signature, Signer};

 use radicle::node::address::Store as _;
 use radicle::node::notifications;
 use radicle::node::Handle as _;
 use radicle::node::UserAgent;
 use radicle::profile::Home;
 use radicle::{cob, git, storage, Storage};

         for (key, _) in &config.extra {
             log::warn!(target: "node", "Unused or deprecated configuration attribute {:?}", key);
         }
         log::info!(target: "node", "Opening node database..");
         log::info!(target: "node", "Opening policy database..");
         let policies = home.policies_mut()?;

                 .expect("Runtime::init: unable to solve proof-of-work puzzle")
         };
         log::info!(target: "node", "Opening node database..");
         let db = home
             .database_mut()?
             .journal_mode(node::db::JournalMode::default())?
             .init(
                 &id,
                 announcement.features,
                 announcement.alias.clone(),
                 &announcement.alias,
                 &announcement.agent,
                 announcement.timestamp,
                 announcement.addresses.iter(),
             )?;

         if config.connect.is_empty() && stores.addresses().is_empty()? {
             log::info!(target: "node", "Address book is empty. Adding bootstrap nodes..");
             for (alias, addr) in config.network.bootstrap() {
             for (alias, version, addr) in config.network.bootstrap() {
                 let (id, addr) = addr.into();
                 stores.addresses_mut().insert(
                     &id,
                     version,
                     radicle::node::Features::SEED,
                     alias,
                     &alias,
 ,
                     &UserAgent::default(),
                     clock.into(),
                     [node::KnownAddress::new(addr, address::Source::Bootstrap)],
                 )?;

 use radicle::storage::RepositoryError;
 use radicle_fetch::policy::SeedingPolicy;
 use crate::crypto;
 use crate::crypto::{Signer, Verified};
 use crate::identity::{Doc, RepoId};
 use crate::node::routing;

 use crate::worker::fetch;
 use crate::worker::FetchError;
 use crate::Link;
 use crate::{crypto, PROTOCOL_VERSION};
 pub use crate::node::events::{Event, Events};
 pub use crate::node::{config::Network, Config, NodeId};

                 match self.db.addresses_mut().insert(
                     announcer,
                     *features,
                     ann.alias.clone(),
                     ann.version,
                     ann.features,
                     &ann.alias,
                     ann.work(),
                     &ann.agent,
                     timestamp,
                     addresses
                         .iter()

                 // Nb. we don't want to connect to any peers that already have a session with us,
                 // even if it's in a disconnected state. Those sessions are re-attempted automatically.
                 let mut peers = entries
                     .filter(|entry| entry.version == PROTOCOL_VERSION)
                     .filter(|entry| !entry.address.banned)
                     .filter(|entry| !entry.penalty.is_connect_threshold_reached())
                     .filter(|entry| !self.sessions.contains_key(&entry.node))

 pub mod store;
 use std::str::FromStr;
 use super::*;
 use crate::{PROTOCOL_VERSION, VERSION};
 use once_cell::sync::Lazy;
 use radicle::node::UserAgent;
 pub use store::{AnnouncementId, Error, RelayStatus, Store};
 /// This node's user agent string.
 pub static USER_AGENT: Lazy<UserAgent> = Lazy::new(|| {
     FromStr::from_str(format!("/radicle:{}/", VERSION.version).as_str())
         .expect("user agent is valid")
 });
 pub fn node(config: &Config, timestamp: Timestamp) -> NodeAnnouncement {
     let features = config.features();
     let alias = config.alias.clone();

         .clone()
         .try_into()
         .expect("external addresses are within the limit");
     let agent = USER_AGENT.clone();
     let version = PROTOCOL_VERSION;
     NodeAnnouncement {
         features,
         version,
         timestamp,
         alias,
         addresses,
         nonce: 0,
         agent,
     }
 }

 use crate::crypto;
 use crate::identity::RepoId;
 use crate::node;
 use crate::node::{Address, Alias};
 use crate::node::{Address, Alias, UserAgent};
 use crate::prelude::BoundedVec;
 use crate::service::filter::Filter;
 use crate::service::{Link, NodeId, Timestamp};

 /// Node announcing itself to the network.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct NodeAnnouncement {
     /// Supported protocol version.
     pub version: u8,
     /// Advertized features.
     pub features: node::Features,
     /// Monotonic timestamp.

     pub addresses: BoundedVec<Address, ADDRESS_LIMIT>,
     /// Nonce used for announcement proof-of-work.
     pub nonce: u64,
     /// User-agent string.
     pub agent: UserAgent,
 }
 impl NodeAnnouncement {

     fn encode<W: io::Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {
         let mut n = 0;
         n += self.version.encode(writer)?;
         n += self.features.encode(writer)?;
         n += self.timestamp.encode(writer)?;
         n += self.alias.encode(writer)?;
         n += self.addresses.encode(writer)?;
         n += self.nonce.encode(writer)?;
         n += self.agent.encode(writer)?;
         Ok(n)
     }

 impl wire::Decode for NodeAnnouncement {
     fn decode<R: std::io::Read + ?Sized>(reader: &mut R) -> Result<Self, wire::Error> {
         let version = u8::decode(reader)?;
         let features = node::Features::decode(reader)?;
         let timestamp = Timestamp::decode(reader)?;
         let alias = wire::Decode::decode(reader)?;
         let addresses = BoundedVec::<Address, ADDRESS_LIMIT>::decode(reader)?;
         let nonce = u64::decode(reader)?;
         let agent = match UserAgent::decode(reader) {
             Ok(ua) => ua,
             Err(e) if e.is_eof() => UserAgent::default(),
             Err(e) => return Err(e),
         };
         Ok(Self {
             version,
             features,
             timestamp,
             alias,
             addresses,
             nonce,
             agent,
         })
     }
 }

 pub struct Announcement {
     /// Node identifier.
     pub node: NodeId,
     /// Unsigned node announcement.
     pub message: AnnouncementMessage,
     /// Signature over the announcement.
     pub signature: crypto::Signature,
     /// Unsigned node announcement.
     pub message: AnnouncementMessage,
 }
 impl Announcement {

 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod tests {
     use super::*;
     use crate::prelude::*;
     use crate::wire::Encode;
     use std::str::FromStr;
     use crate::crypto::test::signer::MockSigner;
     use crate::test::arbitrary;
     use fastrand;
     use qcheck_macros::quickcheck;
     use radicle::git::raw;
     use super::*;
     use crate::crypto::test::signer::MockSigner;
     use crate::prelude::*;
     use crate::test::arbitrary;
     use crate::wire::Encode;
     #[test]
     fn test_ref_remote_limit() {
         let mut refs = BoundedVec::<_, REF_REMOTE_LIMIT>::new();

     #[test]
     fn test_node_announcement_validate() {
         let ann = NodeAnnouncement {
             version: 1,
             features: node::Features::SEED,
             timestamp: Timestamp::try_from(42491841u64).unwrap(),
             alias: Alias::new("alice"),
             addresses: BoundedVec::new(),
             nonce: 0,
             agent: UserAgent::from_str("/heartwood:1.0.0/").unwrap(),
         };
         assert_eq!(ann.work(), 0);
         assert_eq!(ann.clone().solve(1).unwrap().work(), 4);
         assert_eq!(ann.clone().solve(8).unwrap().work(), 9);
         assert_eq!(ann.work(), 1);
         assert_eq!(ann.clone().solve(1).unwrap().work(), 1);
         assert_eq!(ann.clone().solve(8).unwrap().work(), 10);
         assert_eq!(ann.solve(14).unwrap().work(), 14);
     }
 }

 use bloomy::BloomFilter;
 use qcheck::Arbitrary;
 use radicle::node::UserAgent;
 use crate::crypto;
 use crate::identity::DocAt;

             .into(),
             MessageType::NodeAnnouncement => {
                 let message = NodeAnnouncement {
                     version: u8::arbitrary(g),
                     features: u64::arbitrary(g).into(),
                     timestamp: Timestamp::arbitrary(g),
                     alias: Alias::arbitrary(g),
                     addresses: Arbitrary::arbitrary(g),
                     nonce: u64::arbitrary(g),
                     agent: UserAgent::arbitrary(g),
                 }
                 .into();
                 let bytes: [u8; 64] = Arbitrary::arbitrary(g);

 use radicle::node::config::ConnectAddress;
 use radicle::node::policy::store as policy;
 use radicle::node::seed::Store as _;
 use radicle::node::Database;
 use radicle::node::{Alias, POLICIES_DB_FILE};
 use radicle::node::{Alias, Database, UserAgent, POLICIES_DB_FILE};
 use radicle::node::{ConnectOptions, Handle as _};
 use radicle::profile;
 use radicle::profile::{env, Home, Profile};

             .init(
                 &public_key,
                 config.node.features(),
                 Alias::new(alias),
                 &Alias::new(alias),
                 &UserAgent::default(),
                 now.into(),
                 config.node.external_addresses.iter(),
             )

 use std::str::FromStr;
 use radicle::crypto::test::signer::MockSigner;
 use radicle::node;
 use radicle::node::UserAgent;
 use radicle::test::fixtures::gen;
 use crate::test::arbitrary;
 use crate::{
     prelude::{LocalDuration, LocalTime, Message},
     service::message::{InventoryAnnouncement, NodeAnnouncement},
     PROTOCOL_VERSION,
 };
 pub fn messages(count: usize, now: LocalTime, delta: LocalDuration) -> Vec<Message> {

         msgs.push(Message::node(
             NodeAnnouncement {
                 version: PROTOCOL_VERSION,
                 features: node::Features::SEED,
                 timestamp: time.into(),
                 alias: node::Alias::new(gen::string(5)),
                 addresses: None.into(),
                 nonce: 0,
                 agent: UserAgent::from_str("/radicle:test/").unwrap(),
             }
             .solve(0)
             .unwrap(),

 use radicle::identity::Visibility;
 use radicle::node::address::Store as _;
 use radicle::node::Database;
 use radicle::node::UserAgent;
 use radicle::node::{address, Alias, ConnectOptions};
 use radicle::rad;
 use radicle::storage::refs::{RefsAt, SignedRefsAt};

 use crate::test::storage::MockStorage;
 use crate::test::{arbitrary, fixtures, simulator};
 use crate::wire::MessageType;
 use crate::Link;
 use crate::{LocalDuration, LocalTime};
 use crate::{Link, LocalDuration, LocalTime, PROTOCOL_VERSION};
 /// Service instantiation used for testing.
 pub type Service<S, G> = service::Service<Database, S, G>;

             .init(
                 &id,
                 config.config.features(),
                 config.config.alias.clone(),
                 &config.config.alias,
                 &UserAgent::default(),
                 config.local_time.into(),
                 config.config.external_addresses.iter(),
             )

 pub use frame::StreamId;
 pub use message::{AddressType, MessageType};
 pub use protocol::{Control, Wire, WireReader, WireSession, WireWriter};
 use radicle::node::UserAgent;
 use std::collections::BTreeMap;
 use std::convert::TryFrom;

     InvalidRefName(#[from] fmt::Error),
     #[error(transparent)]
     InvalidAlias(#[from] node::AliasError),
     #[error("invalid user agent string: {0:?}")]
     InvalidUserAgent(String),
     #[error("invalid control message with type `{0}`")]
     InvalidControlMessage(u8),
     #[error("invalid protocol version header `{0:x?}`")]