pass strings instead of serde value between plugins

Author: DenisBiryukov91

plugins/zenoh-backend-example/src/lib.rs

@@ -60,8 +60,8 @@ impl Default for ExampleStorage {
 
 #[async_trait]
 impl Volume for ExampleBackend {
-    fn get_admin_status(&self) -> serde_json::Value {
-        serde_json::Value::Null
+    fn get_admin_status(&self) -> String {
+        String::default()
     }
     fn get_capability(&self) -> Capability {
         Capability {

plugins/zenoh-backend-traits/src/lib.rs

@@ -183,9 +183,9 @@ pub struct StoredData {
 /// Trait to be implemented by a Backend.
 #[async_trait]
 pub trait Volume: Send + Sync {
-    /// Returns the status that will be sent as a reply to a query
+    /// Returns the status in the form of json string that will be sent as a reply to a query
     /// on the administration space for this backend.
-    fn get_admin_status(&self) -> serde_json::Value;
+    fn get_admin_status(&self) -> String;
 
     /// Returns the capability of this backend
     fn get_capability(&self) -> Capability;

plugins/zenoh-plugin-example/src/lib.rs

@@ -130,12 +130,9 @@ struct RunningPlugin(Arc<Mutex<RunningPluginInner>>);
 impl PluginControl for RunningPlugin {}
 
 impl RunningPluginTrait for RunningPlugin {
-    fn config_checker(
-        &self,
-        path: &str,
-        old: &serde_json::Map<String, serde_json::Value>,
-        new: &serde_json::Map<String, serde_json::Value>,
-    ) -> ZResult<Option<serde_json::Map<String, serde_json::Value>>> {
+    fn config_checker(&self, path: &str, old: &str, new: &str) -> ZResult<Option<String>> {
+        let old = serde_json::from_str::<serde_json::Map<String, serde_json::Value>>(old)?;
+        let new = serde_json::from_str::<serde_json::Map<String, serde_json::Value>>(new)?;
         let mut guard = zlock!(&self.0);
         const STORAGE_SELECTOR: &str = "storage-selector";
         if path == STORAGE_SELECTOR || path.is_empty() {

plugins/zenoh-plugin-rest/src/config.rs

@@ -40,9 +40,9 @@ pub struct Config {
     __plugin__: Option<String>,
 }
 
-impl From<&Config> for serde_json::Value {
+impl From<&Config> for String {
     fn from(c: &Config) -> Self {
-        serde_json::to_value(c).unwrap()
+        serde_json::to_value(c).unwrap().to_string()
     }
 }
 

plugins/zenoh-plugin-storage-manager/src/lib.rs

@@ -316,15 +316,12 @@ impl PluginControl for StorageRuntime {
 }
 
 impl RunningPluginTrait for StorageRuntime {
-    fn config_checker(
-        &self,
-        _: &str,
-        old: &serde_json::Map<String, serde_json::Value>,
-        new: &serde_json::Map<String, serde_json::Value>,
-    ) -> ZResult<Option<serde_json::Map<String, serde_json::Value>>> {
+    fn config_checker(&self, _: &str, old: &str, new: &str) -> ZResult<Option<String>> {
+        let old = serde_json::from_str::<serde_json::Map<String, serde_json::Value>>(old)?;
+        let new = serde_json::from_str::<serde_json::Map<String, serde_json::Value>>(new)?;
         let name = { zlock!(self.0).name.clone() };
-        let old = PluginConfig::try_from((&name, old))?;
-        let new = PluginConfig::try_from((&name, new))?;
+        let old = PluginConfig::try_from((&name, &old))?;
+        let new = PluginConfig::try_from((&name, &new))?;
         tracing::debug!("config change requested for plugin '{}'", name);
         tracing::debug!("old config: {:?}", &old);
         tracing::debug!("new config: {:?}", &new);
@@ -381,7 +378,7 @@ impl RunningPluginTrait for StorageRuntime {
                                     rx.recv().await
                                 })
                             }) {
-                                responses.push(Response::new(key.clone(), value))
+                                responses.push(Response::new(key.clone(), value.to_string()))
                             }
                         }
                     })

plugins/zenoh-plugin-storage-manager/src/memory_backend/mod.rs

@@ -50,8 +50,8 @@ impl Plugin for MemoryBackend {
 
 #[async_trait]
 impl Volume for MemoryBackend {
-    fn get_admin_status(&self) -> serde_json::Value {
-        self.config.to_json_value()
+    fn get_admin_status(&self) -> String {
+        self.config.to_json_value().to_string()
     }
 
     fn get_capability(&self) -> Capability {

zenoh/src/api/plugins.rs

@@ -43,16 +43,16 @@ impl PluginControl for RunningPlugin {
 impl PluginInstance for RunningPlugin {}
 
 #[non_exhaustive]
-#[derive(serde::Serialize, Debug, Clone)]
+#[derive(Debug, Clone)]
 /// A Response for the administration space.
 pub struct Response {
     pub key: String,
-    pub value: serde_json::Value,
+    pub json_value: String,
 }
 
 impl Response {
-    pub fn new(key: String, value: serde_json::Value) -> Self {
-        Self { key, value }
+    pub fn new(key: String, json_value: String) -> Self {
+        Self { key, json_value }
     }
 }
 
@@ -69,12 +69,7 @@ pub trait RunningPluginTrait: Send + Sync + PluginControl {
     ///   Useful when the changes affect settings that aren't hot-configurable for your plugin.
     /// * `Ok(None)` indicates that the plugin has accepted the configuration change.
     /// * `Ok(Some(value))` indicates that the plugin would rather the new configuration be `value`.
-    fn config_checker(
-        &self,
-        _path: &str,
-        _current: &serde_json::Map<String, serde_json::Value>,
-        _new: &serde_json::Map<String, serde_json::Value>,
-    ) -> ZResult<Option<serde_json::Map<String, serde_json::Value>>> {
+    fn config_checker(&self, _path: &str, _current: &str, _new: &str) -> ZResult<Option<String>> {
         bail!("Runtime configuration change not supported");
     }
     /// Used to request plugin's status for the administration space.

zenoh/src/net/runtime/adminspace.rs

@@ -91,7 +91,14 @@ impl ConfigValidator for AdminSpace {
                 // on config comparison (see `PluginDiff`)
                 return Ok(None);
             };
-            plugin.instance().config_checker(path, current, new)
+            let current = serde_json::to_string(current)?;
+            let new = serde_json::to_string(new)?;
+            match plugin.instance().config_checker(path, &current, &new)? {
+                Some(s) => Ok(Some(serde_json::from_str::<
+                    serde_json::Map<String, serde_json::Value>,
+                >(&s)?)),
+                None => Ok(None),
+            }
         }
         #[cfg(not(feature = "plugins"))]
         {
@@ -958,14 +965,8 @@ fn plugins_status(context: &AdminContext, query: Query) {
                 Ok(Ok(responses)) => {
                     for response in responses {
                         if let Ok(key_expr) = KeyExpr::try_from(response.key) {
-                            match serde_json::to_vec(&response.value) {
-                                Ok(bytes) => {
-                                    if let Err(e) = query.reply(key_expr, bytes).encoding(Encoding::APPLICATION_JSON).wait() {
-                                        tracing::error!("Error sending AdminSpace reply: {:?}", e);
-                                    }
-                                }
-                                Err(e) => tracing::debug!("Admin query error: {}", e),
-
+                            if let Err(e) = query.reply(key_expr, response.json_value).encoding(Encoding::APPLICATION_JSON).wait() {
+                                tracing::error!("Error sending AdminSpace reply: {:?}", e);
                             }
                         } else {
                             tracing::error!("Error: plugin {} replied with an invalid key", plugin_key);