✓ Synced with 1 seed(s)

✓ Synced with 2 seed(s)

✓ Synced with 2 seed(s)

✓ Synced with 2 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

She allows Bob to view the repository. And when she syncs, one seed (Bob) gets

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 2 seed(s)

✓ Synced with 2 seed(s)

✓ Synced with 2 seed(s)

✓ Synced with 2 seed(s)

✓ Synced with 2 seed(s)

✓ Synced with 2 seed(s)

✓ Synced with 2 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 2 seed(s)

✓ Nothing to announce, already in sync with 2 seed(s) (see `rad sync status`)

✓ Nothing to announce, already in sync with 2 seed(s) (see `rad sync status`)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

✓ Synced with 1 seed(s)

use std::collections::BTreeMap;

    match &options.op {

            if [SyncDirection::Fetch, SyncDirection::Both].contains(direction) {

            if [SyncDirection::Announce, SyncDirection::Both].contains(direction) {

                announce_refs(rid, settings, &mut node, &profile, &options)?;

    options: &Options,

    let result = crate::node::announce(

            debug: options.debug,

    if let Some(result) = result {

        print_announcer_result(&result, options.verbose)

    }

fn print_announcer_result(result: &sync::AnnouncerResult, verbose: bool) {

    match result {

        sync::AnnouncerResult::Success(success) if verbose => {

            // N.b. Printing how many seeds were synced with is printed

            // elsewhere

            match success.outcome() {

                sync::announce::SuccessfulOutcome::MinReplicationFactor { preferred, synced }

                | sync::announce::SuccessfulOutcome::MaxReplicationFactor { preferred, synced } => {

                    if preferred == 0 {

                        term::success!("Synced {} seed(s)", term::format::positive(synced));

                    } else {

                        term::success!(

                            "Synced {} preferred seed(s) and {} total seed(s)",

                            term::format::positive(preferred),

                            term::format::positive(synced)

                        );

                    }

                }

            }

            print_synced(success.synced());

        }

        sync::AnnouncerResult::Success(_) => {

            // Successes are ignored when `!verbose`.

        }

        sync::AnnouncerResult::TimedOut(result) => {

            if result.synced().is_empty() {

                term::error("All seeds timed out, use `rad sync -v` to see the list of seeds");

                return;

            }

            let timed_out = result.timed_out();

            term::warning(format!(

                "{} seed(s) timed out, use `rad sync -v` to see the list of seeds",

                timed_out.len(),

            ));

            if verbose {

                print_synced(result.synced());

                for node in timed_out {

                    term::warning(format!("{} timed out", term::format::node(node)));

                }

            }

        }

        sync::AnnouncerResult::NoNodes(result) => {

            term::info!("Announcement could not sync with anymore seeds.");

            if verbose {

                print_synced(result.synced())

            }

        }

    }

}

fn print_synced(synced: &BTreeMap<NodeId, sync::announce::SyncStatus>) {

    for (node, status) in synced.iter() {

        let mut message = format!("🌱 Synced with {}", term::format::node(node));

        match status {

            sync::announce::SyncStatus::AlreadySynced => {

                message.push_str(&format!("{}", term::format::dim(" (already in sync)")));

            }

            sync::announce::SyncStatus::Synced { duration } => {

                message.push_str(&format!(

                    "{}",

                    term::format::dim(format!("in {}s", duration.as_secs()))

                ));

            }

        }

        term::info!("{}", message);

    }

}

use radicle::node::sync;

    #[error(transparent)]

    Target(#[from] sync::announce::TargetError),

) -> Result<Option<sync::AnnouncerResult>, SyncError> {

            Ok(None)

fn announce_<R>(

) -> Result<Option<sync::AnnouncerResult>, SyncError>

where

    R: ReadRepository,

{

    let me = profile.id();

    let settings = settings.with_profile(profile);

    let n_preferred_seeds = settings.seeds.len();

    let config = match sync::PrivateNetwork::private_repo(&doc) {

        None => {

            let (synced, unsynced) = node.seeds(rid)?.iter().fold(

                (BTreeSet::new(), BTreeSet::new()),

                |(mut synced, mut unsynced), seed| {

                    if seed.is_synced() {

                        synced.insert(seed.nid);

                    } else {

                        unsynced.insert(seed.nid);

                    }

                    (synced, unsynced)

                },

            sync::AnnouncerConfig::public(*me, settings.replicas, settings.seeds, synced, unsynced)

        }

        Some(network) => {

            let sessions = node.sessions()?;

            let network =

                network.restrict(|nid| sessions.iter().any(|s| s.nid == *nid && s.is_connected()));

            sync::AnnouncerConfig::private(*me, settings.replicas, network)

    let announcer = match sync::Announcer::new(config) {

        Ok(announcer) => announcer,

        Err(err) => match err {

            sync::AnnouncerError::AlreadySynced(result) => {

                term::success!(

                    &mut reporting.completion;

                    "Nothing to announce, already in sync with {} seed(s) (see `rad sync status`)",

                    term::format::positive(result.synced()),

                );

                return Ok(None);

            }

            sync::AnnouncerError::NoSeeds => {

                term::info!(

                    &mut reporting.completion;

                    "{}",

                    term::format::yellow("No seeds found for {rid}.")

                );

                return Ok(None);

            }

            sync::AnnouncerError::Target(err) => return Err(err.into()),

        },

    };

    let target = announcer.target();

    let min_replicas = target.replicas().lower_bound();

        format!("Found {} seed(s)..", announcer.progress().unsynced()),

    match node.announce(rid, settings.timeout, announcer, |node, progress| {

        spinner.message(format!(

            "Synced with {}, {} of {} preferred seeds, and {} of at least {} replica(s).",

            term::format::node(node),

            term::format::secondary(progress.preferred()),

            term::format::secondary(n_preferred_seeds),

            term::format::secondary(progress.synced()),

            term::format::secondary(min_replicas),

        ));

    }) {

        Ok(result) => {

            spinner.message(format!(

                "Synced with {} seed(s)",

                term::format::positive(result.synced().len())

            ));

            spinner.finish();

            Ok(Some(result))

        Err(err) => {

            spinner.error("Sync failed: {err}");

            Err(err.into())

    alice.connect(&seed).connect(&bob);

    bob.connect(&seed);

    if let Some(result) = result {

        for seed in profile.config.preferred_seeds.iter() {

            if result.is_synced(&seed.id) {

                for resource in updated {

                    let url = profile

                        .config

                        .public_explorer

                        .url(seed.addr.host.clone(), repo.id)

                        .resource(resource);

                    urls.push(url);

                }

                break;

        mut announcer: sync::Announcer,

        mut report: impl FnMut(&NodeId, sync::announce::Progress),

    ) -> Result<sync::AnnouncerResult, Error> {

        let mut events = self.subscribe(timeout)?;

        loop {

            let Some(e) = events.next() else {

                // Consider the announcement as timed out if there are no more

                // events

                return Ok(announcer.timed_out());

            };

                return Ok(announcer.timed_out());

                    match announcer.synced_with(remote, elapsed) {

                        ControlFlow::Continue(progress) => {

                            report(&remote, progress);

                        }

                        ControlFlow::Break(finished) => {

                            return Ok(finished.into());

                    return Ok(announcer.timed_out());

            // Ensure that the announcer is still waiting for nodes to be

            // in-sync with

            announcer = match announcer.can_continue() {

                ControlFlow::Continue(cont) => cont,

                ControlFlow::Break(finished) => return Ok(finished.into()),

            };

pub mod announce;

pub use announce::{Announcer, AnnouncerConfig, AnnouncerError, AnnouncerResult};

use std::{

    collections::{BTreeMap, BTreeSet},

    ops::ControlFlow,

    time,

};

use crate::node::NodeId;

use super::{PrivateNetwork, ReplicationFactor};

pub struct Announcer {

    local_node: NodeId,

    target: Target,

    synced: BTreeMap<NodeId, SyncStatus>,

    to_sync: BTreeSet<NodeId>,

}

impl Announcer {

    /// Construct a new [`Announcer`] from the [`AnnouncerConfig`].

    ///

    /// This will ensure that the local [`NodeId`], provided in the

    /// [`AnnouncerConfig`], will be removed from all sets.

    ///

    /// # Errors

    ///

    /// Returns the following errors:

    ///

    ///   - [`AnnouncerError::NoSeeds`]: both sets of already synchronized and

    ///     un-synchronized nodes were empty

    ///     of nodes were empty

    ///   - [`AnnouncerError::AlreadySynced`]: no more nodes are available for

    ///     synchronizing with

    ///   - [`AnnouncerError::Target`]: the target has no preferred seeds and no

    ///     replicas

    pub fn new(mut config: AnnouncerConfig) -> Result<Self, AnnouncerError> {

        // N.b. ensure that local node is none of the sets

        config.preferred_seeds.remove(&config.local_node);

        config.synced.remove(&config.local_node);

        config.unsynced.remove(&config.local_node);

        if config.synced.is_empty() && config.unsynced.is_empty() {

            return Err(AnnouncerError::NoSeeds);

        }

        if config.unsynced.is_empty() {

            let preferred = config.synced.intersection(&config.preferred_seeds).count();

            return Err(AlreadySynced {

                preferred,

                synced: config.synced.len(),

            }

            .into());

        }

        let replicas = config.replicas.min(config.unsynced.len());

        let announcer = Self {

            local_node: config.local_node,

            target: Target::new(config.preferred_seeds, replicas)

                .map_err(AnnouncerError::Target)?,

            synced: config

                .synced

                .into_iter()

                .map(|nid| (nid, SyncStatus::AlreadySynced))

                .collect(),

            to_sync: config.unsynced,

        };

        match announcer.is_target_reached() {

            None => Ok(announcer),

            Some(outcome) => match outcome {

                SuccessfulOutcome::MinReplicationFactor { preferred, synced } => {

                    Err(AlreadySynced { preferred, synced }.into())

                }

                SuccessfulOutcome::MaxReplicationFactor { preferred, synced } => {

                    Err(AlreadySynced { preferred, synced }.into())

                }

            },

        }

    }

    /// Mark the `node` as synchronized, with the given `duration` it took to

    /// synchronize with.

    ///

    /// If the target for the [`Announcer`] has been reached, then a [`Success`] is

    /// returned via [`ControlFlow::Break`]. Otherwise, [`Progress`] is returned

    /// via [`ControlFlow::Continue`].

    ///

    /// The caller decides whether they wish to continue the announcement process.

    pub fn synced_with(

        &mut self,

        node: NodeId,

        duration: time::Duration,

    ) -> ControlFlow<Success, Progress> {

        if node == self.local_node {

            return ControlFlow::Continue(self.progress());

        }

        self.to_sync.remove(&node);

        self.synced.insert(node, SyncStatus::Synced { duration });

        self.finished()

    }

    /// Complete the [`Announcer`] process returning a [`AnnouncerResult`].

    ///

    /// If the target for the [`Announcer`] has been reached, then the result

    /// will be [`AnnouncerResult::Success`], otherwise, it will be

    /// [`AnnouncerResult::TimedOut`].

    pub fn timed_out(self) -> AnnouncerResult {

        match self.is_target_reached() {

            None => TimedOut {

                synced: self.synced,

                timed_out: self.to_sync,

            }

            .into(),

            Some(outcome) => Success {

                outcome,

                synced: self.synced,

            }

            .into(),

        }

    }

    /// Check if the [`Announcer`] can continue synchronizing with more nodes.

    /// If there are no more nodes, then [`NoNodes`] is returned in the

    /// [`ControlFlow::Break`], otherwise the [`Announcer`] is returned as-is in

    /// the [`ControlFlow::Continue`].

    pub fn can_continue(self) -> ControlFlow<NoNodes, Self> {

        if self.to_sync.is_empty() {

            ControlFlow::Break(NoNodes {

                synced: self.synced,

            })

        } else {

            ControlFlow::Continue(self)

        }

    }

    /// Get all the nodes to be synchronized with.

    pub fn to_sync(&self) -> BTreeSet<NodeId> {

        self.to_sync

            .iter()

            .filter(|node| *node != &self.local_node)

            .copied()

            .collect()

    }

    /// Get the [`Target`] of the [`Announcer`].

    pub fn target(&self) -> &Target {

        &self.target

    }

    /// Get the [`Progress`] of the [`Announcer`].

    pub fn progress(&self) -> Progress {

        let (synced, preferred) = self.success_counts();

        let unsynced = self.to_sync.len().saturating_sub(synced);

        Progress {

            preferred,

            synced,

            unsynced,

        }

    }

    fn finished(&self) -> ControlFlow<Success, Progress> {

        let progress = self.progress();

        self.is_target_reached()

            .map_or(ControlFlow::Continue(progress), |outcome| {

                ControlFlow::Break(Success {

                    outcome,

                    synced: self.synced.clone(),

                })

            })

    }

    fn is_target_reached(&self) -> Option<SuccessfulOutcome> {

        let (preferred, synced) = self.success_counts();

        let reached_preferred = self.target.preferred_seeds.is_empty()

            || preferred >= self.target.preferred_seeds.len();

        let replicas = self.target.replicas();

        let min = replicas.lower_bound();

        match replicas.upper_bound() {

            None => (reached_preferred && synced >= min)

                .then_some(SuccessfulOutcome::MinReplicationFactor { preferred, synced }),

            Some(max) => (reached_preferred && synced >= max)

                .then_some(SuccessfulOutcome::MaxReplicationFactor { preferred, synced }),

        }

    }

    fn success_counts(&self) -> (usize, usize) {

        self.synced

            .keys()

            .fold((0, 0), |(mut preferred, mut succeeded), nid| {

                succeeded += 1;

                if self.target.preferred_seeds.contains(nid) {

                    preferred += 1;

                }

                (preferred, succeeded)

            })

    }

}

/// Configuration of the [`Announcer`].

pub struct AnnouncerConfig {

    local_node: NodeId,

    replicas: ReplicationFactor,

    preferred_seeds: BTreeSet<NodeId>,

    synced: BTreeSet<NodeId>,

    unsynced: BTreeSet<NodeId>,

}

impl AnnouncerConfig {

    /// Setup a private network `AnnouncerConfig`, populating the

    /// [`AnnouncerConfig`]'s preferred seeds with the allowed set from the

    /// [`PrivateNetwork`].

    ///

    /// `replicas` is the target number of seeds the [`Announcer`] should reach

    /// before stopping.

    ///

    /// `local` is the [`NodeId`] of the local node, to ensure it is

    /// excluded from the [`Announcer`] process.

    pub fn private(local: NodeId, replicas: ReplicationFactor, network: PrivateNetwork) -> Self {

        AnnouncerConfig {

            local_node: local,

            replicas,

            preferred_seeds: network.allowed.clone(),

            synced: BTreeSet::new(),

            unsynced: network.allowed,

        }

    }

    /// Setup a public `AnnouncerConfig`.

    ///

    /// `preferred_seeds` is the target set of preferred seeds that [`Announcer`] should

    /// attempt to synchronize with.

    ///

    /// `synced` and `unsynced` are the set of nodes that are currently

    /// synchronized and un-synchronized with, respectively.

    ///

    /// `replicas` is the target number of seeds the [`Announcer`] should reach

    /// before stopping.

    ///

    /// `local` is the [`NodeId`] of the local node, to ensure it is

    /// excluded from the [`Announcer`] process.

    pub fn public(

        local: NodeId,

        replicas: ReplicationFactor,

        preferred_seeds: BTreeSet<NodeId>,

        synced: BTreeSet<NodeId>,

        unsynced: BTreeSet<NodeId>,

    ) -> Self {

        Self {

            local_node: local,

            replicas,

            preferred_seeds,

            synced,

            unsynced,

        }

    }

}

/// Result of running an [`Announcer`] process.

pub enum AnnouncerResult {

    /// The target of the [`Announcer`] was successfully met.

    Success(Success),

    /// The [`Announcer`] process was timed out, and all un-synchronized nodes

    /// are marked as timed out.

    ///

    /// Note that some nodes still may have synchronized.

    TimedOut(TimedOut),

    /// The [`Announcer`] ran out of nodes to synchronize with.

    ///

    /// Note that some nodes still may have synchronized.

    NoNodes(NoNodes),

}

impl AnnouncerResult {

    /// Get the synchronized nodes, regardless of the result.

    pub fn synced(&self) -> &BTreeMap<NodeId, SyncStatus> {

        match self {

            AnnouncerResult::Success(Success { synced, .. }) => synced,

            AnnouncerResult::TimedOut(TimedOut { synced, .. }) => synced,

            AnnouncerResult::NoNodes(NoNodes { synced }) => synced,

        }

    }

    /// Check if a given node is synchronized with.

    pub fn is_synced(&self, node: &NodeId) -> bool {

        let synced = self.synced();

        synced.contains_key(node)

    }

}

impl From<Success> for AnnouncerResult {

    fn from(s: Success) -> Self {

        Self::Success(s)

    }

}

impl From<TimedOut> for AnnouncerResult {

    fn from(to: TimedOut) -> Self {

        Self::TimedOut(to)

    }

}

impl From<NoNodes> for AnnouncerResult {

    fn from(no: NoNodes) -> Self {

        Self::NoNodes(no)

    }

}

pub struct NoNodes {

    synced: BTreeMap<NodeId, SyncStatus>,

}

impl NoNodes {

    /// Get the set of synchronized nodes

    pub fn synced(&self) -> &BTreeMap<NodeId, SyncStatus> {

        &self.synced

    }

}

pub struct TimedOut {

    synced: BTreeMap<NodeId, SyncStatus>,

    timed_out: BTreeSet<NodeId>,

}

impl TimedOut {

    /// Get the set of synchronized nodes

    pub fn synced(&self) -> &BTreeMap<NodeId, SyncStatus> {

        &self.synced

    }

    /// Get the set of timed out nodes

    pub fn timed_out(&self) -> &BTreeSet<NodeId> {

        &self.timed_out

    }

}

pub struct Success {

    outcome: SuccessfulOutcome,

    synced: BTreeMap<NodeId, SyncStatus>,

}

impl Success {

    /// Get the [`SuccessfulOutcome`] of the success.

    pub fn outcome(&self) -> SuccessfulOutcome {

        self.outcome

    }

    /// Get the set of synchronized nodes.

    pub fn synced(&self) -> &BTreeMap<NodeId, SyncStatus> {

        &self.synced

    }

}

/// Error in constructing the [`Announcer`].

pub enum AnnouncerError {

    /// Both sets of already synchronized and un-synchronized nodes were empty

    /// of nodes were empty.

    AlreadySynced(AlreadySynced),

    /// No more nodes are available for synchronizing with.

    NoSeeds,

    /// The target could not be constructed.

    Target(TargetError),

}

impl From<AlreadySynced> for AnnouncerError {

    fn from(value: AlreadySynced) -> Self {

        Self::AlreadySynced(value)

    }

}

pub struct AlreadySynced {

    preferred: usize,

    synced: usize,

}

impl AlreadySynced {

    /// Get the number of preferred nodes that are already synchronized.

    pub fn preferred(&self) -> usize {

        self.preferred

    }

    /// Get the total number of nodes that are already synchronized.

    pub fn synced(&self) -> usize {

        self.synced

    }

}

/// The status of the synchronized node.

#[derive(Clone, Copy, Debug)]

pub enum SyncStatus {

    /// The node was already synchronized before starting the [`Announcer`]

    /// process.

    AlreadySynced,

    /// The node was synchronized as part of the [`Announcer`] process, marking

    /// the amount of time that passed to synchronize with the node.

    Synced { duration: time::Duration },

}

/// Progress of the [`Announcer`] process.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub struct Progress {

    preferred: usize,

    synced: usize,

    unsynced: usize,

}

impl Progress {

    /// The number of preferred seeds that are synchronized.

    pub fn preferred(&self) -> usize {

        self.preferred

    }

    /// The number of seeds that are synchronized.

    pub fn synced(&self) -> usize {

        self.synced

    }

    /// The number of seeds that are un-synchronized.

    pub fn unsynced(&self) -> usize {

        self.unsynced

    }

}

#[derive(Debug, thiserror::Error)]

#[non_exhaustive]

#[error("a minimum number of replicas or set of preferred seeds must be provided")]

pub struct TargetError;

/// The target for the [`Announcer`] to reach.

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct Target {

    preferred_seeds: BTreeSet<NodeId>,

    replicas: ReplicationFactor,

}

impl Target {

    pub fn new(

        preferred_seeds: BTreeSet<NodeId>,

        replicas: ReplicationFactor,

    ) -> Result<Self, TargetError> {

        if replicas.lower_bound() == 0 && preferred_seeds.is_empty() {

            Err(TargetError)

        } else {

            Ok(Self {

                preferred_seeds,

                replicas,

            })

        }

    }

    /// Get the set of preferred seeds that are trying to be synchronized with.

    pub fn preferred_seeds(&self) -> &BTreeSet<NodeId> {

        &self.preferred_seeds

    }

    /// Get the number of replicas that is trying to be reached.

    pub fn replicas(&self) -> &ReplicationFactor {

        &self.replicas

    }

}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum SuccessfulOutcome {

    MinReplicationFactor { preferred: usize, synced: usize },

    MaxReplicationFactor { preferred: usize, synced: usize },

}