e1ap: fix names of e1 gateways

Author: frankist

include/srsran/e1ap/gateways/e1_local_connector_factory.h

@@ -35,6 +35,8 @@ struct e1_local_sctp_connector_config {
   dlt_pcap& pcap;
   /// IO broker to handle the SCTP Rx data and notifications.
   io_broker& broker;
+  /// Port to bind the SCTP socket.
+  int bind_port = 0;
 };
 
 /// Creates an E1 local connector using an SCTP socket as channel.

include/srsran/e1ap/gateways/e1_network_client_factory.h

@@ -18,7 +18,8 @@ namespace srsran {
 class dlt_pcap;
 class io_broker;
 
-struct e1_du_sctp_gateway_config {
+/// Configuration of an SCTP-based E1 Gateway in the CU-UP.
+struct e1_cu_up_sctp_gateway_config {
   /// SCTP configuration.
   sctp_network_connector_config sctp;
   /// IO broker responsible for handling SCTP Rx data and notifications.
@@ -28,6 +29,6 @@ struct e1_du_sctp_gateway_config {
 };
 
 /// \brief Create an E1 gateway connector that the CU-UP can use to connect to the CU-CP.
-std::unique_ptr<srs_cu_up::e1_connection_client> create_e1_gateway_client(const e1_du_sctp_gateway_config& params);
+std::unique_ptr<srs_cu_up::e1_connection_client> create_e1_gateway_client(const e1_cu_up_sctp_gateway_config& params);
 
 } // namespace srsran

include/srsran/e1ap/gateways/e1_network_server_factory.h

@@ -19,8 +19,8 @@ namespace srsran {
 class dlt_pcap;
 class io_broker;
 
-/// Configuration of an SCTP-based E1 Gateway.
-struct e1_cu_sctp_gateway_config {
+/// Configuration of an SCTP-based E1 Gateway in the CU-CP.
+struct e1_cu_cp_sctp_gateway_config {
   /// SCTP configuration.
   sctp_network_gateway_config sctp;
   /// IO broker responsible for handling SCTP Rx data and notifications.
@@ -31,6 +31,6 @@ struct e1_cu_sctp_gateway_config {
 
 /// Creates an E1 Gateway server that listens for incoming SCTP connections, packs/unpacks E1AP PDUs and forwards
 /// them to the GW/CU-CP E1AP handler.
-std::unique_ptr<srs_cu_cp::e1_connection_server> create_e1_gateway_server(const e1_cu_sctp_gateway_config& params);
+std::unique_ptr<srs_cu_cp::e1_connection_server> create_e1_gateway_server(const e1_cu_cp_sctp_gateway_config& params);
 
 } // namespace srsran

lib/cu_cp/cu_up_processor/cu_up_processor_repository.cpp

@@ -88,10 +88,12 @@ async_task<void> cu_up_processor_repository::remove_cu_up(cu_up_index_t cu_up_in
 
     // Stop CU-UP activity, eliminating pending transactions for the CU-UP and respective UEs.
     // TODO
+
+    // Remove CU-UP
     removed_cu_up_db.insert(std::make_pair(cu_up_index, std::move(cu_up_db.at(cu_up_index))));
     cu_up_db.erase(cu_up_index);
 
-    // Remove DU
+    // Remove CU-UP
     logger.info("Removed CU-UP {}", cu_up_index);
 
     CORO_RETURN();

lib/e1ap/gateways/e1_local_connector_factory.cpp

@@ -66,7 +66,7 @@ class e1_local_connector_impl final : public e1_local_connector
   {
     report_fatal_error_if_not(cu_cp_e1_mng != nullptr, "CU-CP has not been attached to E1 gateway.");
 
-    // Decorate DU RX notifier with pcap writing.
+    // Decorate CU-UP RX notifier with pcap writing.
     if (pcap_writer.is_write_enabled()) {
       cu_up_notifier = std::make_unique<e1ap_pdu_pcap_notifier>(
           std::move(cu_up_notifier), pcap_writer, srslog::fetch_basic_logger("CU-UP-E1"));
@@ -89,7 +89,7 @@ class e1_local_connector_impl final : public e1_local_connector
   srs_cu_cp::cu_cp_e1_handler* cu_cp_e1_mng = nullptr;
 };
 
-/// Implementation of a CU-UP and CU-CP E1 SCTP-based gateway for the case that the DU and CU-CP are co-located.
+/// Implementation of a CU-UP and CU-CP E1 SCTP-based gateway for the case that the CU-UP and CU-CP are co-located.
 ///
 /// Note: This class should only be used for testing purposes.
 class e1_sctp_connector_impl final : public e1_local_connector
@@ -103,8 +103,8 @@ class e1_sctp_connector_impl final : public e1_local_connector
     sctp.ppid         = E1AP_PPID;
     sctp.bind_address = "127.0.0.1";
     // Use any bind port available.
-    sctp.bind_port = 0;
-    server         = create_e1_gateway_server(e1_cu_sctp_gateway_config{sctp, broker, pcap_writer});
+    sctp.bind_port = cfg.bind_port;
+    server         = create_e1_gateway_server(e1_cu_cp_sctp_gateway_config{sctp, broker, pcap_writer});
   }
 
   void attach_cu_cp(srs_cu_cp::cu_cp_e1_handler& cu_e1_handler_) override
@@ -119,7 +119,7 @@ class e1_sctp_connector_impl final : public e1_local_connector
     sctp_client.connect_port    = server->get_listen_port().value();
     sctp_client.ppid            = E1AP_PPID;
     // Note: We only need to save the PCAPs in one side of the connection.
-    client = create_e1_gateway_client(e1_du_sctp_gateway_config{sctp_client, broker, *null_pcap_writer});
+    client = create_e1_gateway_client(e1_cu_up_sctp_gateway_config{sctp_client, broker, *null_pcap_writer});
   }
 
   std::optional<uint16_t> get_listen_port() const override { return server->get_listen_port(); }

lib/e1ap/gateways/e1_network_client_factory.cpp

@@ -24,10 +24,10 @@ namespace {
 class sctp_to_e1_pdu_notifier final : public sctp_association_sdu_notifier
 {
 public:
-  sctp_to_e1_pdu_notifier(std::unique_ptr<e1ap_message_notifier> du_rx_pdu_notifier_,
+  sctp_to_e1_pdu_notifier(std::unique_ptr<e1ap_message_notifier> cu_up_rx_pdu_notifier_,
                           dlt_pcap&                              pcap_writer_,
                           srslog::basic_logger&                  logger_) :
-    du_rx_pdu_notifier(std::move(du_rx_pdu_notifier_)), pcap_writer(pcap_writer_), logger(logger_)
+    cu_up_rx_pdu_notifier(std::move(cu_up_rx_pdu_notifier_)), pcap_writer(pcap_writer_), logger(logger_)
   {
   }
 
@@ -47,13 +47,13 @@ class sctp_to_e1_pdu_notifier final : public sctp_association_sdu_notifier
     }
 
     // Forward unpacked Rx PDU to the CU-UP.
-    du_rx_pdu_notifier->on_new_message(msg);
+    cu_up_rx_pdu_notifier->on_new_message(msg);
 
     return true;
   }
 
 private:
-  std::unique_ptr<e1ap_message_notifier> du_rx_pdu_notifier;
+  std::unique_ptr<e1ap_message_notifier> cu_up_rx_pdu_notifier;
   dlt_pcap&                              pcap_writer;
   srslog::basic_logger&                  logger;
 };
@@ -98,7 +98,7 @@ class e1_to_sctp_pdu_notifier final : public e1ap_message_notifier
 class e1_sctp_gateway_client final : public srs_cu_up::e1_connection_client
 {
 public:
-  e1_sctp_gateway_client(const e1_du_sctp_gateway_config& params) :
+  e1_sctp_gateway_client(const e1_cu_up_sctp_gateway_config& params) :
     pcap_writer(params.pcap), broker(params.broker), sctp_params(params.sctp)
   {
     // Create SCTP network adapter.
@@ -152,7 +152,7 @@ class e1_sctp_gateway_client final : public srs_cu_up::e1_connection_client
 } // namespace
 
 std::unique_ptr<srs_cu_up::e1_connection_client>
-srsran::create_e1_gateway_client(const e1_du_sctp_gateway_config& params)
+srsran::create_e1_gateway_client(const e1_cu_up_sctp_gateway_config& params)
 {
   return std::make_unique<e1_sctp_gateway_client>(params);
 }

lib/e1ap/gateways/e1_network_server_factory.cpp

@@ -98,7 +98,7 @@ class gw_to_e1_pdu_notifier final : public sctp_association_sdu_notifier
 class e1_sctp_server final : public srs_cu_cp::e1_connection_server, public sctp_network_association_factory
 {
 public:
-  e1_sctp_server(const e1_cu_sctp_gateway_config& params_) : params(params_)
+  e1_sctp_server(const e1_cu_cp_sctp_gateway_config& params_) : params(params_)
   {
     // Create SCTP server.
     sctp_server = create_sctp_network_server(sctp_network_server_config{params.sctp, params.broker, *this});
@@ -138,16 +138,17 @@ class e1_sctp_server final : public srs_cu_cp::e1_connection_server, public sctp
   }
 
 private:
-  const e1_cu_sctp_gateway_config params;
-  srslog::basic_logger&           logger        = srslog::fetch_basic_logger("CU-CP-E1");
-  srs_cu_cp::cu_cp_e1_handler*    cu_e1_handler = nullptr;
+  const e1_cu_cp_sctp_gateway_config params;
+  srslog::basic_logger&              logger        = srslog::fetch_basic_logger("CU-CP-E1");
+  srs_cu_cp::cu_cp_e1_handler*       cu_e1_handler = nullptr;
 
   std::unique_ptr<sctp_network_server> sctp_server;
 };
 
 } // namespace
 
-std::unique_ptr<srs_cu_cp::e1_connection_server> srsran::create_e1_gateway_server(const e1_cu_sctp_gateway_config& cfg)
+std::unique_ptr<srs_cu_cp::e1_connection_server>
+srsran::create_e1_gateway_server(const e1_cu_cp_sctp_gateway_config& cfg)
 {
   return std::make_unique<e1_sctp_server>(cfg);
 }

tests/unittests/e1ap/gateways/e1_gateway_test.cpp

@@ -83,7 +83,7 @@ class e1_link : public srs_cu_cp::cu_cp_e1_handler
     // Note: May be called from io broker thread.
     cu_cp_tx_pdu_notifier = std::move(e1ap_tx_pdu_notifier);
     std::promise<void> eof_signal;
-    cu_gw_assoc_close_signaled = eof_signal.get_future();
+    cu_cp_gw_assoc_close_signaled = eof_signal.get_future();
 
     logger.info("CU-CP handled new DU connection");
     connection_complete_signal.set_value();
@@ -97,21 +97,21 @@ class e1_link : public srs_cu_cp::cu_cp_e1_handler
   srslog::basic_logger&               logger = srslog::fetch_basic_logger("TEST");
 
   blocking_queue<e1ap_message> cu_rx_pdus{128};
-  blocking_queue<e1ap_message> du_rx_pdus{128};
+  blocking_queue<e1ap_message> cu_up_rx_pdus{128};
 
-  std::future<void>                      cu_gw_assoc_close_signaled;
-  std::future<void>                      du_gw_assoc_close_signaled;
+  std::future<void>                      cu_cp_gw_assoc_close_signaled;
+  std::future<void>                      cu_up_gw_assoc_close_signaled;
   std::unique_ptr<e1ap_message_notifier> cu_cp_tx_pdu_notifier;
-  std::unique_ptr<e1ap_message_notifier> du_tx_pdu_notifier;
+  std::unique_ptr<e1ap_message_notifier> cu_up_tx_pdu_notifier;
 
 protected:
   void connect_client()
   {
     // Connect client to server.
     std::promise<void> eof_signal;
-    du_gw_assoc_close_signaled = eof_signal.get_future();
-    du_tx_pdu_notifier         = connector->handle_cu_up_connection_request(
-        std::make_unique<rx_pdu_notifier>("CU-UP", du_rx_pdus, std::move(eof_signal)));
+    cu_up_gw_assoc_close_signaled = eof_signal.get_future();
+    cu_up_tx_pdu_notifier         = connector->handle_cu_up_connection_request(
+        std::make_unique<rx_pdu_notifier>("CU-UP", cu_up_rx_pdus, std::move(eof_signal)));
 
     // Wait for server to receive connection.
     std::future<void> connection_completed = connection_complete_signal.get_future();
@@ -143,7 +143,7 @@ class e1_gateway_link_test : public ::testing::TestWithParam<bool>
 
   void send_to_cu_up(const e1ap_message& msg) { link->cu_cp_tx_pdu_notifier->on_new_message(msg); }
 
-  void send_to_cu_cp(const e1ap_message& msg) { link->du_tx_pdu_notifier->on_new_message(msg); }
+  void send_to_cu_cp(const e1ap_message& msg) { link->cu_up_tx_pdu_notifier->on_new_message(msg); }
 
   bool pop_cu_rx_pdu(e1ap_message& msg)
   {
@@ -152,10 +152,10 @@ class e1_gateway_link_test : public ::testing::TestWithParam<bool>
     return res;
   }
 
-  bool pop_du_rx_pdu(e1ap_message& msg)
+  bool pop_cu_up_rx_pdu(e1ap_message& msg)
   {
     bool res;
-    msg = link->du_rx_pdus.pop_blocking(&res);
+    msg = link->cu_up_rx_pdus.pop_blocking(&res);
     return res;
   }
 
@@ -190,7 +190,7 @@ static bool is_equal(const e1ap_message& lhs, const e1ap_message& rhs)
   return lhs_pdu == rhs_pdu;
 }
 
-TEST_P(e1_gateway_link_test, when_du_sends_msg_then_cu_receives_msg)
+TEST_P(e1_gateway_link_test, when_cu_up_sends_msg_then_cu_receives_msg)
 {
   create_link();
 
@@ -202,15 +202,15 @@ TEST_P(e1_gateway_link_test, when_du_sends_msg_then_cu_receives_msg)
   ASSERT_TRUE(is_equal(orig_msg, dest_msg));
 }
 
-TEST_P(e1_gateway_link_test, when_cu_sends_msg_then_du_receives_msg)
+TEST_P(e1_gateway_link_test, when_cu_cp_sends_msg_then_cu_up_receives_msg)
 {
   create_link();
 
   e1ap_message orig_msg = create_test_message();
   send_to_cu_up(orig_msg);
 
   e1ap_message dest_msg;
-  ASSERT_TRUE(pop_du_rx_pdu(dest_msg));
+  ASSERT_TRUE(pop_cu_up_rx_pdu(dest_msg));
   ASSERT_TRUE(is_equal(orig_msg, dest_msg));
 }
 
@@ -221,7 +221,7 @@ TEST_P(e1_gateway_link_test, when_pcap_writer_disabled_then_no_pcap_is_written)
   e1ap_message orig_msg = create_test_message();
   send_to_cu_up(orig_msg);
   e1ap_message dest_msg;
-  ASSERT_TRUE(pop_du_rx_pdu(dest_msg));
+  ASSERT_TRUE(pop_cu_up_rx_pdu(dest_msg));
   byte_buffer sdu;
   ASSERT_FALSE(link->pcap.last_sdus.try_pop(sdu));
 
@@ -238,7 +238,7 @@ TEST_P(e1_gateway_link_test, when_pcap_writer_enabled_then_pcap_is_written)
 
   send_to_cu_up(orig_msg);
   e1ap_message dest_msg;
-  ASSERT_TRUE(pop_du_rx_pdu(dest_msg));
+  ASSERT_TRUE(pop_cu_up_rx_pdu(dest_msg));
   bool        popped = false;
   byte_buffer sdu    = link->pcap.last_sdus.pop_blocking(&popped);
   ASSERT_TRUE(popped);
@@ -260,8 +260,8 @@ TEST_P(e1_gateway_link_test, when_cu_tx_pdu_notifier_is_closed_then_connection_c
   logger.info("Closing CU-CP Tx path...");
   link->cu_cp_tx_pdu_notifier.reset();
 
-  // Wait for GW to report to DU that the association is closed.
-  link->du_gw_assoc_close_signaled.wait();
+  // Wait for GW to report to CU-UP that the association is closed.
+  link->cu_up_gw_assoc_close_signaled.wait();
 }
 
 TEST_P(e1_gateway_link_test, when_cu_up_tx_pdu_notifier_is_closed_then_connection_closes)
@@ -270,10 +270,10 @@ TEST_P(e1_gateway_link_test, when_cu_up_tx_pdu_notifier_is_closed_then_connectio
 
   // The CU-UP resets its E1 Tx notifier.
   logger.info("Closing CU-UP Tx path...");
-  link->du_tx_pdu_notifier.reset();
+  link->cu_up_tx_pdu_notifier.reset();
 
   // Wait for GW to report to CU that the association is closed.
-  link->cu_gw_assoc_close_signaled.wait();
+  link->cu_cp_gw_assoc_close_signaled.wait();
 }
 
 INSTANTIATE_TEST_SUITE_P(e1_gateway_link_tests, e1_gateway_link_test, ::testing::Values(true, false));