node: Rename commands with new "seed" nomenclature

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)

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

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

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

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();
+    alice.handle.seed(acme, Scope::All).unwrap();
-    bob.handle.track_node(eve.id, None).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();
+    alice.handle.seed(acme, Scope::All).unwrap();
-    eve.handle.track_repo(acme, Scope::Followed).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();
+    alice.handle.seed(acme, Scope::Followed).unwrap();
-    bob.handle.track_repo(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();
+    alice.handle.seed(rid, Scope::All).unwrap();
-    bob.handle.track_repo(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();
+    bob.handle.seed(acme, Scope::All).unwrap();
-    eve.handle.track_repo(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);

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.seed(proj, Scope::default()).unwrap());
-        assert!(!handle.track_repo(proj, Scope::default()).unwrap());
+        assert!(!handle.seed(proj, Scope::default()).unwrap());
-        assert!(handle.untrack_repo(proj).unwrap());
+        assert!(handle.unseed(proj).unwrap());
-        assert!(!handle.untrack_repo(proj).unwrap());
+        assert!(!handle.unseed(proj).unwrap());
 
-        assert!(handle.track_node(peer, Some(Alias::new("alice"))).unwrap());
+        assert!(handle.follow(peer, Some(Alias::new("alice"))).unwrap());
-        assert!(!handle.track_node(peer, Some(Alias::new("alice"))).unwrap());
+        assert!(!handle.follow(peer, Some(Alias::new("alice"))).unwrap());
-        assert!(handle.untrack_node(peer).unwrap());
+        assert!(handle.unfollow(peer).unwrap());
-        assert!(!handle.untrack_node(peer).unwrap());
+        assert!(!handle.unfollow(peer).unwrap());
     }
 }

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)

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))
     }
 

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.follow(*carol.public_key(), None).unwrap();
-    alice.handle.track_repo(acme, Scope::Followed).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.seed(acme, Scope::Followed).unwrap());
-    assert!(bob.handle.track_node(*carol.public_key(), None).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.seed(acme, Scope::Followed).unwrap());
-    assert!(bob.handle.track_node(alice.id, None).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();
+    alice.handle.seed(rid, Scope::All).unwrap();
-    eve.handle.track_repo(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();
+    bob.handle.seed(rid, Scope::All).unwrap();
-    eve.handle.track_repo(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();
+    bob.handle.seed(rid, Scope::All).unwrap();
-    eve.handle.track_repo(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
+    eve.handle.follow(bob.id, Some(Alias::new("bob"))).unwrap();
-        .track_node(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();
+    alice.handle.seed(rid, Scope::All).unwrap();
-    bob.handle.track_repo(rid, Scope::All).unwrap();
+    bob.handle.seed(rid, Scope::All).unwrap();
     alice.connect(&bob);
     converge([&alice, &bob]);
 

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
+    /// Start seeding the given repo. May update the scope. Does nothing if the
-    /// tracked.
+    /// repo is already seeded.
-    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>;
-    /// Start tracking the given node.
+    /// Start following the given peer.
-    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>;
-    /// Untrack the given project and delete it from storage.
+    /// Un-seed the given repo and delete it from storage.
-    fn untrack_repo(&mut self, id: Id) -> Result<bool, Self::Error>;
+    fn unseed(&mut self, id: Id) -> Result<bool, Self::Error>;
-    /// Untrack the given node.
+    /// Unfollow the given peer.
-    fn untrack_node(&mut self, id: NodeId) -> Result<bool, Self::Error>;
+    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> {
+    fn follow(&mut self, nid: NodeId, alias: Option<Alias>) -> Result<bool, Error> {
-        let mut line = self.call::<Success>(Command::TrackNode { nid, alias }, DEFAULT_TIMEOUT)?;
+        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> {
+    fn seed(&mut self, rid: Id, scope: tracking::Scope) -> Result<bool, Error> {
-        let mut line = self.call::<Success>(Command::TrackRepo { rid, scope }, DEFAULT_TIMEOUT)?;
+        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> {
+    fn unfollow(&mut self, nid: NodeId) -> Result<bool, Error> {
-        let mut line = self.call::<Success>(Command::UntrackNode { nid }, DEFAULT_TIMEOUT)?;
+        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> {
+    fn unseed(&mut self, rid: Id) -> Result<bool, Error> {
-        let mut line = self.call::<Success>(Command::UntrackRepo { rid }, DEFAULT_TIMEOUT)?;
+        let mut line = self.call::<Success>(Command::Unseed { rid }, DEFAULT_TIMEOUT)?;
         let response = line.next().ok_or(Error::EmptyResponse {})??;
 
         Ok(response.updated)