aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/main.rs2
-rw-r--r--src/storage/garage.rs96
-rw-r--r--src/storage/in_memory.rs54
-rw-r--r--src/storage/mod.rs74
4 files changed, 178 insertions, 48 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<GrgTypes> for GrgCreds {
+ fn row_store(&self) -> GrgStore {
+ unimplemented!();
+ }
+}
+
+impl RowStore<GrgTypes> for GrgStore {
+ fn new_row(&self, partition: &str, sort: &str) -> GrgRef {
+ unimplemented!();
+ }
+}
+
+impl RowRef<GrgTypes> for GrgRef {
+ fn set_value(&self, content: Vec<u8>) -> GrgValue {
+ unimplemented!();
+ }
+ async fn fetch(&self) -> Result<GrgValue, Error> {
+ unimplemented!();
+ }
+ async fn rm(&self) -> Result<(), Error> {
+ unimplemented!();
+ }
+ async fn poll(&self) -> Result<Option<GrgValue>, Error> {
+ unimplemented!();
+ }
+}
+
+impl RowValue<GrgTypes> 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<MemTypes> for MemCreds {
+ fn row_store(&self) -> MemStore {
+ unimplemented!();
+ }
+}
+
+impl RowStore<MemTypes> for MemStore {
+ fn new_row(&self, partition: &str, sort: &str) -> MemRef {
+ unimplemented!();
+ }
+}
+
+impl RowRef<MemTypes> for MemRef {
+ fn set_value(&self, content: Vec<u8>) -> MemValue {
+ unimplemented!();
+ }
+ async fn fetch(&self) -> Result<MemValue, Error> {
+ unimplemented!();
+ }
+ async fn rm(&self) -> Result<(), Error> {
+ unimplemented!();
+ }
+ async fn poll(&self) -> Result<Option<MemValue>, Error> {
+ unimplemented!();
+ }
+}
+
+impl RowValue<MemTypes> 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<Alternative>;
+#[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<impl BlobRef>;
+pub trait RowRealization: Sized {
+ type Store: RowStore<Self>;
+ type Ref: RowRef<Self>;
+ type Value: RowValue<Self>;
}
-// ------- Row
-pub trait RowRef {
- fn to_value(&self, content: &[u8]) -> impl RowValue;
- async fn get(&self) -> Result<impl RowValue, Error>;
- async fn rm(&self) -> Result<(), Error>;
- async fn poll(&self) -> Result<Option<impl RowValue>, Error>;
+// ------ Row Builder
+pub trait RowBuilder<R: RowRealization>
+{
+ fn row_store(&self) -> R::Store;
}
-pub trait RowValue {
- fn row_ref(&self) -> impl RowRef;
- fn content(&self) -> ConcurrentValues;
- async fn persist(&self) -> Result<(), Error>;
+// ------ Row Store
+pub trait RowStore<R: RowRealization>
+{
+ fn new_row(&self, partition: &str, sort: &str) -> R::Ref;
}
-// ------ Row batch
-pub trait RowRefBatch {
- fn to_values(&self, content: Vec<&[u8]>) -> impl RowValueBatch;
- fn into_independant(&self) -> Vec<impl RowRef>;
- async fn get(&self) -> Result<impl RowValueBatch, Error>;
+// ------- Row Item
+pub trait RowRef<R: RowRealization>
+{
+ fn set_value(&self, content: Vec<u8>) -> R::Value;
+ async fn fetch(&self) -> Result<R::Value, Error>;
async fn rm(&self) -> Result<(), Error>;
+ async fn poll(&self) -> Result<Option<R::Value>, Error>;
}
-pub trait RowValueBatch {
- fn into_independant(&self) -> Vec<impl RowValue>;
- fn content(&self) -> Vec<ConcurrentValues>;
- 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();
+pub trait RowValue<R: RowRealization>
+{
+ fn to_ref(&self) -> R::Ref;
+ fn content(&self) -> ConcurrentValues;
+ async fn push(&self) -> Result<(), Error>;
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 06:52:57 +0000