use nakamoto_net::Waker;

use thiserror::Error;

use crate::protocol;

use crate::protocol::{CommandError, FetchLookup};

impl<W: Waker> traits::Handle for Handle<W> {

    /// Retrieve or update the given project from the network.

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

        self.commands.send(protocol::Command::Fetch(id, sender))?;

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

    }

    /// Start tracking the given project. Doesn't do anything if the project is already tracked.

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

        self.commands.send(protocol::Command::Track(id, sender))?;

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

    }

    /// Untrack the given project and delete it from storage.

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

        self.commands.send(protocol::Command::Untrack(id, sender))?;

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

    }

    /// Notify the client that a project has been updated.

        self.command(protocol::Command::AnnounceRefsUpdate(id))

    }

    pub trait Handle {

        /// Retrieve or update the project from network.

        /// Start tracking the given project. Doesn't do anything if the project is already

        /// tracked.

        /// Untrack the given project and delete it from storage.

        /// Notify the client that a project has been updated.

        /// Send a command to the command channel, and wake up the event loop.

        fn command(&self, cmd: protocol::Command) -> Result<(), Error>;

        /// Ask the client to shutdown.

use crate::client;

use crate::client::handle::traits::Handle;

use crate::protocol::FetchLookup;

use crate::protocol::FetchResult;

    Ok(())

}

    match handle.fetch(id.clone()) {

        Err(e) => {

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

    use std::{net, thread};

    use super::*;

    use crate::test;

    #[test]

        let tmp = tempfile::tempdir().unwrap();

        let handle = test::handle::Handle::default();

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

        thread::spawn({

            let socket = socket.clone();

use git_ref_format as format;

use crate::collections::HashMap;

use crate::storage::refs::Refs;

use crate::storage::RemoteId;

    let refs = remote.list()?;

    for r in refs {

        let entry = remotes.entry(id).or_insert_with(Refs::default);

        entry.insert(refname, r.oid().into());

use crate::serde_ext;

use crate::storage::Remotes;

#[derive(Error, Debug)]

    #[error("invalid digest: {0}")]

    InvalidDigest(#[from] hash::DecodeError),

}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

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

        write!(f, "{}", self.encode())

    }

}

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

        write!(f, "ProjId({})", self.encode())

    }

}

    pub fn encode(&self) -> String {

        multibase::encode(multibase::Base::Base58Btc, &self.0.as_ref())

    }

}

    fn from_str(s: &str) -> Result<Self, Self::Err> {

        Ok(Self(hash::Digest::from_str(s)?))

    }

}

    fn try_from(value: OsString) -> Result<Self, Self::Error> {

        let string = value.to_string_lossy();

    }

}

    fn from(digest: hash::Digest) -> Self {

        Self(digest)

    }

}

    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

    where

        S: serde::Serializer,

    }

}

    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

    where

        D: serde::Deserializer<'de>,

#[derive(Debug, Clone)]

pub struct Project {

    /// The project identifier.

    /// The latest project identity document.

    pub doc: Doc,

    /// The project remotes.

}

impl Doc {

        let mut buf = Vec::new();

        let mut ser =

            serde_json::Serializer::with_formatter(&mut buf, olpc_cjson::CanonicalFormatter::new());

        self.serialize(&mut ser)?;

        let digest = hash::Digest::new(&buf);

        // TODO: Currently, we serialize the document in canonical JSON. This isn't strictly

        // necessary, as we could use CJSON just to get the hash, but then write a prettified

#[cfg(test)]

mod test {

    use super::*;

    use quickcheck_macros::quickcheck;

    use std::collections::HashSet;

    #[quickcheck]

        assert_ne!(a, b);

        let mut hm = HashSet::new();

    }

    #[quickcheck]

        let encoded = input.to_string();

        assert_eq!(input, decoded);

    }

    #[quickcheck]

        let json = serde_json::to_string(&proj).unwrap();

        assert_eq!(format!("\"{}\"", proj), json);

use crate::clock::RefClock;

use crate::collections::{HashMap, HashSet};

use crate::crypto;

use crate::protocol::config::ProjectTracking;

use crate::protocol::message::Message;

use crate::protocol::peer::{Peer, PeerError, PeerState};

/// Network node identifier.

pub type NodeId = crypto::PublicKey;

/// Network routing table. Keeps track of where projects are hosted.

/// Seconds since epoch.

pub type Timestamp = u64;

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

#[derive(Debug)]

pub enum Command {

    Connect(net::SocketAddr),

}

/// Command-related errors.

        }

    }

            Box::new(

                peers

                    .iter()

        }

    }

        let tracked = match &self.config.project_tracking {

            ProjectTracking::All { blocked } => self

                .storage

    /// Track a project.

    /// Returns whether or not the tracking policy was updated.

        self.out_of_sync

    }

    /// Returns whether or not the tracking policy was updated.

    /// Note that when untracking, we don't announce anything to the network. This is because by

    /// simply not announcing it anymore, it will eventually be pruned by nodes.

    }

    /// Find the closest `n` peers by proximity in tracking graphs.

        &mut self.context.io

    }

        Lookup {

            remote: self

                .context

                .routing

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

        }

    }

    fn get_inventories(&mut self) -> Result<(), storage::Error> {

        let mut msgs = Vec::new();

                if peer.is_negotiated() {

                    msgs.push((

                        peer.addr,

                        Message::GetInventory {

                        },

                    ));

                }

        match cmd {

            Command::Connect(addr) => self.context.connect(addr),

                    resp.send(FetchLookup::NotTracking).ok();

                    return;

                }

                let seeds = if let Some(seeds) = NonEmpty::from_vec(seeds) {

                    seeds

                } else {

                    resp.send(FetchLookup::NotFound).ok();

                    return;

                };

                    Ok(repo) => repo,

                    Err(err) => {

                        resp.send(FetchLookup::Error(err.into())).ok();

                        return;

                        host: Some(peer.addr.ip().to_string()),

                        port: Some(peer.addr.port()),

                        // TODO: Fix upstream crate so that it adds a `/` when needed.

                        ..Url::default()

                    }) {

                        Ok(()) => {

                    }

                }

            }

            }

            }

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

                let refs = remote.refs.unverified();

                self.context

            }

        }

    }

    }

    /// Process a peer inventory update announcement by (maybe) fetching.

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

        }

        // TODO: If refs were updated, return `true`.

        false

    }

        // TODO: Verify refs before adding them to storage.

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

        repo.fetch(&Url {

use git_url::Url;

use crate::collections::HashSet;

use crate::protocol::message::{Address, Envelope, Message};

/// Peer-to-peer network.

#[derive(Debug, Clone)]

pub enum ProjectTracking {

    /// Track all projects we come across.

    /// Track a static list of projects.

}

impl Default for ProjectTracking {

    #[default]

    DelegatesOnly,

    /// Track all remotes.

    /// Track a specific list of users as well as the project delegates.

}

/// Protocol configuration.

        self.connect.contains(addr)

    }

        match &self.project_tracking {

        }

    }

    /// Track a project. Returns whether the policy was updated.

        match &mut self.project_tracking {

            ProjectTracking::All { .. } => false,

        }

    }

    /// Untrack a project. Returns whether the policy was updated.

        match &mut self.project_tracking {

        }

    }

}

use serde::{Deserialize, Serialize};

use crate::crypto;

use crate::protocol::{Context, NodeId, Timestamp, PROTOCOL_VERSION};

use crate::storage;

use crate::storage::refs::SignedRefs;

        announcement: NodeAnnouncement,

    },

    /// Get a peer's inventory.

    /// Send our inventory to a peer. Sent in response to [`Message::GetInventory`].

    /// Nb. This should be the whole inventory, not a partial update.

    Inventory {

        timestamp: Timestamp,

        /// Original peer this inventory came from. We don't set this when we

        /// are the originator, only when relaying.

    /// their view of the project.

    RefsUpdate {

        /// Project under which the refs were updated.

        /// Updated refs.

        refs: SignedRefs<crypto::Unverified>,

    },

        })

    }

        Self::GetInventory { ids: ids.into() }

    }

}

                    }));

                }

            }

                    // TODO: Buffer/throttle fetches.

                    // TODO: Also pass the updated refs so that we can check whether

                    // we need to fetch or not.

                    // TODO: Check that the refs are valid.

                        // TODO: If refs were updated, propagate message to peers.

                    }

                } else {

use crate::crypto::Verified;

use crate::git;

use crate::storage::git::RADICLE_ID_REF;

use crate::storage::refs::SignedRefs;

use crate::storage::{BranchName, ReadRepository as _, WriteRepository as _};

    description: &str,

    default_branch: BranchName,

    storage: S,

    let pk = storage.public_key();

    let delegate = identity::Delegate {

        // TODO: Use actual user name.

    #[error("storage: {0}")]

    Storage(#[from] storage::Error),

    #[error("project `{0}` was not found in storage")]

}

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

    path: P,

    storage: S,

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

use crate::git::Url;

use crate::git::{RefError, RefStr};

use crate::identity;

use crate::storage::refs::Refs;

use self::refs::SignedRefs;

pub type BranchName = String;

/// Storage error.

#[derive(Error, Debug)]

    #[error("git: {0}")]

    Git(#[from] git2::Error),

    #[error("id: {0}")]

    #[error("i/o: {0}")]

    Io(#[from] io::Error),

    #[error("doc: {0}")]

    InvalidHead,

}

/// Project remotes. Tracks the git state of a project.

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

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

pub struct Remote<V> {

    /// ID of remote.

    /// Git references published under this remote, and their hashes.

    pub refs: SignedRefs<V>,

    /// Whether this remote is of a project delegate.

}

impl<V> Remote<V> {

        Self {

            id,

            refs: refs.into(),

pub trait ReadStorage {

    fn public_key(&self) -> &PublicKey;

    fn url(&self) -> Url;

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

}

pub trait WriteStorage<'r>: ReadStorage {

    type Repository: WriteRepository<'r>;

    fn sign_refs(&self, repository: &Self::Repository) -> Result<SignedRefs<Verified>, Error>;

}

    T: Deref<Target = S>,

    S: ReadStorage + 'static,

{

        self.deref().public_key()

    }

        self.deref().inventory()

    }

        self.deref().get(proj)

    }

}

{

    type Repository = S::Repository;

        self.deref().repository(proj)

    }

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

use crate::git;

use crate::identity::{self, IDENTITY_PATH};

use crate::storage::refs;

use crate::storage::refs::{Refs, SignedRefs};

use crate::storage::{

}

impl ReadStorage for Storage {

        self.signer.public_key()

    }

        }

    }

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

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

        let local = self.public_key();

impl<'r> WriteStorage<'r> for Storage {

    type Repository = Repository;

        Repository::open(self.path.join(proj.to_string()))

    }

        }

    }

        let mut projects = Vec::new();

        for result in fs::read_dir(&self.path)? {

            let path = result?;

            projects.push(id);

        }

        let mut rng = fastrand::Rng::new();

        let signer = MockSigner::new(&mut rng);

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

        let alice = *storage.public_key();

        let project = storage.repository(&proj_id).unwrap();

        let backend = &project.backend;

use crate::crypto::{PublicKey, SecretKey};

use crate::git;

use crate::hash;

use crate::storage;

use crate::storage::refs::Refs;

use crate::test::storage::MockStorage;

    }

}

    fn arbitrary(g: &mut quickcheck::Gen) -> Self {

        let digest = hash::Digest::arbitrary(g);

    }

}

use std::path::Path;

use crate::git;

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

use crate::storage::{ReadStorage, WriteStorage};

use crate::test::arbitrary;

pub fn storage<P: AsRef<Path>>(path: P) -> Storage {

    let path = path.as_ref();

    let signers = arbitrary::set::<MockSigner>(1..3);

    let mut storages = signers

        .into_iter()

use crate::client::handle::traits;

use crate::client::handle::Error;

use crate::protocol;

use crate::protocol::FetchLookup;

#[derive(Default, Clone)]

pub struct Handle {

}

impl traits::Handle for Handle {

        Ok(FetchLookup::NotFound)

    }

        Ok(true)

    }

        Ok(true)

    }

        self.updates.lock().unwrap().push(id);

        Ok(())

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

use crate::git;

use crate::storage::refs;

use crate::storage::{

    Error, Inventory, ReadRepository, ReadStorage, Remote, RemoteId, WriteRepository, WriteStorage,

        }

    }

        if let Some(proj) = self.inventory.iter().find(|p| p.id == *proj) {

            return Ok(Some(proj.clone()));

        }

impl WriteStorage<'_> for MockStorage {

    type Repository = MockRepository;

        Ok(MockRepository {})

    }

        MockStorage::empty(),

        fastrand::Rng::new(),

    );

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

    alice.command(Command::Track(proj_id.clone(), sender));