}

fn fetch<W: Write, H: Handle>(id: Id, mut writer: W, handle: &H) -> Result<(), DrainError> {

        Err(e) => {

            return Err(DrainError::Client(e));

        }

    }

    /// Get a project from storage, using the local node's key.

        self.storage.get(&self.node_id(), proj)

    }

        &mut self.reactor

    }

        Lookup {

            local: self.storage.get(&self.node_id(), id).unwrap(),

            remote: self

                .routing

                .map_or(vec![], |r| r.iter().cloned().collect()),

        }

    }

                };

                log::debug!("Found {} seeds for {}", seeds.len(), id);

                    Ok(repo) => repo,

                    Err(err) => {

                        log::error!("Error opening repo for {}: {}", id, err);

            }

            Command::AnnounceRefs(id) => {

                let node = self.node_id();

                let remote = repo.remote(&node).unwrap();

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

                let refs = remote.refs.into();

                    // TODO: Check that we're tracking this user as well.

                    if self.config.is_tracking(&message.id) {

                        // TODO: Check refs to see if we should try to fetch or not.

                        let is_updated = !updated.is_empty();

                        self.reactor.event(Event::RefsFetched {

                            from: git.clone(),

                            updated,

                        });

        for proj_id in inventory {

            let inventory = self

                .routing

                .or_insert_with(|| HashSet::with_hasher(self.rng.clone().into()));

            // TODO: Fire an event on routing update.

            if inventory.insert(from) && self.config.is_tracking(proj_id) {

            }

        }

    }

    /// Relay a message to interested peers.

    pub fn relay<'a>(&mut self, msg: Message, peers: impl IntoIterator<Item = &'a Session>) {

        if let Message::RefsAnnouncement { message, .. } = &msg {

            let peers = peers.into_iter().filter(|p| {

                if let Some(subscribe) = &p.subscribe {

                    subscribe.filter.contains(&id)

    let proj_id: identity::Id = test::arbitrary::gen(1);

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

    let policy_change = receiver

        .recv()

        .map_err(client::handle::Error::from)

    assert!(alice.config().is_tracking(&proj_id));

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

    let policy_change = receiver

        .recv()

        .map_err(client::handle::Error::from)

    // Bob tracks Alice's project.

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

    // Eve tracks Alice's project.

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

    // Neither of them have it in the beginning.

    // Alice announces her refs.

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

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

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

    assert!(eve

        .storage()

        .unwrap()

        .is_some());

    assert!(bob

        .storage()

        .unwrap()

        .is_some());

    assert_matches!(

        ] {

            for id in inv.keys() {

                routing

                    .or_insert_with(|| HashSet::with_hasher(rng.clone().into()))

                    .insert(*peer);

            }

        for (proj_id, remotes) in &routing {

            for peer in peers.values() {

                if lookup.local.is_some() {

                        .expect("There are no errors querying storage")

                        .expect("The project is available locally");

                } else {

                    for remote in &lookup.remote {

                        peers[remote]

                            .expect("There are no errors querying storage")

                            .expect("The project is available remotely");

                    }

    let output = radicle::git::run(&cwd, &["push", "rad"])?;

    println!("{}", output);

    let sigrefs = profile.storage.sign_refs(&project, &profile.signer)?;

    profile.node()?.announce_refs(&id)?;

        //

        let (doc_oid, doc) = self.encode()?;

        let id = Id::from(doc_oid);

        let tree = git::write_tree(*PATH, doc.as_slice(), repo.raw())?;

        let oid = Doc::commit(remote, &tree, msg, &[], repo.raw())?;

    InvalidSignature(PublicKey, crypto::Error),

    #[error("quorum not reached: {0} signatures for a threshold of {1}")]

    QuorumNotReached(usize, usize),

}

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

    pub fn load<R: ReadRepository>(

        remote: &RemoteId,

        repo: &R,

        if let Some(head) = Doc::<Untrusted>::head(remote, repo)? {

            let mut history = repo.revwalk(head)?.collect::<Vec<_>>();

                current = blob.id().into();

            }

                root,

                head,

                current,

                revision,

                doc: trusted,

                signatures: signatures.into_iter().collect(),

        }

    }

}

            fixtures::project(tempdir.path().join("copy"), &storage, &alice).unwrap();

        // Bob and Eve fork the project from Alice.

        // TODO: In some cases we want to get the repo and the project, but don't

        // want to have to create a repository object twice. Perhaps there should

        // be a way of getting a project from a repo.

        // Make a change to the description and sign it.

        proj.payload.description += "!";

        let identity: Identity<Id> = Identity::load(alice.public_key(), &repo)

            .unwrap()

            .unwrap();

        assert_eq!(identity.signatures.len(), 2);

        assert_eq!(identity.head, head);

        assert_eq!(identity.doc, proj);

        assert_eq!(proj.description, "Acme's repository!?");

    }

    Multibase(#[from] multibase::Error),

}

pub struct Id(git::Oid);

impl fmt::Display for Id {

/// Create a local tree for an existing project, from an existing remote.

pub fn fork_remote<G: Signer, S: storage::WriteStorage>(

    remote: &RemoteId,

    signer: G,

    storage: S,

    let me = signer.public_key();

    let project = storage

        .get(remote, proj)?

    let repository = storage.repository(proj)?;

    let raw = repository.raw();

}

pub fn fork<G: Signer, S: storage::WriteStorage>(

    signer: &G,

    storage: &S,

) -> Result<(), ForkError> {

}

pub fn clone<P: AsRef<Path>, G: Signer, S: storage::WriteStorage, H: node::Handle>(

    path: P,

    signer: &G,

    storage: &S,

    handle: &H,

) -> Result<git2::Repository, CloneError> {

    let _ = fork(proj, signer, storage)?;

    let working = checkout(proj, signer.public_key(), path, storage)?;

}

pub fn clone_url<P: AsRef<Path>, G: Signer, S: storage::WriteStorage>(

    url: &git::Url,

    path: P,

    signer: &G,

/// Checkout a project from storage as a working copy.

/// This effectively does a `git-clone` from storage.

pub fn checkout<P: AsRef<Path>, S: storage::ReadStorage>(

    remote: &RemoteId,

    path: P,

    storage: &S,

    // TODO: Look into sharing object databases.

    let project = storage

        .get(remote, proj)?

    let mut opts = git2::RepositoryInitOptions::new();

    opts.no_reinit(true).description(&project.description);

    let repo = git2::Repository::init_opts(path, &opts)?;

    let default_branch = project.default_branch.as_str();

    // Configure and fetch all refs from remote.

    git::configure_remote(&repo, REMOTE_NAME, remote, &url)?.fetch::<&str>(&[], None, None)?;

        )

        .unwrap();

        let remotes: HashMap<_, _> = storage

            .unwrap()

            .remotes()

            .unwrap()

        .unwrap();

        // Bob forks it and creates a checkout.

        assert_eq!(

            bob_remote.refs.get(&refname!("master")),

        )

        .unwrap();

        assert_eq!(

            copy.head().unwrap().target(),

pub trait ReadStorage {

    fn path(&self) -> &Path;

    fn url(&self, proj: &Id) -> Url;

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

}

pub trait WriteStorage: ReadStorage {

    type Repository: WriteRepository;

    fn sign_refs<G: Signer>(

        &self,

        repository: &Self::Repository,

        signer: G,

    ) -> Result<SignedRefs<Verified>, Error>;

}

pub trait ReadRepository {

        self.deref().inventory()

    }

        self.deref().get(remote, proj)

    }

}

{

    type Repository = S::Repository;

        self.deref().repository(proj)

    }

        self.deref().sign_refs(repository, signer)

    }

        self.deref().fetch(proj_id, remote)

    }

}

        }

    }

        // TODO: Don't create a repo here if it doesn't exist?

        // Perhaps for checking we could have a `contains` method?

        self.repository(proj)?

impl WriteStorage for Storage {

    type Repository = Repository;

    }

    fn sign_refs<G: Signer>(

        repository.sign_refs(signer)

    }

        let mut repo = self.repository(proj_id).unwrap();

        let mut path = remote.path.clone();

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

        for proj in self.projects()? {

            for r in repo.raw().references()? {

                let r = r?;

        Ok(())

    }

        Identity::load(remote, self)

    }

        })

        .unwrap();

        let remotes = project.remotes().unwrap();

        // Strip the remote refs of sigrefs so we can compare them.

        let alice = fixtures::storage(tmp.path().join("alice"), alice_signer).unwrap();

        let bob = Storage::open(tmp.path().join("bob")).unwrap();

        let inventory = alice.inventory().unwrap();

        let repo = alice.repository(proj).unwrap();

        let remotes = repo.remotes().unwrap().collect::<Vec<_>>();

        let refname = git::refname!("heads/master");

            .unwrap()

            .fetch(&git::Url {

                scheme: git_url::Scheme::File,

                    .to_string_lossy()

                    .into_owned()

                    .into(),

        };

        // Have Bob fetch Alice's refs.

        // Three refs are created: the branch, the signature and the id.

        assert_eq!(updates.len(), 3);

        let alice_head = proj_repo.find_commit(alice_head).unwrap();

        let alice_head = git::commit(&proj_repo, &alice_head, &refname, "Making changes", "Alice")

            .unwrap()

        alice.sign_refs(&alice_proj_storage, &alice_signer).unwrap();

        // Have Bob fetch Alice's new commit.

        // The branch and signature refs are updated.

        assert_matches!(

            updates.as_slice(),

        );

        // Bob's storage is updated.

        let bob_master = bob_repo.reference(alice_id, &refname).unwrap().unwrap();

        assert_eq!(bob_master.target().unwrap(), alice_head);

        let storage = Storage::open(tmp.path()).unwrap();

        let proj_id = arbitrary::gen::<Id>(1);

        let alice = *signer.public_key();

        let backend = &project.backend;

        let sig = git2::Signature::now(&alice.to_string(), "anonymous@radicle.xyz").unwrap();

        let head = git::initial_commit(backend, &sig).unwrap();

        }

    }

    }

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

impl WriteStorage for MockStorage {

    type Repository = MockRepository;

        Ok(MockRepository {})

    }

        todo!()

    }

        Ok(vec![])

    }

}