mab122
/
radicle-heartwood-lfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

node: Rename commands with new "seed" nomenclature

This commit is contained in:
cloudhead 2023-12-01 13:34:14 +01:00
parent f453090e27
commit e65595c4c7
No known key found for this signature in database
10 changed files with 95 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
radicle-cli/src/commands/clone.rs
View File

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

2
radicle-cli/src/commands/follow.rs
View File

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

2
radicle-cli/src/commands/unfollow.rs
View File

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

4
radicle-cli/src/project.rs
View File

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

32
radicle-cli/tests/commands.rs
View File

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

24
radicle-node/src/control.rs
View File

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

8
radicle-node/src/runtime/handle.rs
View File

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

8
radicle-node/src/test/handle.rs
View File

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

60
radicle-node/src/tests/e2e.rs
View File

@ -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]);

50
radicle/src/node.rs
View File

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