502053d git-storage: remove pool — radicle-git

radicle-git

rad:z6cFWeWpnZNHh9rUW8phgA3b5yGt

Git libraries for Radicle

git-storage: remove pool

Fintan Halpenny committed 3 years ago

commit 502053d972ff8ae7ccdf5a230597f019ff5c3645
parent f3459cd

5 files changed +0 -194

modified git-storage/Cargo.toml

@@ -6,18 +6,12 @@ edition = "2021"

 license = "GPL-3.0-or-later"
 [dependencies]
 async-trait = "0.1"
 globset = "0.4"
 libc = "0.2"
 parking_lot = "0.12"
 thiserror = "1"
 either = "1.8.0"
 [dependencies.deadpool]
 version = "0.7"
 default-features = false
 features = ["managed"]
 [dependencies.git2]
 version = "0.15.0"
 default-features = false

modified git-storage/src/backend/read.rs

@@ -35,8 +35,6 @@ impl Read {

     /// [`Read`] can be sent between threads, but it can't be shared between
     /// threads. _Some_ operations are safe to perform concurrently in much
     /// the same way two `git` processes can access the same repository.
     /// However, if you need multiple [`Read`]s to be shared between
     /// threads, use a [`crate::Pool`] instead.
     pub fn open<P: AsRef<Path>>(path: P) -> Result<Self, error::Init> {
         crate::init();

modified git-storage/src/backend/write.rs

@@ -50,8 +50,6 @@ impl Write {

     /// [`Write`] can be sent between threads, but it can't be shared between
     /// threads. _Some_ operations are safe to perform concurrently in much
     /// 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) -> Result<Self, error::Init> {
         crate::init();

modified git-storage/src/lib.rs

@@ -29,23 +29,15 @@

 //! [`Read`] and [`Write`] can be sent between threads, but it can't be shared
 //! between threads. _Some_ operations are safe to perform concurrently in much
 //! the same way two `git` processes can access the same repository.
 //! However, if you need multiple [`Read`]/[`Write`]s to be shared between
 //! threads, use a [`Pool`] instead.
 //!
 //! [refs]: https://git-scm.com/book/en/v2/Git-Internals-Git-References
 //! [objs]: https://git-scm.com/book/en/v2/Git-Internals-Git-Objects
 #[macro_use]
 extern crate async_trait;
 extern crate radicle_git_ext as git_ext;
 extern crate radicle_std_ext as std_ext;
 pub mod glob;
 pub mod pool;
 pub use pool::Pool;
 pub mod refdb;
 pub use refdb::{Applied, Reference, SymrefTarget, Target, Update, Updated};

deleted git-storage/src/pool.rs

@@ -1,176 +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.
 use std::{
     marker::PhantomData,
     ops::{Deref, DerefMut},
     path::PathBuf,
     sync::Arc,
 };
 use deadpool::managed::{self, Manager, Object, RecycleResult};
 use parking_lot::RwLock;
 use std_ext::Void;
 use thiserror::Error;
 use crate::{read, signature::UserInfo, write, Read, Write};
 #[derive(Debug, Error)]
 #[non_exhaustive]
 pub enum InitError {
     #[error(transparent)]
     Read(#[from] read::error::Init),
     #[error(transparent)]
     Write(#[from] write::error::Init),
 }
 pub type Pool<S> = deadpool::managed::Pool<S, InitError>;
 pub type PoolError = managed::PoolError<InitError>;
 #[async_trait]
 pub trait Pooled<S: Send> {
     async fn get(&self) -> Result<PooledRef<S>, PoolError>;
 }
 #[async_trait]
 impl<S: Send> Pooled<S> for Pool<S> {
     async fn get(&self) -> Result<PooledRef<S>, PoolError> {
         self.get().await.map(PooledRef::from)
     }
 }
 /// A reference to a pooled storage.
 ///
 /// The `S` parameter can be filled by [`Write`] for read-write access or
 /// [`Read`] for read-only access.
 pub struct PooledRef<S>(Object<S, InitError>);
 impl<S> Deref for PooledRef<S> {
     type Target = S;
     fn deref(&self) -> &Self::Target {
         self.0.deref()
     }
 }
 impl<S> DerefMut for PooledRef<S> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.0.deref_mut()
     }
 }
 impl<S> AsRef<S> for PooledRef<S> {
     fn as_ref(&self) -> &S {
         self
     }
 }
 impl<S> AsMut<S> for PooledRef<S> {
     fn as_mut(&mut self) -> &mut S {
         self
     }
 }
 impl AsRef<Read> for PooledRef<Write> {
     fn as_ref(&self) -> &Read {
         self.0.read_only()
     }
 }
 impl<S> From<Object<S, InitError>> for PooledRef<S> {
     fn from(obj: Object<S, InitError>) -> Self {
         Self(obj)
     }
 }
 #[derive(Clone)]
 pub struct Initialised(Arc<RwLock<bool>>);
 impl Initialised {
     pub fn no() -> Self {
         Self(Arc::new(RwLock::new(false)))
     }
 }
 pub struct Writer {
     init: Initialised,
 }
 #[derive(Clone)]
 pub struct Config<W> {
     root: PathBuf,
     info: UserInfo,
     write: W,
 }
 pub type ReadConfig = Config<PhantomData<Void>>;
 pub type WriteConfig = Config<Writer>;
 impl ReadConfig {
     pub fn new(root: PathBuf, info: UserInfo) -> Self {
         Config {
             root,
             info,
             write: PhantomData,
         }
     }
     pub fn write(self, init: Initialised) -> WriteConfig {
         Config {
             root: self.root,
             info: self.info,
             write: Writer { init },
         }
     }
 }
 #[async_trait]
 impl Manager<Read, InitError> for ReadConfig {
     async fn create(&self) -> Result<Read, InitError> {
         Read::open(&self.root).map_err(InitError::from)
     }
     async fn recycle(&self, _: &mut Read) -> RecycleResult<InitError> {
         Ok(())
     }
 }
 impl WriteConfig {
     pub fn new(root: PathBuf, info: UserInfo, init: Initialised) -> Self {
         Self {
             root,
             info,
             write: Writer { init },
         }
     }
     fn mk_storage(&self) -> Result<Write, InitError> {
         Write::open(&self.root, self.info.clone()).map_err(InitError::from)
     }
 }
 #[async_trait]
 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()
         } else {
             drop(initialised);
             let mut initialised = self.write.init.0.write();
             self.mk_storage()
                 .map(|storage| {
                     *initialised = true;
                     storage
                 })
                 .map_err(InitError::from)
         }
     }
     async fn recycle(&self, _: &mut Write) -> RecycleResult<InitError> {
         Ok(())
     }
 }