reporting.completion.clone(),

    );

        Ok(result) => {

            spinner.message(format!(

                "Synced with {} seed(s)",

    // 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));

            }

        },

        Command::AnnounceRefs { rid } => {

            let refs = handle.announce_refs(rid)?;

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

        }

        Command::AnnounceInventory => {

            if let Err(e) = handle.announce_inventory() {

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

        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();

            writeln!(

                &mut stream,

                "{}",

                })

                .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) => {

                    }

                };

                        }

                    Err(err) => {

                        error!(target: "service", "Error announcing refs: {err}");

                    }

                } else {

                    // Finally, announce the refs. This is useful for nodes to know what we've synced,

                    // beyond just knowing that we have added an item to our inventory.

                        error!(target: "service", "Failed to announce new refs: {e}");

                    }

                }

    }

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

        // Update refs database with our signed refs branches.

        // This isn't strictly necessary for now, as we only use the database for fetches, and

        // we don't fetch our own refs that are announced, but it's for good measure.

            self.emitter.emit(Event::LocalRefsAnnounced {

                rid,

                timestamp,

            });

            if let Err(e) = self.database_mut().refs_mut().set(

                );

            }

        }

    }

    /// Announce local refs for given repo.

        rid: RepoId,

        doc: Doc,

        remotes: impl IntoIterator<Item = NodeId>,

    ) -> Result<(Vec<RefsAt>, Timestamp), Error> {

        let (ann, refs) = self.refs_announcement_for(rid, remotes)?;

        let timestamp = ann.timestamp();

        // Update our sync status for our own refs. This is useful for determining if refs were

        // updated while the node was stopped.

            info!(

                target: "service",

            );

            // Update our local node's sync status to mark the refs as announced.

                error!(target: "service", "Error updating sync status for local node: {e}");

            } else {

                debug!(target: "service", "Saved local sync status for {rid}..");

### Added

### Changed

### Deprecated

### Removed

### Security

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

    /// Unfollow the given peer.

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

    /// 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)??;

//! Commands sent to the node via the control socket, and auxiliary types, as

//! well as their results (responses on the socket).

use std::io;

use std::time;

use serde::{Deserialize, Serialize};

use serde_json as json;

use crate::identity::RepoId;

use super::events::Event;

pub enum Command {

    /// Announce repository references for given repository to peers.

    #[serde(rename_all = "camelCase")]

    AnnounceRefs { rid: RepoId },

    /// Announce local repositories to peers.

    #[serde(rename_all = "camelCase")]

    AnnounceInventory,

    }

}

/// Verified [`SignedRefs`] that keeps track of their content address

/// [`Oid`].

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