OFT branch merged with main

Author: vidishac2004

src/lib.rs

@@ -7,6 +7,12 @@ use up_rust::{UListener, UMessage, UStatus, UTransport, UUri, UCode};
 /// such as the service connection and active listeners.
 pub struct Iceoryx2Transport {}
 
+enum MessageType {
+    RpcRequest,
+    RpcResponseOrNotification,
+    Publish,
+}
+
 // The #[async_trait] attribute enables async functions in our trait impl.
 #[async_trait]
 impl UTransport for Iceoryx2Transport {
@@ -49,48 +55,73 @@ impl Iceoryx2Transport {
         format!("{:X}", value)
     }
 
-    fn compute_service_name(source: &UUri,sink: Option<&UUri>) -> Result<String, UStatus> {
-        let join_segments = |segments: Vec<String>| segments.join("/");
-        
-        // [impl->dsn~up-transport-iceoryx2-service-name~1]
-        // Handle RPC Request: source.resource_id == 0, valid sink (1<=sink.resource_id<=0x7FFF)
-        if (source.resource_id==0 )&& !(sink.is_none()){
-            if !((1<=sink.unwrap().resource_id && sink.unwrap().resource_id<=0x7FFF)){
-                UStatus::fail_with_code(UCode::INVALID_ARGUMENT, "Invalid sink URI for RPC request");
+    /// Assumption: valid source and sink URIs provided:
+    /// send() makes use of UAttributesValidator
+    /// register_listener() and unregister_listener() use verify_filter_criteria()
+    /// Criteria for identification of message types can be found here: https://github.com/eclipse-uprotocol/up-spec/blob/main/basics/uattributes.adoc
+    fn determine_message_type(source: &UUri, sink: Option<&UUri>) -> Result<MessageType, UStatus> {
+        let src_id = source.resource_id;
+        let sink_id = sink.map(|s| s.resource_id);
+
+        if src_id == 0 {
+            if let Some(id) = sink_id {
+                if id >= 1 && id <= 0x7FFF {
+                    return Ok(MessageType::RpcRequest);
+                }
             }
-            let segments = Self::encode_uuri_segments(sink.unwrap());
-            Ok(format!("up/{}", join_segments(segments)))
+        } else if sink_id == Some(0) && src_id >= 1 && src_id <= 0xFFFE {
+            return Ok(MessageType::RpcResponseOrNotification);
+        } else if src_id >= 1 && src_id <= 0x7FFF {
+            return Ok(MessageType::Publish);
         }
+
+        Err(UStatus::fail_with_code(
+            UCode::INVALID_ARGUMENT,
+            "Unsupported UMessageType",
+        ))
+    }
+    fn compute_service_name(source: &UUri, sink: Option<&UUri>) -> Result<String, UStatus> {
+        let join_segments = |segments: Vec<String>| segments.join("/");
         // [impl->dsn~up-transport-iceoryx2-service-name~1]
-        // Handle Notification or RPC Response: sink.resource_id == 0, valid source(1<=source.resource_id<=0xFFFE)
-        else if (!(sink.is_none()))&&(sink.unwrap().resource_id==0){
-            if 1<=source.resource_id && source.resource_id <=0xFFFE{
+        match Self::determine_message_type(source, sink)? {
+            // [impl->dsn~up-transport-iceoryx2-service-name~1]
+            MessageType::RpcRequest => {
+                let Some(sink_uri) = sink else {
+                    return Err(UStatus::fail_with_code(
+                        UCode::INVALID_ARGUMENT,
+                        "sink required for RpcRequest",
+                    ));
+                };
+                let segments = Self::encode_uuri_segments(sink_uri);
+                Ok(format!("up/{}", join_segments(segments)))
+            }
+            // [impl->dsn~up-transport-iceoryx2-service-name~1]
+            MessageType::RpcResponseOrNotification => {
+                let Some(sink_uri) = sink else {
+                    return Err(UStatus::fail_with_code(
+                        UCode::INVALID_ARGUMENT,
+                        "sink required for ResponseOrNotification",
+                    ));
+                };
                 let source_segments = Self::encode_uuri_segments(source);
-                let sink_segments = Self::encode_uuri_segments(sink.unwrap());
+                let sink_segments = Self::encode_uuri_segments(sink_uri);
                 Ok(format!(
-                "up/{}/{}",
-                join_segments(source_segments),
-                join_segments(sink_segments)
+                    "up/{}/{}",
+                    join_segments(source_segments),
+                    join_segments(sink_segments)
                 ))
             }
-            else{
-            Err(UStatus::fail_with_code(UCode::INVALID_ARGUMENT, "Invalid sink and source URIs"))}
-        }
-        // [impl->dsn~up-transport-iceoryx2-service-name~1]
-        // Handle Publish: 1 <= source.resource_id <= 0x7FFF
-        else if 1<=source.resource_id && source.resource_id<=0x7FFF {
-            let segments = Self::encode_uuri_segments(source);
-            Ok(format!("up/{}", join_segments(segments)))
-        } else {
-            Err(UStatus::fail_with_code(
-                UCode::INVALID_ARGUMENT,
-                "Unsupported UMessageType",
-            ))
+            // [impl->dsn~up-transport-iceoryx2-service-name~1]
+            MessageType::Publish => {
+                let segments = Self::encode_uuri_segments(source);
+                Ok(format!("up/{}", join_segments(segments)))
+            }
         }
-
     }
 }
 
+    
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -148,4 +179,23 @@ mod tests {
         assert!(result.is_err());
         assert_eq!(result.unwrap_err().get_code(), UCode::INVALID_ARGUMENT);
     }
+
+    #[test]
+    // [utest->dsn~up-transport-iceoryx2-service-name~1]
+    fn test_fail_resource_id_error() {
+        let source = test_uri("device1", 0x0000, 0x00CD, 0x04, 0x000);
+        let sink = test_uri("device1", 0x0004, 0x3AB, 0x3, 0x0000);
+        let result = Iceoryx2Transport::compute_service_name(&source, Some(&sink));
+        assert!(result.is_err_and(|err| err.get_code() == UCode::INVALID_ARGUMENT));
+    }
+
+    #[test]
+    // [utest->dsn~up-transport-iceoryx2-service-name~1]
+    fn test_fail_missing_source_error() {
+        let uuri = UUri::new();
+        let sink = test_uri("device1", 0x0004, 0x3AB, 0x3, 0x000);
+        let result = Iceoryx2Transport::compute_service_name(&uuri, Some(&sink));
+        assert!(result.is_err_and(|err| err.get_code() == UCode::INVALID_ARGUMENT));
+    }
 }
+