radicle: improve sync fetching — heartwood

This patch changes separates the business logic of fetching from the process of fetching itself. It does this through a sans-IO approach, where a Fetcher provides the necessary state to help drive a fetch forward, without performing any of the IO itself.

What the Fetcher cares about is:

What nodes are going to be attempted to be fetched from
In what order should they be attempted
When should the fetching process be considered finished

The Fetcher is then used in radicle-cli to drive forward the sync::fetch function, allowing it to only care about the IO.

 ``` ~bob
 $ rad sync --fetch
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6MknSL…StBU8Vi@[..]..
 ✓ Fetched repository from 1 seed(s)
 Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 1 potential seed(s).
 ✓ Target met: 1 seed(s)
 🌱 Fetched from z6MknSL…StBU8Vi
 ```
 ``` ~alice

 ``` ~bob
 $ rad sync --fetch
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6Mkux1…nVhib7Z@[..]..
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6MknSL…StBU8Vi@[..]..
 ✓ Fetched repository from 2 seed(s)
 Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 2 potential seed(s).
 ✓ Target met: 2 seed(s)
 🌱 Fetched from z6Mkux1…nVhib7Z
 🌱 Fetched from z6MknSL…StBU8Vi
 ```
 ``` ~eve
 $ rad sync --fetch
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6Mkt67…v4N1tRk@[..]..
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6MknSL…StBU8Vi@[..]..
 ✓ Fetched repository from 2 seed(s)
 Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 2 potential seed(s).
 ✓ Target met: 2 seed(s)
 🌱 Fetched from z6Mkt67…v4N1tRk
 🌱 Fetched from z6MknSL…StBU8Vi
 ```
 To demonstrate the divergence, Alice, Bob, and Eve will all create a new change,

 ``` ~alice
 $ rad remote add did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk --name bob
 ✓ Follow policy updated for z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk (bob)
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6Mkux1…nVhib7Z@[..]..
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6Mkt67…v4N1tRk@[..]..
 Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 2 potential seed(s).
 ✓ Target met: 2 seed(s)
 ✓ Remote bob added
 ✓ Remote-tracking branch bob/master created for z6Mkt67…v4N1tRk
 $ rad remote add did:key:z6Mkux1aUQD2voWWukVb5nNUR7thrHveQG4pDQua8nVhib7Z --name eve
 ✓ Follow policy updated for z6Mkux1aUQD2voWWukVb5nNUR7thrHveQG4pDQua8nVhib7Z (eve)
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6Mkux1…nVhib7Z@[..]..
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6Mkt67…v4N1tRk@[..]..
 Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 2 potential seed(s).
 ✓ Target met: 2 seed(s)
 ✓ Remote eve added
 ✓ Remote-tracking branch eve/master created for z6Mkux1…nVhib7Z
 ```

 ``` ~bob
 $ rad remote add did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi --name alice
 ✓ Follow policy updated for z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi (alice)
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6Mkux1…nVhib7Z@[..]..
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6MknSL…StBU8Vi@[..]..
 Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 2 potential seed(s).
 ✓ Target met: 2 seed(s)
 ✓ Remote alice added
 ✓ Remote-tracking branch alice/master created for z6MknSL…StBU8Vi
 $ git reset --hard alice/master

 ``` ~eve
 $ rad remote add did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi --name alice
 ✓ Follow policy updated for z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi (alice)
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6Mkt67…v4N1tRk@[..]..
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6MknSL…StBU8Vi@[..]..
 Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 2 potential seed(s).
 ✓ Target met: 2 seed(s)
 ✓ Remote alice added
 ✓ Remote-tracking branch alice/master created for z6MknSL…StBU8Vi
 $ git reset --hard alice/master

 ```
 $ rad clone rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji --scope all
 ✓ Seeding policy updated for rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji with scope 'all'
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6MknSL…StBU8Vi@[..]..
 Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 1 potential seed(s).
 ✓ Target met: 1 seed(s)
 ✓ Creating checkout in ./heartwood..
 ✓ Remote alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi added
 ✓ Remote-tracking branch alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/master created for z6MknSL…StBU8Vi

 ``` (fail)
 $ rad clone rad:zVNuptPuk5XauitpCWSNVCXGGfXW --scope followed
 ✓ Seeding policy updated for rad:zVNuptPuk5XauitpCWSNVCXGGfXW with scope 'followed'
 ✗ Error: no seeds found for rad:zVNuptPuk5XauitpCWSNVCXGGfXW
 ✗ Error: fetch: no candidate seeds were found to fetch from
 ```

 $ rad ls --all --private
 $ rad clone rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu --seed z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi --timeout 1
 ✓ Seeding policy updated for rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu with scope 'all'
 ✓ Fetching rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu from z6MknSL…StBU8Vi@[..]..
 Fetching rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu from the network, found 1 potential seed(s).
 ✓ Target met: 1 preferred seed(s).
 ✓ Creating checkout in ./heartwood..
 ✓ Remote alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi added
 ✓ Remote-tracking branch alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/master created for z6MknSL…StBU8Vi

 ``` ~bob (fail)
 $ rad clone rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu --seed z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi --timeout 1
 ✓ Seeding policy updated for rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu with scope 'all'
 ✗ Fetching rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu from z6MknSL…StBU8Vi@[..].. error: failed to perform fetch handshake
 Fetching rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu from the network, found 1 potential seed(s).
 ✗ Target not met: could not fetch from [z6MknSL…StBU8Vi], and required 1 more seed(s)
 ✗ Error: repository rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu not found
 ```

 ✓ Branch patch/d004b67 setup to track rad/patches/d004b67355456c46de10c0d287e4a791ad1a6945
 $ rad remote add z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk
 ✓ Follow policy updated for z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk
 ✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6Mkt67…v4N1tRk@[..]..
 Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 1 potential seed(s).
 ✓ Target met: 1 seed(s)
 ✓ Remote bob@z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk added
 ✓ Remote-tracking branch bob@z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk/master created for z6Mkt67…v4N1tRk
 $ git checkout master -q

 ```
 $ rad seed rad:z3Rry7rpdWuGpfjPYGzdJKQADsoNW rad:z3zTnCfi6cVSZG8eCGn6AMDypgAPm
 ✓ Seeding policy updated for rad:z3Rry7rpdWuGpfjPYGzdJKQADsoNW with scope 'all'
 ✓ Fetching rad:z3Rry7rpdWuGpfjPYGzdJKQADsoNW from z6Mkt67…v4N1tRk@[..]
 Fetching rad:z3Rry7rpdWuGpfjPYGzdJKQADsoNW from the network, found 1 potential seed(s).
 ✓ Target met: 1 seed(s)
 ✓ Seeding policy updated for rad:z3zTnCfi6cVSZG8eCGn6AMDypgAPm with scope 'all'
 ✓ Fetching rad:z3zTnCfi6cVSZG8eCGn6AMDypgAPm from z6Mkt67…v4N1tRk@[..]
 Fetching rad:z3zTnCfi6cVSZG8eCGn6AMDypgAPm from the network, found 1 potential seed(s).
 ✓ Target met: 1 seed(s)
 ```

 It's also possible to receive an error if a repository is not found anywhere.
 ```
 $ rad seed rad:z39mP9rQAaGmERfUMPULfPUi473tY
 $ rad seed rad:z39mP9rQAaGmERfUMPULfPUi473tY --no-fetch
 ✓ Seeding policy updated for rad:z39mP9rQAaGmERfUMPULfPUi473tY with scope 'all'
 ```
 ``` (fail)
 $ rad sync rad:z39mP9rQAaGmERfUMPULfPUi473tY
 ✗ Error: no seeds found for rad:z39mP9rQAaGmERfUMPULfPUi473tY
 ✗ Error: nothing to announce, repository rad:z39mP9rQAaGmERfUMPULfPUi473tY is not available locally
 ✗ Error: no candidate seeds were found to fetch from
 ```
 Or when trying to fetch from an unknown seed, using `--seed`:
 ```
 $ rad sync --fetch rad:z39mP9rQAaGmERfUMPULfPUi473tY --seed z6MkjM3HpqNVV4ZsL5s3RAd8ThVG3VG98YsDCjHBNnGMq5o7
 ! Warning: no addresses found for z6MkjM3HpqNVV4ZsL5s3RAd8ThVG3VG98YsDCjHBNnGMq5o7, skipping..
 ✗ Error: repository fetch from 1 seed(s) failed
 Fetching rad:z39mP9rQAaGmERfUMPULfPUi473tY from the network, found 1 potential seed(s).
 ✗ Target not met: could not fetch from [z6MkjM3…nGMq5o7], and required 1 more seed(s)
 ✗ Error: Fetched from 0 preferred seed(s), could not reach 1 seed(s)
 ✗ Error: Could not replicate from 1 preferred seed(s)
 ✗ Error: z6MkjM3…nGMq5o7: Could not connect. No addresses known.
 ```
 Also note that you cannot sync an unseeded repo:

                     let value = term::args::nid(&value)?;
                     sync.seeds.insert(value);
                     sync.replicas = sync.seeds.len();
                     let n = sync.seeds.len();
                     sync.replicas = node::sync::ReplicationFactor::must_reach(n);
                 }
                 Long("scope") => {
                     let value = parser.value()?;

         );
     }
     let results = sync::fetch(id, settings, node, profile)?;
     let result = sync::fetch(id, settings, node, profile)?;
     // FIXME: handle the two cases
     let fetch_results = match &result {
         node::sync::FetcherResult::TargetReached(success) => success.fetch_results(),
         node::sync::FetcherResult::TargetError(failed) => failed.fetch_results(),
     };
     let Ok(repository) = profile.storage.repository(id) else {
         // If we don't have the repository locally, even after attempting to fetch,
         // there's nothing we can do.
         if results.is_empty() {
         if fetch_results.is_empty() {
             return Err(CloneError::NoSeeds(id));
         } else {
             return Err(CloneError::NotFound(id));

         }
     }
     if results.success().next().is_none() {
         if results.failed().next().is_some() {
     if fetch_results.success().next().is_none() {
         if fetch_results.failed().next().is_some() {
             term::warning("Fetching failed, local copy is potentially stale");
         } else {
             term::warning("No seeds found, local copy is potentially stale");

 use std::cmp::Ordering;
 use std::collections::BTreeSet;
 use std::collections::VecDeque;
 use std::collections::HashSet;
 use std::ffi::OsString;
 use std::str::FromStr;
 use std::time;

 use radicle::node;
 use radicle::node::address::Store;
 use radicle::node::{AliasStore, FetchResult, FetchResults, Handle as _, Node, Seed, SyncStatus};
 use radicle::node::sync;
 use radicle::node::sync::fetch::SuccessfulOutcome;
 use radicle::node::{AliasStore, Handle as _, Node, Seed, SyncStatus};
 use radicle::prelude::{NodeId, Profile, RepoId};
 use radicle::storage::ReadRepository;
 use radicle::storage::RefUpdate;
 use radicle::storage::{ReadStorage, RemoteRepository};
 use radicle_term::Element;

     When `--replicas` is specified, the given replication factor will try
     to be matched. For example, `--replicas 5` will sync with 5 seeds.
     The synchronization process can be configured using `--replicas <min>` and
     `--replicas-max <max>`. If these options are used independently, then the
     replication factor is taken as the given `<min>`/`<max>` value. If the
     options are used together, then the replication factor has a minimum and
     maximum bound.
     For fetching, the synchronization process will be considered successful if
     at least `<min>` seeds were fetched from *or* all preferred seeds were
     fetched from. If `<max>` is specified then the process will continue and
     attempt to sync with `<max>` seeds.
     For reference announcing, the synchronization process will be considered
     successful if at least `<min>` seeds were pushed to *and* all preferred
     seeds were pushed to.
     When `--fetch` or `--announce` are specified on their own, this command
     will only fetch or announce.

 Options
         --sort-by   <field>   Sort the table by column (options: nid, alias, status)
     -f, --fetch               Turn on fetching (default: true)
     -a, --announce            Turn on ref announcing (default: true)
     -i, --inventory           Turn on inventory announcing (default: false)
         --timeout   <secs>    How many seconds to wait while syncing
         --seed      <nid>     Sync with the given node (may be specified multiple times)
     -r, --replicas  <count>   Sync with a specific number of seeds
     -v, --verbose             Verbose output
         --debug               Print debug information afer sync
         --help                Print help
         --sort-by       <field>   Sort the table by column (options: nid, alias, status)
     -f, --fetch                   Turn on fetching (default: true)
     -a, --announce                Turn on ref announcing (default: true)
     -i, --inventory               Turn on inventory announcing (default: false)
         --timeout       <secs>    How many seconds to wait while syncing
         --seed          <nid>     Sync with the given node (may be specified multiple times)
     -r, --replicas      <count>   Sync with a specific number of seeds
         --replicas-max  <count>   Sync with an upper bound number of seeds
     -v, --verbose                 Verbose output
         --debug                   Print debug information afer sync
         --help                    Print help
 "#,
 };

         let mut inventory = false;
         let mut debug = false;
         let mut replicas = None;
         let mut max_replicas = None;
         let mut seeds = BTreeSet::new();
         let mut sort_by = SortBy::default();
         let mut op: Option<Operation> = None;

                     }
                     replicas = Some(count);
                 }
                 Long("replicas-max") => {
                     let val = parser.value()?;
                     let count = term::args::number(&val)?;
                     if count == 0 {
                         anyhow::bail!("value for `--replicas-max` must be greater than zero");
                     }
                     max_replicas = Some(count);
                 }
                 Long("seed") => {
                     let val = parser.value()?;
                     let nid = term::args::nid(&val)?;

             };
             let mut settings = SyncSettings::default().timeout(timeout);
             if let Some(r) = replicas {
                 settings.replicas = r;
             }
             let replicas = match (replicas, max_replicas) {
                 (None, None) => sync::ReplicationFactor::default(),
                 (None, Some(min)) => sync::ReplicationFactor::must_reach(min),
                 (Some(min), None) => sync::ReplicationFactor::must_reach(min),
                 (Some(min), Some(max)) => sync::ReplicationFactor::range(min, max),
             };
             settings.replicas = replicas;
             if !seeds.is_empty() {
                 settings.seeds = seeds;
             }

                 if !profile.policies()?.is_seeding(&rid)? {
                     anyhow::bail!("repository {rid} is not seeded");
                 }
                 let results = fetch(rid, settings.clone(), &mut node, &profile)?;
                 let success = results.success().count();
                 let failed = results.failed().count();
                 if results.is_empty() {
                     term::error(format!("no seeds found for {rid}"));
                 } else if success == 0 {
                     term::error(format!("repository fetch from {failed} seed(s) failed"));
                 } else {
                     term::success!("Fetched repository from {success} seed(s)");
                 }
                 let result = fetch(rid, settings.clone(), &mut node, &profile)?;
                 display_fetch_result(&result, options.verbose)
             }
             if [SyncDirection::Announce, SyncDirection::Both].contains(&direction) {
                 announce_refs(rid, settings, options.debug, &mut node, &profile)?;

     Db(#[from] node::db::Error),
     #[error(transparent)]
     Address(#[from] node::address::Error),
     #[error(transparent)]
     Fetcher(#[from] sync::FetcherError),
 }
 pub fn fetch(

     settings: SyncSettings,
     node: &mut Node,
     profile: &Profile,
 ) -> Result<FetchResults, FetchError> {
     let local = node.nid()?;
     let replicas = settings.replicas;
     let mut results = FetchResults::default();
 ) -> Result<sync::FetcherResult, FetchError> {
     let db = profile.database()?;
     let local = profile.id();
     let is_private = profile.storage.repository(rid).ok().and_then(|repo| {
         let doc = repo.identity_doc().ok()?.doc;
         sync::fetch::PrivateNetwork::private_repo(&doc)
     });
     let config = match is_private {
         Some(private) => sync::FetcherConfig::private(private, settings.replicas, *local),
         None => {
             // We push nodes that are in our seed list in attempt to fulfill the
             // replicas, if needed.
             let seeds = node.seeds(rid)?;
             let (connected, disconnected) = seeds.partition();
             let candidates = connected
                 .into_iter()
                 .map(|seed| seed.nid)
                 .chain(disconnected.into_iter().map(|seed| seed.nid))
                 .map(sync::fetch::Candidate::new);
             sync::FetcherConfig::public(settings.seeds.clone(), settings.replicas, *local)
                 .with_candidates(candidates)
         }
     };
     let mut fetcher = sync::Fetcher::new(config)?;
     // Fetch from specified seeds, connecting to them if necessary.
     for nid in &settings.seeds {
         match node.session(*nid)? {
             Some(session) if session.is_connected() => {
                 fetch_from(
                     rid,
                     nid,
                     &session.addr,
                     settings.timeout,
                     &mut results,
                     node,
                 )?;
             }
     let mut progress = fetcher.progress();
     term::info!(
         "Fetching {} from the network, found {} potential seed(s).",
         term::format::tertiary(rid),
         term::format::tertiary(progress.candidate())
     );
     let mut spinner = FetcherSpinner::new(fetcher.target(), &progress);
     while let Some(nid) = fetcher.next_node() {
         match node.session(nid)? {
             Some(session) if session.is_connected() => fetcher.ready_to_fetch(nid, session.addr),
             _ => {
                 let addrs = db.addresses_of(nid)?;
                 let addrs = db.addresses_of(&nid)?;
                 if addrs.is_empty() {
                     results.push(
                         *nid,
                         FetchResult::Failed {
                             reason: format!("no addresses found in routing table for {nid}"),
                         },
                     );
                     term::warning(format!("no addresses found for {nid}, skipping.."));
                     fetcher.fetch_failed(nid, "Could not connect. No addresses known.");
                 } else if let Some(addr) = connect(
                     *nid,
                     nid,
                     addrs.into_iter().map(|ka| ka.addr),
                     settings.timeout,
                     node,
                     &mut spinner,
                     &fetcher.progress(),
                 ) {
                     fetch_from(rid, nid, &addr, settings.timeout, &mut results, node)?;
                     fetcher.ready_to_fetch(nid, addr)
                 } else {
                     fetcher
                         .fetch_failed(nid, "Could not connect. At least one address is known but all attempts timed out.");
                 }
             }
         }
         // We are done when we either hit our replica count,
         // or fetch from all the specified seeds.
         if results.success().count() >= replicas {
             return Ok(results);
         }
         if settings
             .seeds
             .iter()
             .all(|nid| results.get(nid).is_some_and(|r| r.is_success()))
         {
             return Ok(results);
         }
     }
     // If we're here, we haven't met our sync targets, so consult the routing table
     // for more seeds to fetch from.
     let seeds = node.seeds(rid)?;
     let (connected, mut disconnected) = seeds.partition();
     // Fetch from connected seeds.
     let mut connected = connected
         .into_iter()
         .filter(|c| !results.contains(&c.nid))
         .map(|c| c.nid)
         .take(replicas)
         .collect::<VecDeque<_>>();
     while results.success().count() < replicas {
         let Some(nid) = connected.pop_front() else {
             break;
         };
         if let Some(session) = node.session(nid)? {
             fetch_from(
                 rid,
                 &nid,
                 &session.addr,
                 settings.timeout,
                 &mut results,
                 node,
             )?;
         } else {
             log::warn!("Could not obtain session for seed with ID {nid}, even though it should be connected.")
         if let Some((nid, addr)) = fetcher.next_fetch() {
             spinner.emit_fetching(&nid, &addr, &progress);
             let result = node.fetch(rid, nid, settings.timeout)?;
             match fetcher.fetch_complete(nid, result) {
                 std::ops::ControlFlow::Continue(update) => {
                     spinner.emit_progress(&update);
                     progress = update
                 }
                 std::ops::ControlFlow::Break(success) => {
                     spinner.finished(success.outcome());
                     return Ok(sync::FetcherResult::TargetReached(success));
                 }
             }
         }
     }
     // Try to connect to disconnected seeds and fetch from them.
     while results.success().count() < replicas {
         let Some(seed) = disconnected.pop() else {
             break;
         };
         if seed.nid == local {
             // Skip our own node.
             continue;
         }
         if let Some(addr) = connect(
             seed.nid,
             seed.addrs.into_iter().map(|ka| ka.addr),
             settings.timeout,
             node,
         ) {
             fetch_from(rid, &seed.nid, &addr, settings.timeout, &mut results, node)?;
     let result = fetcher.finish();
     match &result {
         sync::FetcherResult::TargetReached(success) => {
             spinner.finished(success.outcome());
         }
         sync::FetcherResult::TargetError(missed) => spinner.failed(missed),
     }
     Ok(results)
     Ok(result)
 }
 // Try all addresses until one succeeds.
 // FIXME(fintohaps): I think this could return a `Result<node::Address,
 // Vec<AddressError>>` which could report back why each address failed
 fn connect(
     nid: NodeId,
     addrs: impl Iterator<Item = node::Address>,
     timeout: time::Duration,
     node: &mut Node,
     spinner: &mut FetcherSpinner,
     progress: &sync::fetch::Progress,
 ) -> Option<node::Address> {
     // Try all addresses until one succeeds.
     for addr in addrs {
         let spinner = term::spinner(format!(
             "Connecting to {}@{}..",
             term::format::tertiary(term::format::node(&nid)),
             &addr
         ));
         spinner.emit_dialing(&nid, &addr, progress);
         let cr = node.connect(
             nid,
             addr.clone(),

         match cr {
             Ok(node::ConnectResult::Connected) => {
                 spinner.finish();
                 return Some(addr);
             }
             Ok(node::ConnectResult::Disconnected { reason }) => {
                 spinner.error(reason);
             Ok(node::ConnectResult::Disconnected { .. }) => {
                 continue;
             }
             Err(e) => {
                 spinner.error(e);
                 log::warn!(target: "cli", "Failed to connect to {nid}@{addr}: {e}");
                 continue;
             }
         }

     None
 }
 fn fetch_from(
     rid: RepoId,
     seed: &NodeId,
     addr: &node::Address,
     timeout: time::Duration,
     results: &mut FetchResults,
     node: &mut Node,
 ) -> Result<(), node::Error> {
     // NOTE: addr is only used for better output.
     // Whether it actually corresponds to the addr
     // of the connection to seed is not checked.
     // There could be races.
     // Our goal is to provide better output to the user,
     // and it should be good enough for that.
     let spinner = term::spinner(format!(
         "Fetching {} from {}@{}..",
         term::format::tertiary(rid),
         term::format::tertiary(term::format::node(seed)),
         addr,
     ));
     let result = node.fetch(rid, *seed, timeout)?;
     match &result {
         FetchResult::Success { .. } => {
             spinner.finish();
         }
         FetchResult::Failed { reason } => {
             spinner.error(reason);
         }
     }
     results.push(*seed, result);
     Ok(())
 }
 fn sort_seeds_by(local: NodeId, seeds: &mut [Seed], aliases: &impl AliasStore, sort_by: &SortBy) {
     let compare = |a: &Seed, b: &Seed| match sort_by {
         SortBy::Nid => a.nid.cmp(&b.nid),

         }
     });
 }
 struct FetcherSpinner {
     preferred_seeds: usize,
     replicas: sync::ReplicationFactor,
     spinner: term::Spinner,
 }
 impl FetcherSpinner {
     fn new(target: &sync::fetch::Target, progress: &sync::fetch::Progress) -> Self {
         let preferred_seeds = target.preferred_seeds().len();
         let replicas = target.replicas();
         let spinner = term::spinner(format!(
             "{} of {} preferred seeds, and {} of at least {} total seeds.",
             term::format::secondary(progress.preferred()),
             term::format::secondary(preferred_seeds),
             term::format::secondary(progress.succeeded()),
             term::format::secondary(replicas.lower_bound())
         ));
         Self {
             preferred_seeds: target.preferred_seeds().len(),
             replicas: *target.replicas(),
             spinner,
         }
     }
     fn emit_progress(&mut self, progress: &sync::fetch::Progress) {
         self.spinner.message(format!(
             "{} of {} preferred seeds, and {} of at least {} total seeds.",
             term::format::secondary(progress.preferred()),
             term::format::secondary(self.preferred_seeds),
             term::format::secondary(progress.succeeded()),
             term::format::secondary(self.replicas.lower_bound()),
         ))
     }
     fn emit_fetching(
         &mut self,
         node: &NodeId,
         addr: &node::Address,
         progress: &sync::fetch::Progress,
     ) {
         self.spinner.message(format!(
             "{} of {} preferred seeds, and {} of at least {} total seeds… [fetch {}@{}]",
             term::format::secondary(progress.preferred()),
             term::format::secondary(self.preferred_seeds),
             term::format::secondary(progress.succeeded()),
             term::format::secondary(self.replicas.lower_bound()),
             term::format::tertiary(term::format::node(node)),
             term::format::tertiary(addr),
         ))
     }
     fn emit_dialing(
         &mut self,
         node: &NodeId,
         addr: &node::Address,
         progress: &sync::fetch::Progress,
     ) {
         self.spinner.message(format!(
             "{} of {} preferred seeds, and {} of at least {} total seeds… [dial {}@{}]",
             term::format::secondary(progress.preferred()),
             term::format::secondary(self.preferred_seeds),
             term::format::secondary(progress.succeeded()),
             term::format::secondary(self.replicas.lower_bound()),
             term::format::tertiary(term::format::node(node)),
             term::format::tertiary(addr),
         ))
     }
     fn finished(mut self, outcome: &SuccessfulOutcome) {
         match outcome {
             SuccessfulOutcome::PreferredNodes { preferred } => {
                 self.spinner.message(format!(
                     "Target met: {} preferred seed(s).",
                     term::format::positive(preferred),
                 ));
             }
             SuccessfulOutcome::MinReplicas { succeeded, .. } => {
                 self.spinner.message(format!(
                     "Target met: {} seed(s)",
                     term::format::positive(succeeded)
                 ));
             }
             SuccessfulOutcome::MaxReplicas {
                 succeeded,
                 min,
                 max,
             } => {
                 self.spinner.message(format!(
                     "Target met: {} of {} min and {} max seed(s)",
                     succeeded,
                     term::format::secondary(min),
                     term::format::secondary(max)
                 ));
             }
         }
         self.spinner.finish()
     }
     fn failed(mut self, missed: &sync::fetch::TargetMissed) {
         let mut message = "Target not met: ".to_string();
         let missing_preferred_seeds = missed
             .missed_nodes()
             .iter()
             .map(|nid| term::format::node(nid).to_string())
             .collect::<Vec<_>>();
         let required = missed.required_nodes();
         if !missing_preferred_seeds.is_empty() {
             message.push_str(&format!(
                 "could not fetch from [{}], and required {} more seed(s)",
                 missing_preferred_seeds.join(", "),
                 required
             ));
         } else {
             message.push_str(&format!("required {} more seed(s)", required));
         }
         self.spinner.message(message);
         self.spinner.failed();
     }
 }
 fn display_fetch_result(result: &sync::FetcherResult, verbose: bool) {
     match result {
         sync::FetcherResult::TargetReached(success) => {
             let progress = success.progress();
             let results = success.fetch_results();
             display_success(results.success(), verbose);
             let failed = progress.failed();
             if failed > 0 && verbose {
                 term::warning(format!("Failed to fetch from {failed} seed(s)."));
                 for (node, reason) in results.failed() {
                     term::warning(format!(
                         "{}: {}",
                         term::format::node(node),
                         term::format::yellow(reason),
                     ))
                 }
             }
         }
         sync::FetcherResult::TargetError(failed) => {
             let results = failed.fetch_results();
             let progress = failed.progress();
             let target = failed.target();
             let succeeded = progress.succeeded();
             let missed = failed.missed_nodes();
             term::error(format!(
                 "Fetched from {} preferred seed(s), could not reach {} seed(s)",
                 succeeded,
                 target.replicas().lower_bound(),
             ));
             term::error(format!(
                 "Could not replicate from {} preferred seed(s)",
                 missed.len()
             ));
             for (node, reason) in results.failed() {
                 term::error(format!(
                     "{}: {}",
                     term::format::node(node),
                     term::format::negative(reason),
                 ))
             }
             if succeeded > 0 {
                 term::info!("Successfully fetched from the following seeds:");
                 display_success(results.success(), verbose)
             }
         }
     }
 }
 fn display_success<'a>(
     results: impl Iterator<Item = (&'a NodeId, &'a [RefUpdate], HashSet<NodeId>)>,
     verbose: bool,
 ) {
     for (node, updates, _) in results {
         term::println(
             "🌱 Fetched from",
             term::format::secondary(term::format::node(node)),
         );
         if verbose {
             let mut updates = updates
                 .iter()
                 .filter(|up| !matches!(up, RefUpdate::Skipped { .. }))
                 .peekable();
             if updates.peek().is_none() {
                 term::indented(term::format::italic("no references were updated"));
             } else {
                 for update in updates {
                     term::indented(term::format::ref_update_verbose(update))
                 }
             }
         }
     }
 }

 use std::io::Write;
 use std::ops::ControlFlow;
 use radicle::node::{self, AnnounceResult};
 use radicle::node::{self, sync, AnnounceResult};
 use radicle::node::{Handle as _, NodeId};
 use radicle::storage::{ReadRepository, RepositoryError};
 use radicle::{Node, Profile};

 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SyncSettings {
     /// Sync with at least N replicas.
     pub replicas: usize,
     pub replicas: sync::ReplicationFactor,
     /// Sync with the given list of seeds.
     pub seeds: BTreeSet<NodeId>,
     /// How long to wait for syncing to complete.

     }
     /// Set replicas.
     pub fn replicas(mut self, replicas: usize) -> Self {
     pub fn replicas(mut self, replicas: sync::ReplicationFactor) -> Self {
         self.replicas = replicas;
         self
     }

 impl Default for SyncSettings {
     fn default() -> Self {
         Self {
             replicas: 3,
             replicas: sync::ReplicationFactor::default(),
             seeds: BTreeSet::new(),
             timeout: DEFAULT_SYNC_TIMEOUT,
         }

         // If the seeds we specified in the sync settings are all synced.
         let is_seeds_synced = settings.seeds.iter().all(|s| synced.contains(s));
         // If we met our desired replica count. Note that this can never exceed the maximum count.
         let is_replicas_synced = replicas >= settings.replicas.min(max_replicas);
         let is_replicas_synced = replicas >= settings.replicas.lower_bound().min(max_replicas);
         // Nothing to do if we've met our sync state.
         if is_seeds_synced && is_replicas_synced {

                 //
                 // 1. We've matched or exceeded our target replica count.
                 // 2. We've synced with one of the seeds specified manually.
                 if replicas.len() >= settings.replicas
                 if replicas.len() >= settings.replicas.lower_bound()
                     && (settings.seeds.is_empty()
                         || settings.seeds.iter().any(|s| replicas.contains_key(s)))
                 {

     }
 }
 pub fn ref_update_verbose(update: &RefUpdate) -> Paint<String> {
     match update {
         RefUpdate::Created { name, .. } => format!(
             "{: <17} {}",
             term::format::positive("* [new ref]"),
             term::format::secondary(name),
         )
         .into(),
         RefUpdate::Updated { name, old, new } => format!(
             "{: <17} {}",
             format!("{}..{}", term::format::oid(*old), term::format::oid(*new)),
             term::format::secondary(name),
         )
         .into(),
         RefUpdate::Deleted { name, .. } => format!(
             "{: <17} {}",
             term::format::negative("- [deleted]"),
             term::format::secondary(name),
         )
         .into(),
         RefUpdate::Skipped { name, .. } => format!(
             "{: <17} {}",
             term::format::italic("* [skipped]"),
             term::format::secondary(name)
         )
         .into(),
     }
 }
 /// Identity formatter that takes a profile and displays it as
 /// `<node-id> (<username>)` depending on the configuration.
 pub struct Identity<'a> {