Merge branch 'main' into 5-ci-integration

tercen · Mar 18, 2023 · a181558 · a181558
2 parents 3a99c46 + 805d0da
commit a181558
Show file tree

Hide file tree

Showing 23 changed files with 406 additions and 77 deletions.
diff --git a/.gitignore b/.gitignore
@@ -11,4 +11,5 @@
 /ondo/target/
 /ondo/coverage
 /ondo/local-coverage
-.idea
+.idea
+/.vscode/launch.json
diff --git a/examples/ondo_example.rs b/examples/ondo_example.rs
@@ -3,8 +3,10 @@
 use ondo::db::server::{
     database_server_trait::DatabaseServerTrait, domain_server_trait::DomainServerTrait,
     rocks_db_accessor::RocksDbAccessor, table_server_trait::TableServerTrait,
+    table_value_server_trait::TableValueServerTrait,
 };
 use ondo::ondo_remote::*;
+use serde::{Deserialize, Serialize};
 use tonic::Request;
 
 fn main() {
@@ -68,7 +70,54 @@ fn table_server_example(rda: &RocksDbAccessor, domain_reference_msg: &DomainRefe
     println!("Updated Table: {:?}", answer);
     let answer = rda.list_indexes(Request::new(table_reference_msg.clone()));
     println!("Listed Tables: {:?}", answer);
+    table_value_server_example(rda, &table_reference_msg);
     let answer = rda.delete_table(Request::new(table_reference_msg.clone()));
     println!("Deleted Table: {:?}", answer);
     println!("TODO list functions not yet implemented")
 }
+
+fn table_value_server_example(rda: &RocksDbAccessor, table_reference_msg: &TableReferenceMessage) {
+    println!("!!! Table Value Server Example !!!");
+
+    #[derive(Serialize, Deserialize)]
+    struct Person {
+        pub _id: u64,
+        pub name: String,
+        pub age: u32,
+    }
+
+    let mut person = Person {
+        _id: 0u64, // Auto id kicks in if _id is 0 or it does not exist in JSON
+        age: 42,
+        name: "Bob".to_owned(),
+    };
+
+    let table_value_msg = TableValueMessage {
+        table_reference: Some(table_reference_msg.clone()),
+        json_value: serde_json::to_string(&person).unwrap(),
+    };
+
+    let answer = rda.create_value(Request::new(table_value_msg.clone()));
+    println!("Created Value: {:?}", answer);
+    let new_id_json = answer.unwrap().get_ref().json_value.clone();
+    let table_value_reference_msg = TableValueReferenceMessage {
+        table_reference: Some(table_reference_msg.clone()),
+        json_id: new_id_json.clone(), //Update reference with new id
+    };
+
+    let answer = rda.get_value(Request::new(table_value_reference_msg.clone()));
+    println!("Got Value: {:?}", answer);
+
+    let new_id_u64: u64 = serde_json::from_str(&new_id_json).unwrap();
+    person._id = new_id_u64;
+    person.age = 43;
+    let table_value_msg2 = TableValueMessage {
+        table_reference: Some(table_reference_msg.clone()),
+        json_value: serde_json::to_string(&person).unwrap(),
+    };
+
+    let answer = rda.update_value(Request::new(table_value_msg2.clone()));
+    println!("Updated Value: {:?}", answer);
+    let answer = rda.delete_value(Request::new(table_value_reference_msg.clone()));
+    println!("Deleted Value: {:?}", answer);
+}
diff --git a/proto/ondo_remote.proto b/proto/ondo_remote.proto
@@ -22,22 +22,22 @@ service OndoRemote {
     rpc GetTable(TableReferenceMessage) returns (TableMessage) {}
     rpc UpdateTable(TableMessage) returns (EmptyMessage) {}
     rpc ListIndexes(TableReferenceMessage) returns (ArrayOfStringResponse) {}
-    rpc ListValues(TableReferenceMessage) returns (JsonResponse) {}
-    rpc ListValuesByIdRange(TableIdRangeReferenceMessage) returns (JsonResponse) {}
-    rpc ListValuesByIdList(TableIdListReferenceMessage) returns (JsonResponse) {}
+    rpc ListValues(TableReferenceMessage) returns (JsonMessage) {}
+    rpc ListValuesByIdRange(TableIdRangeReferenceMessage) returns (JsonMessage) {}
+    rpc ListValuesByIdList(TableIdListReferenceMessage) returns (JsonMessage) {}
 
     rpc CreateIndex(IndexMessage) returns (EmptyMessage) {}
     rpc DeleteIndex(IndexReferenceMessage) returns (EmptyMessage) {}
     rpc GetIndex(IndexReferenceMessage) returns (IndexMessage) {}
     rpc UpdateIndex(IndexMessage) returns (EmptyMessage) {}
 
-    rpc CreateValue(TableValueMessage) returns (EmptyMessage) {}
+    rpc CreateValue(TableValueMessage) returns (JsonMessage) {}
     rpc DeleteValue(TableValueReferenceMessage) returns (EmptyMessage) {}
-    rpc GetValue(TableValueReferenceMessage) returns (JsonResponse) {}
+    rpc GetValue(TableValueReferenceMessage) returns (JsonMessage) {}
     rpc UpdateValue(TableValueMessage) returns (EmptyMessage) {}
 
-    rpc FindValues(IndexedValueReferenceMessage) returns (JsonResponse) {}
-    rpc FindValuesByRange(IndexedValueRangeReferenceMessage) returns (JsonResponse) {}
+    rpc FindValues(IndexedValueReferenceMessage) returns (JsonMessage) {}
+    rpc FindValuesByRange(IndexedValueRangeReferenceMessage) returns (JsonMessage) {}
 }
 
 message EmptyMessage {}
@@ -87,15 +87,15 @@ message IndexMessage {
 
 message TableValueReferenceMessage {
     TableReferenceMessage table_reference = 1;
-    uint64 _id = 2;
+    string json_id = 2;
 }
 
 message TableValueMessage {
     TableReferenceMessage table_reference = 1;
     string json_value = 2; //_id field should be included therefore we use only table_reference
 }
 
-message JsonResponse {
+message JsonMessage {
     string json_value = 1;
 }
 

diff --git a/src/bin/ondo-server.rs b/src/bin/ondo-server.rs
@@ -132,21 +132,21 @@ impl OndoRemote for MyServer {
     async fn list_values(
         &self,
         r: Request<TableReferenceMessage>,
-    ) -> Result<Response<JsonResponse>, Status> {
+    ) -> Result<Response<JsonMessage>, Status> {
         self.rocks_db_accessor.list_values(r)
     }
 
     async fn list_values_by_id_range(
         &self,
         r: Request<TableIdRangeReferenceMessage>,
-    ) -> Result<Response<JsonResponse>, Status> {
+    ) -> Result<Response<JsonMessage>, Status> {
         self.rocks_db_accessor.list_values_by_id_range(r)
     }
 
     async fn list_values_by_id_list(
         &self,
         r: Request<TableIdListReferenceMessage>,
-    ) -> Result<Response<JsonResponse>, Status> {
+    ) -> Result<Response<JsonMessage>, Status> {
         self.rocks_db_accessor.list_values_by_id_list(r)
     }
 
@@ -181,7 +181,7 @@ impl OndoRemote for MyServer {
     async fn create_value(
         &self,
         r: Request<TableValueMessage>,
-    ) -> Result<Response<EmptyMessage>, Status> {
+    ) -> Result<Response<JsonMessage>, Status> {
         self.rocks_db_accessor.create_value(r)
     }
 
@@ -195,7 +195,7 @@ impl OndoRemote for MyServer {
     async fn get_value(
         &self,
         r: Request<TableValueReferenceMessage>,
-    ) -> Result<Response<JsonResponse>, Status> {
+    ) -> Result<Response<JsonMessage>, Status> {
         self.rocks_db_accessor.get_value(r)
     }
 
@@ -209,14 +209,14 @@ impl OndoRemote for MyServer {
     async fn find_values(
         &self,
         r: Request<IndexedValueReferenceMessage>,
-    ) -> Result<Response<JsonResponse>, Status> {
+    ) -> Result<Response<JsonMessage>, Status> {
         self.rocks_db_accessor.find_values(r)
     }
 
     async fn find_values_by_range(
         &self,
         r: Request<IndexedValueRangeReferenceMessage>,
-    ) -> Result<Response<JsonResponse>, Status> {
+    ) -> Result<Response<JsonMessage>, Status> {
         self.rocks_db_accessor.find_values_by_range(r)
     }
 }

diff --git a/src/db/entity/reference/cf_name.rs b/src/db/entity/reference/cf_name.rs
@@ -28,7 +28,10 @@ impl CfNameMaker {
     }
 
     pub fn for_index_values(r: &IndexReference) -> String {
-        format!("{}::/{}/indexes/{}", r.table_reference.domain_name, r.table_reference.table_name, r.index_name)
+        format!(
+            "{}::/{}/indexes/{}",
+            r.table_reference.domain_name, r.table_reference.table_name, r.index_name
+        )
     }
 }
 
@@ -40,7 +43,7 @@ mod tests {
     fn test_for_server_meta() {
         assert_eq!(CfNameMaker::for_server_meta(), "/server");
     }
-   
+
     #[test]
     fn test_for_domain_meta() {
         assert_eq!(CfNameMaker::for_domain_meta(), "/domains");
@@ -61,6 +64,9 @@ mod tests {
     #[test]
     fn test_for_index_values() {
         let r = IndexReference::new("domain1", "table1", "index1");
-        assert_eq!(CfNameMaker::for_index_values(&r), "domain1::/table1/indexes/index1");
+        assert_eq!(
+            CfNameMaker::for_index_values(&r),
+            "domain1::/table1/indexes/index1"
+        );
     }
 }
diff --git a/src/db/entity/reference/domain_reference/mod.rs b/src/db/entity/reference/domain_reference/mod.rs
@@ -50,6 +50,10 @@ impl DomainReference {
     pub fn to_database_server_reference(&self) -> DatabaseServerReference {
         DatabaseServerReference::new()
     }
+
+    pub fn cf_name_for_table_counters(&self) -> String {
+        CfNameMaker::for_table_counters(self)
+    }
 }
 
 impl DomainReferenceTrait for DomainReference {

diff --git a/src/db/entity/reference/domain_reference/stored.rs b/src/db/entity/reference/domain_reference/stored.rs
@@ -42,7 +42,7 @@ impl DomainStoredReferenceTrait for DomainReference {
     fn required_cf_names(&self) -> Vec<String> {
         vec![
             CfNameMaker::for_table_meta(self),
-            CfNameMaker::for_table_counters(self),
+            self.cf_name_for_table_counters(),
         ]
     }
 

diff --git a/src/db/entity/reference/requests/table_value_requests.rs b/src/db/entity/reference/requests/table_value_requests.rs
@@ -0,0 +1,12 @@
+use crate::db::db_error::DbResult;
+use crate::db::entity::reference::table_value_reference::TableValueReference;
+use crate::db::entity::table_value::TableValue;
+
+pub(crate) trait TableValueRequests {
+    //FIXME: Use Column Value instead of TableValueRequests
+    fn get_table_value(
+        &self,
+        cf_name: &str,
+        key: &TableValueReference,
+    ) -> DbResult<Option<TableValue>>;
+}
diff --git a/src/db/entity/reference/table_value_reference.rs b/src/db/entity/reference/table_value_reference.rs
@@ -4,31 +4,32 @@
 //TODO!XXX: post -> put self index
 //TODO!XXX!XXX!XXX: post -> create id
 //TODO!XXX: find by index
+use super::requests::table_value_requests::TableValueRequests;
 use super::{
     effect::{Effect, Effects},
+    requests::column_value_requests::ColumnValueRequests,
     CfNameMaker, TableReference,
 };
+use crate::db::entity::index::DEFAULT_ID_FIELD;
+use crate::db::entity::reference::column_value_reference::ColumnValueReference;
+use crate::db::entity::reference::column_value_reference::ColumnValueReferenceTrait;
+use crate::db::entity::reference::effect::table_value_effect::TableValueEffect;
 use crate::db::{
     db_error::DbResult,
     entity::{IndexValue, TableValue},
 };
-use crate::db::entity::reference::effect::table_value_effect::TableValueEffect;
 use serde::{Deserialize, Serialize};
-
-pub(crate) trait TableValueRequests {
-    //FIXME: Use Column Value instead of TableValueRequests
-    fn get_table_value(
-        &self,
-        cf_name: &str,
-        key: &TableValueReference,
-    ) -> DbResult<Option<TableValue>>;
-}
+use serde_json::Value;
 
 pub(crate) trait TableValueReferenceTrait {
     fn container_cf_name(&self) -> String;
     fn get_table_value(&self, request: &dyn TableValueRequests) -> DbResult<Option<TableValue>>;
     fn put_table_value(&self, value: &TableValue) -> DbResult<Effects>;
-    fn post_table_value(&self, value: &TableValue) -> DbResult<Effects>;
+    fn post_table_value(
+        &mut self,
+        value: &mut TableValue,
+        column_value_requests: &dyn ColumnValueRequests,
+    ) -> DbResult<(Value, Effects)>;
     fn delete_table_value(&self) -> DbResult<Effects>;
 }
 
@@ -71,8 +72,43 @@ impl TableValueReferenceTrait for TableValueReference {
         Ok(vec![effect])
     }
 
-    fn post_table_value(&self, value: &TableValue) -> DbResult<Effects> {
-        self.put_table_value(value)
+    fn post_table_value(
+        &mut self,
+        value: &mut TableValue,
+        column_value_requests: &dyn ColumnValueRequests,
+    ) -> DbResult<(Value, Effects)> {
+        let mut effects: Vec<Effect> = Vec::new();
+        let existing_id_opt = value.get(DEFAULT_ID_FIELD);
+        let no_id = serde_json::json!(0u64);
+        let id_not_found = existing_id_opt.is_none() || existing_id_opt == Some(&no_id);
+
+        let id_used = match id_not_found {
+            true => {
+                let domain_reference = self.table_reference.to_domain_reference();
+                let table_counter_reference = ColumnValueReference {
+                    column_reference: domain_reference.cf_name_for_table_counters(),
+                    id: serde_json::json!(self.table_reference.table_name),
+                };
+                let (new_id, counter_effects) =
+                    table_counter_reference.increment_column_value(column_value_requests)?;
+                effects.extend(counter_effects);
+                if let Some(obj) = value.as_object_mut() {
+                    obj.insert(
+                        DEFAULT_ID_FIELD.to_owned(),
+                        Value::Number(serde_json::Number::from(new_id)),
+                    );
+                }
+                serde_json::json!(new_id)
+            }
+            false => {
+                let value = existing_id_opt.unwrap();
+                value.clone()
+            }
+        };
+        self.id = id_used.clone();
+        let put_effects = self.put_table_value(value)?;
+        effects.extend(put_effects);
+        Ok((id_used, effects))
     }
 
     fn delete_table_value(&self) -> DbResult<Effects> {

diff --git a/src/db/server/indexed_value_server_trait.rs b/src/db/server/indexed_value_server_trait.rs
@@ -6,9 +6,9 @@ pub trait IndexedValueServerTrait {
     fn find_values(
         &self,
         _: Request<IndexedValueReferenceMessage>,
-    ) -> Result<Response<JsonResponse>, Status>;
+    ) -> Result<Response<JsonMessage>, Status>;
     fn find_values_by_range(
         &self,
         _: Request<IndexedValueRangeReferenceMessage>,
-    ) -> Result<Response<JsonResponse>, Status>;
+    ) -> Result<Response<JsonMessage>, Status>;
 }
diff --git a/src/db/server/indexed_value_server_trait_impl.rs b/src/db/server/indexed_value_server_trait_impl.rs
@@ -8,14 +8,14 @@ impl IndexedValueServerTrait for RocksDbAccessor {
     fn find_values(
         &self,
         _: Request<IndexedValueReferenceMessage>,
-    ) -> Result<Response<JsonResponse>, Status> {
+    ) -> Result<Response<JsonMessage>, Status> {
         todo!()
     }
 
     fn find_values_by_range(
         &self,
         _: Request<IndexedValueRangeReferenceMessage>,
-    ) -> Result<Response<JsonResponse>, Status> {
+    ) -> Result<Response<JsonMessage>, Status> {
         todo!()
     }
 }
diff --git a/src/db/server/mod.rs b/src/db/server/mod.rs
@@ -12,7 +12,8 @@ pub mod table_server_trait_impl;
 pub mod table_value_server_trait;
 pub mod table_value_server_trait_impl;
 
+mod db_error_to_status;
+mod source_sink;
 mod to_entity_trait;
 mod to_reference_trait;
-mod db_error_to_status;
-mod source_sink;
+mod value_to_json;
diff --git a/src/db/server/rocks_db_accessor.rs b/src/db/server/rocks_db_accessor.rs
@@ -1,8 +1,8 @@
 // use rocksdb::{Options, DB};
+use crate::db::db_error::DbError;
+use crate::db::db_error::DbResult;
 use rocksdb::{Options, DB};
 use std::sync::{Arc, RwLock};
-use crate::db::db_error::DbResult;
-use crate::db::db_error::DbError;
 
 // Define the struct that contains the RocksDB instance
 #[derive(Clone)]
@@ -48,7 +48,9 @@ impl RocksDbAccessor {
         guarded_db.read().map_err(|_| DbError::CanNotLockDbMutex)
     }
 
-    pub fn db_write_lock(guarded_db: &Arc<RwLock<DB>>) -> DbResult<std::sync::RwLockWriteGuard<DB>> {
+    pub fn db_write_lock(
+        guarded_db: &Arc<RwLock<DB>>,
+    ) -> DbResult<std::sync::RwLockWriteGuard<DB>> {
         guarded_db.write().map_err(|_| DbError::CanNotLockDbMutex)
     }
 }