pub fn fetch(rid: Id, node: &mut Node) -> Result<FetchResults, node::Error> {

    // Get seeds. This consults the local routing table only.

    let mut results = FetchResults::default();

    if seeds.has_connections() {

                resp.send(untracked).ok();

            }

            Command::AnnounceRefs(id) => {

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

                }

            }

    pub fn fetched(

        &mut self,

        rid: Id,

        remote: NodeId,

    ) {

        let result = match result {

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

                for update in &updated {

                    updated: updated.clone(),

                });

            }

            Err(err) => {

                let reason = err.to_string();

            // because the user might want to announce his fork, once he has created one,

            // or may choose to not announce anything.

            match result {

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

                    }

                }

    }

    /// Announce local refs for given id.

        let repo = self.storage.repository(rid)?;

        let peers = self.sessions.connected().map(|(_, p)| p);

        let timestamp = self.time();

        let mut refs = BoundedVec::<_, REF_REMOTE_LIMIT>::new();

            }

        }

        for rid in missing {

            match self.seeds(&rid) {

                    if seeds.has_connections() {

                        for seed in seeds.connected() {

                            self.fetch(rid, seed);

use crate::runtime::HandleError;

use crate::service::NodeId;

use crate::service::{self, tracking};

#[derive(Default, Clone)]

pub struct Handle {

    }

    fn fetch(&mut self, _id: Id, _from: NodeId) -> Result<FetchResult, Self::Error> {

    }

    fn track_repo(&mut self, id: Id, _scope: tracking::Scope) -> Result<bool, Self::Error> {

//! A simple P2P network simulator. Acts as the _reactor_, but without doing any I/O.

#![allow(clippy::collapsible_if)]

#![allow(dead_code)]

use std::marker::PhantomData;

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

use std::rc::Rc;

    /// Fetch completed for a node.

    Fetched(

        Id,

        NodeId,

    ),

    /// Used to advance the state machine after some wall time has passed.

    Wake,

            Input::Wake => {

                write!(f, "{}: Tock", self.node)

            }

                write!(f, "{} <<~ {} ({}): Fetched", self.node, nid, rid)

            }

        }

                            p.received_message(id, msg);

                        }

                    }

                        let result = Rc::try_unwrap(result).unwrap();

                        let mut repo = match p.storage().repository_mut(rid) {

                            Ok(repo) => repo,

                            Err(e) if e.is_not_found() => p.storage().create(rid).unwrap(),

                            Err(e) => panic!("Failed to open repository: {e}"),

                        };

                    }

                }

                while let Some(o) = p.next() {

                            remote,

                            input: Input::Fetched(

                                rid,

                                remote,

                                Rc::new(Err(FetchError::Io(io::ErrorKind::Other.into()))),

                            ),

                        Scheduled {

                            node,

                            remote,

                        },

                    );

                }

use crate::service::*;

use crate::storage::git::transport::{local, remote};

use crate::storage::git::Storage;

use crate::storage::ReadStorage;

use crate::test::arbitrary;

use crate::test::assert_matches;

    alice.elapse(KEEP_ALIVE_DELTA);

    // Finish the 1st fetch.

    // Now the 1st fetch is done, the 2nd fetch is dequeued.

    assert_matches!(alice.fetches().next(), Some((rid, _, _)) if rid == rid2);

    // ... but not the third.

    assert_matches!(alice.fetches().next(), None);

    // Finish the 2nd fetch.

    // Now the 2nd fetch is done, the 3rd fetch is dequeued.

    assert_matches!(alice.fetches().next(), Some((rid, _, _)) if rid == rid3);

}

    assert!(result.is_success());

    let updated = match result {

        FetchResult::Failed { reason } => {

            panic!("Fetch failed from {}: {reason}", bob.id);

        }

    // Fetch shouldn't prune any of our own refs.

    let result = alice.handle.fetch(acme, bob.id).unwrap();

    assert_eq!(updated, vec![]);

    let after = alice

    // Fetch again! This time, everything's up to date.

    let result = alice.handle.fetch(acme, bob.id).unwrap();

}

#[test]

        // Only call into the service if we initiated this fetch.

        match task.result {

            }

            FetchResult::Responder { .. } => {

                // We don't do anything with upload results for now.

mod fetch;

mod tunnel;

use std::io::{prelude::*, BufReader};

use std::ops::ControlFlow;

use std::thread::JoinHandle;

    Initiator {

        /// Repo fetched.

        rid: Id,

    },

    Responder {

        /// Upload result.

                log::debug!(target: "worker", "Worker processing outgoing fetch for {}", rid);

                let result = self.fetch(rid, remote, stream, &namespaces, channels);

            }

            FetchRequest::Responder { remote } => {

                log::debug!(target: "worker", "Worker processing incoming fetch..");

        stream: StreamId,

        namespaces: &Namespaces,

        mut channels: Channels,

        let staging = fetch::StagingPhaseInitial::new(&self.storage, rid, namespaces.clone())?;

        match self._fetch(

            &staging.repo,

use radicle::crypto::{PublicKey, Unverified, Verified};

use radicle::git::url;

use radicle::storage::git::Repository;

use radicle::storage::refs::{SignedRefs, IDENTITY_BRANCH};

use radicle::storage::{Namespaces, RefUpdate, Remote, RemoteId};

    ///

    /// All references that were updated are returned as a

    /// [`RefUpdate`].

        let verifications = self.verify();

        let production = match &self.repo {

            StagedRepository::Cloning(repo) => self.production.create(repo.id)?,

        let mut updates = Vec::new();

        let callbacks = ref_updates(&mut updates);

            let specs = verifications

                .into_iter()

                .flat_map(|(remote, verified)| match verified {

            opts.prune(git::raw::FetchPrune::Off);

            remote.fetch(&specs, Some(&mut opts), None)?;

        let head = production.set_head()?;

        log::debug!(target: "worker", "Head for {} set to {head}", production.id);

        let head = production.set_identity_head()?;

        log::debug!(target: "worker", "'refs/rad/id' for {} set to {head}", production.id);

    }

    fn remotes(&self) -> impl Iterator<Item = Remote> + '_ {

    fn verify(&self) -> BTreeMap<RemoteId, VerifiedRemote> {

        self.trusted

            .iter()

            .map(|remote| {

                            reason: e.to_string(),

                        },

            })

            .collect()

    }

pub mod routing;

pub mod tracking;

use std::io::{BufRead, BufReader};

use std::ops::Deref;

use std::os::unix::net::UnixStream;

#[serde(tag = "state", content = "id")]

pub enum Seed {

    Disconnected(NodeId),

    Connected(NodeId),

}

        self.0.insert(seed);

    }

        self.0.iter().filter_map(|s| match s {

            Seed::Connected(node) => Some(node),

        })

    }

        self.0.iter().filter_map(|s| match s {

            Seed::Disconnected(node) => Some(node),

        })

    }

    pub fn has_connections(&self) -> bool {

        self.0.iter().any(|s| match s {

            Seed::Connected(_) => true,

        })

    }

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

        self.0.contains(&Seed::Disconnected(*node))

    }

}

#[derive(Debug, Serialize, Deserialize)]

#[serde(tag = "status", rename_all = "kebab-case")]

pub enum FetchResult {

    // TODO: Create enum for reason.

}

impl FetchResult {

        matches!(self, FetchResult::Success { .. })

    }

        match self {

            _ => None,

        }

    }

}

        match value {

            Err(err) => Self::Failed {

                reason: err.to_string(),

            },

    }

    /// Iterate over successful fetches.

        self.0.iter().filter_map(|(nid, r)| {

            } else {

                None

            }