From 92fea414d9d113761b788e409a025ad9cff06071 Mon Sep 17 00:00:00 2001 From: Quentin Dufour Date: Wed, 1 Nov 2023 15:15:57 +0100 Subject: [PATCH] v2 api storage --- src/main.rs | 2 - src/storage/garage.rs | 96 ++++++++++++++++++++++++++++++++++++++++ src/storage/in_memory.rs | 54 ++++++++++++++++++++++ src/storage/mod.rs | 80 +++++++++++++-------------------- 4 files changed, 181 insertions(+), 51 deletions(-) diff --git a/src/main.rs b/src/main.rs index 7e1626d..8d2a140 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,6 +1,4 @@ #![feature(async_fn_in_trait)] -#![feature(return_position_impl_trait_in_trait)] -// should be stabilized soon https://github.com/rust-lang/rust/pull/115822 mod bayou; mod config; diff --git a/src/storage/garage.rs b/src/storage/garage.rs index e69de29..91c4fa2 100644 --- a/src/storage/garage.rs +++ b/src/storage/garage.rs @@ -0,0 +1,96 @@ +use crate::storage::*; + +pub struct GrgCreds {} +pub struct GrgStore {} +pub struct GrgRef {} +pub struct GrgValue {} + +pub struct GrgTypes {} +impl RowRealization for GrgTypes { + type Store=GrgStore; + type Ref=GrgRef; + type Value=GrgValue; +} + +impl RowBuilder for GrgCreds { + fn row_store(&self) -> GrgStore { + unimplemented!(); + } +} + +impl RowStore for GrgStore { + fn new_row(&self, partition: &str, sort: &str) -> GrgRef { + unimplemented!(); + } +} + +impl RowRef for GrgRef { + fn set_value(&self, content: Vec) -> GrgValue { + unimplemented!(); + } + async fn fetch(&self) -> Result { + unimplemented!(); + } + async fn rm(&self) -> Result<(), Error> { + unimplemented!(); + } + async fn poll(&self) -> Result, Error> { + unimplemented!(); + } +} + +impl RowValue for GrgValue { + fn to_ref(&self) -> GrgRef { + unimplemented!(); + } + fn content(&self) -> ConcurrentValues { + unimplemented!(); + } + async fn push(&self) -> Result<(), Error> { + unimplemented!(); + } +} + + + + +/* +/// A custom S3 region, composed of a region name and endpoint. +/// We use this instead of rusoto_signature::Region so that we can +/// derive Hash and Eq + + +#[derive(Clone, Debug, Hash, PartialEq, Eq)] +pub struct Region { + pub name: String, + pub endpoint: String, +} + +impl Region { + pub fn as_rusoto_region(&self) -> rusoto_signature::Region { + rusoto_signature::Region::Custom { + name: self.name.clone(), + endpoint: self.endpoint.clone(), + } + } +} +*/ + +/* +pub struct Garage { + pub s3_region: Region, + pub k2v_region: Region, + + pub aws_access_key_id: String, + pub aws_secret_access_key: String, + pub bucket: String, +} + +impl StoreBuilder<> for Garage { + fn row_store(&self) -> +} + +pub struct K2V {} +impl RowStore for K2V { + +}*/ diff --git a/src/storage/in_memory.rs b/src/storage/in_memory.rs index e69de29..a2e9e96 100644 --- a/src/storage/in_memory.rs +++ b/src/storage/in_memory.rs @@ -0,0 +1,54 @@ +use crate::storage::*; + +pub struct MemCreds {} +pub struct MemStore {} +pub struct MemRef {} +pub struct MemValue {} + +pub struct MemTypes {} +impl RowRealization for MemTypes { + type Store=MemStore; + type Ref=MemRef; + type Value=MemValue; +} + +impl RowBuilder for MemCreds { + fn row_store(&self) -> MemStore { + unimplemented!(); + } +} + +impl RowStore for MemStore { + fn new_row(&self, partition: &str, sort: &str) -> MemRef { + unimplemented!(); + } +} + +impl RowRef for MemRef { + fn set_value(&self, content: Vec) -> MemValue { + unimplemented!(); + } + async fn fetch(&self) -> Result { + unimplemented!(); + } + async fn rm(&self) -> Result<(), Error> { + unimplemented!(); + } + async fn poll(&self) -> Result, Error> { + unimplemented!(); + } +} + +impl RowValue for MemValue { + fn to_ref(&self) -> MemRef { + unimplemented!(); + } + fn content(&self) -> ConcurrentValues { + unimplemented!(); + } + async fn push(&self) -> Result<(), Error> { + unimplemented!(); + } +} + + diff --git a/src/storage/mod.rs b/src/storage/mod.rs index 6b410a2..4ef2d61 100644 --- a/src/storage/mod.rs +++ b/src/storage/mod.rs @@ -1,19 +1,14 @@ /* - * T1 : Filter - * T2 : Range - * T3 : Atom - */ - -/* - * My idea: we can encapsulate the causality token - * into the object system so it is not exposed. * * This abstraction goal is to leverage all the semantic of Garage K2V+S3, * to be as tailored as possible to it ; it aims to be a zero-cost abstraction * compared to when we where directly using the K2V+S3 client. + * + * My idea: we can encapsulate the causality token + * into the object system so it is not exposed. */ - +mod in_memory; mod garage; pub enum Selector<'a> { @@ -27,55 +22,42 @@ pub enum Alternative { } type ConcurrentValues = Vec; +#[derive(Debug)] pub enum Error { NotFound, Internal, } -// ------ Store -pub trait RowStore { - fn new_row(&self, partition: &str, sort: &str) -> impl RowRef; - fn new_row_batch(&self, partition: &str, filter: Selector) -> impl RowRefBatch; - fn new_blob(&self, key: &str) -> impl BlobRef; - fn new_blob_list(&self) -> Vec; +pub trait RowRealization: Sized { + type Store: RowStore; + type Ref: RowRef; + type Value: RowValue; } -// ------- Row -pub trait RowRef { - fn to_value(&self, content: &[u8]) -> impl RowValue; - async fn get(&self) -> Result; +// ------ Row Builder +pub trait RowBuilder +{ + fn row_store(&self) -> R::Store; +} + +// ------ Row Store +pub trait RowStore +{ + fn new_row(&self, partition: &str, sort: &str) -> R::Ref; +} + +// ------- Row Item +pub trait RowRef +{ + fn set_value(&self, content: Vec) -> R::Value; + async fn fetch(&self) -> Result; async fn rm(&self) -> Result<(), Error>; - async fn poll(&self) -> Result, Error>; + async fn poll(&self) -> Result, Error>; } -pub trait RowValue { - fn row_ref(&self) -> impl RowRef; +pub trait RowValue +{ + fn to_ref(&self) -> R::Ref; fn content(&self) -> ConcurrentValues; - async fn persist(&self) -> Result<(), Error>; -} - -// ------ Row batch -pub trait RowRefBatch { - fn to_values(&self, content: Vec<&[u8]>) -> impl RowValueBatch; - fn into_independant(&self) -> Vec; - async fn get(&self) -> Result; - async fn rm(&self) -> Result<(), Error>; -} - -pub trait RowValueBatch { - fn into_independant(&self) -> Vec; - fn content(&self) -> Vec; - async fn persist(&self) -> Result<(), Error>; -} - -// ----- Blobs -pub trait BlobRef { - fn set_value(&self, content: &[u8]) -> impl BlobValue; - async fn get(&self) -> impl BlobValue; - async fn copy(&self, dst: &impl BlobRef) -> (); - async fn rm(&self, key: &str) -> (); -} - -pub trait BlobValue { - async fn persist(); + async fn push(&self) -> Result<(), Error>; }