Add `create space` txn impl

server/src/engine/storage/v1/inf/map.rs

@@ -54,12 +54,10 @@ impl<'a, M: PersistMapSpec> PersistObject for PersistMapImpl<'a, M>
 where
     M::MapType: 'a + STIndex<M::Key, M::Value>,
 {
+    const METADATA_SIZE: usize = sizeof!(u64);
     type InputType = &'a M::MapType;
     type OutputType = M::MapType;
     type Metadata = MapIndexSizeMD;
-    fn pretest_can_dec_metadata(scanner: &BufferedScanner) -> bool {
-        scanner.has_left(sizeof!(u64))
-    }
     fn pretest_can_dec_object(
         s: &BufferedScanner,
         MapIndexSizeMD(dict_size): &Self::Metadata,

server/src/engine/storage/v1/inf/mod.rs

@@ -28,8 +28,8 @@
 
 use crate::engine::idx::STIndex;
 
-mod map;
-mod obj;
+pub mod map;
+pub mod obj;
 // tests
 #[cfg(test)]
 mod tests;
@@ -105,6 +105,9 @@ impl PersistDictEntryDscr {
 
 /// Any object that can be persisted
 pub trait PersistObject {
+    // const
+    /// Size of the metadata region
+    const METADATA_SIZE: usize;
     // types
     /// Input type for enc operations
     type InputType: Copy;
@@ -113,8 +116,10 @@ pub trait PersistObject {
     /// Metadata type
     type Metadata;
     // pretest
-    /// Pretest to see if the src has the required data for metadata dec
-    fn pretest_can_dec_metadata(scanner: &BufferedScanner) -> bool;
+    /// Pretest to see if the src has the required data for metadata dec. Defaults to the metadata size
+    fn pretest_can_dec_metadata(scanner: &BufferedScanner) -> bool {
+        scanner.has_left(Self::METADATA_SIZE)
+    }
     /// Pretest to see if the src has the required data for object dec
     fn pretest_can_dec_object(scanner: &BufferedScanner, md: &Self::Metadata) -> bool;
     // meta
@@ -222,6 +227,7 @@ pub trait PersistMapSpec {
 // enc
 pub mod enc {
     use super::{map, PersistMapSpec, PersistObject, VecU8};
+    // obj
     pub fn enc_full<Obj: PersistObject>(obj: Obj::InputType) -> Vec<u8> {
         let mut v = vec![];
         enc_full_into_buffer::<Obj>(&mut v, obj);
@@ -230,6 +236,7 @@ pub mod enc {
     pub fn enc_full_into_buffer<Obj: PersistObject>(buf: &mut VecU8, obj: Obj::InputType) {
         Obj::default_full_enc(buf, obj)
     }
+    // dict
     pub fn enc_dict_full<PM: PersistMapSpec>(dict: &PM::MapType) -> Vec<u8> {
         let mut v = vec![];
         enc_dict_full_into_buffer::<PM>(&mut v, dict);

server/src/engine/storage/v1/inf/obj.rs

@@ -79,12 +79,10 @@ impl<'a> From<&'a Layer> for LayerRef<'a> {
     }
 }
 impl<'a> PersistObject for LayerRef<'a> {
+    const METADATA_SIZE: usize = sizeof!(u64, 2);
     type InputType = LayerRef<'a>;
     type OutputType = Layer;
     type Metadata = LayerMD;
-    fn pretest_can_dec_metadata(scanner: &BufferedScanner) -> bool {
-        scanner.has_left(sizeof!(u64, 2))
-    }
     fn pretest_can_dec_object(_: &BufferedScanner, _: &Self::Metadata) -> bool {
         true
     }
@@ -136,12 +134,10 @@ impl<'a> From<&'a Field> for FieldRef<'a> {
     }
 }
 impl<'a> PersistObject for FieldRef<'a> {
+    const METADATA_SIZE: usize = sizeof!(u64, 2) + 1;
     type InputType = &'a Field;
     type OutputType = Field;
     type Metadata = FieldMD;
-    fn pretest_can_dec_metadata(scanner: &BufferedScanner) -> bool {
-        scanner.has_left(sizeof!(u64, 2) + 1)
-    }
     fn pretest_can_dec_object(_: &BufferedScanner, _: &Self::Metadata) -> bool {
         true
     }
@@ -223,12 +219,10 @@ impl<'a> From<(&'a Model, &'a IRModel<'a>)> for ModelLayoutRef<'a> {
     }
 }
 impl<'a> PersistObject for ModelLayoutRef<'a> {
+    const METADATA_SIZE: usize = sizeof!(u128) + sizeof!(u64, 3);
     type InputType = ModelLayoutRef<'a>;
     type OutputType = Model;
     type Metadata = ModelLayoutMD;
-    fn pretest_can_dec_metadata(scanner: &BufferedScanner) -> bool {
-        scanner.has_left(sizeof!(u128) + sizeof!(u64, 3))
-    }
     fn pretest_can_dec_object(scanner: &BufferedScanner, md: &Self::Metadata) -> bool {
         scanner.has_left(md.p_key_len as usize)
     }
@@ -302,12 +296,10 @@ impl<'a> From<(&'a Space, &'a DictGeneric)> for SpaceLayoutRef<'a> {
     }
 }
 impl<'a> PersistObject for SpaceLayoutRef<'a> {
+    const METADATA_SIZE: usize = sizeof!(u128) + sizeof!(u64);
     type InputType = SpaceLayoutRef<'a>;
     type OutputType = Space;
     type Metadata = SpaceLayoutMD;
-    fn pretest_can_dec_metadata(scanner: &BufferedScanner) -> bool {
-        scanner.has_left(sizeof!(u128) + sizeof!(u64)) // u64 for props dict
-    }
     fn pretest_can_dec_object(_: &BufferedScanner, _: &Self::Metadata) -> bool {
         true
     }

server/src/engine/storage/v1/mod.rs

@@ -30,14 +30,17 @@ mod header_impl;
 mod journal;
 mod rw;
 // hl
-mod inf;
+pub mod inf;
 mod start_stop;
 // test
 #[cfg(test)]
 mod tests;
 
 // re-exports
-pub use journal::JournalAdapter;
+pub use {
+    journal::{open_journal, JournalAdapter, JournalWriter},
+    rw::BufferedScanner,
+};
 
 use crate::util::os::SysIOError as IoError;
 

server/src/engine/txn/gns.rs

@@ -26,7 +26,18 @@
 
 use {
     super::{TransactionError, TransactionResult},
-    crate::engine::{core::GlobalNS, storage::v1::JournalAdapter},
+    crate::{
+        engine::{
+            core::{space::Space, GlobalNS},
+            data::DictGeneric,
+            storage::v1::{
+                inf::{obj, PersistObject},
+                JournalAdapter, SDSSError,
+            },
+        },
+        util::EndianQW,
+    },
+    std::marker::PhantomData,
 };
 
 /*
@@ -55,7 +66,84 @@ impl JournalAdapter for GNSAdapter {
     FIXME(@ohsayan): In the current impl, we unnecessarily use an intermediary buffer which we clearly don't need to (and also makes
     pointless allocations). We need to fix this, but with a consistent API (and preferably not something like commit_*(...) unless
     we have absolutely no other choice)
+    ---
+    [OPC:2B][PAYLOAD]
 */
 
-// ah that stinging buffer
 pub struct GNSSuperEvent(Box<[u8]>);
+
+pub trait GNSEvent: PersistObject {
+    const OPC: u16;
+    type InputItem;
+}
+
+/*
+    create space
+*/
+
+pub struct CreateSpaceTxn<'a>(PhantomData<&'a ()>);
+#[derive(Clone, Copy)]
+pub struct CreateSpaceTxnCommitPL<'a> {
+    space_meta: &'a DictGeneric,
+    space_name: &'a str,
+    space: &'a Space,
+}
+pub struct CreateSpaceTxnRestorePL {
+    space_name: Box<str>,
+    space: Space,
+}
+pub struct CreateSpaceTxnMD {
+    space_name_l: u64,
+    space_meta: <obj::SpaceLayoutRef<'static> as PersistObject>::Metadata,
+}
+
+impl<'a> GNSEvent for CreateSpaceTxn<'a> {
+    const OPC: u16 = 0;
+    type InputItem = CreateSpaceTxnCommitPL<'a>;
+}
+
+impl<'a> PersistObject for CreateSpaceTxn<'a> {
+    const METADATA_SIZE: usize =
+        <obj::SpaceLayoutRef<'static> as PersistObject>::METADATA_SIZE + sizeof!(u64);
+    type InputType = CreateSpaceTxnCommitPL<'a>;
+    type OutputType = CreateSpaceTxnRestorePL;
+    type Metadata = CreateSpaceTxnMD;
+    fn pretest_can_dec_object(
+        scanner: &crate::engine::storage::v1::BufferedScanner,
+        md: &Self::Metadata,
+    ) -> bool {
+        scanner.has_left(md.space_name_l as usize)
+    }
+    fn meta_enc(buf: &mut Vec<u8>, data: Self::InputType) {
+        buf.extend(data.space_name.len().u64_bytes_le());
+        <obj::SpaceLayoutRef<'a> as PersistObject>::meta_enc(
+            buf,
+            obj::SpaceLayoutRef::from((data.space, data.space_meta)),
+        );
+    }
+    unsafe fn meta_dec(
+        scanner: &mut crate::engine::storage::v1::BufferedScanner,
+    ) -> crate::engine::storage::v1::SDSSResult<Self::Metadata> {
+        let space_name_l = u64::from_le_bytes(scanner.next_chunk());
+        let space_meta = <obj::SpaceLayoutRef as PersistObject>::meta_dec(scanner)?;
+        Ok(CreateSpaceTxnMD {
+            space_name_l,
+            space_meta,
+        })
+    }
+    fn obj_enc(buf: &mut Vec<u8>, data: Self::InputType) {
+        buf.extend(data.space_name.as_bytes());
+        <obj::SpaceLayoutRef as PersistObject>::meta_enc(buf, (data.space, data.space_meta).into());
+    }
+    unsafe fn obj_dec(
+        s: &mut crate::engine::storage::v1::BufferedScanner,
+        md: Self::Metadata,
+    ) -> crate::engine::storage::v1::SDSSResult<Self::OutputType> {
+        let space_name =
+            String::from_utf8(s.next_chunk_variable(md.space_name_l as usize).to_owned())
+                .map_err(|_| SDSSError::InternalDecodeStructureCorruptedPayload)?
+                .into_boxed_str();
+        let space = <obj::SpaceLayoutRef as PersistObject>::obj_dec(s, md.space_meta)?;
+        Ok(CreateSpaceTxnRestorePL { space_name, space })
+    }
+}