RPPL-3298 : fix: error response added for the thunderclient call fn

core/main/src/broker/thunder/thunder_plugins_status_mgr.rs

@@ -366,7 +366,10 @@ impl StatusManager {
                     if !pending_requests.is_empty() {
                         for pending_request in pending_requests {
                             if expired {
-                                error!("Expired request: {:?}", pending_request);
+                                error!(
+                                    "plugin activation timeout for request: {:?}",
+                                    pending_request
+                                );
                                 callback
                                     .send_error(pending_request, RippleError::ServiceError)
                                     .await;
@@ -413,7 +416,10 @@ impl StatusManager {
 
             for pending_request in pending_requests {
                 if expired {
-                    error!("Expired request: {:?}", pending_request);
+                    error!(
+                        "plugin activation timeout for request: {:?}",
+                        pending_request
+                    );
                     callback
                         .send_error(pending_request, RippleError::ServiceError)
                         .await;
@@ -492,7 +498,10 @@ impl StatusManager {
 
             for pending_request in pending_requests {
                 if expired {
-                    error!("Expired request: {:?}", pending_request);
+                    error!(
+                        "plugin activation timeout for request: {:?}",
+                        pending_request
+                    );
                     callback
                         .send_error(pending_request, RippleError::ServiceError)
                         .await;

device/thunder_ripple_sdk/src/client/device_operator.rs

@@ -190,11 +190,14 @@ impl DeviceResponseMessage {
         json_resp: &JsonRpcApiResponse,
         sub_id: Option<String>,
     ) -> Option<DeviceResponseMessage> {
+        let json_value = serde_json::to_value(json_resp).ok();
         let mut device_response_msg = None;
         if let Some(res) = &json_resp.result {
             device_response_msg = Some(DeviceResponseMessage::new(res.clone(), sub_id));
-        } else if let Some(er) = &json_resp.error {
-            device_response_msg = Some(DeviceResponseMessage::new(er.clone(), sub_id));
+        } else if let Some(_er) = &json_resp.error {
+            if let Some(val) = json_value {
+                device_response_msg = Some(DeviceResponseMessage::new(val, sub_id));
+            }
         } else if json_resp.clone().method.is_some() {
             if let Some(params) = &json_resp.params {
                 if let Ok(dev_resp) = serde_json::to_value(params) {

device/thunder_ripple_sdk/src/client/thunder_client.rs

@@ -165,7 +165,7 @@ impl DeviceOperator for ThunderClient {
             }
             let result = rx.await;
             if let Err(ref e) = result {
-                error!("subscribe: e={:?}", e);
+                error!("subscribe: error={:?}", e);
             }
             result
         } else {

device/thunder_ripple_sdk/src/processors/thunder_analytics.rs

@@ -15,6 +15,7 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+use ripple_sdk::log::error;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
@@ -50,13 +51,23 @@ pub async fn send_to_analytics_plugin(
 ) -> DeviceResponseMessage {
     let method: String = ThunderPlugin::Analytics.method("sendEvent");
 
-    thunder_state
+    let resp = thunder_state
         .get_thunder_client()
         .call(DeviceCallRequest {
             method,
             params: Some(DeviceChannelParams::Json(
                 serde_json::to_string(&metrics_event).unwrap(),
             )),
         })
-        .await
+        .await;
+
+    if let Some(error) = resp.message.get("error") {
+        error!("sendEvent call FAILED response of error:{:?}", error);
+        DeviceResponseMessage {
+            message: Value::Null,
+            sub_id: None,
+        }
+    } else {
+        resp
+    }
 }

device/thunder_ripple_sdk/src/processors/thunder_device_info.rs

@@ -187,19 +187,28 @@ pub struct ThunderNetworkService;
 
 impl ThunderNetworkService {
     pub async fn has_internet(state: &ThunderState) -> bool {
-        let response = state
+        let resp = state
             .get_thunder_client()
             .call(DeviceCallRequest {
                 method: ThunderPlugin::Network.method("isConnectedToInternet"),
                 params: None,
             })
             .await;
-        info!("{}", response.message);
-        let response = response.message.get("connectedToInternet");
-        if response.is_none() {
+
+        if let Some(error) = resp.message.get("error") {
+            error!(
+                "isConnectedToInternet call FAILED response of error:{:?}",
+                error
+            );
             return false;
         }
-        let v = response.unwrap().as_bool().unwrap_or(false);
+
+        let response = match resp.message.get("connectedToInternet") {
+            Some(val) => val,
+            None => return false,
+        };
+
+        let v = response.as_bool().unwrap_or(false);
         let _ = state
             .get_client()
             .request_transient(RippleContextUpdateRequest::InternetStatus(v.into()));
@@ -262,7 +271,11 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
-        info!("{}", resp.message);
+
+        if let Some(error) = resp.message.get("error") {
+            error!("getSerialNumber call FAILED response of error:{:?}", error);
+            return "".to_string();
+        }
 
         resp.message["serialNumber"]
             .as_str()
@@ -277,12 +290,20 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
-        info!("{}", resp.message);
-        let resp = resp.message.get("stbVersion");
-        if resp.is_none() {
-            return "NA".to_owned();
+
+        if let Some(error) = resp.message.get("error") {
+            error!(
+                "getSystemVersions call FAILED response of error:{:?}",
+                error
+            );
+            return "".to_string();
         }
-        let resp = resp.unwrap().as_str().unwrap().trim_matches('"');
+
+        let response = match resp.message.get("stbVersion") {
+            Some(val) => val,
+            None => return "NA".to_owned(),
+        };
+        let resp = response.as_str().unwrap().trim_matches('"');
         let split_string: Vec<&str> = resp.split('_').collect();
         String::from(split_string[0])
     }
@@ -313,7 +334,7 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
-        info!("{}", response.message);
+
         if !check_thunder_response_success(&response) {
             error!("{}", response.message);
             return HashMap::new();
@@ -347,7 +368,7 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
-        info!("{}", response.message);
+
         let mut hdcp_response = HashMap::new();
         let resp = response.message.get("supportedHDCPVersion");
 
@@ -409,7 +430,8 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
-        info!("{}", resp.message);
+
+        info!("getHDCPStatus call response msg: {}", resp.message);
         if let Ok(thdcp) = serde_json::from_value::<ThunderHDCPStatus>(resp.message) {
             response = thdcp.hdcp_status;
         }
@@ -442,7 +464,19 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
-        info!("{}", response.message);
+
+        if let Some(error) = response.message.get("error") {
+            error!(
+                "getTVHDRCapabilities call FAILED response of error:{:?}",
+                error
+            );
+            return HashMap::new();
+        }
+
+        info!(
+            "getTVHDRCapabilities call response msg: {}",
+            response.message
+        );
         let supported_cap: u32 = response.message["capabilities"]
             .to_string()
             .parse()
@@ -480,7 +514,15 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
-        info!("{}", resp.message);
+
+        if let Some(error) = resp.message.get("error") {
+            error!(
+                "getSystemVersions call FAILED response of error:{:?}",
+                error
+            );
+            return FireboltSemanticVersion::default();
+        }
+
         if let Ok(tsv) = serde_json::from_value::<SystemVersion>(resp.message) {
             let tsv_split = tsv.receiver_version.split('.');
             let tsv_vec: Vec<&str> = tsv_split.collect();
@@ -546,15 +588,15 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
-        info!("{}", response.message);
+
         if check_thunder_response_success(&response) {
             if let Some(v) = response.message["freeRam"].as_u64() {
                 return Self::respond(state.get_client(), req, ExtnResponse::Value(json!(v)))
                     .await
                     .is_ok();
             }
         }
-        error!("{}", response.message);
+        error!("getSystemMemory call response msg: {}", response.message);
         Self::handle_error(state.get_client(), req, RippleError::ProcessorError).await
     }
 
@@ -567,7 +609,7 @@ impl ThunderDeviceInfoRequestProcessor {
             })
             .await;
 
-        info!("getTimeZoneDST: {}", response.message);
+        info!("getTimeZoneDST call response msg: {}", response.message);
         if check_thunder_response_success(&response) {
             if let Ok(v) = serde_json::from_value::<ThunderTimezoneResponse>(response.message) {
                 return Ok(v.time_zone);
@@ -685,6 +727,7 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
+
         if let Some(v) = response.message["isenabled"].as_bool() {
             return Self::respond(state.get_client(), request, ExtnResponse::Boolean(v))
                 .await
@@ -711,6 +754,7 @@ impl ThunderDeviceInfoRequestProcessor {
                 params,
             })
             .await;
+
         if check_thunder_response_success(&response) {
             return Self::ack(state.get_client(), request).await.is_ok();
         }
@@ -725,6 +769,15 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
+
+        if let Some(error) = response.message.get("error") {
+            error!(
+                "getttsconfiguration call FAILED response of error:{:?}",
+                error
+            );
+            return false;
+        }
+
         if let Some(rate) = response.message["rate"].as_f64() {
             return Self::respond(
                 state.get_client(),
@@ -746,6 +799,14 @@ impl ThunderDeviceInfoRequestProcessor {
             })
             .await;
 
+        if let Some(error) = response.message.get("error") {
+            error!(
+                "getttsconfiguration call FAILED response of error:{:?}",
+                error
+            );
+            return Err(());
+        }
+
         if let Some(rate) = response.message["rate"].as_f64() {
             return Ok(scale_voice_speed_from_thunder_to_firebolt(rate as f32));
         }
@@ -771,6 +832,7 @@ impl ThunderDeviceInfoRequestProcessor {
                 params,
             })
             .await;
+
         if check_thunder_response_success(&response) {
             return Self::ack(state.get_client(), request).await.is_ok();
         }
@@ -815,6 +877,15 @@ impl ThunderDeviceInfoRequestProcessor {
                 params: None,
             })
             .await;
+
+        if let Some(error) = resp.message.get("error") {
+            error!(
+                "getSystemVersions call FAILED response of error:{:?}",
+                error
+            );
+            return false;
+        }
+
         if let Ok(tsv) = serde_json::from_value::<SystemVersion>(resp.message) {
             let release_regex = Regex::new(r"([^_]*)_(.*)_(VBN|PROD[^_]*)_(.*)").unwrap();
             let non_release_regex =

device/thunder_ripple_sdk/src/processors/thunder_persistent_store.rs

@@ -147,6 +147,7 @@ impl ThunderStorageRequestProcessor {
                 params,
             })
             .await;
+
         if response.message.get("success").is_none()
             || !response.message["success"].as_bool().unwrap_or_default()
         {
@@ -203,7 +204,6 @@ impl ThunderStorageRequestProcessor {
                 params,
             })
             .await;
-        info!("{}", response.message);
 
         if let Some(status) = response.message["success"].as_bool() {
             if status {
@@ -270,8 +270,13 @@ impl ThunderStorageRequestProcessor {
                 params,
             })
             .await;
-        info!("{}", response.message);
 
+        if let Some(error) = response.message.get("error") {
+            error!("setValue call FAILED response of error:{:?}", error);
+            return Err(RippleError::InvalidOutput);
+        }
+
+        info!("setValue call response msg: {}", response.message);
         match response.message["success"].as_bool() {
             Some(v) => Ok(v),
             None => Err(RippleError::InvalidOutput),

device/thunder_ripple_sdk/src/processors/thunder_rfc.rs

@@ -111,17 +111,23 @@ impl ExtnRequestProcessor for ThunderRFCProcessor {
     ) -> bool {
         let flag = extracted_message.flag.clone();
         let rfc_request = json!({ "rfcList": vec![flag] }).to_string();
-        let resp = state
+        let response = state
             .get_thunder_client()
             .call(DeviceCallRequest {
                 method: ThunderPlugin::System.method("getRFCConfig"),
                 params: Some(DeviceChannelParams::Json(rfc_request)),
             })
             .await;
+
+        if let Some(error) = response.message.get("error") {
+            error!("getRFCConfig call FAILED response of error:{:?}", error);
+            return false;
+        }
+
         Self::respond(
             state.get_client(),
             msg,
-            match serde_json::from_value::<ThunderRFCResponse>(resp.message) {
+            match serde_json::from_value::<ThunderRFCResponse>(response.message) {
                 Ok(rfc_response) => rfc_response.get_extn_response(&extracted_message),
                 Err(e) => {
                     error!("rfc serialization error {:?}", e);

device/thunder_ripple_sdk/src/processors/thunder_telemetry.rs

@@ -161,7 +161,7 @@ impl ExtnEventProcessor for ThunderTelemetryProcessor {
 
         if let Ok(data) = render_event_data(&extracted_message) {
             info!("Sending telemetry event: {}", data);
-            state
+            let _ = state
                 .get_thunder_client()
                 .call(DeviceCallRequest {
                     method: ThunderPlugin::Telemetry.unversioned_method("logApplicationEvent"),