✓ Seeding policy updated for rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji with scope 'all'

✓ Seeding policy updated for rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji with scope 'all'

✓ Seeding policy updated for rad:zVNuptPuk5XauitpCWSNVCXGGfXW with scope 'followed'

✓ Seeding policy updated for rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji with scope 'followed'

✓ Seeding policy updated for rad:zhbMU4DUXrzB8xT6qAJh6yZ7bFMK with scope 'all'

use radicle::node::policy::Scope;

    --scope <scope>   Follow scope (default: all)

            "Seeding policy updated for {} with scope '{scope}'",

use radicle::node::{Alias, Handle, NodeId};

use radicle::node::policy::Scope;

        --scope <scope>            Repository follow scope (default: all)

use radicle::node::policy::Policy;

use radicle::node::{policy, AliasStore};

    for policy::Repo { id, scope, policy } in store.repo_policies()? {

    for policy::Node { id, alias, policy } in store.node_policies()? {

use radicle::node::policy::Scope;

use radicle::node::policy::Scope;

use radicle_node::service::policy::{Policy, Scope};

    use radicle::node::policy;

        Tracking(#[from] policy::config::Error),

            err: policy::store::Error,

            err: policy::store::Error,

use radicle::node::policy::config::Config;

use radicle::node::policy::store::Read;

pub use radicle::node::policy::{Policy, Scope};

    use radicle::node::policy;

    pub struct Blocked(#[from] policy::config::Error);

            err: policy::store::Error,

            err: policy::store::Error,

use radicle::node::policy::Scope;

    TrackingStore(#[from] radicle::node::policy::store::Error),

use radicle::node::{policy, Handle, DEFAULT_TIMEOUT};

            put(node_policies_seed_handler).delete(node_policies_unseed_handler),

    for policy::Repo { id, scope, policy } in tracking.repo_policies()? {

async fn node_policies_seed_handler(

    node.seed(project, qs.scope.unwrap_or_default())?;

async fn node_policies_unseed_handler(

    node.unseed(project)?;

    use crate::service::policy::Scope;

use crate::service::{gossip, policy, Event};

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

        let tracking = policy::Config::new(policy, scope, tracking);

use crate::service::policy;

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

use crate::service::policy::{store::Write, Policy, Scope};

pub use radicle::node::policy::config as policy;

use self::policy::NamespacesError;

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

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

    tracking: policy::Config<Write>,

        tracking: policy::Config<Write>,

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

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

                .filter_map(|t| (t.policy == Policy::Allow).then_some(t.id)),

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

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

                .filter_map(|t| (t.policy == Policy::Allow).then_some(t.id)),

                if repo_entry.policy == Policy::Allow {

        scope: &policy::Scope,

            policy::Scope::All => Ok(refs),

            policy::Scope::Followed => {

        if self.config.policy == Policy::Allow {

            .filter_map(|t| (t.policy == Policy::Allow).then_some(t.id))

use radicle::node::policy::store as policy;

        let tracking = policy::Config::open(tracking_db).unwrap();

        policy::Config::open(tracking_db).unwrap();

    pub tracking: policy::Config<policy::Write>,

            .track_repo(&id, node::policy::Scope::Followed)

use crate::service::policy;

    fn seed(&mut self, id: Id, _scope: policy::Scope) -> Result<bool, Self::Error> {

use crate::service::policy::{Policy, Scope};

        let tracking = policy::Store::<policy::store::Write>::memory().unwrap();

        let mut tracking = policy::Config::new(config.policy, config.scope, tracking);

        policy::Scope::default(),

            alice.track_repo(&rid, policy::Scope::All).unwrap();

    alice.track_repo(&bob_inv[0], policy::Scope::All).unwrap();

    alice.track_repo(&bob_inv[1], policy::Scope::All).unwrap();

    alice.track_repo(&bob_inv[2], policy::Scope::All).unwrap();

    alice.track_repo(&rid, policy::Scope::Followed).unwrap();

    alice.track_repo(&rid, policy::Scope::Followed).unwrap();

    alice.track_repo(&id, policy::Scope::All).unwrap();

    bob.track_repo(rid, policy::Scope::All).unwrap();

    alice.command(Command::TrackRepo(rid, policy::Scope::default(), send));

    alice.track_repo(&rid, node::policy::Scope::All).unwrap();

    alice.track_repo(&rid, node::policy::Scope::All).unwrap();

    alice.track_repo(&acme, policy::Scope::All).unwrap();

        policy::Scope::default(),

        policy::Scope::default(),

use crate::service::policy::Scope;

use crate::service::policy;

use crate::service::policy::Policy;

    TrackingConfig(#[from] radicle::node::policy::store::Error),

    pub policy: Policy,

    pub scope: policy::Scope,

        let policies = policy::Config::new(*policy, *scope, policy::Store::reader(tracking_db)?);

        let tracked = radicle_fetch::Tracked::from_config(rid, &policies)?;

        let blocked = radicle_fetch::BlockList::from_config(&policies)?;

pub mod policy;

    Seed { rid: Id, scope: policy::Scope },

    fn seed(&mut self, id: Id, scope: policy::Scope) -> Result<bool, Self::Error>;

    fn seed(&mut self, rid: Id, scope: policy::Scope) -> Result<bool, Error> {

use crate::node::policy::{Policy, Scope};

pub mod config;

pub mod store;

use std::fmt;

use std::str::FromStr;

use serde::{Deserialize, Serialize};

use thiserror::Error;

use crate::prelude::Id;

pub use super::{Alias, NodeId};

/// Repository seeding policy.

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

pub struct Repo {

    pub id: Id,

    pub scope: Scope,

    pub policy: Policy,

}

/// Node following policy.

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

pub struct Node {

    pub id: NodeId,

    pub alias: Option<Alias>,

    pub policy: Policy,

}

/// Resource policy.

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

#[serde(rename_all = "camelCase")]

pub enum Policy {

    /// The resource is allowed.

    Allow,

    /// The resource is blocked.

    #[default]

    Block,

}

impl fmt::Display for Policy {

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

        match self {

            Self::Allow => write!(f, "allow"),

            Self::Block => write!(f, "block"),

        }

    }

}

impl FromStr for Policy {

    type Err = String;

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

        match s {

            "allow" => Ok(Self::Allow),

            "block" => Ok(Self::Block),

            _ => Err(s.to_owned()),

        }

    }

}

impl sqlite::BindableWithIndex for Policy {

    fn bind<I: sqlite::ParameterIndex>(

        self,

        stmt: &mut sqlite::Statement<'_>,

        i: I,

    ) -> sqlite::Result<()> {

        match self {

            Self::Allow => "allow",

            Self::Block => "block",

        }

        .bind(stmt, i)

    }

}

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

    type Error = sqlite::Error;

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

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

        match value {

            sqlite::Value::String(s) if s == "allow" => Ok(Policy::Allow),

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

            _ => Err(sqlite::Error {

                code: None,

                message,

            }),

        }

    }

}

/// Follow scope of a seeded repository.

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

#[serde(rename_all = "camelCase")]

pub enum Scope {

    /// Seed remotes that are explicitly followed.

    #[default]

    Followed,

    /// Seed all remotes.

    All,

}

impl fmt::Display for Scope {

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

        match self {

            Scope::Followed => f.write_str("followed"),

            Scope::All => f.write_str("all"),

        }

    }

}

#[derive(Debug, Error)]

#[error("invalid tracking scope: {0:?}")]

pub struct ParseScopeError(String);

impl FromStr for Scope {

    type Err = ParseScopeError;

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

        match s {

            "followed" => Ok(Self::Followed),

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

            _ => Err(ParseScopeError(s.to_string())),

        }

    }

}

impl sqlite::BindableWithIndex for Scope {

    fn bind<I: sqlite::ParameterIndex>(

        self,

        stmt: &mut sqlite::Statement<'_>,

        i: I,

    ) -> sqlite::Result<()> {

        let s = match self {

            Self::Followed => "followed",

            Self::All => "all",

        };

        s.bind(stmt, i)

    }

}

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

    type Error = sqlite::Error;

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

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

        match value {

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

                code: None,

                message,

            }),

            _ => Err(sqlite::Error {

                code: None,

                message,

            }),

        }

    }

}

use core::fmt;

use std::collections::HashSet;

use std::ops;

use log::error;

use thiserror::Error;

use crate::crypto::PublicKey;

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

use crate::storage::{Namespaces, ReadRepository as _, ReadStorage, RepositoryError};

pub use crate::node::policy::store;

pub use crate::node::policy::store::Config as Store;

pub use crate::node::policy::store::Error;

pub use crate::node::policy::{Alias, Node, Policy, Repo, Scope};

#[derive(Debug, Error)]

pub enum NamespacesError {

    #[error("failed to find tracking policy for {rid}")]

    FailedPolicy {

        rid: Id,

        #[source]

        err: Error,

    },

    #[error("cannot fetch {rid} as it is not tracked")]

    BlockedPolicy { rid: Id },

    #[error("failed to get tracking nodes for {rid}")]

    FailedNodes {

        rid: Id,

        #[source]

        err: Error,

    },

    #[error("failed to get delegates for {rid}")]

    FailedDelegates {

        rid: Id,

        #[source]

        err: RepositoryError,

    },

    #[error(transparent)]

    Git(#[from] crate::git::raw::Error),

    #[error("could not find any followed nodes for {rid}")]

    NoFollowed { rid: Id },

}

/// Tracking configuration.

pub struct Config<T> {

    /// Default policy, if a policy for a specific node or repository was not found.

    policy: Policy,

    /// Default scope, if a scope for a specific repository was not found.

    scope: Scope,

    /// Underlying configuration store.

    store: Store<T>,

}

// N.b. deriving `Debug` will require `T: Debug` so we manually

// implement it here.

impl<T> fmt::Debug for Config<T> {

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

        f.debug_struct("Config")

            .field("policy", &self.policy)

            .field("scope", &self.scope)

            .field("store", &self.store)

            .finish()

    }

}

impl<T> Config<T> {

    /// Create a new tracking configuration.

    pub fn new(policy: Policy, scope: Scope, store: Store<T>) -> Self {

        Self {

            policy,

            scope,

            store,

        }

    }

    /// Check if a repository is tracked.

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

        self.repo_policy(id)

            .map(|entry| entry.policy == Policy::Allow)

    }

    /// Check if a node is tracked.

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

        self.node_policy(id)

            .map(|entry| entry.policy == Policy::Allow)

    }

    /// Get a node's tracking information.

    /// Returns the default policy if the node isn't found.

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

        Ok(self.store.node_policy(id)?.unwrap_or(Node {

            id: *id,

            alias: None,

            policy: self.policy,

        }))

    }

    /// Get a repository's tracking information.

    /// Returns the default policy if the repo isn't found.

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

        Ok(self.store.repo_policy(id)?.unwrap_or(Repo {

            id: *id,

            scope: self.scope,

            policy: self.policy,

        }))

    }

    pub fn namespaces_for<S>(&self, storage: &S, rid: &Id) -> Result<Namespaces, NamespacesError>

    where

        S: ReadStorage,

    {

        use NamespacesError::*;

        let entry = self

            .repo_policy(rid)

            .map_err(|err| FailedPolicy { rid: *rid, err })?;

        match entry.policy {

            Policy::Block => {

                error!(target: "service", "Attempted to fetch untracked repo {rid}");

                Err(NamespacesError::BlockedPolicy { rid: *rid })

            }

            Policy::Allow => match entry.scope {

                Scope::All => Ok(Namespaces::All),

                Scope::Followed => {

                    let nodes = self

                        .node_policies()

                        .map_err(|err| FailedNodes { rid: *rid, err })?;

                    let mut followed: HashSet<_> = nodes

                        .filter_map(|node| (node.policy == Policy::Allow).then_some(node.id))

                        .collect();

                    if let Ok(repo) = storage.repository(*rid) {

                        let delegates = repo

                            .delegates()

                            .map_err(|err| FailedDelegates { rid: *rid, err })?

                            .map(PublicKey::from);

                        followed.extend(delegates);

                    };

                    if followed.is_empty() {

                        // Nb. returning All here because the

                        // fetching logic will correctly determine

                        // followed and delegate remotes.

                        Ok(Namespaces::All)

                    } else {

                        Ok(Namespaces::Followed(followed))

                    }

                }

            },

        }

    }

}

impl<T> ops::Deref for Config<T> {

    type Target = Store<T>;

    fn deref(&self) -> &Self::Target {

        &self.store

    }

}

impl<T> ops::DerefMut for Config<T> {

    fn deref_mut(&mut self) -> &mut Self::Target {

        &mut self.store

    }

}

--

-- Node policy database.

--

-- Node follow policies.

create table if not exists "following" (

  -- 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 'allow'

  --

) strict;

-- Repository seeding policies.

create table if not exists "seeding" (

  -- Repository ID.

  "id"                 text      primary key not null,

  -- Tracking scope for this repository.

  --

  -- Valid values are:

  --

  -- "followed"        seed repository delegates and remotes in the `following` table.

  -- "all"             seed all remotes.

  --

  "scope"              text      default 'followed',

  -- Tracking policy for this repository.

  "policy"             text      default 'allow'

  --

) strict;

#![allow(clippy::type_complexity)]

use std::marker::PhantomData;

use std::path::Path;

use std::{fmt, io, ops::Not as _, str::FromStr, time};

use sqlite as sql;

use thiserror::Error;

use crate::node::{Alias, AliasStore};

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

use super::{Node, Policy, Repo, Scope};

/// How long to wait for the database lock to be released before failing a read.

const DB_READ_TIMEOUT: time::Duration = time::Duration::from_secs(3);

/// How long to wait for the database lock to be released before failing a write.

const DB_WRITE_TIMEOUT: time::Duration = time::Duration::from_secs(6);

#[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),

}

/// Read-only type witness.

pub struct Read;

/// Read-write type witness.

pub struct Write;

/// Read only config.

pub type ConfigReader = Config<Read>;

/// Read-write config.

pub type ConfigWriter = Config<Write>;

/// Tracking configuration.

pub struct Config<T> {

    db: sql::Connection,

    _marker: PhantomData<T>,

}

impl<T> fmt::Debug for Config<T> {

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

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

    }

}

impl Config<Read> {

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

    /// Same as [`Self::open`], but in read-only mode. This is useful to have multiple

    /// open databases, as no locking is required.

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

        let mut db =

            sql::Connection::open_with_flags(path, sqlite::OpenFlags::new().with_read_only())?;

        db.set_busy_timeout(DB_READ_TIMEOUT.as_millis() as usize)?;

        db.execute(Self::SCHEMA)?;

        Ok(Self {

            db,

            _marker: PhantomData,

        })

    }

    /// Create a new in-memory address book.

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

        let db = sql::Connection::open_with_flags(

            ":memory:",

            sqlite::OpenFlags::new().with_read_only(),

        )?;

        db.execute(Self::SCHEMA)?;

        Ok(Self {

            db,

            _marker: PhantomData,

        })

    }

}

impl Config<Write> {

    const SCHEMA: &'static 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 mut db = sql::Connection::open(path)?;

        db.set_busy_timeout(DB_WRITE_TIMEOUT.as_millis() as usize)?;

        db.execute(Self::SCHEMA)?;

        Ok(Self {

            db,

            _marker: PhantomData,

        })

    }

    /// 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,

            _marker: PhantomData,

        })

    }

    /// Get a read-only version of this store.

    pub fn read_only(self) -> ConfigReader {

        Config {

            db: self.db,

            _marker: PhantomData,

        }

    }

    /// 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 `following` (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 `seeding` (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 `following` (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 `seeding` (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 `following` 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 `seeding` WHERE id = ?")?;

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

        stmt.next()?;

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

    }

}

/// `Read` methods for `Config`. This implies that a

/// `Config<Write>` can access these functions as well.

impl<T> Config<T> {

    /// Check if a node is tracked.

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

        Ok(matches!(

            self.node_policy(id)?,

            Some(Node {

                policy: Policy::Allow,

                ..

            })

        ))

    }

    /// Check if a repository is tracked.

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

        Ok(matches!(

            self.repo_policy(id)?,

            Some(Repo {

                policy: Policy::Allow,

                ..

            })

        ))

    }

    /// Get a node's tracking policy.

    pub fn node_policy(&self, id: &NodeId) -> Result<Option<Node>, Error> {

        let mut stmt = self

            .db

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

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

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

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

            let alias = alias

                .is_empty()

                .not()

                .then_some(alias.to_owned())

                .and_then(|s| Alias::from_str(&s).ok());

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

            return Ok(Some(Node {

                id: *id,

                alias,

                policy,

            }));

        }

        Ok(None)

    }

    /// Get a repository's tracking policy.

    pub fn repo_policy(&self, id: &Id) -> Result<Option<Repo>, Error> {

        let mut stmt = self

            .db

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

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

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

            return Ok(Some(Repo {

                id: *id,

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

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

            }));

        }

        Ok(None)

    }

    /// Get node tracking policies.

    pub fn node_policies(&self) -> Result<Box<dyn Iterator<Item = Node>>, Error> {

        let mut stmt = self

            .db

            .prepare("SELECT id, alias, policy FROM `following`")?

            .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").to_owned();

            let alias = alias

                .is_empty()

                .not()

                .then_some(alias.to_owned())

                .and_then(|s| Alias::from_str(&s).ok());

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

            entries.push(Node { id, alias, policy });

        }

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

    }

    // TODO: see if sql can return iterator directly

    /// Get repository tracking policies.

    pub fn repo_policies(&self) -> Result<Box<dyn Iterator<Item = Repo>>, Error> {

        let mut stmt = self

            .db

            .prepare("SELECT id, scope, policy FROM `seeding`")?

            .into_iter();

        let mut entries = Vec::new();

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

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

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

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

            entries.push(Repo { id, scope, policy });

        }

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

    }

}

impl<T> AliasStore for Config<T> {

    /// Retrieve `alias` of given node.

    /// Calls `Self::node_policy` under the hood.

    fn alias(&self, nid: &NodeId) -> Option<Alias> {

        self.node_policy(nid)

            .map(|node| node.and_then(|n| n.alias))

            .unwrap_or(None)

    }

}

#[cfg(test)]

mod test {

    use crate::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_policies() {

        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_policies().unwrap();

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

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

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

    }

    #[test]

    fn test_repo_policies() {

        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());