Adapt to changes in the everest-framework MR.

Signed-off-by: Holger Rapp <[email protected]>

modules/RsSmokeTest/src/eventually_generated.rs

@@ -4,33 +4,33 @@ pub trait KvsService: Sync {
     /// This command removes the value stored under a given key
     ///
     /// `key`: Key to delete the value for
-    fn delete(&mut self, key: String) -> everestrs::Result<()>;
+    fn delete(&self, key: String) -> everestrs::Result<()>;
 
     /// This command checks if something is stored under a given key
     ///
     /// `key`: Key to check the existence for
     ///
     /// Returns: Returns 'True' if something was stored for this key*/
-    fn exists(&mut self, key: String) -> ::everestrs::Result<bool>;
+    fn exists(&self, key: String) -> ::everestrs::Result<bool>;
 
     /// This command loads the previously stored value for a given key (it will return null if the
     /// key does not exist)
     ///
     /// `key`: Key to load the value for
     ///
     /// Returns: The previously stored value
-    fn load(&mut self, key: String) -> ::everestrs::Result<serde_json::Value>;
+    fn load(&self, key: String) -> ::everestrs::Result<serde_json::Value>;
 
     /// This command stores a value under a given key
     ///
     /// `key`: Key to store the value for
     /// `value`: Value to store
-    fn store(&mut self, key: String, value: ::serde_json::Value) -> ::everestrs::Result<()>;
+    fn store(&self, key: String, value: ::serde_json::Value) -> ::everestrs::Result<()>;
 }
 
 pub trait Module: Sync + Sized {
-    fn on_ready(&mut self) {}
-    fn main(&mut self) -> &mut dyn KvsService;
+    fn on_ready(&self) {}
+    fn main(&self) -> &dyn KvsService;
 }
 
 /// We want the user to just implement the `Module` trait above to get access to everything that
@@ -41,7 +41,7 @@ pub struct GenericToSpecificModuleProxy<T: Module>(T);
 
 impl<T: Module> everestrs::GenericModule for GenericToSpecificModuleProxy<T> {
     fn handle_command(
-        &mut self,
+        &self,
         implementation_id: &str,
         cmd_name: &str,
         parameters: HashMap<String, serde_json::Value>,
@@ -54,7 +54,7 @@ impl<T: Module> everestrs::GenericModule for GenericToSpecificModuleProxy<T> {
         }
     }
 
-    fn on_ready(&mut self) {
+    fn on_ready(&self) {
         self.0.on_ready()
     }
 }
@@ -70,7 +70,7 @@ mod main {
     use std::collections::HashMap;
 
     pub fn handle_command(
-        main_service: &mut dyn super::KvsService,
+        main_service: &dyn super::KvsService,
         cmd_name: &str,
         mut parameters: HashMap<String, serde_json::Value>,
     ) -> ::everestrs::Result<serde_json::Value> {

modules/RsSmokeTest/src/main.rs

@@ -1,33 +1,34 @@
 use std::collections::BTreeMap;
+use std::sync::RwLock;
 use std::{thread, time};
 
 mod eventually_generated;
 
 struct Kvs {
-    values: BTreeMap<String, serde_json::Value>,
+    values: RwLock<BTreeMap<String, serde_json::Value>>,
 }
 
 impl eventually_generated::KvsService for Kvs {
-    fn store(&mut self, key: String, value: serde_json::Value) -> ::everestrs::Result<()> {
-        self.values.insert(key, value);
+    fn store(&self, key: String, value: serde_json::Value) -> ::everestrs::Result<()> {
+        let mut v = self.values.write().expect("should never be poisoned.");
+        v.insert(key, value);
         Ok(())
     }
 
-    fn load(&mut self, key: String) -> ::everestrs::Result<serde_json::Value> {
-        Ok(self
-            .values
-            .get(&key)
-            .cloned()
-            .unwrap_or(serde_json::Value::Null))
+    fn load(&self, key: String) -> ::everestrs::Result<serde_json::Value> {
+        let v = self.values.read().expect("should never be poisoned.");
+        Ok(v.get(&key).cloned().unwrap_or(serde_json::Value::Null))
     }
 
-    fn delete(&mut self, key: String) -> ::everestrs::Result<()> {
-        self.values.remove(&key);
+    fn delete(&self, key: String) -> ::everestrs::Result<()> {
+        let mut v = self.values.write().expect("should never be poisoned.");
+        v.remove(&key);
         Ok(())
     }
 
-    fn exists(&mut self, key: String) -> ::everestrs::Result<bool> {
-        Ok(self.values.contains_key(&key))
+    fn exists(&self, key: String) -> ::everestrs::Result<bool> {
+        let v = self.values.read().expect("should never be poisoned.");
+        Ok(v.contains_key(&key))
     }
 }
 
@@ -36,19 +37,19 @@ pub struct Module {
 }
 
 impl eventually_generated::Module for Module {
-    fn main(&mut self) -> &mut dyn eventually_generated::KvsService {
-        &mut self.kvs
+    fn main(&self) -> &dyn eventually_generated::KvsService {
+        &self.kvs
     }
 
-    fn on_ready(&mut self) {
+    fn on_ready(&self) {
         println!("Welcome to the RsSmokeTest module!");
     }
 }
 
 fn main() {
     let module = Module {
         kvs: Kvs {
-            values: BTreeMap::new(),
+            values: RwLock::new(BTreeMap::new()),
         },
     };
     let _mod = eventually_generated::init_from_commandline(module);