let events = node.subscribe(time::Duration::from_secs(3))?;

    let sessions = node.sessions()?;

    spinner.message("Announcing..");

    if !sessions.iter().any(|s| s.is_connected()) {

    let peers = node.sessions()?.iter().filter(|s| s.is_connected()).count();

    let spinner = term::spinner(format!("Announcing inventory to {peers} peers.."));

    node.announce_inventory()?;

    spinner.finish();

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

pub enum Error {

    }

}

impl<T, const N: usize> From<BoundedVec<T, N>> for Vec<T> {

    fn from(value: BoundedVec<T, N>) -> Self {

        value.v

            }

            CommandResult::ok().to_writer(writer).ok();

        }

            Ok(result) => {

                CommandResult::updated(result).to_writer(writer)?;

            }

            .map_err(Error::from)

    }

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

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

    }

pub mod session;

use std::collections::hash_map::Entry;

use std::ops::{Deref, DerefMut};

use std::sync::Arc;

use std::{fmt, net, time};

use radicle::node::seed::Store as _;

use radicle::node::{ConnectOptions, Penalty, Severity};

use radicle::storage::refs::SignedRefsUpdate;

use crate::crypto;

use crate::crypto::{Signer, Verified};

    AnnounceRefs(RepoId, chan::Sender<RefsAt>),

    /// Announce local repositories to peers.

    AnnounceInventory,

    /// Connect to node with the given address.

    Connect(NodeId, Address, ConnectOptions),

    /// Disconnect from node.

        match self {

            Self::AnnounceRefs(id, _) => write!(f, "AnnounceRefs({id})"),

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

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

            Self::Disconnect(id) => write!(f, "Disconnect({id})"),

            Self::Config(_) => write!(f, "Config"),

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

                }

            }

                let synced = self

                    .sync_inventory()

                    .expect("Service::command: error syncing inventory");

            Ok(fetch::FetchResult {

                updated,

                namespaces,

            }) => {

                debug!(target: "service", "Fetched {rid} from {remote} successfully");

                FetchResult::Success {

                    updated,

                    namespaces,

                }

            }

            Err(err) => {

                FetchResult::Success {

                    updated,

                    namespaces,

                } if !updated.is_empty() => {

                    if let Err(e) = self.announce_refs(rid, namespaces.iter().cloned()) {

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

                _ => debug!(target: "service", "Nothing to announce, no refs were updated.."),

            }

        }

        // We can now try to dequeue another fetch.

        self.dequeue_fetch();

                    inventory: message.inventory.to_vec(),

                    timestamp: message.timestamp,

                });

                    Ok(synced) => {

                        if synced.is_empty() {

                            trace!(target: "service", "No routes updated by inventory announcement from {announcer}");

                // Other than crashing the node completely, there's nothing we can do

                // here besides returning an empty inventory and logging an error.

                error!(target: "service", "Error getting local inventory for initial messages: {e}");

            }

        };

    /// Update our routing table with our local node's inventory.

    fn sync_inventory(&mut self) -> Result<SyncedRouting, Error> {

        let inventory = self.storage.inventory()?;

        Ok(result)

    }

    /// given inventory.

    fn sync_routing(

        &mut self,

        from: NodeId,

        timestamp: Timestamp,

    ) -> Result<SyncedRouting, Error> {

        let mut synced = SyncedRouting::default();

            match result {

                InsertResult::SeedAdded => {

                    info!(target: "service", "Routing table updated for {rid} with seed {from}");

    ////////////////////////////////////////////////////////////////////////////

    /// Announce our inventory to all connected peers.

        let time = if self.clock > self.last_announce {

            self.clock.as_millis()

        } else if self.last_announce - self.clock < LocalDuration::from_secs(1) {

    }

}

        error!(

            target: "service",

            "inventory announcement limit ({}) exceeded, other nodes will see only some of your projects",

        Ok(FetchResult::Success {

            updated: vec![],

            namespaces: HashSet::new(),

        })

    }

        Ok(())

    }

        unimplemented!()

    }

                                        Namespaces::Followed(hs) => hs,

                                        Namespaces::All => HashSet::new(),

                                    },

                                })),

                            ),

                        },

            },

        )

    };

    alice.seed(&bob_inv[0], policy::Scope::All).unwrap();

    alice.seed(&bob_inv[1], policy::Scope::All).unwrap();

        )

    };

    let bob_inv = bob.storage().inventory().unwrap();

    alice.seed(&rid, policy::Scope::Followed).unwrap();

    alice.connect_to(&bob);

    // Alice receives Bob's refs.

    // Alice fetches Bob's refs as this is a new repo.

    assert_matches!(alice.outbox().next(), Some(Io::Fetch { .. }));

                oid,

            }],

            namespaces: [carol.id()].into_iter().collect(),

        }),

    );

    // Now the 1st fetch is done, but the 2nd and 3rd fetches are redundant.

    // We now expect Eve to fetch Alice's project from Alice.

    // Then we expect Bob to fetch Alice's project from Eve.

    alice.elapse(LocalDuration::from_secs(1)); // Make sure our announcement is fresh.

    sim.run_while([&mut alice, &mut bob, &mut eve], |s| !s.is_settled());

    pub updated: Vec<RefUpdate>,

    /// The set of remote namespaces that were updated.

    pub namespaces: HashSet<PublicKey>,

}

pub enum Handle {

        remote: PublicKey,

        refs_at: Option<Vec<SignedRefsUpdate>>,

    ) -> Result<FetchResult, error::Fetch> {

            Self::Clone { mut handle, tmp } => {

                log::debug!(target: "worker", "{} cloning from {remote}", handle.local());

                let result = radicle_fetch::clone(&mut handle, limit, remote)?;

                mv(tmp, storage, &rid)?;

            }

            Self::Pull {

                mut handle,

            } => {

                log::debug!(target: "worker", "{} pulling from {remote}", handle.local());

                let result = radicle_fetch::pull(&mut handle, limit, remote, refs_at)?;

            }

        };

                Ok(FetchResult {

                    updated: applied.updated,

                    namespaces: remotes.into_iter().collect(),

                })

            }

        }

    #[serde(rename_all = "camelCase")]

    AnnounceInventory,

    /// Get the current node condiguration.

    Config,

    Success {

        updated: Vec<RefUpdate>,

        namespaces: HashSet<NodeId>,

    },

    // TODO: Create enum for reason.

    Failed {

            Self::Success {

                updated,

                namespaces,

            } => Some((updated, namespaces)),

            _ => None,

        }

    }

}

        match value {

                updated,

                namespaces,

            },

            Err(err) => Self::Failed {

                reason: err.to_string(),

            if let FetchResult::Success {

                updated,

                namespaces,

            } = r

            {

                Some((nid, updated.as_slice(), namespaces.clone()))

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

    /// Announce local inventory.

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

    /// Ask the service to shutdown.

    fn shutdown(self) -> Result<(), Self::Error>;

    /// Query the peer session state.

        Ok(())

    }

        let response = line.next().ok_or(Error::EmptyResponse {})??;

        Ok(response.updated)

pub mod git;

pub mod refs;

use std::ops::Deref;

use std::path::{Path, PathBuf};

use std::{fmt, io};

use self::refs::SignedRefs;

pub type BranchName = git::RefString;

/// Describes one or more namespaces.

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

    /// Get the inventory of repositories hosted under this storage.

    /// This function should typically only return public repositories.

    fn inventory(&self) -> Result<Inventory, Error>;

    /// Refresh storage inventory.

    fn refresh(&self) -> Result<(), Error>;

    /// Open or create a read-only repository.

        self.deref().path_of(rid)

    }

    fn contains(&self, rid: &RepoId) -> Result<bool, RepositoryError> {

        self.deref().contains(rid)

    }

pub struct Storage {

    path: PathBuf,

    info: UserInfo,

}

impl ReadStorage for Storage {

        }

    }

    fn refresh(&self) -> Result<(), Error> {

        let repos = self.repositories()?;

        let rids = repos

        let storage = Self {

            path,

            info,

        };

        storage.refresh()?;

use std::convert::Infallible;

use std::io;

use std::path::{Path, PathBuf};

    }

    fn inventory(&self) -> Result<Inventory, Error> {

    }

    fn refresh(&self) -> Result<(), Error> {

        Ok(())

    }