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

radicle/sigrefs: Merge `SignedRefs{,At}` 

Since now all callers expect `SignedRefsAt`, merge the two structs
and name the result just `SignedRefs`.
This commit is contained in:
Lorenz Leutgeb 2026-03-24 21:48:18 +01:00 committed by Fintan Halpenny
parent 07011233eb
commit ec36d1c3ae
15 changed files with 147 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
crates/radicle-cli/src/commands/inspect.rs
View File

@ -75,7 +75,7 @@ pub fn run(args: Args, ctx: impl term::Context) -> anyhow::Result<()> {
term::format::tertiary(remote.to_human()),
term::format::secondary(refs.at),
match sigrefs {
Ok(refs) => {
Ok(Some(refs)) => {
let mut level = refs.feature_level();
// For their own refs, be more strict, and interpret
@ -101,6 +101,9 @@ pub fn run(args: Args, ctx: impl term::Context) -> anyhow::Result<()> {
Err(err) => {
term::format::negative(err.to_string())
}
Ok(None) => {
term::format::negative("missing".to_string())
}
}
);
}

6
crates/radicle-fetch/src/sigrefs.rs
View File

@ -1,7 +1,7 @@
use std::collections::BTreeMap;
use std::ops::Not as _;
pub use radicle::storage::refs::SignedRefsAt;
pub use radicle::storage::refs::SignedRefs;
pub use radicle::storage::{git::Validation, Validations};
use radicle::{crypto::PublicKey, storage::ValidateRepository};
@ -23,7 +23,7 @@ pub mod error {
pub(crate) fn validate(
repo: &impl ValidateRepository,
sigrefs: SignedRefsAt,
sigrefs: SignedRefs,
) -> Result<Option<Validations>, radicle::storage::Error> {
let remote = radicle::storage::Remote::new(sigrefs);
let validations = repo.validate_remote(&remote)?;
@ -33,5 +33,5 @@ pub(crate) fn validate(
/// The sigrefs found for each remote.
pub(crate) type RemoteRefs = BTreeMap<
PublicKey,
Result<Option<SignedRefsAt>, radicle::storage::refs::sigrefs::read::error::Read>,
Result<Option<SignedRefs>, radicle::storage::refs::sigrefs::read::error::Read>,
>;

18
crates/radicle-fetch/src/state.rs
View File

@ -17,7 +17,7 @@ use crate::git;
use crate::git::packfile::Keepfile;
use crate::git::refs::{Applied, Update};
use crate::git::repository;
use crate::sigrefs::SignedRefsAt;
use crate::sigrefs::SignedRefs;
use crate::stage;
use crate::stage::ProtocolStage;
use crate::{refs, sigrefs, transport, Handle};
@ -529,8 +529,8 @@ impl FetchState {
(Ok(Some(refs)), false) => {
let level_reachable = refs.feature_level();
match SignedRefsAt::load(remote, handle.repository()) {
Ok(Some(SignedRefsAt { at, .. })) => {
match SignedRefs::load(remote, handle.repository()) {
Ok(Some(SignedRefs { at, .. })) => {
// Prune non-delegates if they're behind or
// diverged. A diverged case is non-fatal for
// delegates.
@ -576,8 +576,8 @@ impl FetchState {
(Ok(Some(refs)), true) => {
let level_reachable = refs.feature_level();
match SignedRefsAt::load(remote, handle.repository()) {
Ok(Some(SignedRefsAt { at, .. })) => {
match SignedRefs::load(remote, handle.repository()) {
Ok(Some(SignedRefs { at, .. })) => {
let ancestry = repository::ancestry(handle.repository(), at, refs.at)?;
if matches!(ancestry, repository::Ancestry::Behind) {
log::trace!(
@ -754,10 +754,10 @@ where
pub fn load(
&self,
remote: &PublicKey,
) -> Result<Option<SignedRefsAt>, radicle::storage::refs::sigrefs::read::error::Read> {
) -> Result<Option<SignedRefs>, radicle::storage::refs::sigrefs::read::error::Read> {
match self.state.sigrefs.get(remote) {
None => SignedRefsAt::load(*remote, self.handle.repository()),
Some(tip) => SignedRefsAt::load_at(*tip, *remote, self.handle.repository()).map(Some),
None => SignedRefs::load(*remote, self.handle.repository()),
Some(tip) => SignedRefs::load_at(*tip, *remote, self.handle.repository()),
}
}
@ -799,7 +799,7 @@ where
// with it.
fn validate_remote(&self, remote: &Remote) -> Result<Validations, storage::Error> {
// Contains a copy of the signed refs of this remote.
let mut signed = BTreeMap::from((*remote.refs.sigrefs).clone());
let mut signed = BTreeMap::from((*remote.refs).clone());
let mut validations = Validations::default();
let mut has_sigrefs = false;

4
crates/radicle-node/src/test/peer.rs
View File

@ -17,7 +17,7 @@ use radicle::node::UserAgent;
use radicle::node::{address, Alias, ConnectOptions};
use radicle::rad;
use radicle::storage::refs;
use radicle::storage::refs::{RefsAt, SignedRefsAt};
use radicle::storage::refs::{RefsAt, SignedRefs};
use radicle::storage::{ReadRepository, RemoteRepository};
use radicle::Storage;
@ -362,7 +362,7 @@ where
ann.into().signed(self.signer()).into()
}
pub fn signed_refs_at(&self, root: Oid) -> SignedRefsAt {
pub fn signed_refs_at(&self, root: Oid) -> SignedRefs {
arbitrary::with_gen(8, |g| {
refs::arbitrary::signed_refs_at(g, root, self.signer())
})

4
crates/radicle/src/identity/doc/update.rs
View File

@ -250,13 +250,13 @@ fn verify_delegates(
let mut missing = Vec::with_capacity(dids.len());
for did in dids {
match refs::SignedRefsAt::load((*did).into(), repo)
match refs::SignedRefs::load((*did).into(), repo)
.map_err(|err| storage::Error::Refs(storage::refs::Error::Read(err)))?
{
None => {
missing.push(error::DelegateVerification::MissingDelegate { did: *did });
}
Some(refs::SignedRefsAt { sigrefs, .. }) => {
Some(sigrefs) => {
if sigrefs.get(&canonical).is_none() {
missing.push(error::DelegateVerification::MissingDefaultBranch {
branch: canonical.to_ref_string(),

6
crates/radicle/src/rad.rs
View File

@ -15,7 +15,7 @@ use crate::identity::project::{Project, ProjectName};
use crate::node::device::Device;
use crate::storage::git::transport;
use crate::storage::git::Repository;
use crate::storage::refs::SignedRefsAt;
use crate::storage::refs::SignedRefs;
use crate::storage::RepositoryError;
use crate::storage::{ReadRepository as _, RemoteId, SignRepository as _};
use crate::storage::{WriteRepository, WriteStorage};
@ -55,7 +55,7 @@ pub fn init<G, S>(
visibility: Visibility,
signer: &Device<G>,
storage: S,
) -> Result<(RepoId, identity::Doc, SignedRefsAt), InitError>
) -> Result<(RepoId, identity::Doc, SignedRefs), InitError>
where
G: crypto::signature::Signer<crypto::Signature>,
S: WriteStorage,
@ -102,7 +102,7 @@ fn init_configure<G>(
url: &git::Url,
identity: git::Oid,
signer: &Device<G>,
) -> Result<SignedRefsAt, InitError>
) -> Result<SignedRefs, InitError>
where
G: crypto::signature::Signer<crypto::Signature>,
{

18
crates/radicle/src/storage.rs
View File

@ -26,7 +26,7 @@ use crate::identity::{Identity, RepoId};
use crate::node::device::Device;
use crate::node::SyncedAt;
use crate::storage::git::NAMESPACES_GLOB;
use crate::storage::refs::{FeatureLevel, Refs, SignedRefsAt};
use crate::storage::refs::{FeatureLevel, Refs, SignedRefs};
use self::refs::RefsAt;
use crate::git::UserInfo;
@ -36,13 +36,13 @@ pub enum SignedRefsInfo {
/// Repositories with this set to `None` are ones that are seeded but not forked.
None,
/// Local signed refs, if any.
Some(refs::SignedRefsAt),
Some(refs::SignedRefs),
NeedsMigration,
}
impl SignedRefsInfo {
pub(crate) fn new(
result: Result<Option<SignedRefsAt>, refs::sigrefs::read::error::Read>,
result: Result<Option<SignedRefs>, refs::sigrefs::read::error::Read>,
) -> Result<Self, refs::sigrefs::read::error::Read> {
Ok(match result {
Ok(Some(refs))
@ -385,7 +385,7 @@ impl IntoIterator for Remotes {
}
}
impl From<Remotes> for RandomMap<RemoteId, SignedRefsAt> {
impl From<Remotes> for RandomMap<RemoteId, SignedRefs> {
fn from(other: Remotes) -> Self {
let mut remotes = RandomMap::with_hasher(fastrand::Rng::new().into());
@ -401,12 +401,12 @@ impl From<Remotes> for RandomMap<RemoteId, SignedRefsAt> {
pub struct Remote {
/// Git references published under this remote, and their hashes.
#[serde(flatten)]
pub refs: SignedRefsAt,
pub refs: SignedRefs,
}
impl Remote {
/// Create a new remotes object.
pub fn new(refs: impl Into<SignedRefsAt>) -> Self {
pub fn new(refs: impl Into<SignedRefs>) -> Self {
Self { refs: refs.into() }
}
@ -428,7 +428,7 @@ impl Remote {
}
impl Deref for Remote {
type Target = SignedRefsAt;
type Target = SignedRefs;
fn deref(&self) -> &Self::Target {
&self.refs
@ -697,14 +697,14 @@ pub trait WriteRepository: ReadRepository + SignRepository {
/// Allows signing refs.
pub trait SignRepository {
/// Sign the repository's refs under the `refs/rad/sigrefs` branch.
fn sign_refs<G>(&self, signer: &Device<G>) -> Result<SignedRefsAt, RepositoryError>
fn sign_refs<G>(&self, signer: &Device<G>) -> Result<SignedRefs, RepositoryError>
where
G: crypto::signature::Signer<crypto::Signature>;
/// Sign the repository's refs under the `refs/rad/sigrefs` branch, even if unchanged.
///
/// Most users will prefer [`Self::sign_refs`].
fn force_sign_refs<G>(&self, signer: &Device<G>) -> Result<SignedRefsAt, RepositoryError>
fn force_sign_refs<G>(&self, signer: &Device<G>) -> Result<SignedRefs, RepositoryError>
where
G: crypto::signature::Signer<crypto::Signature>;
}

18
crates/radicle/src/storage/git.rs
View File

@ -18,7 +18,7 @@ use crate::identity::doc::DocError;
use crate::identity::{CanonicalRefs, Doc, DocAt, RepoId};
use crate::identity::{Identity, Project};
use crate::node::device::Device;
use crate::storage::refs::{FeatureLevel, Refs, SignedRefsAt};
use crate::storage::refs::{FeatureLevel, Refs, SignedRefs};
use crate::storage::{refs, SignedRefsInfo};
use crate::storage::{
ReadRepository, ReadStorage, Remote, Remotes, RepositoryInfo, SetHead, SignRepository,
@ -166,7 +166,7 @@ impl ReadStorage for Storage {
}
};
// Nb. This will be `None` if they were not found.
let refs = SignedRefsInfo::new(refs::SignedRefsAt::load(self.info.key, &repo))
let refs = SignedRefsInfo::new(refs::SignedRefs::load(self.info.key, &repo))
.map_err(|err| Error::Refs(refs::Error::Read(err)))?;
let synced_at = match &refs {
@ -201,7 +201,7 @@ impl WriteStorage for Storage {
let repo = self.repository(rid)?;
// N.b. we remove the repository if the `local` peer has no
// `rad/sigrefs`. There's no risk of them corrupting data.
let has_sigrefs = SignedRefsAt::load(self.info.key, &repo)
let has_sigrefs = SignedRefs::load(self.info.key, &repo)
.map_err(|err| RepositoryError::from(refs::Error::Read(err)))?
.is_some();
if has_sigrefs {
@ -258,7 +258,7 @@ impl Storage {
let repo = self.repository(*rid)?;
let (_, head) = repo.head()?;
let refs = SignedRefsInfo::new(refs::SignedRefsAt::load(self.info.key, &repo))
let refs = SignedRefsInfo::new(refs::SignedRefs::load(self.info.key, &repo))
.map_err(|err| Error::Refs(refs::Error::Read(err)))?;
let synced_at = match &refs {
@ -631,7 +631,7 @@ impl RemoteRepository for Repository {
}
fn remote(&self, remote: &RemoteId) -> Result<Remote, refs::Error> {
let refs = SignedRefsAt::load(*remote, self)?;
let refs = SignedRefs::load(*remote, self)?;
let refs = refs.ok_or_else(|| {
refs::Error::Read(refs::sigrefs::read::error::Read::MissingSigrefs {
namespace: *remote,
@ -656,7 +656,7 @@ impl RemoteRepository for Repository {
impl ValidateRepository for Repository {
fn validate_remote(&self, remote: &Remote) -> Result<Validations, Error> {
// Contains a copy of the signed refs of this remote.
let mut signed = BTreeMap::from((*remote.refs.sigrefs).clone());
let mut signed = BTreeMap::from((*remote.refs).clone());
let mut failures = Validations::default();
let mut has_sigrefs = false;
@ -1007,14 +1007,14 @@ impl SignRepository for Repository {
fn sign_refs<G: crypto::signature::Signer<crypto::Signature>>(
&self,
signer: &Device<G>,
) -> Result<SignedRefsAt, RepositoryError> {
) -> Result<SignedRefs, RepositoryError> {
self.sign_refs_with(signer, false)
}
fn force_sign_refs<G: crypto::signature::Signer<crypto::Signature>>(
&self,
signer: &Device<G>,
) -> Result<SignedRefsAt, RepositoryError> {
) -> Result<SignedRefs, RepositoryError> {
self.sign_refs_with(signer, true)
}
}
@ -1024,7 +1024,7 @@ impl Repository {
&self,
signer: &Device<G>,
force: bool,
) -> Result<SignedRefsAt, RepositoryError> {
) -> Result<SignedRefs, RepositoryError> {
let remote = signer.public_key();
// Ensure the root reference is set, which is checked during sigref verification.
if self

4
crates/radicle/src/storage/git/cob.rs
View File

@ -239,7 +239,7 @@ where
fn sign_refs<G: crypto::signature::Signer<crypto::Signature>>(
&self,
signer: &Device<G>,
) -> Result<storage::refs::SignedRefsAt, RepositoryError> {
) -> Result<storage::refs::SignedRefs, RepositoryError> {
// Since this is a draft store, we do not actually want to sign the refs.
// Instead, we just return the existing signed refs.
let remote = self.repo.remote(signer.public_key())?;
@ -250,7 +250,7 @@ where
fn force_sign_refs<G: crypto::signature::Signer<crypto::Signature>>(
&self,
signer: &Device<G>,
) -> Result<storage::refs::SignedRefsAt, RepositoryError> {
) -> Result<storage::refs::SignedRefs, RepositoryError> {
self.sign_refs(signer)
}
}

198
crates/radicle/src/storage/refs.rs
View File

@ -21,7 +21,7 @@ use crate::git::raw::ErrorExt as _;
use crate::git::Oid;
use crate::storage;
use crate::storage::refs::sigrefs::read::Tip;
use crate::storage::{ReadRepository, RemoteId};
use crate::storage::RemoteId;
pub use crate::git::refs::storage::*;
@ -76,7 +76,7 @@ impl Refs {
committer: sigrefs::git::Committer,
repo: &R,
signer: &S,
) -> Result<SignedRefsAt, Error>
) -> Result<SignedRefs, Error>
where
R: sigrefs::git::object::Reader + sigrefs::git::object::Writer,
R: sigrefs::git::reference::Reader + sigrefs::git::reference::Writer,
@ -94,7 +94,7 @@ impl Refs {
committer: sigrefs::git::Committer,
repo: &R,
signer: &S,
) -> Result<SignedRefsAt, Error>
) -> Result<SignedRefs, Error>
where
R: sigrefs::git::object::Reader + sigrefs::git::object::Writer,
R: sigrefs::git::reference::Reader + sigrefs::git::reference::Writer,
@ -112,7 +112,7 @@ impl Refs {
repo: &R,
signer: &S,
force: bool,
) -> Result<SignedRefsAt, Error>
) -> Result<SignedRefs, Error>
where
R: sigrefs::git::object::Reader + sigrefs::git::object::Writer,
R: sigrefs::git::reference::Reader + sigrefs::git::reference::Writer,
@ -257,12 +257,6 @@ impl From<Refs> for BTreeMap<git::fmt::RefString, Oid> {
}
}
impl From<SignedRefs> for Refs {
fn from(signed: SignedRefs) -> Self {
signed.refs
}
}
impl<I> From<I> for Refs
where
I: Iterator<Item = (git::fmt::RefString, Oid)>,
@ -333,96 +327,10 @@ impl std::fmt::Display for FeatureLevel {
}
}
/// Combination of [`Refs`] and a [`Signature`]. The signature is a cryptographic
/// signature over the refs. This allows us to easily verify if a set of refs
/// came from a particular key.
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct SignedRefs {
/// The signed refs.
refs: Refs,
/// The signature of the signer over the refs.
#[serde(skip)]
signature: Signature,
/// This is the remote under which these refs exist, and the public key of the signer.
id: PublicKey,
#[serde(skip)]
level: FeatureLevel,
/// The [`Oid`] of the parent commit of the commit in which.
#[serde(skip)]
parent: Option<Oid>,
}
impl SignedRefs {
/// Returns the [`NodeId`] of the [`SignedRefs`].
pub fn id(&self) -> NodeId {
self.id
}
/// Returns the [`Refs`] of the [`SignedRefs`].
pub fn refs(&self) -> &Refs {
&self.refs
}
/// Returns the [`FeatureLevel`] computed for the signed references.
pub fn feature_level(&self) -> FeatureLevel {
self.level
}
/// The [`Oid`] of the parent commit, or [`None`] if these signed references
/// were found at a root commit.
pub fn parent(&self) -> Option<&Oid> {
self.parent.as_ref()
}
pub fn load<R>(remote: RemoteId, repo: &R) -> Result<Self, sigrefs::read::error::Read>
where
R: HasRepoId,
R: sigrefs::git::object::Reader + sigrefs::git::reference::Reader,
{
Self::load_internal(remote, repo, sigrefs::read::Tip::Reference(remote))
}
pub fn load_at<R>(
oid: Oid,
remote: RemoteId,
repo: &R,
) -> Result<Self, sigrefs::read::error::Read>
where
R: HasRepoId,
R: sigrefs::git::object::Reader + sigrefs::git::reference::Reader,
{
Self::load_internal(remote, repo, sigrefs::read::Tip::Commit(oid))
}
fn load_internal<R>(
remote: RemoteId,
repo: &R,
tip: Tip,
) -> Result<Self, sigrefs::read::error::Read>
where
R: HasRepoId,
R: sigrefs::git::object::Reader + sigrefs::git::reference::Reader,
{
let root = repo.rid();
let latest = sigrefs::SignedRefsReader::new(root, tip, repo, &remote).read()?;
Ok(latest.into_sigrefs_at(remote).sigrefs)
}
}
impl Deref for SignedRefs {
type Target = Refs;
fn deref(&self) -> &Self::Target {
&self.refs
}
}
/// The content-addressable information required to load a remote's
/// `rad/sigrefs`.
///
/// Use [`RefsAt::load`] to produce a [`SignedRefsAt`].
/// Use [`RefsAt::load`] to produce [`SignedRefs`].
///
/// `RefsAt` can also be used for communicating announcements of updates
/// references to other nodes.
@ -450,12 +358,12 @@ impl RefsAt {
Ok(RefsAt { remote, at })
}
pub fn load<R>(&self, repo: &R) -> Result<SignedRefsAt, sigrefs::read::error::Read>
pub fn load<R>(&self, repo: &R) -> Result<Option<SignedRefs>, sigrefs::read::error::Read>
where
R: HasRepoId,
R: sigrefs::git::object::Reader + sigrefs::git::reference::Reader,
{
SignedRefsAt::load_at(self.at, self.remote, repo)
SignedRefs::load_at(self.at, self.remote, repo)
}
pub fn path(&self) -> &git::fmt::Qualified<'_> {
@ -471,13 +379,52 @@ impl std::fmt::Display for RefsAt {
/// Verified [`SignedRefs`] that keeps track of their content address
/// [`Oid`].
///
/// The signature is a cryptographic signature over the refs.
/// This allows us to easily verify if a set of refs
/// came from a particular key.
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct SignedRefsAt {
pub sigrefs: SignedRefs,
pub struct SignedRefs {
/// The signed refs.
refs: Refs,
/// The signature of the signer over the refs.
#[serde(skip)]
signature: Signature,
/// This is the remote under which these refs exist, and the public key of the signer.
id: PublicKey,
#[serde(skip)]
level: FeatureLevel,
/// The [`Oid`] of the parent commit of the commit in which.
#[serde(skip)]
parent: Option<Oid>,
pub at: Oid,
}
impl SignedRefsAt {
impl SignedRefs {
/// Returns the [`NodeId`] of the [`SignedRefs`].
pub fn id(&self) -> NodeId {
self.id
}
/// Returns the [`Refs`] of the [`SignedRefs`].
pub fn refs(&self) -> &Refs {
&self.refs
}
/// Returns the [`FeatureLevel`] computed for the signed references.
pub fn feature_level(&self) -> FeatureLevel {
self.level
}
/// The [`Oid`] of the parent commit, or [`None`] if these signed references
/// were found at a root commit.
pub fn parent(&self) -> Option<&Oid> {
self.parent.as_ref()
}
/// Load the [`SignedRefs`] found under `remote`'s [`SIGREFS_BRANCH`].
///
/// This will return `None` if the branch was not found, all other
@ -485,42 +432,53 @@ impl SignedRefsAt {
pub fn load<R>(remote: RemoteId, repo: &R) -> Result<Option<Self>, sigrefs::read::error::Read>
where
R: HasRepoId,
R: ReadRepository,
R: sigrefs::git::object::Reader + sigrefs::git::reference::Reader,
{
let at = match RefsAt::new(repo, remote) {
Ok(RefsAt { at, .. }) => at,
Err(sigrefs::read::error::Read::MissingSigrefs { .. }) => return Ok(None),
Err(e) => return Err(e),
};
Self::load_at(at, remote, repo).map(Some)
Self::load_internal(remote, repo, sigrefs::read::Tip::Reference(remote))
}
pub fn load_at<R>(
at: Oid,
oid: Oid,
remote: RemoteId,
repo: &R,
) -> Result<Self, sigrefs::read::error::Read>
) -> Result<Option<Self>, sigrefs::read::error::Read>
where
R: HasRepoId,
R: sigrefs::git::object::Reader + sigrefs::git::reference::Reader,
{
Ok(Self {
sigrefs: SignedRefs::load_at(at, remote, repo)?,
at,
})
Self::load_internal(remote, repo, sigrefs::read::Tip::Commit(oid))
}
fn load_internal<R>(
remote: RemoteId,
repo: &R,
tip: Tip,
) -> Result<Option<Self>, sigrefs::read::error::Read>
where
R: HasRepoId,
R: sigrefs::git::object::Reader + sigrefs::git::reference::Reader,
{
let root = repo.rid();
match sigrefs::SignedRefsReader::new(root, tip, repo, &remote).read() {
Ok(latest) => Ok(Some(latest.into_sigrefs_at(remote))),
Err(sigrefs::read::error::Read::MissingSigrefs { namespace }) => {
debug_assert_eq!(namespace, remote);
Ok(None)
}
Err(err) => Err(err),
}
}
pub fn iter(&self) -> impl Iterator<Item = (&git::fmt::RefString, &Oid)> {
self.sigrefs.refs.iter()
self.refs.iter()
}
}
impl Deref for SignedRefsAt {
type Target = SignedRefs;
impl Deref for SignedRefs {
type Target = Refs;
fn deref(&self) -> &Self::Target {
&self.sigrefs
&self.refs
}
}
@ -678,7 +636,7 @@ mod tests {
{
// Sanity check: make sure the default branches don't already match between Alice and Bob.
let alice_paris_sigrefs = SignedRefsAt::load(*alice.public_key(), &paris)
let alice_paris_sigrefs = SignedRefs::load(*alice.public_key(), &paris)
.unwrap()
.unwrap();
assert_ne!(

7
crates/radicle/src/storage/refs/arbitrary.rs
View File

@ -6,7 +6,7 @@ use crate::node::device::Device;
use super::*;
pub fn signed_refs_at<S>(g: &mut qcheck::Gen, root: Oid, signer: &Device<S>) -> SignedRefsAt
pub fn signed_refs_at<S>(g: &mut qcheck::Gen, root: Oid, signer: &Device<S>) -> SignedRefs
where
S: crypto::signature::Signer<crypto::Signature>,
{
@ -22,15 +22,12 @@ where
}
let signature = crypto::signature::Signer::sign(signer, &refs.canonical());
let sigrefs = SignedRefs {
SignedRefs {
refs,
signature,
id: *signer.node_id(),
level: level.unwrap_or_else(|| FeatureLevel::arbitrary(g)),
parent: Arbitrary::arbitrary(g),
};
SignedRefsAt {
sigrefs,
at: Oid::from_sha1(Arbitrary::arbitrary(g)),
}
}

10
crates/radicle/src/storage/refs/sigrefs/read.rs
View File

@ -19,8 +19,8 @@ use crate::git;
use crate::identity::doc;
use crate::storage::refs::sigrefs::git::{object, reference};
use crate::storage::refs::{
FeatureLevel, Refs, SignedRefs, SignedRefsAt, IDENTITY_ROOT, REFS_BLOB_PATH,
SIGNATURE_BLOB_PATH, SIGREFS_BRANCH,
FeatureLevel, Refs, SignedRefs, IDENTITY_ROOT, REFS_BLOB_PATH, SIGNATURE_BLOB_PATH,
SIGREFS_BRANCH,
};
/// A `rad/sigrefs` that has passed the following verification checks:
@ -50,15 +50,13 @@ impl VerifiedCommit {
self.level
}
pub(crate) fn into_sigrefs_at(self, id: PublicKey) -> SignedRefsAt {
SignedRefsAt {
sigrefs: SignedRefs {
pub(crate) fn into_sigrefs_at(self, id: PublicKey) -> SignedRefs {
SignedRefs {
refs: self.commit.refs,
signature: self.commit.signature,
id,
level: self.level,
parent: self.commit.parent,
},
at: self.commit.oid,
}
}

8
crates/radicle/src/storage/refs/sigrefs/write.rs
View File

@ -16,11 +16,11 @@ use crate::git;
use crate::storage::refs::sigrefs::git::{object, reference, Committer};
use crate::storage::refs::sigrefs::read::CommitReader;
use crate::storage::refs::sigrefs::{read, VerifiedCommit};
use crate::storage::refs::SignedRefs;
use crate::storage::refs::{
FeatureLevel, Refs, IDENTITY_ROOT, REFS_BLOB_PATH, SIGNATURE_BLOB_PATH, SIGREFS_BRANCH,
SIGREFS_PARENT,
};
use crate::storage::refs::{SignedRefs, SignedRefsAt};
/// The result of attempting to write signed references using
/// [`SignedRefsWriter`].
@ -204,16 +204,14 @@ impl Commit {
self.refs
}
pub(crate) fn into_sigrefs_at(self, id: PublicKey, level: FeatureLevel) -> SignedRefsAt {
SignedRefsAt {
pub(crate) fn into_sigrefs_at(self, id: PublicKey, level: FeatureLevel) -> SignedRefs {
SignedRefs {
at: self.oid,
sigrefs: SignedRefs {
id,
signature: self.signature,
refs: self.refs,
level,
parent: self.parent,
},
}
}
}

4
crates/radicle/src/test/fixtures.rs
View File

@ -10,7 +10,7 @@ use crate::node::Alias;
use crate::rad;
use crate::storage::git::transport;
use crate::storage::git::Storage;
use crate::storage::refs::SignedRefsAt;
use crate::storage::refs::SignedRefs;
/// The birth of the radicle project, January 1st, 2018.
pub const RADICLE_EPOCH: i64 = 1514817556;
@ -72,7 +72,7 @@ pub fn project<P, G>(
path: P,
storage: &Storage,
signer: &Device<G>,
) -> Result<(RepoId, SignedRefsAt, git::raw::Repository, git::raw::Oid), rad::InitError>
) -> Result<(RepoId, SignedRefs, git::raw::Repository, git::raw::Oid), rad::InitError>
where
P: AsRef<Path>,
G: crypto::signature::Signer<crypto::Signature>,

10
crates/radicle/src/test/storage.rs
View File

@ -134,7 +134,7 @@ impl WriteStorage for MockStorage {
pub struct MockRepository {
pub id: RepoId,
pub doc: DocAt,
pub remotes: HashMap<NodeId, refs::SignedRefsAt>,
pub remotes: HashMap<NodeId, refs::SignedRefs>,
}
impl MockRepository {
@ -170,7 +170,7 @@ impl self::refs::sigrefs::git::reference::Reader for MockRepository {
if reference == *refs::SIGREFS_BRANCH {
Ok(Some(refs.at))
} else {
Ok(refs.sigrefs.get(&reference))
Ok(refs.get(&reference))
}
}
}
@ -292,7 +292,7 @@ impl ReadRepository for MockRepository {
if reference == &*refs::SIGREFS_BRANCH {
Ok(refs.at)
} else {
refs.sigrefs.get(reference).ok_or_else(not_found)
refs.get(reference).ok_or_else(not_found)
}
}
@ -370,14 +370,14 @@ impl SignRepository for MockRepository {
fn sign_refs<G: crypto::signature::Signer<crypto::Signature>>(
&self,
_signer: &Device<G>,
) -> Result<crate::storage::refs::SignedRefsAt, RepositoryError> {
) -> Result<crate::storage::refs::SignedRefs, RepositoryError> {
todo!()
}
fn force_sign_refs<G: crypto::signature::Signer<crypto::Signature>>(
&self,
_signer: &Device<G>,
) -> Result<crate::storage::refs::SignedRefsAt, RepositoryError> {
) -> Result<crate::storage::refs::SignedRefs, RepositoryError> {
todo!()
}
}