e65595c node: Rename commands with new "seed" nomenclature — heartwood

modified radicle-cli/src/commands/clone.rs

@@ -217,7 +217,7 @@ pub fn clone<G: Signer>(

     let me = *signer.public_key();
     // Track.
     if node.track_repo(id, scope)? {
     if node.seed(id, scope)? {
         term::success!(
             "Tracking relationship established for {} with scope '{scope}'",
             term::format::tertiary(id)

modified radicle-cli/src/commands/follow.rs

@@ -98,7 +98,7 @@ pub fn follow(

     node: &mut Node,
     profile: &Profile,
 ) -> Result<(), anyhow::Error> {
     let followed = match node.track_node(nid, alias.clone()) {
     let followed = match node.follow(nid, alias.clone()) {
         Ok(updated) => updated,
         Err(e) if e.is_connection_err() => {
             let mut config = profile.tracking_mut()?;

modified radicle-cli/src/commands/unfollow.rs

@@ -76,7 +76,7 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

     let mut node = radicle::Node::new(profile.socket());
     let nid = options.nid;
     let unfollowed = match node.untrack_node(nid) {
     let unfollowed = match node.unfollow(nid) {
         Ok(updated) => updated,
         Err(e) if e.is_connection_err() => {
             let mut config = profile.tracking_mut()?;

modified radicle-cli/src/project.rs

@@ -60,7 +60,7 @@ pub fn track(

     node: &mut Node,
     profile: &Profile,
 ) -> Result<bool, anyhow::Error> {
     match node.track_repo(rid, scope) {
     match node.seed(rid, scope) {
         Ok(updated) => Ok(updated),
         Err(e) if e.is_connection_err() => {
             let mut config = profile.tracking_mut()?;

@@ -73,7 +73,7 @@ pub fn track(

 /// Untrack a repository by first trying to untrack through the node, and if the node isn't running,
 /// by updating the tracking database directly.
 pub fn untrack(rid: Id, node: &mut Node, profile: &Profile) -> Result<bool, anyhow::Error> {
     match node.untrack_repo(rid) {
     match node.unseed(rid) {
         Ok(updated) => Ok(updated),
         Err(e) if e.is_connection_err() => {
             let mut config = profile.tracking_mut()?;

modified radicle-cli/tests/commands.rs

@@ -261,7 +261,7 @@ fn rad_id() {

     let mut alice = alice.spawn();
     let bob = bob.spawn();
     alice.handle.track_repo(acme, Scope::All).unwrap();
     alice.handle.seed(acme, Scope::All).unwrap();
     alice.connect(&bob).converge([&bob]);
     let events = alice.handle.events();

@@ -316,8 +316,8 @@ fn rad_id_multi_delegate() {

     let mut bob = bob.spawn();
     let mut eve = eve.spawn();
     alice.handle.track_repo(acme, Scope::All).unwrap();
     bob.handle.track_node(eve.id, None).unwrap();
     alice.handle.seed(acme, Scope::All).unwrap();
     bob.handle.follow(eve.id, None).unwrap();
     alice.connect(&bob).converge([&bob]);
     eve.connect(&alice).converge([&alice]);

@@ -544,7 +544,7 @@ fn rad_patch_checkout_force() {

     let mut alice = alice.spawn();
     let mut bob = bob.spawn();
     bob.handle.track_repo(acme, Scope::All).unwrap();
     bob.handle.seed(acme, Scope::All).unwrap();
     alice.connect(&bob).converge([&bob]);
     test(

@@ -699,8 +699,8 @@ fn rad_clean() {

     let mut alice = alice.spawn();
     let mut bob = bob.spawn();
     let mut eve = eve.spawn();
     alice.handle.track_repo(acme, Scope::All).unwrap();
     eve.handle.track_repo(acme, Scope::Followed).unwrap();
     alice.handle.seed(acme, Scope::All).unwrap();
     eve.handle.seed(acme, Scope::Followed).unwrap();
     bob.connect(&alice).converge([&alice]);
     eve.connect(&alice).converge([&alice]);

@@ -769,7 +769,7 @@ fn rad_clone() {

     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.
     alice.handle.track_repo(acme, Scope::Followed).unwrap();
     alice.handle.seed(acme, Scope::Followed).unwrap();
     bob.connect(&alice).converge([&alice]);

@@ -791,7 +791,7 @@ fn rad_clone_all() {

     let mut bob = bob.spawn();
     let mut eve = eve.spawn();
     alice.handle.track_repo(acme, Scope::All).unwrap();
     alice.handle.seed(acme, Scope::All).unwrap();
     bob.connect(&alice).converge([&alice]);
     eve.connect(&alice).converge([&alice]);

@@ -873,8 +873,8 @@ fn rad_clone_connect() {

     let eve = eve.spawn();
     alice.handle.track_repo(acme, Scope::Followed).unwrap();
     bob.handle.track_repo(acme, Scope::Followed).unwrap();
     alice.handle.seed(acme, Scope::Followed).unwrap();
     bob.handle.seed(acme, Scope::Followed).unwrap();
     alice.connect(&bob);
     bob.routes_to(&[(acme, alice.id)]);
     eve.routes_to(&[(acme, alice.id), (acme, bob.id)]);

@@ -1105,7 +1105,7 @@ fn test_cob_replication() {

     let mut bob = bob.spawn();
     let events = alice.handle.events();
     alice.handle.track_node(bob.id, None).unwrap();
     alice.handle.follow(bob.id, None).unwrap();
     alice.connect(&bob);
     bob.routes_to(&[(rid, alice.id)]);

@@ -1165,8 +1165,8 @@ fn test_cob_deletion() {

     let mut alice = alice.spawn();
     let mut bob = bob.spawn();
     alice.handle.track_repo(rid, Scope::All).unwrap();
     bob.handle.track_repo(rid, Scope::All).unwrap();
     alice.handle.seed(rid, Scope::All).unwrap();
     bob.handle.seed(rid, Scope::All).unwrap();
     alice.connect(&bob);
     bob.routes_to(&[(rid, alice.id)]);

@@ -1229,8 +1229,8 @@ fn rad_sync() {

     let mut bob = bob.spawn();
     let mut eve = eve.spawn();
     bob.handle.track_repo(acme, Scope::All).unwrap();
     eve.handle.track_repo(acme, Scope::All).unwrap();
     bob.handle.seed(acme, Scope::All).unwrap();
     eve.handle.seed(acme, Scope::All).unwrap();
     alice.connect(&bob);
     eve.connect(&alice);

@@ -1359,7 +1359,7 @@ fn rad_remote() {

     let mut bob = bob.spawn();
     alice
         .handle
         .track_node(bob.id, Some(Alias::new("bob")))
         .follow(bob.id, Some(Alias::new("bob")))
         .unwrap();
     bob.connect(&alice);

modified radicle-node/src/control.rs

@@ -120,7 +120,7 @@ where

             CommandResult::Okay(sessions).to_writer(writer)?;
         }
         Command::TrackRepo { rid, scope } => match handle.track_repo(rid, scope) {
         Command::Seed { rid, scope } => match handle.seed(rid, scope) {
             Ok(result) => {
                 CommandResult::updated(result).to_writer(writer)?;
             }

@@ -128,7 +128,7 @@ where

                 return Err(CommandError::Runtime(e));
             }
         },
         Command::UntrackRepo { rid } => match handle.untrack_repo(rid) {
         Command::Unseed { rid } => match handle.unseed(rid) {
             Ok(result) => {
                 CommandResult::updated(result).to_writer(writer)?;
             }

@@ -136,7 +136,7 @@ where

                 return Err(CommandError::Runtime(e));
             }
         },
         Command::TrackNode { nid, alias } => match handle.track_node(nid, alias) {
         Command::Follow { nid, alias } => match handle.follow(nid, alias) {
             Ok(result) => {
                 CommandResult::updated(result).to_writer(writer)?;
             }

@@ -144,7 +144,7 @@ where

                 return Err(CommandError::Runtime(e));
             }
         },
         Command::UntrackNode { nid } => match handle.untrack_node(nid) {
         Command::Unfollow { nid } => match handle.unfollow(nid) {
             Ok(result) => {
                 CommandResult::updated(result).to_writer(writer)?;
             }

@@ -297,14 +297,14 @@ mod tests {

         // Wait for node to be online.
         while !handle.is_running() {}
         assert!(handle.track_repo(proj, Scope::default()).unwrap());
         assert!(!handle.track_repo(proj, Scope::default()).unwrap());
         assert!(handle.untrack_repo(proj).unwrap());
         assert!(!handle.untrack_repo(proj).unwrap());
         assert!(handle.seed(proj, Scope::default()).unwrap());
         assert!(!handle.seed(proj, Scope::default()).unwrap());
         assert!(handle.unseed(proj).unwrap());
         assert!(!handle.unseed(proj).unwrap());
         assert!(handle.track_node(peer, Some(Alias::new("alice"))).unwrap());
         assert!(!handle.track_node(peer, Some(Alias::new("alice"))).unwrap());
         assert!(handle.untrack_node(peer).unwrap());
         assert!(!handle.untrack_node(peer).unwrap());
         assert!(handle.follow(peer, Some(Alias::new("alice"))).unwrap());
         assert!(!handle.follow(peer, Some(Alias::new("alice"))).unwrap());
         assert!(handle.unfollow(peer).unwrap());
         assert!(!handle.unfollow(peer).unwrap());
     }
 }

modified radicle-node/src/runtime/handle.rs

@@ -201,25 +201,25 @@ impl radicle::node::Handle for Handle {

         receiver.recv().map_err(Error::from)
     }
     fn track_node(&mut self, id: NodeId, alias: Option<Alias>) -> Result<bool, Error> {
     fn follow(&mut self, id: NodeId, alias: Option<Alias>) -> Result<bool, Error> {
         let (sender, receiver) = chan::bounded(1);
         self.command(service::Command::TrackNode(id, alias, sender))?;
         receiver.recv().map_err(Error::from)
     }
     fn untrack_node(&mut self, id: NodeId) -> Result<bool, Error> {
     fn unfollow(&mut self, id: NodeId) -> Result<bool, Error> {
         let (sender, receiver) = chan::bounded(1);
         self.command(service::Command::UntrackNode(id, sender))?;
         receiver.recv().map_err(Error::from)
     }
     fn track_repo(&mut self, id: Id, scope: tracking::Scope) -> Result<bool, Error> {
     fn seed(&mut self, id: Id, scope: tracking::Scope) -> Result<bool, Error> {
         let (sender, receiver) = chan::bounded(1);
         self.command(service::Command::TrackRepo(id, scope, sender))?;
         receiver.recv().map_err(Error::from)
     }
     fn untrack_repo(&mut self, id: Id) -> Result<bool, Error> {
     fn unseed(&mut self, id: Id) -> Result<bool, Error> {
         let (sender, receiver) = chan::bounded(1);
         self.command(service::Command::UntrackRepo(id, sender))?;
         receiver.recv().map_err(Error::from)

modified radicle-node/src/test/handle.rs

@@ -60,15 +60,15 @@ impl radicle::node::Handle for Handle {

         })
     }
     fn track_repo(&mut self, id: Id, _scope: tracking::Scope) -> Result<bool, Self::Error> {
     fn seed(&mut self, id: Id, _scope: tracking::Scope) -> Result<bool, Self::Error> {
         Ok(self.tracking_repos.lock().unwrap().insert(id))
     }
     fn untrack_repo(&mut self, id: Id) -> Result<bool, Self::Error> {
     fn unseed(&mut self, id: Id) -> Result<bool, Self::Error> {
         Ok(self.tracking_repos.lock().unwrap().remove(&id))
     }
     fn track_node(&mut self, id: NodeId, _alias: Option<Alias>) -> Result<bool, Self::Error> {
     fn follow(&mut self, id: NodeId, _alias: Option<Alias>) -> Result<bool, Self::Error> {
         Ok(self.tracking_nodes.lock().unwrap().insert(id))
     }

@@ -79,7 +79,7 @@ impl radicle::node::Handle for Handle {

         Ok(Box::new(std::iter::empty()))
     }
     fn untrack_node(&mut self, id: NodeId) -> Result<bool, Self::Error> {
     fn unfollow(&mut self, id: NodeId) -> Result<bool, Self::Error> {
         Ok(self.tracking_nodes.lock().unwrap().remove(&id))
     }

modified radicle-node/src/tests/e2e.rs

@@ -163,7 +163,7 @@ fn test_replication() {

     let inventory = alice.storage.inventory().unwrap();
     assert!(inventory.is_empty());
     let tracked = alice.handle.track_repo(acme, Scope::All).unwrap();
     let tracked = alice.handle.seed(acme, Scope::All).unwrap();
     assert!(tracked);
     let seeds = alice.handle.seeds(acme).unwrap();

@@ -229,7 +229,7 @@ fn test_replication_ref_in_sigrefs() {

     alice.connect(&bob);
     converge([&alice, &bob]);
     alice.handle.track_repo(acme, Scope::All).unwrap();
     alice.handle.seed(acme, Scope::All).unwrap();
     let result = alice.handle.fetch(acme, bob.id, DEFAULT_TIMEOUT).unwrap();
     assert_matches!(result, FetchResult::Success { .. });

@@ -283,8 +283,8 @@ fn test_replication_invalid() {

     alice.connect(&bob);
     converge([&alice, &bob]);
     alice.handle.track_node(*carol.public_key(), None).unwrap();
     alice.handle.track_repo(acme, Scope::Followed).unwrap();
     alice.handle.follow(*carol.public_key(), None).unwrap();
     alice.handle.seed(acme, Scope::Followed).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.

@@ -314,7 +314,7 @@ fn test_migrated_clone() {

     alice.connect(&bob);
     converge([&alice, &bob]);
     let tracked = bob.handle.track_repo(acme, Scope::All).unwrap();
     let tracked = bob.handle.seed(acme, Scope::All).unwrap();
     assert!(tracked);
     let result = bob.handle.fetch(acme, alice.id, DEFAULT_TIMEOUT).unwrap();

@@ -367,7 +367,7 @@ fn test_dont_fetch_owned_refs() {

     alice.connect(&bob);
     converge([&alice, &bob]);
     assert!(bob.handle.track_repo(acme, Scope::Followed).unwrap());
     assert!(bob.handle.seed(acme, Scope::Followed).unwrap());
     let result = bob.handle.fetch(acme, alice.id, DEFAULT_TIMEOUT).unwrap();
     assert!(result.is_success());

@@ -412,9 +412,9 @@ fn test_fetch_followed_remotes() {

         followed.len() < signers.len(),
         "Bob is only trusting a subset of peers"
     );
     assert!(bob.handle.track_repo(acme, Scope::Followed).unwrap());
     assert!(bob.handle.seed(acme, Scope::Followed).unwrap());
     for nid in &followed {
         assert!(bob.handle.track_node(*nid, None).unwrap());
         assert!(bob.handle.follow(*nid, None).unwrap());
     }
     let result = bob.handle.fetch(acme, alice.id, DEFAULT_TIMEOUT).unwrap();

@@ -450,8 +450,8 @@ fn test_missing_remote() {

     alice.connect(&bob);
     converge([&alice, &bob]);
     assert!(bob.handle.track_repo(acme, Scope::Followed).unwrap());
     assert!(bob.handle.track_node(*carol.public_key(), None).unwrap());
     assert!(bob.handle.seed(acme, Scope::Followed).unwrap());
     assert!(bob.handle.follow(*carol.public_key(), None).unwrap());
     let result = bob.handle.fetch(acme, alice.id, DEFAULT_TIMEOUT).unwrap();
     assert!(result.is_success());
     log::debug!(target: "test", "Fetch complete with {}", bob.id);

@@ -477,8 +477,8 @@ fn test_fetch_preserve_owned_refs() {

     alice.connect(&bob);
     converge([&alice, &bob]);
     assert!(bob.handle.track_repo(acme, Scope::Followed).unwrap());
     assert!(bob.handle.track_node(alice.id, None).unwrap());
     assert!(bob.handle.seed(acme, Scope::Followed).unwrap());
     assert!(bob.handle.follow(alice.id, None).unwrap());
     let result = bob.handle.fetch(acme, alice.id, DEFAULT_TIMEOUT).unwrap();
     assert!(result.is_success());

@@ -526,7 +526,7 @@ fn test_clone() {

     transport::local::register(alice.storage.clone());
     let _ = alice.handle.track_repo(acme, Scope::All).unwrap();
     let _ = alice.handle.seed(acme, Scope::All).unwrap();
     let seeds = alice.handle.seeds(acme).unwrap();
     assert!(seeds.is_connected(&bob.id));

@@ -584,7 +584,7 @@ fn test_fetch_up_to_date() {

     transport::local::register(alice.storage.clone());
     let _ = alice.handle.track_repo(acme, Scope::All).unwrap();
     let _ = alice.handle.seed(acme, Scope::All).unwrap();
     let result = alice.handle.fetch(acme, bob.id, DEFAULT_TIMEOUT).unwrap();
     assert!(result.is_success());

@@ -615,7 +615,7 @@ fn test_large_fetch() {

     let mut bob = bob.spawn();
     let bob_events = bob.handle.events();
     bob.handle.track_repo(rid, Scope::All).unwrap();
     bob.handle.seed(rid, Scope::All).unwrap();
     alice.connect(&bob);
     bob_events

@@ -688,10 +688,10 @@ fn test_concurrent_fetches() {

     let bob_events = bob.handle.events();
     for rid in &bob_repos {
         alice.handle.track_repo(*rid, Scope::All).unwrap();
         alice.handle.seed(*rid, Scope::All).unwrap();
     }
     for rid in &alice_repos {
         bob.handle.track_repo(*rid, Scope::All).unwrap();
         bob.handle.seed(*rid, Scope::All).unwrap();
     }
     alice.connect(&bob);

@@ -801,8 +801,8 @@ fn test_non_fastforward_sigrefs() {

     let bob = bob.spawn();
     let mut eve = eve.spawn();
     alice.handle.track_repo(rid, Scope::All).unwrap();
     eve.handle.track_repo(rid, Scope::All).unwrap();
     alice.handle.seed(rid, Scope::All).unwrap();
     eve.handle.seed(rid, Scope::All).unwrap();
     alice.connect(&bob);
     alice.connect(&eve);

@@ -875,8 +875,8 @@ fn test_outdated_sigrefs() {

     let mut bob = bob.spawn();
     let mut eve = eve.spawn();
     bob.handle.track_repo(rid, Scope::All).unwrap();
     eve.handle.track_repo(rid, Scope::All).unwrap();
     bob.handle.seed(rid, Scope::All).unwrap();
     eve.handle.seed(rid, Scope::All).unwrap();
     alice.connect(&bob);
     bob.connect(&eve);
     eve.connect(&alice);

@@ -892,7 +892,7 @@ fn test_outdated_sigrefs() {

     alice
         .handle
         .track_node(eve.id, Some(Alias::new("eve")))
         .follow(eve.id, Some(Alias::new("eve")))
         .unwrap();
     alice.handle.fetch(rid, eve.id, DEFAULT_TIMEOUT).unwrap();
     let repo = alice.storage.repository(rid).unwrap();

@@ -934,7 +934,7 @@ fn test_outdated_sigrefs() {

     alice
         .handle
         .track_node(bob.id, Some(Alias::new("bob")))
         .follow(bob.id, Some(Alias::new("bob")))
         .unwrap();
     assert_matches!(
         alice.handle.fetch(rid, bob.id, DEFAULT_TIMEOUT).unwrap(),

@@ -966,8 +966,8 @@ fn test_outdated_delegate_sigrefs() {

     let mut bob = bob.spawn();
     let mut eve = eve.spawn();
     bob.handle.track_repo(rid, Scope::All).unwrap();
     eve.handle.track_repo(rid, Scope::All).unwrap();
     bob.handle.seed(rid, Scope::All).unwrap();
     eve.handle.seed(rid, Scope::All).unwrap();
     alice.connect(&bob);
     bob.connect(&eve);
     eve.connect(&alice);

@@ -983,7 +983,7 @@ fn test_outdated_delegate_sigrefs() {

     alice
         .handle
         .track_node(eve.id, Some(Alias::new("eve")))
         .follow(eve.id, Some(Alias::new("eve")))
         .unwrap();
     alice.handle.fetch(rid, eve.id, DEFAULT_TIMEOUT).unwrap();
     let repo = alice.storage.repository(rid).unwrap();

@@ -1023,9 +1023,7 @@ fn test_outdated_delegate_sigrefs() {

     log::debug!(target: "test", "Alice fetches from Bob..");
     eve.handle
         .track_node(bob.id, Some(Alias::new("bob")))
         .unwrap();
     eve.handle.follow(bob.id, Some(Alias::new("bob"))).unwrap();
     assert_matches!(
         eve.handle.fetch(rid, bob.id, DEFAULT_TIMEOUT).unwrap(),
         FetchResult::Success { .. }

@@ -1054,8 +1052,8 @@ fn missing_default_branch() {

     let mut alice = alice.spawn();
     let mut bob = bob.spawn();
     alice.handle.track_repo(rid, Scope::All).unwrap();
     bob.handle.track_repo(rid, Scope::All).unwrap();
     alice.handle.seed(rid, Scope::All).unwrap();
     bob.handle.seed(rid, Scope::All).unwrap();
     alice.connect(&bob);
     converge([&alice, &bob]);

modified radicle/src/node.rs

@@ -412,21 +412,21 @@ pub enum Command {

         timeout: time::Duration,
     },
     /// Track the given repository.
     /// Seed the given repository.
     #[serde(rename_all = "camelCase")]
     TrackRepo { rid: Id, scope: tracking::Scope },
     Seed { rid: Id, scope: tracking::Scope },
     /// Untrack the given repository.
     /// Unseed the given repository.
     #[serde(rename_all = "camelCase")]
     UntrackRepo { rid: Id },
     Unseed { rid: Id },
     /// Track the given node.
     /// Follow the given node.
     #[serde(rename_all = "camelCase")]
     TrackNode { nid: NodeId, alias: Option<Alias> },
     Follow { nid: NodeId, alias: Option<Alias> },
     /// Untrack the given node.
     /// Unfollow the given node.
     #[serde(rename_all = "camelCase")]
     UntrackNode { nid: NodeId },
     Unfollow { nid: NodeId },
     /// Get the node's status.
     Status,

@@ -775,15 +775,15 @@ pub trait Handle: Clone + Sync + Send {

         from: NodeId,
         timeout: time::Duration,
     ) -> Result<FetchResult, Self::Error>;
     /// Start tracking the given project. Doesn't do anything if the project is already
     /// tracked.
     fn track_repo(&mut self, id: Id, scope: tracking::Scope) -> Result<bool, Self::Error>;
     /// Start tracking the given node.
     fn track_node(&mut self, id: NodeId, alias: Option<Alias>) -> Result<bool, Self::Error>;
     /// Untrack the given project and delete it from storage.
     fn untrack_repo(&mut self, id: Id) -> Result<bool, Self::Error>;
     /// Untrack the given node.
     fn untrack_node(&mut self, id: NodeId) -> Result<bool, Self::Error>;
     /// Start seeding the given repo. May update the scope. Does nothing if the
     /// repo is already seeded.
     fn seed(&mut self, id: Id, scope: tracking::Scope) -> Result<bool, Self::Error>;
     /// Start following the given peer.
     fn follow(&mut self, id: NodeId, alias: Option<Alias>) -> Result<bool, Self::Error>;
     /// Un-seed the given repo and delete it from storage.
     fn unseed(&mut self, id: Id) -> Result<bool, Self::Error>;
     /// Unfollow the given peer.
     fn unfollow(&mut self, id: NodeId) -> Result<bool, Self::Error>;
     /// Notify the service that a project has been updated, and announce local refs.
     fn announce_refs(&mut self, id: Id) -> Result<RefsAt, Self::Error>;
     /// Announce local inventory.

@@ -981,29 +981,29 @@ impl Handle for Node {

         Ok(result)
     }
     fn track_node(&mut self, nid: NodeId, alias: Option<Alias>) -> Result<bool, Error> {
         let mut line = self.call::<Success>(Command::TrackNode { nid, alias }, DEFAULT_TIMEOUT)?;
     fn follow(&mut self, nid: NodeId, alias: Option<Alias>) -> Result<bool, Error> {
         let mut line = self.call::<Success>(Command::Follow { nid, alias }, DEFAULT_TIMEOUT)?;
         let response = line.next().ok_or(Error::EmptyResponse)??;
         Ok(response.updated)
     }
     fn track_repo(&mut self, rid: Id, scope: tracking::Scope) -> Result<bool, Error> {
         let mut line = self.call::<Success>(Command::TrackRepo { rid, scope }, DEFAULT_TIMEOUT)?;
     fn seed(&mut self, rid: Id, scope: tracking::Scope) -> Result<bool, Error> {
         let mut line = self.call::<Success>(Command::Seed { rid, scope }, DEFAULT_TIMEOUT)?;
         let response = line.next().ok_or(Error::EmptyResponse)??;
         Ok(response.updated)
     }
     fn untrack_node(&mut self, nid: NodeId) -> Result<bool, Error> {
         let mut line = self.call::<Success>(Command::UntrackNode { nid }, DEFAULT_TIMEOUT)?;
     fn unfollow(&mut self, nid: NodeId) -> Result<bool, Error> {
         let mut line = self.call::<Success>(Command::Unfollow { nid }, DEFAULT_TIMEOUT)?;
         let response = line.next().ok_or(Error::EmptyResponse)??;
         Ok(response.updated)
     }
     fn untrack_repo(&mut self, rid: Id) -> Result<bool, Error> {
         let mut line = self.call::<Success>(Command::UntrackRepo { rid }, DEFAULT_TIMEOUT)?;
     fn unseed(&mut self, rid: Id) -> Result<bool, Error> {
         let mut line = self.call::<Success>(Command::Unseed { rid }, DEFAULT_TIMEOUT)?;
         let response = line.next().ok_or(Error::EmptyResponse {})??;
         Ok(response.updated)