use radicle_node::logger;

use radicle_node::prelude::Address;

type Reactor = nakamoto_net_poll::Reactor<net::TcpStream>;

struct Options {

    connect: Vec<Address>,

    listen: Vec<net::SocketAddr>,

}

impl Options {

        let mut parser = lexopt::Parser::from_env();

        let mut connect = Vec::new();

        let mut listen = Vec::new();

        while let Some(arg) = parser.next()? {

            match arg {

                    let addr = parser.value()?.parse()?;

                    listen.push(addr);

                }

                Long("help") => {

                    println!("usage: radicle-node [--connect <addr>]..");

                    process::exit(0);

                _ => return Err(arg.unexpected()),

            }

        }

    }

}

    let config = client::Config {

        service: service::Config {

            connect: options.connect,

            ..service::Config::default()

        },

        listen: options.listen,

use nakamoto_net::Link;

use nonempty::NonEmpty;

use radicle::node::Features;

use crate::address;

use crate::address::AddressBook;

use crate::crypto;

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

use crate::git;

use crate::identity::{Doc, Id};

use crate::node;

use crate::service::config::ProjectTracking;

#[derive(Debug, Clone)]

pub enum Event {

    RefsFetched {

        project: Id,

        updated: Vec<RefUpdate>,

    },

                .ok();

                // TODO: Limit the number of seeds we fetch from? Randomize?

                        Ok(updated) => {

                            results_

                                .send(FetchResult::Fetched {

    pub fn handle_announcement(

        &mut self,

        session: &NodeId,

        announcement: &Announcement,

    ) -> Result<bool, peer::SessionError> {

        if !announcement.verify() {

                    return Ok(false);

                }

                    error!("Error processing inventory from {}: {}", node, err);

                    if let Error::Fetch(storage::FetchError::Verify(err)) = err {

                    // Refs are only supposed to be relayed by peers who are tracking

                    // the resource. Therefore, it's safe to fetch from the remote

                    // peer, even though it isn't the announcer.

                    let is_updated = !updated.is_empty();

                    self.reactor.event(Event::RefsFetched {

                        project: message.id,

                        updated,

                    });

        debug!("Received {:?} from {}", &message, peer.ip());

        match (&mut peer.state, message) {

                if version != PROTOCOL_VERSION {

                    return Err(SessionError::WrongVersion(version));

                }

                    id,

                    since: self.clock.local_time(),

                    addrs,

                    ping: Default::default(),

                };

            }

                return Err(SessionError::Misbehavior);

            }

            // Process a peer announcement.

                let id = *id;

                // Returning true here means that the message should be relayed.

                    self.gossip.received(ann.clone(), ann.message.timestamp());

                    // Choose peers we should relay this message to.

    }

    /// Process a peer inventory announcement by updating our routing table.

        for proj_id in inventory {

            // TODO: Fire an event on routing update.

            // FIXME: The timestamp we insert should be the announcement timestamp.

                .insert(*proj_id, from, self.clock.timestamp())?

                && self.config.is_tracking(proj_id)

            {

            }

        }

        Ok(())

        signer: &G,

        config: &Config,

    ) -> [Message; 4] {

        let inventory = match storage.inventory() {

            Ok(i) => i,

            Err(e) => {

        };

        [

            Message::node(gossip::node(timestamp, config), signer),

            Message::inventory(gossip::inventory(timestamp, inventory), signer),

            Message::subscribe(config.filter(), timestamp, Timestamp::MAX),

use crate::collections::HashSet;

use crate::identity::{Id, PublicKey};

use crate::service::filter::Filter;

use crate::service::message::Address;

    pub relay: bool,

    /// List of addresses to listen on for protocol connections.

    pub listen: Vec<Address>,

}

impl Default for Config {

            remote_tracking: RemoteTracking::default(),

            relay: true,

            listen: vec![],

        }

    }

}

use thiserror::Error;

use crate::crypto;

use crate::identity::Id;

use crate::node;

use crate::service::filter::Filter;

        id: NodeId,

        version: u32,

        addrs: Vec<Address>,

    },

    /// Subscribe to gossip messages matching the filter and time range.

}

impl Message {

        Self::Initialize {

            id,

            version: PROTOCOL_VERSION,

            addrs,

        }

    }

        since: LocalTime,

        /// Addresses this peer is reachable on.

        addrs: Vec<Address>,

        ping: PingState,

    },

    /// When a peer is disconnected.

use crate::address;

use crate::clock::{RefClock, Timestamp};

use crate::crypto::Signer;

use crate::identity::Id;

use crate::node;

use crate::prelude::NodeId;

use crate::service::message::*;

use crate::service::reactor::Io;

use crate::service::*;

use crate::test::arbitrary;

use crate::test::signer::MockSigner;

use crate::test::simulator;

    S: WriteStorage + 'static,

{

    pub fn new(name: &'static str, ip: impl Into<net::IpAddr>, storage: S) -> Self {

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

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

    }

}

        self.service.clock().timestamp()

    }

    }

    pub fn node_id(&self) -> NodeId {

    pub fn connect_from(&mut self, peer: &Self) {

        let remote = simulator::Peer::<S, G>::addr(peer);

        let local = net::SocketAddr::new(self.ip, self.rng.u16(..));

        self.initialize();

        self.service.connected(remote, &local, Link::Inbound);

        self.receive(

            &remote,

        );

        let mut msgs = self.messages(&remote);

        })

        .expect("`inventory-announcement` is sent");

        self.receive(

            &remote,

        );

    }

use crate::service::reactor::Io;

use crate::service::ServiceState as _;

use crate::service::*;

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

use crate::storage::ReadStorage;

use crate::test::arbitrary;

        let seeds = alice.routing().get(proj).unwrap();

        assert!(seeds.contains(&bob.node_id()));

    }

}

#[test]

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

        let storage = fixtures::storage(tmp.path().join("bob"), &signer).unwrap();

    };

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

    let storage_eve = Storage::open(tempdir.path().join("eve").join("storage")).unwrap();

    let mut eve = Peer::new("eve", [9, 9, 9, 9], storage_eve);

    // Alice and Bob connect to Eve.

    alice.command(service::Command::Connect(eve.addr()));

    bob.command(service::Command::Connect(eve.addr()));

    assert_matches!(

        sim.events(&bob.ip).next(),

        Some(service::Event::RefsFetched { from, .. })

        "Bob fetched from Eve"

    );

}

    }

}

impl Decode for Id {

    fn decode<R: io::Read + ?Sized>(reader: &mut R) -> Result<Self, Error> {

        let oid: git::Oid = Decode::decode(reader)?;

    }

    #[test]

    fn test_filter_invalid() {

        let b = bloomy::BloomFilter::with_size(filter::FILTER_SIZE_M / 3);

        let f = filter::Filter::from(b);

use byteorder::{NetworkEndian, ReadBytesExt};

use crate::prelude::*;

use crate::service::message::*;

use crate::wire;

        let mut n = self.type_id().encode(writer)?;

        match self {

                n += id.encode(writer)?;

                n += version.encode(writer)?;

                n += addrs.as_slice().encode(writer)?;

            }

            Self::Subscribe(Subscribe {

                filter,

                let id = NodeId::decode(reader)?;

                let version = u32::decode(reader)?;

                let addrs = Vec::<Address>::decode(reader)?;

            }

            Ok(MessageType::Subscribe) => {

                let filter = Filter::decode(reader)?;

    lit, name, qualified, refname, Component, Namespaced, Qualified, RefStr, RefString,

};

pub use git_url as url;

pub use radicle_git_ext as ext;

pub use storage::BranchName;

/// Default port of the `git` transport protocol.

    Ok(remote)

}

}

/// Push `refspecs` to the given `remote` using the provided `namespace`.

    repo: &git2::Repository,

    remote: &str,

    let refspecs = refspecs

        .into_iter()

}

/// Set the upstream of the given branch to the given remote.

use crate::crypto::{KeyPair, PublicKey, SecretKey, Signature, Signer};

use crate::keystore::{Error, UnsafeKeystore};

use crate::node;

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

#[derive(Debug)]

        };

        let storage = Storage::open(&home.join("storage"))?;

        keystore.put(&signer.public, &signer.secret)?;

        Ok(Profile {

        let signer = UnsafeSigner { public, secret };

        let storage = Storage::open(&home.join("storage"))?;

        Ok(Profile {

            home,

            signer,

use crate::identity::project::DocError;

use crate::identity::Id;

use crate::node;

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

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

use crate::{identity, storage};

}

/// Initialize a new radicle project from a git repository.

    repo: &git2::Repository,

    name: &str,

    description: &str,

    default_branch: BranchName,

    signer: G,

) -> Result<(Id, SignedRefs<Verified>), InitError> {

    // TODO: Better error when project id already exists in storage, but remote doesn't.

    let pk = signer.public_key();

    .verified()?;

    let (id, _, project) = doc.create(pk, "Initialize Radicle\n", storage)?;

    git::set_upstream(

        repo,

    )?;

    git::configure_remote(repo, &REMOTE_NAME, &url)?;

    let signed = project.sign_refs(signer)?;

    let _head = project.set_head()?;

#[derive(Error, Debug)]

pub enum CloneUrlError {

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

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

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

}

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

    path: P,

    signer: &G,

    storage: &S,

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

    Ok(working)

}

#[derive(Error, Debug)]

pub enum CheckoutError {

    #[error("failed to fetch to working copy")]

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

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

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

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

    let repo = git2::Repository::init_opts(path.as_ref().join(&project.name), &opts)?;

    // Configure and fetch all refs from remote.

    git::configure_remote(&repo, &REMOTE_NAME, &url)?;

    {

        // Setup default branch.

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

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

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

}

/// Get the radicle ("rad") remote of a repository, and return the associated project id.

pub fn remote(repo: &git2::Repository) -> Result<(git2::Remote<'_>, Id), RemoteError> {

    let remote = repo.find_remote(&REMOTE_NAME)?;

}

#[cfg(test)]

    use super::*;

    use crate::git::fmt::refname;

    use crate::identity::{Delegate, Did};

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

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

    use crate::test::{fixtures, signer::MockSigner};

        let signer = MockSigner::default();

        let public_key = *signer.public_key();

        let storage = Storage::open(tempdir.path().join("storage")).unwrap();

        let (proj, refs) = init(

            &repo,

            "acme",

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

        let bob_id = bob.public_key();

        let storage = Storage::open(tempdir.path().join("storage")).unwrap();

        // Alice creates a project.

        let (id, alice_refs) = init(

            &original,

            "acme",

        let signer = MockSigner::default();

        let remote_id = signer.public_key();

        let storage = Storage::open(tempdir.path().join("storage")).unwrap();

        let (id, _) = init(

            &original,

            "acme",

use crate::crypto;

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

use crate::git::ext as git_ext;

use crate::git::{Qualified, RefError, RefString};

use crate::identity;

use crate::identity::{Id, IdError};

pub type BranchName = git::RefString;

pub type Inventory = Vec<Id>;

/// Storage error.

#[derive(Error, Debug)]

pub enum Error {

pub trait ReadStorage {

    fn path(&self) -> &Path;

    fn get(

        &self,

        remote: &RemoteId,

    type Repository: WriteRepository;

    fn repository(&self, proj: Id) -> Result<Self::Repository, Error>;

}

pub trait ReadRepository {

}

pub trait WriteRepository: ReadRepository {

    fn set_head(&self) -> Result<Oid, ProjectError>;

    fn sign_refs<G: Signer>(&self, signer: G) -> Result<SignedRefs<Verified>, Error>;

    fn raw(&self) -> &git2::Repository;

        self.deref().path()

    }

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

        self.deref().inventory()

    }

    fn repository(&self, proj: Id) -> Result<Self::Repository, Error> {

        self.deref().repository(proj)

    }

}

#[cfg(test)]

use std::collections::{BTreeMap, HashMap};

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

use git_ref_format::refspec;

use once_cell::sync::Lazy;

pub use crate::git::*;

pub static REMOTES_GLOB: Lazy<refspec::PatternString> =

    Lazy::new(|| refspec::pattern!("refs/namespaces/*"));

    }

}

pub struct Storage {

    path: PathBuf,

}

impl ReadStorage for Storage {

    fn path(&self) -> &Path {

        self.path.as_path()

    }

    fn get(&self, remote: &RemoteId, proj: Id) -> Result<Option<Doc<Verified>>, ProjectError> {

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

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

    fn repository(&self, proj: Id) -> Result<Self::Repository, Error> {

        Repository::open(paths::repository(self, &proj), proj)

    }

}

impl Storage {

        let backend = match git2::Repository::open_bare(path.as_ref()) {

            Err(e) if ext::is_not_found_err(&e) => {

                let backend = git2::Repository::init_opts(

                    git2::RepositoryInitOptions::new()

                        .bare(true)

                        .no_reinit(true)

    /// with pruning *on*, and discard the staging copy. If it fails, we just discard the

    /// staging copy.

    ///

        // The steps are summarized in the following diagram:

        //

        //     staging <- git-clone -- local (canonical) # create staging copy

        //

        //     local <- git-fetch -- staging             # fetch from staging copy

        //

        let mut updates = Vec::new();

        let mut callbacks = git2::RemoteCallbacks::new();

        let tempdir = tempfile::tempdir()?;

                // TODO: Due to this, I think we'll have to run GC when there is a failure.

                .clone_local(git2::build::CloneLocal::Local)

                .clone(

                        scheme: git::url::Scheme::File,

                        path: self.backend.path().to_string_lossy().to_string().into(),

                    }

                    .to_string(),

                    &path,

            // Fetch from the remote into the staging copy.

            staging_repo

            // Verify the staging copy as if it was the canonical copy.

            Repository {

        {

            let mut remote = self.backend.remote_anonymous(

                    scheme: git::url::Scheme::File,

                    path: staging.to_string_lossy().to_string().into(),

                }

                .to_string(),

            )?;

            let mut opts = git2::FetchOptions::default();

            opts.remote_callbacks(callbacks);

            // TODO: Make sure we verify before pruning, as pruning may get us into

            // a state we can't roll back.

            opts.prune(git2::FetchPrune::On);

            // Fetch from the staging copy into the canonical repo.

        }

        // Set repository HEAD for git cloning support.

        self.set_head()?;

        let storage = fixtures::storage(dir.path(), &signer).unwrap();

        let inv = storage.inventory().unwrap();

        let proj = inv.first().unwrap();

        let project = storage.repository(*proj).unwrap();

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

    fn test_fetch() {

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

        let alice_signer = MockSigner::default();

        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 updates = bob

            .repository(proj)

            .unwrap()

            .unwrap();

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

        for update in updates {

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

        let alice = Storage::open(tmp.path().join("alice/storage")).unwrap();

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

        let alice_signer = MockSigner::new(&mut fastrand::Rng::new());

        let alice_id = alice_signer.public_key();

        let (proj_id, _, proj_repo, alice_head) =

            fixtures::project(tmp.path().join("alice/project"), &alice, &alice_signer).unwrap();

        let refname = Qualified::from_refstr(git::refname!("refs/heads/master")).unwrap();

        // 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 = git::commit(&proj_repo, &alice_head, &refname, "Making changes", "Alice")

            .unwrap()

            .id();

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

        alice_proj_storage.set_head().unwrap();

        // Have Bob fetch Alice's new commit.

        // The branch and signature refs are updated.

        assert_matches!(

            updates.as_slice(),

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

        let signer = MockSigner::default();

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

        let (id, _, _, _) =

            fixtures::project(tmp.path().join("project"), &storage, &signer).unwrap();

        let proj = storage.repository(id).unwrap();

    }

    #[test]

    fn test_upload_pack() {

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

        let signer = MockSigner::default();

        let source_path = tmp.path().join("source");

        let target_path = tmp.path().join("target");

        let (source, _) = fixtures::repository(&source_path);

        let (proj, _) = rad::init(

            &source,

            "radicle",

            });

            opts.remote_callbacks(callbacks);

            let target = git2::Repository::init_bare(target_path).unwrap();

            let stream = net::TcpStream::connect(addr).unwrap();

            // Fetch with the `heartwood://` transport.

            target

pub mod local;

pub mod remote;

pub mod url;

pub use url::{Url, UrlError};

///

/// `rad://<repo>[/<namespace>]`

///

pub struct Url {

    /// Repository identifier.

    pub repo: Id,

impl Url {

    /// URL scheme.

    pub const SCHEME: &str = "rad";

}

impl fmt::Display for Url {

//! To have control over the communication, and to allow git streams to be multiplexed over

//! existing TCP connections, we implement the [`git2::transport::SmartSubtransport`] trait.

//!

//!

//!

pub mod url;

use std::collections::HashMap;

use std::str::FromStr;

use git2::transport::SmartSubtransportStream;

use once_cell::sync::Lazy;

pub use url::{Url, UrlError};

/// The map of git smart sub-transport streams. We keep a global map because we have

/// no control over how [`git2::transport::register`] instantiates our [`Smart`] transport

/// or its underlying streams.

/// The stream associated with a repository.

type Stream = Box<dyn SmartSubtransportStream>;

/// Git transport protocol over an I/O stream.

#[derive(Clone)]

impl git2::transport::SmartSubtransport for Smart {

    /// Run a git service on this transport.

    ///

    /// we retrieve an underlying stream and return it.

    ///

    /// We only support the upload-pack service, since only fetches are authorized by the

        action: git2::transport::Service,

    ) -> Result<Box<dyn git2::transport::SmartSubtransportStream>, git2::Error> {

        let url = Url::from_str(url).map_err(|e| git2::Error::from_str(e.to_string().as_str()))?;

            match action {

                    return Err(git2::Error::from_str(

                        "git-receive-pack is not supported with the custom transport",

                    ));

            Ok(stream)

        } else {

            Err(git2::Error::from_str(&format!(

            )))

        }

    }

/// Register the radicle transport with `git`.

///

///

    // Registration is not thread-safe, so make sure we prevent re-entrancy.

}