diff --git a/radicle-cli/src/commands/clone.rs b/radicle-cli/src/commands/clone.rs index d937e6ef..5ae9c9dc 100644 --- a/radicle-cli/src/commands/clone.rs +++ b/radicle-cli/src/commands/clone.rs @@ -217,7 +217,7 @@ pub fn clone( 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) diff --git a/radicle-cli/src/commands/follow.rs b/radicle-cli/src/commands/follow.rs index b4514e54..bdac1bb3 100644 --- a/radicle-cli/src/commands/follow.rs +++ b/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()?; diff --git a/radicle-cli/src/commands/unfollow.rs b/radicle-cli/src/commands/unfollow.rs index 8fa2c939..d12167dd 100644 --- a/radicle-cli/src/commands/unfollow.rs +++ b/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()?; diff --git a/radicle-cli/src/project.rs b/radicle-cli/src/project.rs index 939fe2e1..71e99f16 100644 --- a/radicle-cli/src/project.rs +++ b/radicle-cli/src/project.rs @@ -60,7 +60,7 @@ pub fn track( node: &mut Node, profile: &Profile, ) -> Result { - 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 { - 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()?; diff --git a/radicle-cli/tests/commands.rs b/radicle-cli/tests/commands.rs index 22a8fe6d..8aa5b590 100644 --- a/radicle-cli/tests/commands.rs +++ b/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); diff --git a/radicle-node/src/control.rs b/radicle-node/src/control.rs index 084755f7..59b0050e 100644 --- a/radicle-node/src/control.rs +++ b/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()); } } diff --git a/radicle-node/src/runtime/handle.rs b/radicle-node/src/runtime/handle.rs index 11df49b3..a74bee98 100644 --- a/radicle-node/src/runtime/handle.rs +++ b/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) -> Result { + fn follow(&mut self, id: NodeId, alias: Option) -> Result { 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 { + fn unfollow(&mut self, id: NodeId) -> Result { 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 { + fn seed(&mut self, id: Id, scope: tracking::Scope) -> Result { 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 { + fn unseed(&mut self, id: Id) -> Result { let (sender, receiver) = chan::bounded(1); self.command(service::Command::UntrackRepo(id, sender))?; receiver.recv().map_err(Error::from) diff --git a/radicle-node/src/test/handle.rs b/radicle-node/src/test/handle.rs index 37004ffa..7219b6f7 100644 --- a/radicle-node/src/test/handle.rs +++ b/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 { + fn seed(&mut self, id: Id, _scope: tracking::Scope) -> Result { Ok(self.tracking_repos.lock().unwrap().insert(id)) } - fn untrack_repo(&mut self, id: Id) -> Result { + fn unseed(&mut self, id: Id) -> Result { Ok(self.tracking_repos.lock().unwrap().remove(&id)) } - fn track_node(&mut self, id: NodeId, _alias: Option) -> Result { + fn follow(&mut self, id: NodeId, _alias: Option) -> Result { 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 { + fn unfollow(&mut self, id: NodeId) -> Result { Ok(self.tracking_nodes.lock().unwrap().remove(&id)) } diff --git a/radicle-node/src/tests/e2e.rs b/radicle-node/src/tests/e2e.rs index 714f720e..fd6458dd 100644 --- a/radicle-node/src/tests/e2e.rs +++ b/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]); diff --git a/radicle/src/node.rs b/radicle/src/node.rs index af777823..2ffecf0f 100644 --- a/radicle/src/node.rs +++ b/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 }, + Follow { nid: NodeId, alias: Option }, - /// 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; - /// 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; - /// Start tracking the given node. - fn track_node(&mut self, id: NodeId, alias: Option) -> Result; - /// Untrack the given project and delete it from storage. - fn untrack_repo(&mut self, id: Id) -> Result; - /// Untrack the given node. - fn untrack_node(&mut self, id: NodeId) -> Result; + /// 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; + /// Start following the given peer. + fn follow(&mut self, id: NodeId, alias: Option) -> Result; + /// Un-seed the given repo and delete it from storage. + fn unseed(&mut self, id: Id) -> Result; + /// Unfollow the given peer. + fn unfollow(&mut self, id: NodeId) -> Result; /// Notify the service that a project has been updated, and announce local refs. fn announce_refs(&mut self, id: Id) -> Result; /// Announce local inventory. @@ -981,29 +981,29 @@ impl Handle for Node { Ok(result) } - fn track_node(&mut self, nid: NodeId, alias: Option) -> Result { - let mut line = self.call::(Command::TrackNode { nid, alias }, DEFAULT_TIMEOUT)?; + fn follow(&mut self, nid: NodeId, alias: Option) -> Result { + let mut line = self.call::(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 { - let mut line = self.call::(Command::TrackRepo { rid, scope }, DEFAULT_TIMEOUT)?; + fn seed(&mut self, rid: Id, scope: tracking::Scope) -> Result { + let mut line = self.call::(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 { - let mut line = self.call::(Command::UntrackNode { nid }, DEFAULT_TIMEOUT)?; + fn unfollow(&mut self, nid: NodeId) -> Result { + let mut line = self.call::(Command::Unfollow { nid }, DEFAULT_TIMEOUT)?; let response = line.next().ok_or(Error::EmptyResponse)??; Ok(response.updated) } - fn untrack_repo(&mut self, rid: Id) -> Result { - let mut line = self.call::(Command::UntrackRepo { rid }, DEFAULT_TIMEOUT)?; + fn unseed(&mut self, rid: Id) -> Result { + let mut line = self.call::(Command::Unseed { rid }, DEFAULT_TIMEOUT)?; let response = line.next().ok_or(Error::EmptyResponse {})??; Ok(response.updated)