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

node: remove Namespaces::One 

The One variant caused many paint points for fetching logic, where it
was not necessary. It was only constructed in one place, which could
be replaced by using the variant that holds a set of keys.

Remove the Namespaces::One variant and rename Namespaces::Many to
Namespaces::Trusted.

Signed-off-by: Fintan Halpenny <fintan.halpenny@gmail.com>
X-Clacks-Overhead: GNU Terry Pratchett
This commit is contained in:
Fintan Halpenny 2023-03-30 16:09:13 +01:00
parent adf6312a55
commit c618c3e443
No known key found for this signature in database
GPG Key ID: 2552FB6F64066CB7
6 changed files with 16 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -516,7 +516,7 @@ where
resp.send(untracked).ok();
}
Command::AnnounceRefs(id) => {
if let Err(err) = self.announce_refs(id, &Namespaces::One(self.node_id())) {
if let Err(err) = self.announce_refs(id, &Namespaces::from_iter([self.node_id()])) {
error!("Error announcing refs: {}", err);
}
}
@ -1004,7 +1004,7 @@ where
tracking::Scope::Trusted => {
match self.tracking.namespaces_for(&self.storage, &message.rid) {
Ok(Namespaces::All) => Ok(true),
Ok(Namespaces::Many(mut trusted)) => {
Ok(Namespaces::Trusted(mut trusted)) => {
// Get the set of trusted nodes except self.
trusted.remove(&self.node_id());
@ -1014,9 +1014,6 @@ where
.iter()
.any(|(pub_key, _refs)| trusted.contains(pub_key)))
}
Ok(Namespaces::One(key)) => {
Ok(message.refs.iter().any(|(pub_key, _refs)| pub_key == &key))
}
Err(NamespacesError::NoTrusted { rid }) => {
debug!(target: "service", "No trusted nodes to fetch {}", &rid);
Ok(false)
@ -1272,12 +1269,7 @@ where
}
}
}
Namespaces::One(pk) => refs
.push((*pk, repo.remote(pk)?.refs.unverified()))
// SAFETY: `REF_REMOTE_LIMIT` is greater than 1, thus the bounded vec can hold at least
// one remote.
.unwrap(),
Namespaces::Many(trusted) => {
Namespaces::Trusted(trusted) => {
for remote_id in trusted.iter() {
if refs
.push((*remote_id, repo.remote(remote_id)?.refs.unverified()))

2
radicle-node/src/service/tracking.rs
View File

@ -131,7 +131,7 @@ impl Config {
// trusted and delegate remotes.
Ok(Namespaces::All)
} else {
Ok(Namespaces::Many(trusted))
Ok(Namespaces::Trusted(trusted))
}
}
},

3
radicle-node/src/test/simulator.rs
View File

@ -670,8 +670,7 @@ fn fetch<W: WriteRepository>(
) -> Result<Vec<RefUpdate>, radicle::storage::FetchError> {
let namespace = match namespaces.into() {
Namespaces::All => None,
Namespaces::One(ns) => Some(ns),
Namespaces::Many(trusted) => trusted.into_iter().next(),
Namespaces::Trusted(trusted) => trusted.into_iter().next(),
};
let mut updates = Vec::new();
let mut callbacks = git::RemoteCallbacks::new();

12
radicle-node/src/worker/fetch.rs
View File

@ -132,11 +132,7 @@ impl<'a> StagingPhaseInitial<'a> {
let doc = doc.verified()?;
let mut trusted = match self.namespaces.clone() {
Namespaces::All => HashSet::new(),
// TODO(finto): this is one of those cases where
// having the `One` variant doesn't make any
// sense.
Namespaces::One(pk) => [pk].into_iter().collect(),
Namespaces::Many(trusted) => trusted,
Namespaces::Trusted(trusted) => trusted,
};
let delegates = doc.delegates.map(PublicKey::from);
trusted.extend(delegates);
@ -148,13 +144,13 @@ impl<'a> StagingPhaseInitial<'a> {
// Nb. Namespaces::One is not constructed in
// namespaces_for so it's safe to just bundle this
// with Namespaces::All
Namespaces::One(_) | Namespaces::All => {
Namespaces::All => {
let mut trusted = repo.remote_ids()?.collect::<Result<HashSet<_>, _>>()?;
trusted.extend(repo.delegates()?.map(PublicKey::from));
trusted
}
Namespaces::Many(trusted) => trusted,
Namespaces::Trusted(trusted) => trusted,
}
}
};
@ -202,7 +198,7 @@ impl<'a> StagingPhaseFinal<'a> {
/// references.
pub fn refspecs(&self) -> Vec<Refspec<git::PatternString, git::PatternString>> {
match self.repo {
StagedRepository::Cloning(_) => Namespaces::Many(self.trusted.clone()).as_refspecs(),
StagedRepository::Cloning(_) => Namespaces::Trusted(self.trusted.clone()).as_refspecs(),
StagedRepository::Fetching(_) => {
self.remotes().fold(Vec::new(), |mut specs, remote| {
specs.extend(remote.as_refspecs());

13
radicle-node/src/worker/fetch/refspecs.rs
View File

@ -54,8 +54,7 @@ impl AsRefspecs for SpecialRefs {
},
]
}
Namespaces::One(pk) => rad_refs(pk),
Namespaces::Many(pks) => pks.iter().flat_map(rad_refs).collect(),
Namespaces::Trusted(pks) => pks.iter().flat_map(rad_refs).collect(),
}
}
@ -106,15 +105,7 @@ impl AsRefspecs for Namespaces {
dst: (*storage::git::NAMESPACES_GLOB).clone(),
force: false,
}],
Namespaces::One(pk) => {
let ns = pk.to_namespace().with_pattern(git::refspec::STAR);
vec![Refspec {
src: ns.clone(),
dst: ns,
force: false,
}]
}
Namespaces::Many(pks) => pks
Namespaces::Trusted(pks) => pks
.iter()
.map(|pk| {
let ns = pk.to_namespace().with_pattern(git::refspec::STAR);

12
radicle/src/storage.rs
View File

@ -34,15 +34,13 @@ pub enum Namespaces {
/// All namespaces.
#[default]
All,
/// A single namespace, by public key.
One(PublicKey),
/// Many namespaces, by public keys.
Many(HashSet<PublicKey>),
/// The trusted set of namespaces.
Trusted(HashSet<PublicKey>),
}
impl From<PublicKey> for Namespaces {
fn from(pk: PublicKey) -> Self {
Self::One(pk)
impl FromIterator<PublicKey> for Namespaces {
fn from_iter<T: IntoIterator<Item = PublicKey>>(iter: T) -> Self {
Self::Trusted(iter.into_iter().collect())
}
}