name = "ahash"

version = "0.7.6"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"

dependencies = [

 "getrandom",

 "once_cell",

 "version_check",

]

[[package]]

name = "fallible-iterator"

version = "0.2.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"

[[package]]

name = "fallible-streaming-iterator"

version = "0.1.9"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"

[[package]]

dependencies = [

 "ahash",

]

[[package]]

name = "hashlink"

version = "0.8.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "69fe1fcf8b4278d860ad0548329f892a3631fb63f82574df68275f34cdbe0ffa"

dependencies = [

 "hashbrown",

]

name = "libsqlite3-sys"

version = "0.25.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "9f0455f2c1bc9a7caa792907026e469c1d91761fb0ea37cbb16427c77280cf35"

dependencies = [

 "cc",

 "pkg-config",

 "vcpkg",

]

[[package]]

 "rusqlite",

 "rusqlite",

name = "rusqlite"

version = "0.28.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "01e213bc3ecb39ac32e81e51ebe31fd888a940515173e3a18a35f8c6e896422a"

dependencies = [

 "bitflags",

 "fallible-iterator",

 "fallible-streaming-iterator",

 "hashlink",

 "libsqlite3-sys",

 "smallvec",

]

[[package]]

name = "smallvec"

version = "1.10.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"

[[package]]

rusqlite = { version = "0.28.0", features = ["bundled"] }

features = ["sql"]

use std::{io, net};

use thiserror::Error;

use crate::service::routing;

/// Directory in `$RAD_HOME` under which node-specific files are stored.

pub const NODE_DIR: &str = "node";

/// Filename of routing table database under [`NODE_DIR`].

pub const ROUTING_DB_FILE: &str = "routing.db";

/// A client error.

#[derive(Error, Debug)]

pub enum Error {

    /// A routing database error.

    #[error("routing database error: {0}")]

    Routing(#[from] routing::Error),

    /// An I/O error.

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

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

    /// A networking error.

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

    Net(#[from] nakamoto_net::error::Error),

}

    pub fn new(profile: Profile) -> Result<Self, Error> {

    pub fn run(mut self, config: Config) -> Result<(), Error> {

        let routing = routing::Table::open(self.profile.home.join(NODE_DIR).join(ROUTING_DB_FILE))?;

            routing,

    fn routing(&self) -> Result<chan::Receiver<(Id, NodeId)>, Error> {

            for (id, node) in state.routing().entries()? {

                if sender.send((id, node)).is_err() {

        /// Query the routing table entries.

        fn routing(&self) -> Result<chan::Receiver<(Id, NodeId)>, Error>;

                        for (id, seed) in c.iter() {

                            writeln!(writer, "{id} {seed}",)?;

pub mod routing;

    #[error(transparent)]

    Routing(#[from] routing::Error),

pub struct Service<R, A, S, G> {

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

    routing: R,

impl<R, A, S, G> Service<R, A, S, G>

impl<R, A, S, G> Service<R, A, S, G>

    R: routing::Store,

        routing: R,

    pub fn seeds(&self, id: &Id) -> Vec<(NodeId, &Session)> {

        if let Ok(seeds) = self.routing.get(id) {

            seeds

                .into_iter()

                .filter_map(|id| self.sessions.by_id(&id).map(|p| (id, p)))

                .collect()

            vec![]

    pub fn lookup(&self, id: Id) -> Result<Lookup, routing::Error> {

        let remote = self.routing.get(&id)?.iter().cloned().collect();

        Ok(Lookup {

            remote,

        })

                let seeds = self.seeds(&id);

                self.process_inventory(&message.inventory, *node, git)

                    .unwrap();

    fn process_inventory(

        &mut self,

        inventory: &Inventory,

        from: NodeId,

        remote: &Url,

    ) -> Result<(), routing::Error> {

            if self.routing.insert(*proj_id, from)? && self.config.is_tracking(proj_id) {

        Ok(())

    fn routing(&self) -> &dyn routing::Store;

impl<R, A, S, G> ServiceState for Service<R, A, S, G>

    R: routing::Store,

    fn routing(&self) -> &dyn routing::Store {

impl<R, A, S, G> Iterator for Service<R, A, S, G> {

use std::collections::HashSet;

use std::path::Path;

use rusqlite as sql;

use thiserror::Error;

use crate::prelude::{Id, NodeId};

/// An error occuring in peer-to-peer networking code.

#[derive(Error, Debug)]

pub enum Error {

    /// An Internal error.

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

    Internal(#[from] sql::Error),

}

/// Persistent file storage for a routing table.

#[derive(Debug)]

pub struct Table {

    db: sql::Connection,

}

impl Table {

    const SCHEMA: &str = include_str!("routing/schema.sql");

    /// Open a routing file store at the given path. Creates a new empty store

    /// if an existing store isn't found.

    pub fn open<P: AsRef<Path>>(path: P) -> Result<Self, Error> {

        let db = sql::Connection::open(path)?;

        db.execute(Self::SCHEMA, [])?;

        Ok(Self { db })

    }

    /// Create a new in-memory routing table.

    pub fn memory() -> Result<Self, Error> {

        let db = sql::Connection::open_in_memory()?;

        db.execute(Self::SCHEMA, [])?;

        Ok(Self { db })

    }

}

/// Backing store for a routing table.

pub trait Store {

    /// Get the nodes seeding the given id.

    fn get(&self, id: &Id) -> Result<HashSet<NodeId>, Error>;

    /// Add a new node seeding the given id.

    fn insert(&mut self, id: Id, node: NodeId) -> Result<bool, Error>;

    /// Remove a node for the given id.

    fn remove(&mut self, id: &Id, node: &NodeId) -> Result<bool, Error>;

    /// Iterate over all entries in the routing table.

    fn entries(&self) -> Result<Box<dyn Iterator<Item = (Id, NodeId)>>, Error>;

}

impl Store for Table {

    fn get(&self, id: &Id) -> Result<HashSet<NodeId>, Error> {

        let mut stmt = self

            .db

            .prepare("SELECT (node) FROM routing WHERE resource = ?")?;

        let mut rows = stmt.query([id])?;

        let mut nodes = HashSet::new();

        while let Ok(Some(row)) = rows.next() {

            let field = row.get(0)?;

            nodes.insert(field);

        }

        Ok(nodes)

    }

    fn insert(&mut self, id: Id, node: NodeId) -> Result<bool, Error> {

        let updated = self.db.execute(

            "INSERT INTO routing (resource, node, time) VALUES (?, ?, ?) ON CONFLICT DO NOTHING",

            (id, node, 0),

        )?;

        Ok(updated > 0)

    }

    fn entries(&self) -> Result<Box<dyn Iterator<Item = (Id, NodeId)>>, Error> {

        let mut stmt = self

            .db

            .prepare("SELECT resource, node FROM routing ORDER BY resource")?;

        let mut rows = stmt.query([])?;

        let mut entries = Vec::new();

        while let Ok(Some(row)) = rows.next() {

            let id = row.get(0)?;

            let node = row.get(1)?;

            entries.push((id, node));

        }

        Ok(Box::new(entries.into_iter()))

    }

    fn remove(&mut self, id: &Id, node: &NodeId) -> Result<bool, Error> {

        let deleted = self.db.execute(

            "DELETE FROM routing WHERE resource = ? AND node = ?",

            (id, node),

        )?;

        Ok(deleted > 0)

    }

}

#[cfg(test)]

mod test {

    use super::*;

    use crate::test::arbitrary;

    #[test]

    fn test_insert_and_get() {

        let ids = arbitrary::set::<Id>(5..10);

        let nodes = arbitrary::set::<NodeId>(5..10);

        let mut db = Table::open(":memory:").unwrap();

        for id in &ids {

            for node in &nodes {

                assert!(db.insert(*id, *node).unwrap());

            }

        }

        for id in &ids {

            let seeds = db.get(id).unwrap();

            for node in &nodes {

                assert!(seeds.contains(node));

            }

        }

    }

    #[test]

    fn test_iter() {

        let ids = arbitrary::set::<Id>(6..9);

        let nodes = arbitrary::set::<NodeId>(6..9);

        let mut db = Table::open(":memory:").unwrap();

        for id in &ids {

            for node in &nodes {

                assert!(db.insert(*id, *node).unwrap());

            }

        }

        let results = db.entries().unwrap().collect::<Vec<_>>();

        assert_eq!(results.len(), ids.len() * nodes.len());

        let mut results_ids = results.iter().map(|(id, _)| *id).collect::<Vec<_>>();

        results_ids.dedup();

        assert_eq!(results_ids.len(), ids.len(), "Entries are grouped by id");

    }

    #[test]

    fn test_insert_and_remove() {

        let ids = arbitrary::set::<Id>(5..10);

        let nodes = arbitrary::set::<NodeId>(5..10);

        let mut db = Table::open(":memory:").unwrap();

        for id in &ids {

            for node in &nodes {

                db.insert(*id, *node).unwrap();

            }

        }

        for id in &ids {

            for node in &nodes {

                assert!(db.remove(id, node).unwrap());

            }

        }

        for id in &ids {

            assert!(db.get(id).unwrap().is_empty());

        }

    }

    #[test]

    fn test_insert_duplicate() {

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

        let node = arbitrary::gen::<NodeId>(1);

        let mut db = Table::open(":memory:").unwrap();

        assert!(db.insert(id, node).unwrap());

        assert!(!db.insert(id, node).unwrap());

        assert!(!db.insert(id, node).unwrap());

    }

    #[test]

    fn test_remove_redundant() {

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

        let node = arbitrary::gen::<NodeId>(1);

        let mut db = Table::open(":memory:").unwrap();

        assert!(db.insert(id, node).unwrap());

        assert!(db.remove(&id, &node).unwrap());

        assert!(!db.remove(&id, &node).unwrap());

    }

}

--

-- Routing table SQL schema.

--

create table if not exists "routing" (

  "id"           integer   primary key,

  -- Resource being seeded.

  "resource"     text      not null,

  -- Node ID.

  "node"         text      not null,

  -- UNIX time at which this entry was added or refreshed.

  "time"         integer   not null,

  unique("resource", "node")

);

create index "routing_index" on routing ("resource", "node");

    fn routing(&self) -> Result<chan::Receiver<(Id, service::NodeId)>, Error> {

use crate::prelude::NodeId;

pub type Service<S> =

    service::Service<routing::Table, HashMap<net::IpAddr, KnownAddress>, S, MockSigner>;

        let routing = routing::Table::memory().unwrap();

        let service = Service::new(config, clock, routing, storage, addrs, signer, rng.clone());

        let mut routing = HashMap::with_hasher(rng.clone().into());

                let lookup = peer.lookup(*proj_id).unwrap();

use crate::service::routing;

pub struct Transport<R, S, T, G> {

    inner: Wire<R, S, T, G>,

impl<R, S, T, G> Transport<R, S, T, G> {

    pub fn new(inner: Wire<R, S, T, G>) -> Self {

impl<R, S, T, G> nakamoto::Protocol for Transport<R, S, T, G>

    R: routing::Store,

impl<R, S, T, G> Iterator for Transport<R, S, T, G> {

impl<R, S, T, G> Deref for Transport<R, S, T, G> {

    type Target = Service<R, S, T, G>;

impl<R, S, T, G> DerefMut for Transport<R, S, T, G> {

use crate::service::{filter, routing};

pub struct Wire<R, S, T, G> {

    inner: service::Service<R, S, T, G>,

impl<R, S, T, G> Wire<R, S, T, G> {

    pub fn new(inner: service::Service<R, S, T, G>) -> Self {

impl<R, S, T, G> Wire<R, S, T, G>

    R: routing::Store,

impl<R, S, T, G> Iterator for Wire<R, S, T, G> {

impl<R, S, T, G> Deref for Wire<R, S, T, G> {

    type Target = service::Service<R, S, T, G>;

impl<R, S, T, G> DerefMut for Wire<R, S, T, G> {

sql = ["rusqlite"]

rusqlite = { version = "0.28.0", features = ["bundled"], optional = true }

#[cfg(feature = "sql")]

pub mod sql;

use std::str;

use std::str::FromStr;

use rusqlite as sql;

use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};

use crate::crypto::PublicKey;

use crate::identity::Id;

impl FromSql for Id {

    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {

        match value {

            ValueRef::Text(id) => {

                let id = str::from_utf8(id).map_err(|e| FromSqlError::Other(Box::new(e)))?;

                let id = Id::from_str(id).map_err(|e| FromSqlError::Other(Box::new(e)))?;

                Ok(id)

            }

            _ => Err(FromSqlError::InvalidType),

        }

    }

}

impl ToSql for Id {

    fn to_sql(&self) -> sql::Result<ToSqlOutput<'_>> {

        Ok(ToSqlOutput::from(self.to_string()))

    }

}

impl FromSql for PublicKey {

    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {

        match value {

            ValueRef::Text(pk) => {

                let pk = str::from_utf8(pk).map_err(|e| FromSqlError::Other(Box::new(e)))?;

                let pk = PublicKey::from_str(pk).map_err(|e| FromSqlError::Other(Box::new(e)))?;

                Ok(pk)

            }

            _ => Err(FromSqlError::InvalidType),

        }

    }

}

impl ToSql for PublicKey {

    fn to_sql(&self) -> sql::Result<ToSqlOutput<'_>> {

        Ok(ToSqlOutput::from(self.to_string()))

    }

}