reporting.completion.clone(),

    );

        spinner.message(format!(

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

            term::format::node_id_human_compact(node),

    // announcement, otherwise Alice will consider it stale.

    thread::sleep(time::Duration::from_millis(3));

    // Wait for Alice to fetch the issue refs.

    events

                return Err(CommandError::Runtime(e));

            }

        },

            CommandResult::Okay(refs).to_writer(writer)?;

        }

#[cfg(test)]

mod tests {

    use std::io::prelude::*;

    use std::thread;

        let socket = tmp.path().join("alice.sock");

        let rids = test::arbitrary::set::<RepoId>(1..3);

        let listener = Listener::bind(&socket).unwrap();

        thread::spawn({

            let handle = handle.clone();

                &mut stream,

                "{}",

                json::to_string(&Command::AnnounceRefs {

                })

                .unwrap()

            )

        }

        for rid in &rids {

        }

    }

use std::net;

use std::sync::atomic::{AtomicBool, Ordering};

use std::sync::Arc;

use winpipe::WinStream as Stream;

use crossbeam_channel as chan;

use radicle::node::events::{Event, Events};

use radicle::node::policy;

use radicle::node::{Config, NodeId};

        receiver.recv().map_err(Error::from)

    }

        let (sender, receiver) = chan::bounded(1);

        receiver.recv().map_err(Error::from)

    }

use std::sync::{Arc, Mutex};

use std::time;

use radicle::git;

use radicle::storage::refs::RefsAt;

#[derive(Default, Clone)]

pub struct Handle {

    pub seeding: Arc<Mutex<HashSet<RepoId>>>,

    pub following: Arc<Mutex<HashSet<NodeId>>>,

}

        Ok(self.following.lock().unwrap().remove(&id))

    }

        Ok(RefsAt {

            remote: self.nid()?,

        Title::new("Concurrent fetches").unwrap(),

        "Concurrent fetches are harshing my vibes",

    );

    alice_events

        .wait(

            |e| matches!(e, Event::RefsAnnounced { .. }).then_some(()),

    log::debug!(target: "test", "Bob creating his issue..");

    bob.issue(acme, Title::new("Bob's issue").unwrap(), "[..]");

    log::debug!(target: "test", "Waiting for seed to fetch Bob's refs from Bob..");

    seed.has_remote_of(&acme, &bob.id); // Seed fetches Bob's refs.

/// Commands sent to the service by the operator.

pub enum Command {

    /// Announce local repositories to peers.

    AnnounceInventory,

    /// Add repository to local inventory.

impl fmt::Debug for Command {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            Self::AnnounceInventory => write!(f, "AnnounceInventory"),

            Self::AddInventory(rid, _) => write!(f, "AddInventory({rid})"),

            Self::Connect(id, addr, opts) => write!(f, "Connect({id}, {addr}, {opts:?})"),

                    .expect("Service::command: error unfollowing node");

                resp.send(updated).ok();

            }

                let doc = match self.storage.get(id) {

                    Ok(Some(doc)) => doc,

                    Ok(None) => {

                    }

                };

                        &[refs] => {

                            resp.send(refs).ok();

                        }

    }

    /// Announce our own refs for the given repo.

        let (refs, timestamp) = self.announce_refs(rid, doc, [self.node_id()])?;

        // Update refs database with our signed refs branches.

                );

            }

        }

    }

    /// Announce local refs for given repo.

#[serde(rename_all = "camelCase", tag = "command")]

#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]

pub enum Command {

    #[serde(rename_all = "camelCase")]

    /// Announce local repositories to peers.

    #[serde(rename_all = "camelCase")]

    /// Update node's inventory.

    AddInventory { rid: RepoId },

    Config,

    /// Get the node's listen addresses.

    /// Unfollow the given peer.

    fn unfollow(&mut self, id: NodeId) -> Result<bool, Self::Error>;

    /// Notify the service that a project has been updated, and announce local refs.

    /// Announce local inventory.

    fn announce_inventory(&mut self) -> Result<(), Self::Error>;

    /// Notify the service that our inventory was updated with the given repository.

    pub fn announce(

        &mut self,

        rid: RepoId,

        timeout: time::Duration,

        mut announcer: sync::Announcer,

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

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

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

        let started = time::Instant::now();

        Ok(response.updated)

    }

        let refs: RefsAt = self

            .next()

            .ok_or(Error::EmptyResponse)??;