[eclipse-iceoryx#139] Failing to send notification due to listener problems does not cause failure on notifier side

Author: elfenpiff

iceoryx2/src/port/notifier.rs

@@ -41,7 +41,7 @@ use crate::{
     service::{self, naming_scheme::event_concept_name},
 };
 use iceoryx2_bb_lock_free::mpmc::container::{ContainerHandle, ContainerState};
-use iceoryx2_bb_log::{fail, warn};
+use iceoryx2_bb_log::{debug, fail, warn};
 use iceoryx2_cal::{dynamic_storage::DynamicStorage, event::NotifierBuilder};
 use iceoryx2_cal::{event::Event, named_concept::NamedConceptBuilder};
 use std::{cell::UnsafeCell, rc::Rc, sync::atomic::Ordering};
@@ -102,19 +102,36 @@ impl<Service: service::Service> ListenerConnections<Service> {
         new_self
     }
 
-    fn create(&self, index: usize, listener_id: UniqueListenerId) -> Result<(), ()> {
+    fn create(&self, index: usize, listener_id: UniqueListenerId) {
+        let msg = "Unable to establish connection to listener";
         let event_name = event_concept_name(&listener_id);
         if self.get(index).is_none() {
-            let notifier = fail!(from self, when <Service::Event as iceoryx2_cal::event::Event>::NotifierBuilder::new(&event_name).open(),
-                                    with (),
-                                    "Unable to establish a connection to Listener port {:?}.", listener_id);
-            *self.get_mut(index) = Some(Connection {
-                notifier,
-                listener_id,
-            });
+            match <Service::Event as iceoryx2_cal::event::Event>::NotifierBuilder::new(&event_name)
+                .open()
+            {
+                Ok(notifier) => {
+                    *self.get_mut(index) = Some(Connection {
+                        notifier,
+                        listener_id,
+                    });
+                }
+                Err(
+                    iceoryx2_cal::event::NotifierCreateError::DoesNotExist
+                    | iceoryx2_cal::event::NotifierCreateError::InitializationNotYetFinalized,
+                ) => (),
+                Err(iceoryx2_cal::event::NotifierCreateError::VersionMismatch) => {
+                    warn!(from self,
+                        "{} since a version mismatch was detected! All entities must use the same iceoryx2 version!",
+                        msg);
+                }
+                Err(iceoryx2_cal::event::NotifierCreateError::InsufficientPermissions) => {
+                    warn!(from self, "{} since the permissions do not match. The service or the participants are maybe misconfigured.", msg);
+                }
+                Err(iceoryx2_cal::event::NotifierCreateError::InternalFailure) => {
+                    debug!(from self, "{} due to an internal failure.", msg);
+                }
+            }
         }
-
-        Ok(())
     }
 
     fn get(&self, index: usize) -> &Option<Connection<Service>> {
@@ -180,9 +197,7 @@ impl<Service: service::Service> Notifier<Service> {
             port_id,
         };
 
-        if let Err(e) = new_self.populate_listener_channels() {
-            warn!(from new_self, "The new Notifier port is unable to connect to every Listener port, caused by {:?}.", e);
-        }
+        new_self.populate_listener_channels();
 
         std::sync::atomic::compiler_fence(Ordering::SeqCst);
 
@@ -206,23 +221,19 @@ impl<Service: service::Service> Notifier<Service> {
         Ok(new_self)
     }
 
-    fn update_connections(&self) -> Result<(), NotifierNotifyError> {
+    fn update_connections(&self) {
         if unsafe {
             self.dynamic_storage
                 .get()
                 .event()
                 .listeners
                 .update_state(&mut *self.listener_list_state.get())
         } {
-            fail!(from self, when self.populate_listener_channels(),
-                with NotifierNotifyError::OnlyPartialUpdate,
-                "Connections were updated only partially since at least one connection to a Listener port failed.");
+            self.populate_listener_channels();
         }
-
-        Ok(())
     }
 
-    fn populate_listener_channels(&self) -> Result<(), ()> {
+    fn populate_listener_channels(&self) {
         let mut visited_indices = vec![];
         visited_indices.resize(self.listener_connections.len(), None);
 
@@ -247,21 +258,12 @@ impl<Service: service::Service> Notifier<Service> {
                     };
 
                     if create_connection {
-                        match self.listener_connections.create(i, *listener_id) {
-                            Ok(()) => (),
-                            Err(()) => {
-                                fail!(from self, with (),
-                                    "Unable to establish connection to Listener port {:?}.",
-                                    *listener_id);
-                            }
-                        };
+                        self.listener_connections.create(i, *listener_id);
                     }
                 }
                 None => self.listener_connections.remove(i),
             }
         }
-
-        Ok(())
     }
 
     /// Returns the [`UniqueNotifierId`] of the [`Notifier`]
@@ -288,9 +290,7 @@ impl<Service: service::Service> Notifier<Service> {
         value: EventId,
     ) -> Result<usize, NotifierNotifyError> {
         let msg = "Unable to notify event";
-        fail!(from self, when self.update_connections(),
-            "{} with id {:?} since the underlying connections could not be updated.",
-            msg, value);
+        self.update_connections();
 
         use iceoryx2_cal::event::Notifier;
         let mut number_of_triggered_listeners = 0;
@@ -304,6 +304,9 @@ impl<Service: service::Service> Notifier<Service> {
         for i in 0..self.listener_connections.len() {
             match self.listener_connections.get(i) {
                 Some(ref connection) => match connection.notifier.notify(value) {
+                    Err(iceoryx2_cal::event::NotifierNotifyError::Disconnected) => {
+                        self.listener_connections.remove(i);
+                    }
                     Err(e) => {
                         warn!(from self, "Unable to send notification via connection {:?} due to {:?}.",
                             connection, e)

iceoryx2/tests/service_event_tests.rs

@@ -431,7 +431,6 @@ mod service_event {
     }
 
     #[test]
-    #[ignore]
     fn concurrent_reconnecting_notifier_can_trigger_waiting_listener<Sut: Service>() {
         let _watch_dog = Watchdog::new();