message: Some("sql: invalid type for public key".to_owned()),

        write!(f, "Book(..)")

            sql::Value::String(s) => Address::from_str(s.as_str()).map_err(|e| sql::Error {

                message: Some(e.to_string()),

                message: Some("sql: invalid type for address".to_owned()),

        let err = sql::Error {

            code: None,

            message: Some("sql: invalid source".to_owned()),

        };

                _ => Err(err),

            _ => Err(err),

        let err = sql::Error {

            code: None,

            message: Some("sql: invalid address type".to_owned()),

        };

                _ => Err(err),

            _ => Err(err),

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

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

pub const TRACKING_DB_FILE: &str = "tracking.db";

    /// A tracking database error.

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

    Tracking(#[from] tracking::Error),

        let tracking_db = node_dir.join(TRACKING_DB_FILE);

        log::info!("Opening tracking policy table {}..", tracking_db.display());

        let tracking = tracking::Config::open(tracking_db)?;

            tracking,

#![allow(clippy::too_many_arguments)]

pub mod tracking;

    /// Tracking policy configuration.

    tracking: tracking::Config,

    /// Current tracked repository bloom filter.

    filter: Filter,

        tracking: tracking::Config,

            tracking,

            filter: Filter::empty(),

    pub fn track(&mut self, id: &Id, scope: tracking::Scope) -> Result<bool, tracking::Error> {

        self.out_of_sync = self.tracking.track_repo(id, scope)?;

        self.filter.insert(id);

        Ok(self.out_of_sync)

    pub fn untrack(&mut self, id: &Id) -> Result<bool, tracking::Error> {

        // Nb. This is potentially slow if we have lots of projects. We should probably

        // only re-compute the filter when we've untracked a certain amount of projects

        // and the filter is really out of date.

        self.filter = Filter::new(self.tracking.repo_entries()?.map(|(e, _)| e));

        self.tracking.untrack_repo(id)

    }

    /// Check whether we are tracking a certain repository.

    pub fn is_tracking(&self, id: &Id) -> Result<bool, tracking::Error> {

        self.tracking.is_repo_tracked(id)

    /// Get the tracking policy.

    pub fn tracking(&self) -> &tracking::Config {

        &self.tracking

    }

                if !self

                    .tracking

                    .is_repo_tracked(&id)

                    .expect("Service::command: error accessing tracking configuration")

                {

                let tracked = self

                    .track(&id, tracking::Scope::All)

                    .expect("Service::command: error tracking repository");

                resp.send(tracked).ok();

                let untracked = self

                    .untrack(&id)

                    .expect("Service::command: error untracking repository");

                resp.send(untracked).ok();

                            self.filter.clone(),

                if self

                    .tracking

                    .is_repo_tracked(&message.id)

                    .expect("Service::handle_announcement: error accessing tracking configuration")

                {

                } else {

                    log::debug!(

                        "Ignoring refs announcement from {announcer}: repository {} isn't tracked",

                        message.id

                    );

                            self.filter.clone(),

            if self.routing.insert(*proj_id, from, *timestamp)?

                && self

                    .tracking

                    .is_repo_tracked(proj_id)

                    .expect("Service::process_inventory: error accessing tracking configuration")

        filter: Filter,

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

    /// Configured service limits.

    pub fn new(network: Network) -> Self {

        Self {

            network,

            ..Self::default()

    pub fn is_persistent(&self, addr: &Address) -> bool {

        self.connect.contains(addr)

    pub fn new(ids: impl IntoIterator<Item = Id>) -> Self {

            bloom.insert(&id);

    /// Empty filter with nothing set.

    pub fn empty() -> Self {

        Self(BloomFilter::from(vec![0x0; FILTER_SIZE_S]))

    }

        let f = Filter::new(ids.iter().cloned().take(10));

        let f = Filter::new(ids.iter().cloned().take(1000));

        let f = Filter::new(ids.iter().cloned());

mod store;

use std::str::FromStr;

pub use store::{Config, Error};

/// Tracking policy.

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

pub enum Policy {

    /// The resource is tracked.

    Track,

    /// The resource is blocked.

    Block,

}

/// Tracking scope of a repository tracking policy.

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

pub enum Scope {

    /// Track remotes of nodes that are already tracked.

    Trusted,

    /// Track remotes of repository delegates.

    DelegatesOnly,

    /// Track all remotes.

    All,

}

impl FromStr for Scope {

    type Err = ();

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

        match s {

            "trusted" => Ok(Self::Trusted),

            "delegates-only" => Ok(Self::DelegatesOnly),

            "all" => Ok(Self::All),

            _ => Err(()),

        }

    }

}

--

-- Service configuration schema.

--

-- Node tracking policy.

create table if not exists "node-policies" (

  -- Node ID.

  "id"                 text      primary key not null,

  -- Node alias. May override the alias announced by the node.

  "alias"              text      default '',

  -- Tracking policy for this node.

  "policy"             text      default 'track'

  --

) strict;

-- Repository tracking policy.

create table if not exists "repo-policies" (

  -- Repository ID.

  "id"                 text      primary key not null,

  -- Tracking scope for this repository.

  --

  -- Valid values are:

  --

  -- "trusted"         track repository delegates and remotes in the `node-policies` table.

  -- "delegates-only"  only track repository delegates.

  -- "all"             track all remotes.

  --

  "scope"              text      default 'trusted',

  -- Tracking policy for this repository.

  "policy"             text      default 'track'

  --

) strict;

use std::path::Path;

use std::str::FromStr;

use std::{fmt, io};

use sqlite as sql;

use thiserror::Error;

use crate::prelude::Id;

use crate::service::NodeId;

use super::{Policy, Scope};

#[derive(Error, Debug)]

pub enum Error {

    /// I/O error.

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

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

    /// An Internal error.

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

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

}

pub type Alias = String;

impl sqlite::BindableWithIndex for Scope {

    fn bind<I: sql::ParameterIndex>(self, stmt: &mut sql::Statement<'_>, i: I) -> sql::Result<()> {

        let s = match self {

            Self::Trusted => "trusted",

            Self::DelegatesOnly => "delegates-only",

            Self::All => "all",

        };

        s.bind(stmt, i)

    }

}

impl TryFrom<&sql::Value> for Scope {

    type Error = sql::Error;

    fn try_from(value: &sql::Value) -> Result<Self, Self::Error> {

        let message = Some("invalid remote scope".to_owned());

        match value {

            sql::Value::String(scope) => Scope::from_str(scope).map_err(|_| sql::Error {

                code: None,

                message,

            }),

            _ => Err(sql::Error {

                code: None,

                message,

            }),

        }

    }

}

impl sqlite::BindableWithIndex for Policy {

    fn bind<I: sql::ParameterIndex>(self, stmt: &mut sql::Statement<'_>, i: I) -> sql::Result<()> {

        match self {

            Self::Track => "track",

            Self::Block => "block",

        }

        .bind(stmt, i)

    }

}

impl TryFrom<&sql::Value> for Policy {

    type Error = sql::Error;

    fn try_from(value: &sql::Value) -> Result<Self, Self::Error> {

        let message = Some("sql: invalid policy".to_owned());

        match value {

            sql::Value::String(s) if s == "track" => Ok(Policy::Track),

            sql::Value::String(s) if s == "block" => Ok(Policy::Block),

            _ => Err(sql::Error {

                code: None,

                message,

            }),

        }

    }

}

/// Tracking configuration.

pub struct Config {

    db: sql::Connection,

}

impl fmt::Debug for Config {

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

        write!(f, "Config(..)")

    }

}

impl Config {

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

    /// Open a policy store at the given path. Creates a new store if it

    /// doesn't exist.

    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 address book.

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

        let db = sql::Connection::open(":memory:")?;

        db.execute(Self::SCHEMA)?;

        Ok(Self { db })

    }

    /// Track a node.

    pub fn track_node(&mut self, id: &NodeId, alias: Option<&str>) -> Result<bool, Error> {

        let mut stmt = self.db.prepare(

            "INSERT INTO `node-policies` (id, alias)

             VALUES (?1, ?2)

             ON CONFLICT DO UPDATE

             SET alias = ?2 WHERE alias != ?2",

        )?;

        stmt.bind((1, id))?;

        stmt.bind((2, alias.unwrap_or_default()))?;

        stmt.next()?;

        Ok(self.db.change_count() > 0)

    }

    /// Track a repository.

    pub fn track_repo(&mut self, id: &Id, scope: Scope) -> Result<bool, Error> {

        let mut stmt = self.db.prepare(

            "INSERT INTO `repo-policies` (id, scope)

             VALUES (?1, ?2)

             ON CONFLICT DO UPDATE

             SET scope = ?2 WHERE scope != ?2",

        )?;

        stmt.bind((1, id))?;

        stmt.bind((2, scope))?;

        stmt.next()?;

        Ok(self.db.change_count() > 0)

    }

    /// Set a node's tracking policy.

    pub fn set_node_policy(&mut self, id: &NodeId, policy: Policy) -> Result<bool, Error> {

        let mut stmt = self.db.prepare(

            "INSERT INTO `node-policies` (id, policy)

             VALUES (?1, ?2)

             ON CONFLICT DO UPDATE

             SET policy = ?2 WHERE policy != ?2",

        )?;

        stmt.bind((1, id))?;

        stmt.bind((2, policy))?;

        stmt.next()?;

        Ok(self.db.change_count() > 0)

    }

    /// Set a repository's tracking policy.

    pub fn set_repo_policy(&mut self, id: &Id, policy: Policy) -> Result<bool, Error> {

        let mut stmt = self.db.prepare(

            "INSERT INTO `repo-policies` (id, policy)

             VALUES (?1, ?2)

             ON CONFLICT DO UPDATE

             SET policy = ?2 WHERE policy != ?2",

        )?;

        stmt.bind((1, id))?;

        stmt.bind((2, policy))?;

        stmt.next()?;

        Ok(self.db.change_count() > 0)

    }

    /// Untrack a node.

    pub fn untrack_node(&mut self, id: &NodeId) -> Result<bool, Error> {

        let mut stmt = self

            .db

            .prepare("DELETE FROM `node-policies` WHERE id = ?")?;

        stmt.bind((1, id))?;

        stmt.next()?;

        Ok(self.db.change_count() > 0)

    }

    /// Untrack a repository.

    pub fn untrack_repo(&mut self, id: &Id) -> Result<bool, Error> {

        let mut stmt = self

            .db

            .prepare("DELETE FROM `repo-policies` WHERE id = ?")?;

        stmt.bind((1, id))?;

        stmt.next()?;

        Ok(self.db.change_count() > 0)

    }

    /// Check if a node is tracked.

    pub fn is_node_tracked(&self, id: &NodeId) -> Result<bool, Error> {

        Ok(matches!(self.node_entry(id)?, Some((_, Policy::Track))))

    }

    /// Check if a repository is tracked.

    pub fn is_repo_tracked(&self, id: &Id) -> Result<bool, Error> {

        Ok(matches!(self.repo_entry(id)?, Some((_, Policy::Track))))

    }

    /// Get a node's tracking information.

    pub fn node_entry(&self, id: &NodeId) -> Result<Option<(Option<Alias>, Policy)>, Error> {

        let mut stmt = self

            .db

            .prepare("SELECT alias, policy FROM `node-policies` WHERE id = ?")?;

        stmt.bind((1, id))?;

        if let Some(Ok(row)) = stmt.into_iter().next() {

            let alias = row.read::<&str, _>("alias");

            return Ok(Some((

                if alias.is_empty() {

                    None

                } else {

                    Some(alias.to_owned())

                },

                row.read::<Policy, _>("policy"),

            )));

        }

        Ok(None)

    }

    /// Get a repository's tracking information.

    pub fn repo_entry(&self, id: &Id) -> Result<Option<(Scope, Policy)>, Error> {

        let mut stmt = self

            .db

            .prepare("SELECT scope, policy FROM `repo-policies` WHERE id = ?")?;

        stmt.bind((1, id))?;

        if let Some(Ok(row)) = stmt.into_iter().next() {

            return Ok(Some((

                row.read::<Scope, _>("scope"),

                row.read::<Policy, _>("policy"),

            )));

        }

        Ok(None)

    }

    /// Get node tracking entries.

    pub fn node_entries(&self) -> Result<Box<dyn Iterator<Item = (NodeId, Alias)>>, Error> {

        let mut stmt = self

            .db

            .prepare("SELECT id, alias FROM `node-policies`")?

            .into_iter();

        let mut entries = Vec::new();

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

            let id = row.read("id");

            let alias = row.read::<&str, _>("alias");

            entries.push((id, alias.to_owned()));

        }

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

    }

    /// Get repository tracking entries.

    pub fn repo_entries(&self) -> Result<Box<dyn Iterator<Item = (Id, Scope)>>, Error> {

        let mut stmt = self

            .db

            .prepare("SELECT id, scope FROM `repo-policies`")?

            .into_iter();

        let mut entries = Vec::new();

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

            let id = row.read("id");

            let scope = row.read("scope");

            entries.push((id, scope));

        }

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

    }

}

#[cfg(test)]

mod test {

    use radicle::assert_matches;

    use super::*;

    use crate::test::arbitrary;

    #[test]

    fn test_track_and_untrack_node() {

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

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

        assert!(db.track_node(&id, Some("eve")).unwrap());

        assert!(db.is_node_tracked(&id).unwrap());

        assert!(!db.track_node(&id, Some("eve")).unwrap());

        assert!(db.untrack_node(&id).unwrap());

        assert!(!db.is_node_tracked(&id).unwrap());

    }

    #[test]

    fn test_track_and_untrack_repo() {

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

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

        assert!(db.track_repo(&id, Scope::All).unwrap());

        assert!(db.is_repo_tracked(&id).unwrap());

        assert!(!db.track_repo(&id, Scope::All).unwrap());

        assert!(db.untrack_repo(&id).unwrap());

        assert!(!db.is_repo_tracked(&id).unwrap());

    }

    #[test]

    fn test_node_entries() {

        let ids = arbitrary::vec::<NodeId>(3);

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

        for id in &ids {

            assert!(db.track_node(id, None).unwrap());

        }

        let mut entries = db.node_entries().unwrap();

        assert_matches!(entries.next(), Some((id, _)) if id == ids[0]);

        assert_matches!(entries.next(), Some((id, _)) if id == ids[1]);

        assert_matches!(entries.next(), Some((id, _)) if id == ids[2]);

    }

    #[test]

    fn test_repo_entries() {

        let ids = arbitrary::vec::<Id>(3);

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

        for id in &ids {

            assert!(db.track_repo(id, Scope::All).unwrap());

        }

        let mut entries = db.repo_entries().unwrap();

        assert_matches!(entries.next(), Some((id, _)) if id == ids[0]);

        assert_matches!(entries.next(), Some((id, _)) if id == ids[1]);

        assert_matches!(entries.next(), Some((id, _)) if id == ids[2]);

    }

    #[test]

    fn test_update_alias() {

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

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

        assert!(db.track_node(&id, Some("eve")).unwrap());

        assert_eq!(

            db.node_entry(&id).unwrap().unwrap().0,

            Some(String::from("eve"))

        );

        assert!(db.track_node(&id, None).unwrap());

        assert_eq!(db.node_entry(&id).unwrap().unwrap().0, None);

        assert!(!db.track_node(&id, None).unwrap());

        assert!(db.track_node(&id, Some("alice")).unwrap());

        assert_eq!(

            db.node_entry(&id).unwrap().unwrap().0,

            Some(String::from("alice"))

        );

    }

    #[test]

    fn test_update_scope() {

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

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

        assert!(db.track_repo(&id, Scope::All).unwrap());

        assert_eq!(db.repo_entry(&id).unwrap().unwrap().0, Scope::All);

        assert!(db.track_repo(&id, Scope::DelegatesOnly).unwrap());

        assert_eq!(db.repo_entry(&id).unwrap().unwrap().0, Scope::DelegatesOnly);

    }

    #[test]

    fn test_repo_policy() {

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

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

        assert!(db.track_repo(&id, Scope::All).unwrap());

        assert_eq!(db.repo_entry(&id).unwrap().unwrap().1, Policy::Track);

        assert!(db.set_repo_policy(&id, Policy::Block).unwrap());

        assert_eq!(db.repo_entry(&id).unwrap().unwrap().1, Policy::Block);

    }

    #[test]

    fn test_node_policy() {

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

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

        assert!(db.track_node(&id, None).unwrap());

        assert_eq!(db.node_entry(&id).unwrap().unwrap().1, Policy::Track);

        assert!(db.set_node_policy(&id, Policy::Block).unwrap());

        assert_eq!(db.node_entry(&id).unwrap().unwrap().1, Policy::Block);

    }

}

        let tracking = tracking::Config::memory().unwrap();

        let service = Service::new(

            config,

            clock,

            routing,

            storage,

            addrs,

            tracking,

            signer,

            rng.clone(),

        );

        Config::default(),

    assert!(alice.tracking().is_repo_tracked(&proj_id).unwrap());

    assert!(!alice.tracking().is_repo_tracked(&proj_id).unwrap());

    alice.track(&bob_inv[0], tracking::Scope::All).unwrap();

    alice.track(&bob_inv[1], tracking::Scope::All).unwrap();

    alice.track(&bob_inv[2], tracking::Scope::All).unwrap();

    alice.track(&id, tracking::Scope::All).unwrap();

    let mut sim = Simulation::new(

        LocalTime::now(),

        alice.rng.clone(),

        simulator::Options::default(),

    )

    .initialize([&mut alice, &mut bob, &mut eve]);

    // Here we expect Alice to connect to Eve.

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

    // Neither Eve nor Bob have Alice's project for now.

                message: Some("sql: invalid type for id".to_owned()),

                message: Some("sql: invalid type for node features".to_owned()),