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

node: Rename certain functions for clarity

This commit is contained in:
cloudhead 2024-06-08 21:31:19 +02:00
parent b24f8a30d6
commit a6b5c723c8
No known key found for this signature in database
10 changed files with 74 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -59,12 +59,13 @@ pub fn add_inventory(
node: &mut Node,
profile: &Profile,
) -> Result<bool, anyhow::Error> {
match node.update_inventory(rid) {
match node.add_inventory(rid) {
Ok(updated) => Ok(updated),
Err(e) if e.is_connection_err() => {
let now = LocalTime::now();
let mut db = profile.database_mut()?;
let updates = routing::Store::insert(&mut db, [&rid], *profile.id(), now.into())?;
let updates =
routing::Store::add_inventory(&mut db, [&rid], *profile.id(), now.into())?;
Ok(!updates.is_empty())
}
@ -91,7 +92,7 @@ pub fn seed(
let now = LocalTime::now();
let mut db = profile.database_mut()?;
routing::Store::insert(&mut db, [&rid], *profile.id(), now.into())?;
routing::Store::add_inventory(&mut db, [&rid], *profile.id(), now.into())?;
}
Ok(result)
}
@ -109,7 +110,7 @@ pub fn unseed(rid: RepoId, node: &mut Node, profile: &Profile) -> Result<bool, a
let result = config.unseed(&rid)?;
let mut db = profile.database_mut()?;
radicle::node::routing::Store::remove(&mut db, &rid, profile.id())?;
radicle::node::routing::Store::remove_inventory(&mut db, &rid, profile.id())?;
Ok(result)
}

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

@ -1313,7 +1313,7 @@ fn rad_clone_partial_fail() {
.unwrap();
eve.db
.routing_mut()
.insert([&acme], carol, localtime::LocalTime::now().into())
.add_inventory([&acme], carol, localtime::LocalTime::now().into())
.unwrap();
eve.config.peers = node::config::PeerConfig::Static;
@ -1390,8 +1390,14 @@ fn rad_clone_connect() {
)],
)
.unwrap();
eve.db.routing_mut().insert([&acme], alice.id, now).unwrap();
eve.db.routing_mut().insert([&acme], bob.id, now).unwrap();
eve.db
.routing_mut()
.add_inventory([&acme], alice.id, now)
.unwrap();
eve.db
.routing_mut()
.add_inventory([&acme], bob.id, now)
.unwrap();
eve.config.peers = node::config::PeerConfig::Static;
let eve = eve.spawn();

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

@ -174,7 +174,7 @@ where
}
CommandResult::ok().to_writer(writer).ok();
}
Command::UpdateInventory { rid } => match handle.update_inventory(rid) {
Command::AddInventory { rid } => match handle.add_inventory(rid) {
Ok(result) => {
CommandResult::updated(result).to_writer(writer)?;
}

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

@ -260,9 +260,9 @@ impl radicle::node::Handle for Handle {
.map_err(Error::from)
}
fn update_inventory(&mut self, rid: RepoId) -> Result<bool, Error> {
fn add_inventory(&mut self, rid: RepoId) -> Result<bool, Error> {
let (sender, receiver) = chan::bounded(1);
self.command(service::Command::UpdateInventory(rid, sender))?;
self.command(service::Command::AddInventory(rid, sender))?;
receiver.recv().map_err(Error::from)
}

33
radicle-node/src/service.rs
View File

@ -216,8 +216,8 @@ pub enum Command {
AnnounceRefs(RepoId, chan::Sender<RefsAt>),
/// Announce local repositories to peers.
AnnounceInventory,
/// Update local inventory.
UpdateInventory(RepoId, chan::Sender<bool>),
/// Add repository to local inventory.
AddInventory(RepoId, chan::Sender<bool>),
/// Connect to node with the given address.
Connect(NodeId, Address, ConnectOptions),
/// Disconnect from node.
@ -247,7 +247,7 @@ impl fmt::Debug for Command {
match self {
Self::AnnounceRefs(id, _) => write!(f, "AnnounceRefs({id})"),
Self::AnnounceInventory => write!(f, "AnnounceInventory"),
Self::UpdateInventory(rid, _) => write!(f, "UpdateInventory({rid})"),
Self::AddInventory(rid, _) => write!(f, "AddInventory({rid})"),
Self::Connect(id, addr, opts) => write!(f, "Connect({id}, {addr}, {opts:?})"),
Self::Disconnect(id) => write!(f, "Disconnect({id})"),
Self::Config(_) => write!(f, "Config"),
@ -734,7 +734,7 @@ where
// user creates a new repository while the node is stopped.
self.db
.routing_mut()
.insert(inventory.iter(), nid, time.into())?;
.add_inventory(inventory.iter(), nid, time.into())?;
self.inventory = gossip::inventory(self.timestamp(), inventory);
}
@ -943,7 +943,7 @@ where
Command::AnnounceInventory => {
self.announce_inventory();
}
Command::UpdateInventory(rid, resp) => match self.add_inventory(rid) {
Command::AddInventory(rid, resp) => match self.add_inventory(rid) {
Ok(updated) => {
resp.send(updated).ok();
}
@ -1890,7 +1890,7 @@ where
/// Add a seed to our routing table.
fn seed_discovered(&mut self, rid: RepoId, nid: NodeId, time: Timestamp) {
if let Ok(result) = self.db.routing_mut().insert([&rid], nid, time) {
if let Ok(result) = self.db.routing_mut().add_inventory([&rid], nid, time) {
if let &[(_, InsertResult::SeedAdded)] = result.as_slice() {
self.emitter.emit(Event::SeedDiscovered { rid, nid });
info!(target: "service", "Routing table updated for {} with seed {nid}", rid);
@ -1940,8 +1940,7 @@ where
let node = self.node_id();
let now = self.timestamp();
// Remove inventory.
let removed = self.db.routing_mut().remove(rid, &node)?;
let removed = self.db.routing_mut().remove_inventory(rid, &node)?;
if removed {
// Update cached inventory message.
let inventory = self.inventory()?;
@ -1960,8 +1959,8 @@ where
error!(target: "service", "Attempt to add non-existing inventory {rid}: repository not found in storage");
return Ok(false);
}
// Add to our inventory.
let updates = self.db.routing_mut().insert([&rid], node, now)?;
// Add to our local inventory.
let updates = self.db.routing_mut().add_inventory([&rid], node, now)?;
let updated = !updates.is_empty();
if updated {
@ -1986,7 +1985,7 @@ where
fn inventory(&self) -> Result<HashSet<RepoId>, Error> {
self.db
.routing()
.get_resources(self.nid())
.get_inventory(self.nid())
.map_err(Error::from)
}
@ -2002,10 +2001,10 @@ where
let mut synced = SyncedRouting::default();
let included = inventory.into_iter().collect::<BTreeSet<_>>();
for (rid, result) in self
.db
.routing_mut()
.insert(included.iter(), from, timestamp)?
for (rid, result) in
self.db
.routing_mut()
.add_inventory(included.iter(), from, timestamp)?
{
match result {
InsertResult::SeedAdded => {
@ -2028,9 +2027,9 @@ where
InsertResult::NotUpdated => {}
}
}
for rid in self.db.routing().get_resources(&from)?.into_iter() {
for rid in self.db.routing().get_inventory(&from)?.into_iter() {
if !included.contains(&rid) {
if self.db.routing_mut().remove(&rid, &from)? {
if self.db.routing_mut().remove_inventory(&rid, &from)? {
synced.removed.push(rid);
self.emitter.emit(Event::SeedDropped { rid, nid: from });
}

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

@ -104,7 +104,7 @@ impl radicle::node::Handle for Handle {
Ok(())
}
fn update_inventory(&mut self, _rid: RepoId) -> Result<bool, Self::Error> {
fn add_inventory(&mut self, _rid: RepoId) -> Result<bool, Self::Error> {
unimplemented!()
}

2
radicle-node/src/test/peer.rs
View File

@ -269,7 +269,7 @@ where
self.service
.database()
.routing()
.get_resources(self.nid())
.get_inventory(self.nid())
.unwrap()
}

4
radicle-node/src/tests.rs
View File

@ -1680,7 +1680,7 @@ fn test_init_and_seed() {
// We now expect Eve to fetch Alice's project from Alice.
// Then we expect Bob to fetch Alice's project from Eve.
alice.elapse(LocalDuration::from_secs(1)); // Make sure our announcement is fresh.
alice.command(service::Command::UpdateInventory(proj_id, send));
alice.command(service::Command::AddInventory(proj_id, send));
sim.run_while([&mut alice, &mut bob, &mut eve], |s| !s.is_settled());
@ -1925,7 +1925,7 @@ fn test_announcement_message_amplification() {
.storage_mut()
.repos
.insert(rid, gen::<MockRepository>(1));
alice.command(Command::UpdateInventory(rid, tx));
alice.command(Command::AddInventory(rid, tx));
sim.run_while([&mut alice, &mut bob, &mut eve, &mut zod, &mut tom], |s| {
s.elapsed() < LocalDuration::from_mins(3)

8
radicle/src/node.rs
View File

@ -463,7 +463,7 @@ pub enum Command {
AnnounceInventory,
/// Update node's inventory.
UpdateInventory { rid: RepoId },
AddInventory { rid: RepoId },
/// Get the current node condiguration.
Config,
@ -924,7 +924,7 @@ pub trait Handle: Clone + Sync + Send {
/// Announce local inventory.
fn announce_inventory(&mut self) -> Result<(), Self::Error>;
/// Notify the service that our inventory was updated with the given repository.
fn update_inventory(&mut self, rid: RepoId) -> Result<bool, Self::Error>;
fn add_inventory(&mut self, rid: RepoId) -> Result<bool, Self::Error>;
/// Ask the service to shutdown.
fn shutdown(self) -> Result<(), Self::Error>;
/// Query the peer session state.
@ -1224,8 +1224,8 @@ impl Handle for Node {
Ok(())
}
fn update_inventory(&mut self, rid: RepoId) -> Result<bool, Error> {
let mut lines = self.call::<Success>(Command::UpdateInventory { rid }, DEFAULT_TIMEOUT)?;
fn add_inventory(&mut self, rid: RepoId) -> Result<bool, Error> {
let mut lines = self.call::<Success>(Command::AddInventory { rid }, DEFAULT_TIMEOUT)?;
let response = lines.next().ok_or(Error::EmptyResponse)??;
Ok(response.updated)

64
radicle/src/node/routing.rs
View File

@ -36,8 +36,8 @@ pub enum Error {
pub trait Store {
/// Get the nodes seeding the given id.
fn get(&self, id: &RepoId) -> Result<HashSet<NodeId>, Error>;
/// Get the resources seeded by the given node.
fn get_resources(&self, node_id: &NodeId) -> Result<HashSet<RepoId>, Error>;
/// Get the inventory seeded by the given node.
fn get_inventory(&self, node_id: &NodeId) -> Result<HashSet<RepoId>, Error>;
/// Get a specific entry.
fn entry(&self, id: &RepoId, node: &NodeId) -> Result<Option<Timestamp>, Error>;
/// Checks if any entries are available.
@ -45,14 +45,14 @@ pub trait Store {
Ok(self.len()? == 0)
}
/// Add a new node seeding the given id.
fn insert<'a>(
fn add_inventory<'a>(
&mut self,
ids: impl IntoIterator<Item = &'a RepoId>,
node: NodeId,
time: Timestamp,
) -> Result<Vec<(RepoId, InsertResult)>, Error>;
/// Remove a node for the given id.
fn remove(&mut self, id: &RepoId, node: &NodeId) -> Result<bool, Error>;
fn remove_inventory(&mut self, id: &RepoId, node: &NodeId) -> Result<bool, Error>;
/// Iterate over all entries in the routing table.
fn entries(&self) -> Result<Box<dyn Iterator<Item = (RepoId, NodeId)>>, Error>;
/// Get the total number of routing entries.
@ -77,15 +77,15 @@ impl Store for Database {
Ok(nodes)
}
fn get_resources(&self, node: &NodeId) -> Result<HashSet<RepoId>, Error> {
fn get_inventory(&self, node: &NodeId) -> Result<HashSet<RepoId>, Error> {
let mut stmt = self.db.prepare("SELECT repo FROM routing WHERE node = ?")?;
stmt.bind((1, node))?;
let mut resources = HashSet::new();
let mut inventory = HashSet::new();
for row in stmt.into_iter() {
resources.insert(row?.read::<RepoId, _>("repo"));
inventory.insert(row?.read::<RepoId, _>("repo"));
}
Ok(resources)
Ok(inventory)
}
fn entry(&self, id: &RepoId, node: &NodeId) -> Result<Option<Timestamp>, Error> {
@ -102,7 +102,7 @@ impl Store for Database {
Ok(None)
}
fn insert<'a>(
fn add_inventory<'a>(
&mut self,
ids: impl IntoIterator<Item = &'a RepoId>,
node: NodeId,
@ -160,7 +160,7 @@ impl Store for Database {
Ok(Box::new(entries.into_iter()))
}
fn remove(&mut self, id: &RepoId, node: &NodeId) -> Result<bool, Error> {
fn remove_inventory(&mut self, id: &RepoId, node: &NodeId) -> Result<bool, Error> {
let mut stmt = self
.db
.prepare("DELETE FROM routing WHERE repo = ? AND node = ?")?;
@ -242,7 +242,7 @@ mod test {
for node in &nodes {
assert_eq!(
db.insert(&ids, *node, Timestamp::EPOCH).unwrap(),
db.add_inventory(&ids, *node, Timestamp::EPOCH).unwrap(),
ids.iter()
.map(|id| (*id, InsertResult::SeedAdded))
.collect::<Vec<_>>()
@ -264,11 +264,11 @@ mod test {
let mut db = database(":memory:");
for node in &nodes {
db.insert(&ids, *node, Timestamp::EPOCH).unwrap();
db.add_inventory(&ids, *node, Timestamp::EPOCH).unwrap();
}
for node in &nodes {
let projects = db.get_resources(node).unwrap();
let projects = db.get_inventory(node).unwrap();
for id in &ids {
assert!(projects.contains(id));
}
@ -283,7 +283,7 @@ mod test {
for node in &nodes {
assert!(db
.insert(&ids, *node, Timestamp::EPOCH)
.add_inventory(&ids, *node, Timestamp::EPOCH)
.unwrap()
.iter()
.all(|(_, r)| *r == InsertResult::SeedAdded));
@ -305,11 +305,11 @@ mod test {
let mut db = database(":memory:");
for node in &nodes {
db.insert(&ids, *node, Timestamp::EPOCH).unwrap();
db.add_inventory(&ids, *node, Timestamp::EPOCH).unwrap();
}
for id in &ids {
for node in &nodes {
assert!(db.remove(id, node).unwrap());
assert!(db.remove_inventory(id, node).unwrap());
}
}
for id in &ids {
@ -324,15 +324,15 @@ mod test {
let mut db = database(":memory:");
assert_eq!(
db.insert([&id], node, Timestamp::EPOCH).unwrap(),
db.add_inventory([&id], node, Timestamp::EPOCH).unwrap(),
vec![(id, InsertResult::SeedAdded)]
);
assert_eq!(
db.insert([&id], node, Timestamp::EPOCH).unwrap(),
db.add_inventory([&id], node, Timestamp::EPOCH).unwrap(),
vec![(id, InsertResult::NotUpdated)]
);
assert_eq!(
db.insert([&id], node, Timestamp::EPOCH).unwrap(),
db.add_inventory([&id], node, Timestamp::EPOCH).unwrap(),
vec![(id, InsertResult::NotUpdated)]
);
}
@ -344,11 +344,11 @@ mod test {
let mut db = database(":memory:");
assert_eq!(
db.insert([&id], node, Timestamp::EPOCH).unwrap(),
db.add_inventory([&id], node, Timestamp::EPOCH).unwrap(),
vec![(id, InsertResult::SeedAdded)]
);
assert_eq!(
db.insert([&id], node, Timestamp::try_from(1u64).unwrap())
db.add_inventory([&id], node, Timestamp::try_from(1u64).unwrap())
.unwrap(),
vec![(id, InsertResult::TimeUpdated)]
);
@ -366,18 +366,19 @@ mod test {
let mut db = database(":memory:");
assert_eq!(
db.insert([&id1], node, Timestamp::EPOCH).unwrap(),
db.add_inventory([&id1], node, Timestamp::EPOCH).unwrap(),
vec![(id1, InsertResult::SeedAdded)]
);
assert_eq!(
db.insert([&id1, &id2], node, Timestamp::EPOCH).unwrap(),
db.add_inventory([&id1, &id2], node, Timestamp::EPOCH)
.unwrap(),
vec![
(id1, InsertResult::NotUpdated),
(id2, InsertResult::SeedAdded)
]
);
assert_eq!(
db.insert([&id1, &id2], node, Timestamp::try_from(1u64).unwrap())
db.add_inventory([&id1, &id2], node, Timestamp::try_from(1u64).unwrap())
.unwrap(),
vec![
(id1, InsertResult::TimeUpdated),
@ -393,11 +394,11 @@ mod test {
let mut db = database(":memory:");
assert_eq!(
db.insert([&id], node, Timestamp::EPOCH).unwrap(),
db.add_inventory([&id], node, Timestamp::EPOCH).unwrap(),
vec![(id, InsertResult::SeedAdded)]
);
assert!(db.remove(&id, &node).unwrap());
assert!(!db.remove(&id, &node).unwrap());
assert!(db.remove_inventory(&id, &node).unwrap());
assert!(!db.remove_inventory(&id, &node).unwrap());
}
#[test]
@ -406,7 +407,8 @@ mod test {
let ids = arbitrary::vec::<RepoId>(10);
let node = arbitrary::gen(1);
db.insert(&ids, node, LocalTime::now().into()).unwrap();
db.add_inventory(&ids, node, LocalTime::now().into())
.unwrap();
assert_eq!(10, db.len().unwrap(), "correct number of rows in table");
}
@ -421,7 +423,7 @@ mod test {
for node in &nodes {
let time = rng.u64(..now.as_millis());
db.insert(&ids, *node, Timestamp::try_from(time).unwrap())
db.add_inventory(&ids, *node, Timestamp::try_from(time).unwrap())
.unwrap();
}
@ -430,7 +432,7 @@ mod test {
for node in &nodes {
let time = rng.u64(now.as_millis()..i64::MAX as u64);
db.insert(&ids, *node, Timestamp::try_from(time).unwrap())
db.add_inventory(&ids, *node, Timestamp::try_from(time).unwrap())
.unwrap();
}
@ -452,7 +454,7 @@ mod test {
let mut db = database(":memory:");
for node in &nodes {
db.insert([&id], *node, Timestamp::EPOCH).unwrap();
db.add_inventory([&id], *node, Timestamp::EPOCH).unwrap();
}
assert_eq!(db.count(&id).unwrap(), nodes.len());
}