$ rad ls

By default, your node will subscribe to updates from _all_ peers. This

=== Publishing a repository on Radicle

Trying to clone a repository that is not in our routing table returns an error:

``` (fail)

✗ Error: no seeds found for rad:zVNuptPuk5XauitpCWSNVCXGGfXW

```

`clone` command, followed by the identifier or *RID* of the repository:

```

✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6MknSL…StBU8Vi..

✓ Forking under z6Mkt67…v4N1tRk..

✓ Creating checkout in ./heartwood..

      }

    },

    "policy": "block",

  }

}

```

Bob tries to fetch it, and even though he's connected to Alice, it fails.

``` ~bob

$ rad ls

```

``` ~bob (fail)

the `init` command:

```

Initializing public radicle 👾 project in .

```

$ rad node seeding

```

If we wish to see which nodes we are following:

╭───────────────────────────────────────────────────────────────────────────╮

│ DID                                                        Alias   Policy │

├───────────────────────────────────────────────────────────────────────────┤

╰───────────────────────────────────────────────────────────────────────────╯

```

Now let's track one of Eve's repositories:

```

```

            let tracking = profile.tracking()?;

            if let Some(repo) = tracking.repo_policy(&rid)? {

                let tracking = match repo.policy {

                    Policy::Block => term::format::negative("blocked"),

                };

                println!(

    To delete a policy, use the `--delete` flag.

    When seeding a repository, a scope can be specified: this can be either `all` or

    plus any remote that is explicitly followed via `rad follow <nid>`.

Options

    --delete, -d           Delete the seeding policy

    --[no-]fetch           Fetch repository after updating seeding policy

    --verbose, -v          Verbose output

    --help                 Print help

"#,

    let mut bob = bob.spawn();

    let mut eve = eve.spawn();

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

    bob.connect(&alice).converge([&alice]);

    eve.connect(&alice).converge([&alice]);

    let mut alice = alice.spawn();

    let mut bob = bob.spawn();

    // Prevent Alice from fetching Bob's fork, as we're not testing that and it may cause errors.

    bob.connect(&alice).converge([&alice]);

    let eve = eve.spawn();

    alice.connect(&bob);

    bob.routes_to(&[(acme, alice.id)]);

    eve.routes_to(&[(acme, alice.id), (acme, bob.id)]);

    let alice = environment.node(Config::test(Alias::new("alice")));

    let bob = environment.node(Config::test(Alias::new("bob")));

    let seed = environment.node(Config {

        scope: Scope::All,

        ..Config::test(Alias::new("seed"))

    });

//!      delegate data for the repository.

//!   2. [`SpecialRefs`]: fetches the special references, `rad/id` and

//!      `rad/sigrefs`, for each configured namespace, i.e. tracked

//!      scope is all.

//!   3. [`DataRefs`]: fetches the `Oid`s for each reference listed in

//!      the `rad/sigrefs` for each fetched peer in the

    fn ls_refs(&self) -> Option<NonEmpty<BString>> {

        match &self.tracked {

            tracking::Tracked::All => Some(NonEmpty::new("refs/namespaces".into())),

                remotes

                    .iter()

                    .chain(self.delegates.iter())

#[derive(Clone, Debug)]

pub enum Tracked {

    All,

}

impl Tracked {

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

                Err(error::Tracking::BlockedPolicy { rid })

            }

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

                    let nodes = config

                        .node_policies()

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

                        .collect();

                }

            },

        }

        self.filter = Filter::new(

            self.tracking

                .repo_policies()?

        );

        Ok(updated)

    }

        self.filter = Filter::new(

            self.tracking

                .repo_policies()?

        );

        // Try to establish some connections.

        self.maintain_connections();

                    "Service::handle_announcement: error accessing repo tracking configuration",

                );

                    let (fresh, stale) = match self.refs_status_of(message, &repo_entry.scope) {

                        Ok(RefsStatus { fresh, stale }) => (fresh, stale),

                        Err(e) => {

        // Second, check the scope.

        match scope {

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

                match self.tracking.namespaces_for(&self.storage, &message.rid) {

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

                        Ok(refs)

                    }

    /// Return a new filter object, based on our tracking policy.

    fn filter(&self) -> Filter {

            // TODO: Remove bits for blocked repos.

            Filter::default()

        } else {

        let missing = self

            .tracking

            .repo_policies()?

            .filter(|rid| !inventory.contains(rid));

        for rid in missing {

        assert!(self

            .tracking

            .unwrap());

        log::debug!(

        config.config.external_addresses.push(local_addr.into());

        for rid in storage.inventory().unwrap() {

        }

        let announcement = service::gossip::node(&config.config, config.local_time.as_secs());

        let emitter: Emitter<Event> = Default::default();

                                radicle::test::fetch(

                                    &repo,

                                    &nid,

                                )

                                .unwrap();

                            }

                                Rc::new(Ok(fetch::FetchResult {

                                    updated: vec![],

                                    namespaces: match namespaces {

                                        Namespaces::All => HashSet::new(),

                                    },

                                })),

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

    let rid = bob_inv[0];

    alice.connect_to(&bob);

    // Alice receives Bob's refs.

/// Alice and Bob both have the same repo.

///

/// First, Alice will not fetch from Bob's `RefsAnnouncement` as Alice does not

///

#[test]

    logger::init(log::Level::Debug);

    // Create MockStorage for Alice and Bob. Both will have repo with `rid`.

        },

    );

    alice.connect_to(&bob);

    // Alice receives Bob's refs

    alice.receive(bob.id(), bob.refs_announcement(rid));

    assert!(eve.get(proj_id).unwrap().is_none());

    assert!(bob.get(proj_id).unwrap().is_none());

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

    bob.command(service::Command::TrackRepo(

        proj_id,

        tracking::Scope::default(),

        sender,

    ));

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

    eve.command(service::Command::TrackRepo(

        proj_id,

    converge([&alice, &bob]);

    alice.handle.track_node(*carol.public_key(), None).unwrap();

    let result = alice.handle.fetch(acme, bob.id, DEFAULT_TIMEOUT).unwrap();

    // Fetch is successful despite not fetching Carol's refs, since she isn't a delegate.

    alice.connect(&bob);

    converge([&alice, &bob]);

    let result = bob.handle.fetch(acme, alice.id, DEFAULT_TIMEOUT).unwrap();

    assert!(result.is_success());

}

#[test]

    logger::init(log::Level::Debug);

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

    alice.connect(&bob);

    converge([&alice, &bob]);

        .iter()

        .map(|s| *s.public_key())

        .take(2)

        .collect::<HashSet<_>>();

    assert!(

        "Bob is only trusting a subset of peers"

    );

        assert!(bob.handle.track_node(*nid, None).unwrap());

    }

        .collect::<Result<HashSet<_>, _>>()

        .unwrap();

    assert!(bob_remotes.contains(&alice.id));

}

    alice.connect(&bob);

    converge([&alice, &bob]);

    assert!(bob.handle.track_node(*carol.public_key(), None).unwrap());

    let result = bob.handle.fetch(acme, alice.id, DEFAULT_TIMEOUT).unwrap();

    assert!(result.is_success());

    alice.connect(&bob);

    converge([&alice, &bob]);

    assert!(bob.handle.track_node(alice.id, None).unwrap());

    let result = bob.handle.fetch(acme, alice.id, DEFAULT_TIMEOUT).unwrap();

    pub policy: Policy,

}

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

#[serde(rename_all = "camelCase")]

pub enum Policy {

    /// The resource is blocked.

    #[default]

    Block,

impl fmt::Display for Policy {

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

        match self {

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

        }

    }

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

        match s {

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

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

        }

        i: I,

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

        match self {

            Self::Block => "block",

        }

        .bind(stmt, i)

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

        match value {

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

            _ => Err(sqlite::Error {

                code: None,

    }

}

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

#[serde(rename_all = "camelCase")]

pub enum Scope {

    #[default]

    All,

}

impl fmt::Display for Scope {

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

        match self {

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

        }

    }

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

        match s {

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

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

        }

        i: I,

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

        let s = match self {

            Self::All => "all",

        };

        s.bind(stmt, i)

#[derive(Debug, Error)]

pub enum NamespacesError {

    FailedPolicy {

        rid: Id,

        #[source]

        err: Error,

    },

    BlockedPolicy { rid: Id },

    FailedNodes {

        rid: Id,

        #[source]

        err: Error,

    },

    FailedDelegates {

        rid: Id,

        #[source]

    },

    #[error(transparent)]

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

}

/// Tracking configuration.

    /// Check if a repository is tracked.

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

        self.repo_policy(id)

    }

    /// Check if a node is tracked.

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

        self.node_policy(id)

    }

    /// Get a node's tracking information.

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

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

            }

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

                    let nodes = self

                        .node_policies()

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

                        .collect();

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

                            .delegates()

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

                            .map(PublicKey::from);

                    };

                        // Nb. returning All here because the

                        // fetching logic will correctly determine

                        Ok(Namespaces::All)

                    } else {

                    }

                }

            },

-- Service configuration schema.

--

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

  --

) strict;

  -- Repository ID.

  "id"                 text      primary key not null,

  -- Tracking scope for this repository.

  --

  -- Valid values are:

  --

  --

  -- Tracking policy for this repository.

  --

) strict;

    /// Track a node.

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

        let mut stmt = self.db.prepare(

             VALUES (?1, ?2)

             ON CONFLICT DO UPDATE

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

    /// Track a repository.

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

        let mut stmt = self.db.prepare(

             VALUES (?1, ?2)

             ON CONFLICT DO UPDATE

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

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

             VALUES (?1, ?2)

             ON CONFLICT DO UPDATE

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

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

             VALUES (?1, ?2)

             ON CONFLICT DO UPDATE

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

    /// Untrack a node.

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

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

        stmt.next()?;

    /// Untrack a repository.

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

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

        stmt.next()?;

        Ok(matches!(

            self.node_policy(id)?,

            Some(Node {

                ..

            })

        ))

        Ok(matches!(

            self.repo_policy(id)?,

            Some(Repo {

                ..

            })

        ))

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

        let mut stmt = self

            .db

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

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

        let mut stmt = self

            .db

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

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

        let mut stmt = self

            .db

            .into_iter();

        let mut entries = Vec::new();

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

        let mut stmt = self

            .db

            .into_iter();

        let mut entries = Vec::new();

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

        assert_eq!(db.repo_policy(&id).unwrap().unwrap().scope, Scope::All);

    }

    #[test]

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

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

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

        assert_eq!(db.repo_policy(&id).unwrap().unwrap().policy, Policy::Block);

    }

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

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

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

        assert_eq!(db.node_policy(&id).unwrap().unwrap().policy, Policy::Block);

    }

    /// All namespaces.

    #[default]

    All,

}

impl Namespaces {

                dst: (*NAMESPACES_GLOB).clone(),

                force: true,

            }],

                .iter()

                .map(|pk| {

                    let ns = pk.to_namespace().with_pattern(git::refspec::STAR);

impl FromIterator<PublicKey> for Namespaces {

    fn from_iter<T: IntoIterator<Item = PublicKey>>(iter: T) -> Self {

    }

}

) -> Result<Vec<RefUpdate>, crate::storage::FetchError> {

    let namespace = match namespaces.into() {

        Namespaces::All => None,

    };

    let mut updates = Vec::new();

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