git-storage: remove owner and config

The idea of an owner came from radicle-link storing the signer in the
storage which was needed for performing signing when writing
particular rad references. The peer_id and personal identity was also
stored within the monorepo config.

Since git-storage is just general reading & writing of references and
objects, these concepts are not necessarily needed at this
level. Remove the owner from Write and remove the config module.

Signed-off-by: Fintan Halpenny <fintan.halpenny@gmail.com>
This commit is contained in:
Fintan Halpenny
2022-09-27 12:32:21 +01:00
parent ee7a9029ce
commit 0730453ac5
7 changed files with 35 additions and 351 deletions
+2 -18
View File
@@ -3,13 +3,12 @@
// This file is part of radicle-link, distributed under the GPLv3 with Radicle
// Linking Exception. For full terms see the included LICENSE file.
use std::{path::Path, str::FromStr};
use std::path::Path;
use git_ext::{error::is_not_found_err, Oid};
use std_ext::result::ResultExt as _;
use crate::{
config::Config,
glob,
odb::{self, Blob, Commit, Object, Tag, Tree},
refdb::{self, Reference, References, ReferencesGlob},
@@ -45,25 +44,12 @@ impl Read {
Ok(Self { raw })
}
/// Read the identifier from the underlying [`Config`]. The identifier is
/// expected to exist already.
///
/// See [`crate::config::Owner`] for more information on the identifier.
pub fn rad_identifier<Id>(&self) -> Result<Id, error::Identifier>
where
Id: FromStr,
Id::Err: std::error::Error + Send + Sync + 'static,
{
let config = Config::try_from(&self.raw)?;
Ok(config.rad_identifier::<Id>()?)
}
}
pub mod error {
use thiserror::Error;
use crate::{config, refdb::error::ParseReference};
use crate::refdb::error::ParseReference;
#[derive(Debug, Error)]
pub enum Init {
@@ -73,8 +59,6 @@ pub mod error {
#[derive(Debug, Error)]
pub enum Identifier {
#[error(transparent)]
Config(#[from] config::Error),
#[error(transparent)]
Git(#[from] git2::Error),
}
+14 -62
View File
@@ -3,20 +3,14 @@
// This file is part of radicle-link, distributed under the GPLv3 with Radicle
// Linking Exception. For full terms see the included LICENSE file.
use std::{
marker::PhantomData,
path::{Path, PathBuf},
str::FromStr,
};
use std::path::Path;
use either::Either;
use git_ext::{error::is_not_found_err, Oid};
use git_ref_format::{Qualified, RefStr, RefString};
use std_ext::Void;
use crate::{
config::{self, Config},
odb,
refdb::{
self,
@@ -42,23 +36,14 @@ pub mod error;
/// For write access to the refdb see [`refdb::Write`].
///
/// To construct the `Write` storage use [`Read::open`].
pub struct Write<Owner> {
pub struct Write {
inner: Read,
owner: Owner,
info: UserInfo,
}
impl<O> Write<O>
where
O: config::Owner,
<O::RadIdentifier as FromStr>::Err: std::error::Error + Send + Sync + 'static,
{
impl Write {
/// Open the [`Write`] storage, initialising it if it doesn't exist.
///
/// Note that a [`Write`] is tied to the [`config::Owner`] with which it was
/// initialised, attempting to open it with a different one (that is, a
/// different owner) will return an error.
///
/// # Concurrency
///
/// [`Write`] can be sent between threads, but it can't be shared between
@@ -66,71 +51,38 @@ where
/// the same way two `git` processes can access the same repository.
/// However, if you need multiple [`Write`]s to be shared between
/// threads, use a [`crate::Pool`] instead.
pub fn open<P: AsRef<Path>>(path: P, info: UserInfo, owner: O) -> Result<Self, error::Init> {
pub fn open<P: AsRef<Path>>(path: P, info: UserInfo) -> Result<Self, error::Init> {
crate::init();
let path = path.as_ref();
let raw = match git2::Repository::open_bare(path) {
Err(e) if is_not_found_err(&e) => {
let mut backend = git2::Repository::init_opts(
let backend = git2::Repository::init_opts(
path,
git2::RepositoryInitOptions::new()
.bare(true)
.no_reinit(true)
.external_template(false),
)?;
Config::init(&mut backend, &owner, info.clone())?;
Ok(backend)
},
Ok(repo) => Ok(repo),
Err(e) => Err(e),
}?;
let config = Config::try_from(&raw)?;
let actual = config.rad_identifier::<O::RadIdentifier>()?;
let current = owner.rad_identifier();
if actual != current {
return Err(error::Init::OwnerMismatch {
current: current.to_string(),
actual: actual.to_string(),
});
}
Ok(Self {
inner: Read { raw },
owner,
info,
})
}
/// Get the underlying [`Config`] of the [`Write`] storage.
pub fn config(&self) -> Result<Config<O>, config::Error> {
Config::try_from(self)
}
/// Get the read-only [`Config`] of the [`Write`] storage.
pub fn config_readonly(&self) -> Result<Config<PhantomData<Void>>, git2::Error> {
Config::try_from(&self.inner.raw)
}
pub(crate) fn config_path(&self) -> PathBuf {
config::path(&self.inner.raw)
}
}
impl<O> Write<O> {
impl Write {
/// Return a read-only handle of the storage.
pub fn read_only(&self) -> &Read {
&self.inner
}
/// Return the owner of the storage.
pub fn owner(&self) -> &O {
&self.owner
}
/// Return the [`UserInfo`] of the storage.
pub fn info(&self) -> &UserInfo {
&self.info
@@ -143,7 +95,7 @@ impl<O> Write<O> {
// refdb impls
impl<'a, S> refdb::Read for &'a Write<S> {
impl<'a> refdb::Read for &'a Write {
type FindRef = <&'a Read as refdb::Read>::FindRef;
type FindRefs = <&'a Read as refdb::Read>::FindRefs;
type FindRefOid = <&'a Read as refdb::Read>::FindRefOid;
@@ -172,7 +124,7 @@ impl<'a, S> refdb::Read for &'a Write<S> {
}
}
impl<'a, S> refdb::Write for &'a Write<S> {
impl<'a> refdb::Write for &'a Write {
type UpdateError = error::Update;
fn update<'b, U>(&mut self, updates: U) -> Result<refdb::write::Applied<'b>, Self::UpdateError>
@@ -217,13 +169,13 @@ impl<'a, S> refdb::Write for &'a Write<S> {
/// An internal struct combining a [`Write`] and [`git2::Transaction`].
// TODO: include optional namespace
struct Transaction<'a, O> {
refdb: &'a Write<O>,
struct Transaction<'a> {
refdb: &'a Write,
txn: git2::Transaction<'a>,
}
impl<'a, S> Transaction<'a, S> {
pub fn new(refdb: &'a Write<S>) -> Result<Self, git2::Error> {
impl<'a> Transaction<'a> {
pub fn new(refdb: &'a Write) -> Result<Self, git2::Error> {
let txn = refdb.inner.raw.transaction()?;
Ok(Self { refdb, txn })
}
@@ -551,7 +503,7 @@ impl<'a, S> Transaction<'a, S> {
// odb impls
impl<S> odb::Read for Write<S> {
impl odb::Read for Write {
type FindObj = <Read as odb::Read>::FindObj;
type FindBlob = <Read as odb::Read>::FindBlob;
type FindCommit = <Read as odb::Read>::FindCommit;
@@ -579,7 +531,7 @@ impl<S> odb::Read for Write<S> {
}
}
impl<S> odb::Write for Write<S> {
impl odb::Write for Write {
type WriteBlob = git2::Error;
type WriteCommit = git2::Error;
type WriteTag = git2::Error;
-4
View File
@@ -9,12 +9,8 @@ use super::*;
#[derive(Debug, Error)]
pub enum Init {
#[error(transparent)]
Config(#[from] config::Error),
#[error(transparent)]
Git(#[from] git2::Error),
#[error("the current identifier '{current}' does not match the identifier used to create the storage '{actual}'")]
OwnerMismatch { current: String, actual: String },
}
#[derive(Debug, Error)]
-225
View File
@@ -1,225 +0,0 @@
// Copyright © 2019-2020 The Radicle Foundation <hello@radicle.foundation>
//
// This file is part of radicle-link, distributed under the GPLv3 with Radicle
// Linking Exception. For full terms see the included LICENSE file.
//! The [git config][config] for a particular storage.
//!
//! As well as encapsulating the git config, it also holds the [`Owner`] of the
//! config.
//!
//! A [`Config`] can either be constructed by it's [`Config::init`] constuctor
//! or by its `TryFrom` instances for [`git2::Repository`] and [`Write`].
//!
//! [config]: https://git-scm.com/docs/git-config
use std::{convert::TryFrom, marker::PhantomData, path::PathBuf, str::FromStr};
use git_ext::is_not_found_err;
use std_ext::prelude::*;
use thiserror::Error;
use crate::{signature::UserInfo, Write};
const CONFIG_USER_NAME: &str = "user.name";
const CONFIG_USER_EMAIL: &str = "user.email";
const CONFIG_RAD_ID: &str = "rad.identifier";
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum Error {
#[error("storage was already initialised with identifier {0}")]
AlreadyInitialised(String),
#[error("could not parse the identifier found at 'rad.self' in the storage config")]
Identifier(#[source] Box<dyn std::error::Error + Send + Sync + 'static>),
#[error("could not parse the identifier found at 'rad.peerid' in the storage config")]
RadSelf(#[source] Box<dyn std::error::Error + Send + Sync + 'static>),
#[error(transparent)]
Git(#[from] git2::Error),
}
/// The `RadIdentifier` is expected to uniquely identify the owner of this
/// repository. The value should be unique and should only be able to be
/// constructed by the owner. For example, this could be a signing key unique to
/// the owner.
pub trait Owner {
type RadIdentifier: ToString + FromStr + PartialEq;
fn rad_identifier(&self) -> Self::RadIdentifier;
}
/// The _local_ config for the give [`git2::Repository`].
///
/// This is typically `$GIT_DIR/.git/config` for non-bare, and `$GIT_DIR/config`
/// for bare repositories.
pub fn path(repo: &git2::Repository) -> PathBuf {
repo.path().join("config")
}
/// A git config paired with the owner information.
///
/// The config is initialised with the following config keys:
///
/// * `user.name`: the provided name of the user.
/// * `user.email`: the provided email of the user. This does not necessarily
/// have to be a valid email, see [`UserInfo`].
/// * `rad.identifier`: the unqiue value identifying the owner of this
/// `Config`.
///
/// # Constructors
///
/// * [`Config::init`]
/// * `TryFrom<&'a Write>`
/// * `TryFrom<git2::Repository`
pub struct Config<'a, O> {
inner: git2::Config,
owner: &'a O,
info: UserInfo,
}
impl<'a, O> TryFrom<&'a Write<O>> for Config<'a, O>
where
O: Owner,
<O::RadIdentifier as FromStr>::Err: std::error::Error + Send + Sync + 'static,
{
type Error = Error;
fn try_from(storage: &'a Write<O>) -> Result<Self, Self::Error> {
let inner = git2::Config::open(&storage.config_path())?;
let mut this = Self {
inner,
owner: storage.owner(),
info: storage.info().clone(),
};
this.guard_key_change()?;
this.ensure_reflog()?;
Ok(this)
}
}
impl TryFrom<&git2::Repository> for Config<'_, PhantomData<Void>> {
type Error = git2::Error;
fn try_from(repo: &git2::Repository) -> Result<Self, Self::Error> {
let inner = git2::Config::open(&self::path(repo))?.snapshot()?;
let name = inner.get_string(CONFIG_USER_NAME)?;
let email = inner.get_string(CONFIG_USER_EMAIL)?;
Ok(Self {
inner,
owner: &PhantomData,
info: UserInfo { name, email },
})
}
}
impl<'a, O> Config<'a, O>
where
O: Owner,
<O::RadIdentifier as FromStr>::Err: std::error::Error + Send + Sync + 'static,
{
fn guard_key_change(&self) -> Result<(), Error> {
let configured_identifier = self
.rad_identifier::<O::RadIdentifier>()
.map(Some)
.or_matches::<Error, _, _>(
|err| matches!(err, Error::Git(e) if is_not_found_err(e)),
|| Ok(None),
)?;
let owner_identifier = self.owner.rad_identifier();
match configured_identifier {
Some(initialised_with) if initialised_with != owner_identifier => {
Err(Error::AlreadyInitialised(initialised_with.to_string()))
},
_ => Ok(()),
}
}
fn ensure_reflog(&mut self) -> Result<(), Error> {
if let Err(e) = self.inner.get_bool("core.logAllRefUpdates") {
return if is_not_found_err(&e) {
Ok(self.inner.set_bool("core.logAllRefUpdates", true)?)
} else {
Err(e.into())
};
}
Ok(())
}
/// Initialise the [`Config`] with the given `owner` and `info`.
///
/// # Errors
///
/// * The identifier of the `owner` differs from the existing identifier
/// stored
pub fn init(repo: &mut git2::Repository, owner: &'a O, info: UserInfo) -> Result<Self, Error> {
let identifier = owner.rad_identifier();
let config = git2::Config::open(&self::path(repo))?;
let mut this = Config {
inner: config,
owner,
info,
};
this.guard_key_change()?;
this.ensure_reflog()?;
this.set_identifier(identifier)?;
this.set_user_info()?;
Ok(this)
}
fn set_user_info(&mut self) -> Result<(), Error> {
self.inner.set_str(CONFIG_USER_NAME, &self.info.name)?;
self.inner.set_str(CONFIG_USER_EMAIL, &self.info.email)?;
Ok(())
}
fn set_identifier(&mut self, rad_identifier: O::RadIdentifier) -> Result<(), Error> {
self.inner
.set_str(CONFIG_RAD_ID, &rad_identifier.to_string())
.map_err(Error::from)
}
}
impl<O> Config<'_, O> {
pub fn user(&self) -> &UserInfo {
&self.info
}
pub fn user_name(&self) -> Result<String, Error> {
self.inner.get_string(CONFIG_USER_NAME).map_err(Error::from)
}
pub fn user_email(&self) -> Result<String, Error> {
self.inner
.get_string(CONFIG_USER_EMAIL)
.map_err(Error::from)
}
pub fn rad_identifier<Id>(&self) -> Result<Id, Error>
where
Id: FromStr,
Id::Err: std::error::Error + Send + Sync + 'static,
{
self.inner
.get_string(CONFIG_RAD_ID)
.map_err(Error::from)
.and_then(|peer_id| {
peer_id
.parse()
.map_err(|err| Error::Identifier(Box::new(err)))
})
}
}
impl Config<'_, PhantomData<Void>> {
pub fn readonly(repo: &git2::Repository) -> Result<Self, git2::Error> {
Self::try_from(repo)
}
}
+2 -6
View File
@@ -3,12 +3,9 @@
//! # `git-storage`
//!
//! This crate provides access to git [references][refs] and [objects][objs], in
//! a Radicle context. The particular difference for Radicle is that a storage
//! must be *owned*, generally using a signing key.
//! This crate provides access to git [references][refs] and [objects][objs].
//!
//! To first initialise the storage use [`Write::open`]. This will intialise the
//! underlying git repository and its [`config`].
//! To first initialise the storage use [`Write::open`].
//!
//! After the storage is initialised, use [`Write::open`] or [`Read::open`] for
//! read-write or read-only access to the underlying storage. These structs will
@@ -44,7 +41,6 @@ extern crate async_trait;
extern crate radicle_git_ext as git_ext;
extern crate radicle_std_ext as std_ext;
pub mod config;
pub mod glob;
pub mod pool;
+14 -33
View File
@@ -7,7 +7,6 @@ use std::{
marker::PhantomData,
ops::{Deref, DerefMut},
path::PathBuf,
str::FromStr,
sync::Arc,
};
@@ -16,7 +15,7 @@ use parking_lot::RwLock;
use std_ext::Void;
use thiserror::Error;
use crate::{config, read, signature::UserInfo, write, Read, Write};
use crate::{read, signature::UserInfo, write, Read, Write};
#[derive(Debug, Error)]
#[non_exhaustive]
@@ -75,11 +74,7 @@ impl<S> AsMut<S> for PooledRef<S> {
}
}
impl<S> AsRef<Read> for PooledRef<Write<S>>
where
S: config::Owner,
<S::RadIdentifier as FromStr>::Err: std::error::Error + Send + Sync + 'static,
{
impl AsRef<Read> for PooledRef<Write> {
fn as_ref(&self) -> &Read {
self.0.read_only()
}
@@ -100,8 +95,7 @@ impl Initialised {
}
}
pub struct Writer<S> {
signer: S,
pub struct Writer {
init: Initialised,
}
@@ -113,7 +107,7 @@ pub struct Config<W> {
}
pub type ReadConfig = Config<PhantomData<Void>>;
pub type WriteConfig<S> = Config<Writer<S>>;
pub type WriteConfig = Config<Writer>;
impl ReadConfig {
pub fn new(root: PathBuf, info: UserInfo) -> Self {
@@ -124,11 +118,11 @@ impl ReadConfig {
}
}
pub fn write<S>(self, signer: S, init: Initialised) -> WriteConfig<S> {
pub fn write(self, init: Initialised) -> WriteConfig {
Config {
root: self.root,
info: self.info,
write: Writer { signer, init },
write: Writer { init },
}
}
}
@@ -144,36 +138,23 @@ impl Manager<Read, InitError> for ReadConfig {
}
}
impl<S> WriteConfig<S>
where
S: config::Owner,
<S::RadIdentifier as FromStr>::Err: std::error::Error + Send + Sync + 'static,
{
pub fn new(root: PathBuf, info: UserInfo, signer: S, init: Initialised) -> Self {
impl WriteConfig {
pub fn new(root: PathBuf, info: UserInfo, init: Initialised) -> Self {
Self {
root,
info,
write: Writer { signer, init },
write: Writer { init },
}
}
fn mk_storage(&self) -> Result<Write<S>, InitError>
where
S: Clone,
{
Write::open(&self.root, self.info.clone(), self.write.signer.clone())
.map_err(InitError::from)
fn mk_storage(&self) -> Result<Write, InitError> {
Write::open(&self.root, self.info.clone()).map_err(InitError::from)
}
}
#[async_trait]
impl<S> Manager<Write<S>, InitError> for WriteConfig<S>
where
S: Clone + Send + Sync + 'static,
S: config::Owner,
<S::RadIdentifier as FromStr>::Err: std::error::Error + Send + Sync + 'static,
{
async fn create(&self) -> Result<Write<S>, InitError> {
impl Manager<Write, InitError> for WriteConfig {
async fn create(&self) -> Result<Write, InitError> {
let initialised = self.write.init.0.read();
if *initialised {
self.mk_storage()
@@ -189,7 +170,7 @@ where
}
}
async fn recycle(&self, _: &mut Write<S>) -> RecycleResult<InitError> {
async fn recycle(&self, _: &mut Write) -> RecycleResult<InitError> {
Ok(())
}
}
+3 -3
View File
@@ -5,9 +5,9 @@
pub struct UserInfo {
/// Provided `name` of the user.
pub name: String,
/// Proivded `email` of the user. Note that this does not necessarily have
/// to be an email, but will be used as the email field in [`crate::config`]
/// and the [`git2::Signature`].
/// Proivded `email` of the user. Note that this does not
/// necessarily have to be an email, but will be used as the email
/// field in the [`git2::Signature`].
pub email: String,
}