f1u: rename some functions from handler to notifier

Author: alvasMan

include/srsran/f1u/local_connector/f1u_local_connector.h

@@ -47,17 +47,17 @@ class f1u_gateway_cu_bearer : public f1u_cu_up_gateway_bearer
 
   void stop() override { disconnector.disconnect_cu_bearer(ul_tnl_info); }
 
-  void attach_du_handler(srs_du::f1u_du_gateway_bearer_rx_notifier& handler_,
-                         const up_transport_layer_info&             dl_tnl_info_)
+  void attach_du_notifier(srs_du::f1u_du_gateway_bearer_rx_notifier& notifier_,
+                          const up_transport_layer_info&             dl_tnl_info_)
   {
-    handler = &handler_;
+    notifier = &notifier_;
     dl_tnl_info.emplace(dl_tnl_info_);
   }
 
-  void detach_du_handler(const up_transport_layer_info& dl_tnl_info_)
+  void detach_du_notifier(const up_transport_layer_info& dl_tnl_info_)
   {
     if (dl_tnl_info == dl_tnl_info_) {
-      handler = nullptr;
+      notifier = nullptr;
       dl_tnl_info.reset();
     } else {
       logger.log_info("Cannot dettach DU bearer, DL-FTEID does not match. F-TEID={}, requested F-TEID={}",
@@ -66,20 +66,19 @@ class f1u_gateway_cu_bearer : public f1u_cu_up_gateway_bearer
     }
   }
 
-  /// This should be handle_sdu...
   void on_new_pdu(nru_dl_message msg) override
   {
-    if (handler == nullptr) {
+    if (notifier == nullptr) {
       logger.log_info("Cannot handle F1-U GW DL message. F1-U DU GW bearer does not exist.");
       return;
     }
     logger.log_debug("Passing PDU to DU bearer. {}", dl_tnl_info);
-    handler->on_new_pdu(std::move(msg));
+    notifier->on_new_pdu(std::move(msg));
   }
 
 private:
   srs_cu_up::f1u_bearer_logger               logger;
-  srs_du::f1u_du_gateway_bearer_rx_notifier* handler = nullptr;
+  srs_du::f1u_du_gateway_bearer_rx_notifier* notifier = nullptr;
   srs_cu_up::f1u_bearer_disconnector&        disconnector;
   up_transport_layer_info                    ul_tnl_info;
 
@@ -115,26 +114,26 @@ class f1u_gateway_du_bearer : public srs_du::f1u_du_gateway_bearer
 
   void stop() override { disconnector.remove_du_bearer(dl_tnl_info); }
 
-  void attach_cu_handler(f1u_cu_up_gateway_bearer_rx_notifier& handler_)
+  void attach_cu_notifier(f1u_cu_up_gateway_bearer_rx_notifier& handler_)
   {
-    std::unique_lock<std::mutex> lock(handler_mutex);
-    handler = &handler_;
+    std::unique_lock<std::mutex> lock(notifier_mutex);
+    notifier = &handler_;
   }
 
-  void detach_cu_handler()
+  void detach_cu_notifier()
   {
-    std::unique_lock<std::mutex> lock(handler_mutex);
-    handler = nullptr;
+    std::unique_lock<std::mutex> lock(notifier_mutex);
+    notifier = nullptr;
   }
 
   void on_new_pdu(nru_ul_message msg) override
   {
-    std::unique_lock<std::mutex> lock(handler_mutex);
-    if (handler == nullptr) {
+    std::unique_lock<std::mutex> lock(notifier_mutex);
+    if (notifier == nullptr) {
       logger.log_info("Cannot handle NR-U UL message. CU-UP bearer does not exist.");
       return;
     }
-    handler->on_new_pdu(std::move(msg));
+    notifier->on_new_pdu(std::move(msg));
   };
 
   srs_du::f1u_du_gateway_bearer_rx_notifier* f1u_rx = nullptr;
@@ -143,8 +142,8 @@ class f1u_gateway_du_bearer : public srs_du::f1u_du_gateway_bearer
 
   srs_du::f1u_bearer_logger logger;
 
-  f1u_cu_up_gateway_bearer_rx_notifier* handler = nullptr;
-  std::mutex                            handler_mutex;
+  f1u_cu_up_gateway_bearer_rx_notifier* notifier = nullptr;
+  std::mutex                            notifier_mutex;
   srs_du::f1u_bearer_disconnector&      disconnector;
 };
 

lib/f1u/local_connector/f1u_local_connector.cpp

@@ -57,7 +57,7 @@ void f1u_local_connector::attach_dl_teid(const up_transport_layer_info& ul_up_tn
   f1u_gateway_du_bearer* du_tun = du_map.at(dl_up_tnl_info);
   f1u_gateway_cu_bearer* cu_tun = cu_map.at(ul_up_tnl_info);
   cu_tun->dl_tnl_info           = dl_up_tnl_info;
-  cu_tun->attach_du_handler(*du_tun->f1u_rx, dl_up_tnl_info);
+  cu_tun->attach_du_notifier(*du_tun->f1u_rx, dl_up_tnl_info);
 }
 
 void f1u_local_connector::disconnect_cu_bearer(const up_transport_layer_info& ul_up_tnl_info)
@@ -76,18 +76,17 @@ void f1u_local_connector::disconnect_cu_bearer(const up_transport_layer_info& ul
   if (cu_tun->dl_tnl_info.has_value()) {
     auto du_bearer_it = du_map.find(cu_tun->dl_tnl_info.value());
     if (du_bearer_it != du_map.end()) {
-      logger_cu.debug("Disconnecting DU F1-U bearer with DL GTP Tunnel={} from CU handler. UL GTP Tunnel={}",
-                      cu_tun->dl_tnl_info,
-                      ul_up_tnl_info);
-      du_bearer_it->second->detach_cu_handler();
+      logger_cu.debug(
+          "Disconnecting DU F1-U bearer with DL GTP Tunnel={}. UL GTP Tunnel={}", cu_tun->dl_tnl_info, ul_up_tnl_info);
+      du_bearer_it->second->detach_cu_notifier();
     } else {
       // Bearer could already been removed from DU.
-      logger_cu.info("Could not find DL GTP Tunnel={} at DU to disconnect DU F1-U bearer from CU handler. UL GTP "
+      logger_cu.info("Could not find DL GTP Tunnel={} at DU to disconnect DU F1-U bearer. UL GTP "
                      "Tunnel={}",
                      cu_tun->dl_tnl_info,
                      ul_up_tnl_info);
     }
-    cu_tun->detach_du_handler(cu_tun->dl_tnl_info.value());
+    cu_tun->detach_du_notifier(cu_tun->dl_tnl_info.value());
   } else {
     logger_cu.warning(
         "Could not find DU F1-U bearer from which to disconect CU bearer, no DL-TEID info present at CU bearer. "
@@ -123,7 +122,7 @@ f1u_local_connector::create_du_bearer(uint32_t
   std::unique_ptr<f1u_gateway_du_bearer> du_bearer =
       std::make_unique<f1u_gateway_du_bearer>(ue_index, drb_id, dl_up_tnl_info, &du_rx, ul_up_tnl_info, *this);
 
-  du_bearer->attach_cu_handler(cu_tun->cu_rx);
+  du_bearer->attach_cu_notifier(cu_tun->cu_rx);
 
   du_map.insert({dl_up_tnl_info, du_bearer.get()});
   return du_bearer;
@@ -142,10 +141,10 @@ void f1u_local_connector::remove_du_bearer(const up_transport_layer_info& dl_up_
 
   auto cu_bearer_it = cu_map.find(du_bearer_it->second->ul_up_tnl_info);
   if (cu_bearer_it != cu_map.end()) {
-    logger_du.debug("Detaching CU handler do to removal at DU. UL GTP Tunnel={}", du_bearer_it->second->ul_up_tnl_info);
-    cu_bearer_it->second->detach_du_handler(dl_up_tnl_info);
+    logger_du.debug("Detaching DU notifier to CU. UL GTP Tunnel={}", du_bearer_it->second->ul_up_tnl_info);
+    cu_bearer_it->second->detach_du_notifier(dl_up_tnl_info);
   }
 
-  du_bearer_it->second->detach_cu_handler();
+  du_bearer_it->second->detach_cu_notifier();
   du_map.erase(du_bearer_it);
 }