Digital Twin Graph

Author: ashbeitz

core/module/digital_twin_graph/src/digital_twin_graph_impl.rs

@@ -240,6 +240,10 @@ impl DigitalTwinGraph for DigitalTwinGraphImpl {
         let find_request = request.into_inner();
         let model_id = find_request.model_id;
 
+        if model_id.is_empty() {
+            return Err(tonic::Status::invalid_argument("Model id is required"));
+        }
+
         debug!("Received a find request for model id {model_id}");
 
         // Retrieve the provider details.
@@ -334,6 +338,12 @@ impl DigitalTwinGraph for DigitalTwinGraphImpl {
         let instance_id = get_request.instance_id;
         let member_path = get_request.member_path;
 
+        if instance_id.is_empty() {
+            return Err(tonic::Status::invalid_argument("Model id is required"));
+        }
+
+        // Note: The member path is optional.
+
         debug!("Received a get request for instance id {instance_id}");
 
         // Retrieve the provider details.
@@ -416,6 +426,16 @@ impl DigitalTwinGraph for DigitalTwinGraphImpl {
         let member_path = invoke_request.member_path;
         let request_payload = invoke_request.request_payload;
 
+        if instance_id.is_empty() {
+            return Err(tonic::Status::invalid_argument("Instance id is required"));
+        }
+
+        if member_path.is_empty() {
+            return Err(tonic::Status::invalid_argument("Member path is required"));
+        }
+
+        // Note: The request payload is optional.
+
         debug!("Received an invoke request for instance id {instance_id}");
 
         // Retrieve the provider details.

core/module/digital_twin_registry/src/digital_twin_registry_impl.rs

@@ -109,15 +109,13 @@ impl DigitalTwinRegistry for DigitalTwinRegistryImpl {
         let request_inner = request.into_inner();
 
         for entity_access_info in &request_inner.entity_access_info_list {
-            self.register_entity(entity_access_info.clone()).map_err(|e| {
-                Status::internal(format!(
-                    "Failed to register the entity with instance id: {}, error: {}",
-                    entity_access_info.instance_id, e
-                ))
-            })?;
+            self.register_entity(&entity_access_info)?;
+
             info!(
-                "Registered the entity with model id: {} and instance id: {}",
-                entity_access_info.model_id, entity_access_info.instance_id
+                "Registered the entity with provider id: {} instance id: {} model id: {}",
+                entity_access_info.provider_id,
+                entity_access_info.instance_id,
+                entity_access_info.model_id
             );
         }
 
@@ -134,33 +132,33 @@ impl DigitalTwinRegistryImpl {
     ///
     /// # Arguments
     /// * `entity` - The entity.
-    fn register_entity(&self, entity_access_info: EntityAccessInfo) -> Result<(), String> {
-        // This block controls the lifetime of the lock.
-        {
-            if entity_access_info.provider_id.is_empty() {
-                return Err("Provider id cannot be empty".to_string());
-            }
+    fn register_entity(&self, entity_access_info: &EntityAccessInfo) -> Result<(), Status> {
+        if entity_access_info.provider_id.is_empty() {
+            return Err(Status::invalid_argument("Provider id is required"));
+        }
 
-            if entity_access_info.model_id.is_empty() {
-                return Err("Model id cannot be empty".to_string());
-            }
+        if entity_access_info.model_id.is_empty() {
+            return Err(Status::invalid_argument("Model id is required"));
+        }
 
-            if entity_access_info.instance_id.is_empty() {
-                return Err("Instance id cannot be empty".to_string());
-            }
+        if entity_access_info.instance_id.is_empty() {
+            return Err(Status::invalid_argument("Instance id is required"));
+        }
 
-            if entity_access_info.protocol.is_empty() {
-                return Err("Protocol cannot be empty".to_string());
-            }
+        if entity_access_info.protocol.is_empty() {
+            return Err(Status::invalid_argument("Protocol is required"));
+        }
 
-            if entity_access_info.uri.is_empty() {
-                return Err("Uri cannot be empty".to_string());
-            }
+        if entity_access_info.uri.is_empty() {
+            return Err(Status::invalid_argument("Uri is required"));
+        }
 
-            if entity_access_info.operations.is_empty() {
-                return Err("Operations cannot be empty".to_string());
-            }
+        if entity_access_info.operations.is_empty() {
+            return Err(Status::invalid_argument("Operations is required"));
+        }
 
+        // This block controls the lifetime of the lock.
+        {
             // Note: the context is optional.
 
             let mut lock: RwLockWriteGuard<HashMap<String, Vec<EntityAccessInfo>>> =