table server

List functions are not yet implemented
tercen · Mar 16, 2023 · 5edcf1a · 5edcf1a
1 parent 0ec5555
commit 5edcf1a
Show file tree

Hide file tree

Showing 4 changed files with 163 additions and 62 deletions.
diff --git a/examples/ondo_example.rs b/examples/ondo_example.rs
@@ -2,7 +2,7 @@
 
 use ondo::db::server::{
     database_server_trait::DatabaseServerTrait, domain_server_trait::DomainServerTrait,
-    rocks_db_accessor::RocksDbAccessor,
+    rocks_db_accessor::RocksDbAccessor, table_server_trait::TableServerTrait,
 };
 use ondo::ondo_remote::*;
 use tonic::Request;
@@ -46,6 +46,29 @@ fn domain_server_example(rda: &RocksDbAccessor) {
     println!("Updated Domain: {:?}", answer);
     let answer = rda.list_tables(Request::new(domain_reference_msg.clone()));
     println!("Listed Tables: {:?}", answer);
+    table_server_example(rda, &domain_reference_msg);
     let answer = rda.delete_domain(Request::new(domain_reference_msg.clone()));
     println!("Deleted Domain: {:?}", answer);
 }
+
+fn table_server_example(rda: &RocksDbAccessor, domain_reference_msg: &DomainReferenceMessage) {
+    let table_name = "test_table";
+    let table_reference_msg = TableReferenceMessage {
+        domain_reference: Some(domain_reference_msg.clone()),
+        table_name: table_name.to_owned(),
+    };
+    let table_msg = TableMessage {
+        table_reference: Some(table_reference_msg.clone()),
+    };
+    let answer = rda.create_table(Request::new(table_msg.clone()));
+    println!("Created Table: {:?}", answer);
+    let answer = rda.get_table(Request::new(table_reference_msg.clone()));
+    println!("Got Table: {:?}", answer);
+    let answer = rda.update_table(Request::new(table_msg.clone()));
+    println!("Updated Table: {:?}", answer);
+    let answer = rda.list_indexes(Request::new(table_reference_msg.clone()));
+    println!("Listed Tables: {:?}", answer);
+    let answer = rda.delete_table(Request::new(table_reference_msg.clone()));
+    println!("Deleted Table: {:?}", answer);
+    println!("TODO list functions not yet implemented")
+}
diff --git a/src/db/entity/reference/requests/table_stored_requests.rs b/src/db/entity/reference/requests/table_stored_requests.rs
@@ -8,3 +8,4 @@ pub(crate) trait TableStoredRequests {
     fn get_table_stored(&self, cf_name: &str, key: &TableName) -> DbResult<Option<TableStored>>;
     fn iter<'a>(&'a self, value_cf_name: &str) -> CallbackIterator<'a, TableValue>;
 }
+//TODO: need get values also by id range and id list
diff --git a/src/db/server/domain_server_trait_impl.rs b/src/db/server/domain_server_trait_impl.rs
@@ -5,47 +5,75 @@ use super::rocks_db_accessor::RocksDbAccessor;
 use super::source_sink::effects_sink::EffectsSink;
 use super::to_entity_trait::FromEntity;
 use super::to_entity_trait::ToEntity;
+use super::to_reference_trait::FromReference;
 use super::to_reference_trait::ToReference;
 use crate::db::entity::domain::Domain;
 use crate::db::entity::reference::domain_reference::DomainReference;
 use crate::db::entity::reference::domain_reference::DomainReferenceTrait;
 use crate::ondo_remote::*;
 use tonic::{Request, Response, Status};
 
-impl ToReference<DomainReference> for Request<DomainReferenceMessage> {
+impl ToReference<DomainReference> for DomainReferenceMessage {
     fn to_reference(&self) -> DomainReference {
         DomainReference {
-            domain_name: self.get_ref().domain_name.clone(),
+            domain_name: self.domain_name.clone(),
         }
     }
 }
 
+impl ToReference<DomainReference> for Request<DomainReferenceMessage> {
+    fn to_reference(&self) -> DomainReference {
+        self.get_ref().to_reference()
+    }
+}
+
+impl ToReference<DomainReference> for DomainMessage {
+    fn to_reference(&self) -> DomainReference {
+        let r_msg = self.domain_reference.as_ref().unwrap();
+        r_msg.to_reference()
+    }
+}
+
 impl ToReference<DomainReference> for Request<DomainMessage> {
     fn to_reference(&self) -> DomainReference {
-        let msg = self.get_ref();
-        let r_msg = msg.domain_reference.as_ref().unwrap();
-        DomainReference {
-            domain_name: r_msg.domain_name.clone(),
-        }
+        self.get_ref().to_reference()
     }
 }
 
-impl ToEntity<Domain> for Request<DomainMessage> {
+impl ToEntity<Domain> for DomainMessage {
     fn to_entity(&self) -> Domain {
         let r = self.to_reference();
         Domain { id: r }
     }
 }
 
-impl FromEntity<Domain> for Response<DomainMessage> {
-    fn from_entity(entity: Domain) -> Self {
-        let r = entity.id;
-        let r_msg = DomainReferenceMessage {
+impl ToEntity<Domain> for Request<DomainMessage> {
+    fn to_entity(&self) -> Domain {
+        self.get_ref().to_entity()
+    }
+}
+
+impl FromReference<DomainReference> for DomainReferenceMessage {
+    fn from_reference(r: DomainReference) -> Self {
+        DomainReferenceMessage {
             domain_name: r.domain_name,
-        };
-        Response::new(DomainMessage {
+        }
+    }
+}
+
+impl FromEntity<Domain> for DomainMessage {
+    fn from_entity(entity: Domain) -> Self {
+        let r_msg = DomainReferenceMessage::from_reference(entity.id);
+        DomainMessage {
             domain_reference: Some(r_msg),
-        })
+        }
+    }
+}
+
+impl FromEntity<Domain> for Response<DomainMessage> {
+    fn from_entity(entity: Domain) -> Self {
+        let msg = DomainMessage::from_entity(entity);
+        Response::new(msg)
     }
 }
 

diff --git a/src/db/server/table_server_trait_impl.rs b/src/db/server/table_server_trait_impl.rs
@@ -5,6 +5,7 @@ use super::source_sink::effects_sink::EffectsSink;
 use super::table_server_trait::TableServerTrait;
 use super::to_entity_trait::FromEntity;
 use super::to_entity_trait::ToEntity;
+use super::to_reference_trait::FromReference;
 use super::to_reference_trait::ToReference;
 use crate::db::entity::reference::table_reference::TableReference;
 use crate::db::entity::reference::table_reference::TableReferenceTrait;
@@ -13,71 +14,119 @@ use crate::ondo_remote;
 use ondo_remote::*;
 use tonic::{Request, Response, Status};
 
-// impl ToReference<TableReference> for Request<TableReferenceMessage> {
-//     fn to_reference(&self) -> TableReference {
-//         TableReference {
-//             domain_name: self.get_ref().domain_name.clone(),
-//         }
-//     }
-// }
-
-// impl ToReference<TableReference> for Request<TableMessage> {
-//     fn to_reference(&self) -> TableReference {
-//         let msg = self.get_ref();
-//         let r_msg = msg.domain_reference.as_ref().unwrap();
-//         TableReference {
-//             domain_name: r_msg.domain_name.clone(),
-//         }
-//     }
-// }
-
-// impl ToEntity<Table> for Request<TableMessage> {
-//     fn to_entity(&self) -> Table {
-//         let r = self.to_reference();
-//         Table { id: r }
-//     }
-// }
-
-// impl FromEntity<Table> for Response<TableMessage> {
-//     fn from_entity(entity: Table) -> Self {
-//         let r = entity.id;
-//         let r_msg = TableReferenceMessage {
-//             domain_name: r.domain_name,
-//         };
-//         Response::new(TableMessage {
-//             domain_reference: Some(r_msg),
-//         })
-//     }
-// }
+impl ToReference<TableReference> for TableReferenceMessage {
+    fn to_reference(&self) -> TableReference {
+        TableReference {
+            domain_name: self.domain_reference.as_ref().unwrap().domain_name.clone(),
+            table_name: self.table_name.clone(),
+        }
+    }
+}
+
+impl ToReference<TableReference> for Request<TableReferenceMessage> {
+    fn to_reference(&self) -> TableReference {
+        self.get_ref().to_reference()
+    }
+}
+
+impl ToReference<TableReference> for TableMessage {
+    fn to_reference(&self) -> TableReference {
+        let r_msg = self.table_reference.as_ref().unwrap();
+        r_msg.to_reference()
+    }
+}
+
+impl ToReference<TableReference> for Request<TableMessage> {
+    fn to_reference(&self) -> TableReference {
+        self.get_ref().to_reference()
+    }
+}
+
+impl ToEntity<Table> for TableMessage {
+    fn to_entity(&self) -> Table {
+        let r = self.to_reference();
+        Table { id: r }
+    }
+}
+
+impl ToEntity<Table> for Request<TableMessage> {
+    fn to_entity(&self) -> Table {
+        self.get_ref().to_entity()
+    }
+}
+
+impl FromReference<TableReference> for TableReferenceMessage {
+    fn from_reference(r: TableReference) -> Self {
+        TableReferenceMessage {
+            domain_reference: Some(DomainReferenceMessage {
+                domain_name: r.domain_name,
+            }),
+            table_name: r.table_name,
+        }
+    }
+}
+
+impl FromEntity<Table> for TableMessage {
+    fn from_entity(entity: Table) -> Self {
+        let r_msg = TableReferenceMessage::from_reference(entity.id);
+        TableMessage {
+            table_reference: Some(r_msg),
+        }
+    }
+}
+
+impl FromEntity<Table> for Response<TableMessage> {
+    fn from_entity(entity: Table) -> Self {
+        let msg = TableMessage::from_entity(entity);
+        Response::new(msg)
+    }
+}
 
 impl TableServerTrait for RocksDbAccessor {
-    fn create_table(&self, _: Request<TableMessage>) -> Result<Response<EmptyMessage>, Status> {
-        todo!()
+    fn create_table(&self, r: Request<TableMessage>) -> Result<Response<EmptyMessage>, Status> {
+        r.to_reference()
+            .post_table(&r.to_entity(), self, self)
+            .map_db_err_to_status()?
+            .apply_effects(self)
     }
 
     fn delete_table(
         &self,
-        _: Request<TableReferenceMessage>,
+        r: Request<TableReferenceMessage>,
     ) -> Result<Response<EmptyMessage>, Status> {
-        todo!()
+        r.to_reference()
+            .delete_table(self, self)
+            .map_db_err_to_status()?
+            .apply_effects(self)
     }
 
     fn get_table(
         &self,
-        _: Request<TableReferenceMessage>,
+        r: Request<TableReferenceMessage>,
     ) -> Result<Response<TableMessage>, Status> {
-        todo!()
+        r.to_reference()
+            .get_table(self)
+            .map_db_err_option_to_status()
+            .map(|entity| Response::<TableMessage>::from_entity(entity))
     }
 
-    fn update_table(&self, _: Request<TableMessage>) -> Result<Response<EmptyMessage>, Status> {
-        todo!()
+    fn update_table(&self, r: Request<TableMessage>) -> Result<Response<EmptyMessage>, Status> {
+        r.to_reference()
+            .put_table(&r.to_entity(), self)
+            .map_db_err_to_status()?
+            .apply_effects(self)
     }
 
     fn list_indexes(
         &self,
-        _: Request<TableReferenceMessage>,
+        r: Request<TableReferenceMessage>,
     ) -> Result<Response<ArrayOfStringResponse>, Status> {
-        todo!()
+        let names = r
+            .to_reference()
+            .list_index_names(self)
+            .map_db_err_to_status()?;
+        let response = ArrayOfStringResponse { values: names };
+        Ok(Response::new(response))
     }
 
     fn list_values(