e2ap: adding support for RIC subscription delete

Author: yagoda

include/srsran/e2/e2_event_manager.h

@@ -14,6 +14,7 @@
 #include "srsran/asn1/e2ap/e2ap.h"
 #include "srsran/support/async/event_signal.h"
 #include "srsran/support/async/protocol_transaction_manager.h"
+#include <map>
 
 namespace srsran {
 
@@ -26,11 +27,16 @@ class e2_event_manager
   constexpr static size_t                                          MAX_NOF_TRANSACTIONS = 256;
   protocol_transaction_manager<e2ap_outcome, MAX_NOF_TRANSACTIONS> transactions;
 
-  protocol_transaction_event_source<asn1::e2ap::ricsubscription_delete_request_s> sub_del_request;
-  // CU initiated E2 Setup Procedure
+  std::map<int, std::unique_ptr<protocol_transaction_event_source<asn1::e2ap::ricsubscription_delete_request_s>>>
+      sub_del_reqs;
 
+  void add_sub_del_req(int ric_instance_id, timer_factory timer)
+  {
+    sub_del_reqs[ric_instance_id] =
+        std::make_unique<protocol_transaction_event_source<asn1::e2ap::ricsubscription_delete_request_s>>(timer);
+  }
   explicit e2_event_manager(timer_factory timers) :
-    transactions(timers, e2ap_outcome{asn1::e2ap::unsuccessful_outcome_s{}}), sub_del_request(timers)
+    transactions(timers, e2ap_outcome{asn1::e2ap::unsuccessful_outcome_s{}})
   {
   }
 };

include/srsran/e2/e2_messages.h

@@ -45,6 +45,18 @@ struct e2_subscribe_reponse_message {
   bool                                       success;
 };
 
+struct e2_subscribe_delete_request_message {
+  asn1::e2ap::ri_crequest_id_s                 request_id;
+  asn1::e2ap::ricsubscription_delete_request_s subscription;
+};
+
+struct e2_subscribe_delete_response_message {
+  asn1::e2ap::ri_crequest_id_s              request_id;
+  asn1::e2ap::ricsubscription_delete_resp_s response;
+  asn1::e2ap::ricsubscription_delete_fail_s failure;
+  bool                                      success;
+};
+
 struct e2_indication_message {
   asn1::e2ap::ri_crequest_id_s request_id;
   asn1::e2ap::ri_cind_s        indication;

include/srsran/e2/subscription/e2_subscription.h

@@ -44,8 +44,15 @@ class e2_subscription_proc
   virtual ~e2_subscription_proc() = default;
   /// \brief Handle the incoming subscription message.
   virtual e2_subscribe_reponse_message handle_subscription_setup(const asn1::e2ap::ricsubscription_request_s& msg) = 0;
+  /// \brief Handle the incoming subscription delete message.
+  virtual e2_subscribe_delete_response_message
+  handle_subscription_delete(const asn1::e2ap::ricsubscription_delete_request_s& msg) = 0;
   /// \brief start the subscription request
   virtual void start_subscription(int ric_instance_id, e2_event_manager& ev_mng, uint16_t ran_func_id) = 0;
+  /// \brief void stop the subscription request
+  virtual void stop_subscription(int                                                 ric_instance_id,
+                                 e2_event_manager&                                   ev_mng,
+                                 const asn1::e2ap::ricsubscription_delete_request_s& msg) = 0;
 };
 
 class e2_subscriber_mgmt

lib/e2/CMakeLists.txt

@@ -9,6 +9,7 @@
 set(SOURCES
     procedures/e2_setup_procedure.cpp
     procedures/e2_subscription_setup_procedure.cpp
+    procedures/e2_subscription_delete_procedure.cpp
     procedures/e2_indication_procedure.cpp
     common/e2ap_asn1_packer.cpp
     common/e2_factory.cpp

lib/e2/common/e2_impl.cpp

@@ -29,6 +29,7 @@ e2_impl::e2_impl(e2ap_configuration&      cfg_,
   pdu_notifier(e2_pdu_notifier_),
   subscription_mngr(subscription_mngr_),
   subscribe_proc(e2_pdu_notifier_, subscription_mngr_, timers, logger),
+  subscribe_delete_proc(e2_pdu_notifier_, subscription_mngr_, timers, logger),
   events(std::make_unique<e2_event_manager>(timers))
 {
 }
@@ -120,6 +121,12 @@ void e2_impl::handle_ric_subscription_request(const asn1::e2ap::ricsubscription_
   subscribe_proc.run_subscription_procedure(msg, *events);
 }
 
+void e2_impl::handle_ric_subscription_delete_request(const asn1::e2ap::ricsubscription_delete_request_s& msg)
+{
+  logger.info("Received RIC Subscription Delete Request");
+  subscribe_delete_proc.run_subscription_delete_procedure(msg, *events);
+}
+
 void e2_impl::handle_message(const e2_message& msg)
 {
   logger.info("Handling E2 PDU of type {}", msg.pdu.type().to_string());
@@ -158,9 +165,7 @@ void e2_impl::handle_initiating_message(const asn1::e2ap::init_msg_s& msg)
       handle_ric_subscription_request(msg.value.ricsubscription_request());
       break;
     case asn1::e2ap::e2_ap_elem_procs_o::init_msg_c::types_opts::options::ricsubscription_delete_request:
-      logger.info("Received RIC Subscription Delete Request");
-      events->sub_del_request.set(msg.value.ricsubscription_delete_request());
-      // TODO - add subscription delete procedure
+      handle_ric_subscription_delete_request(msg.value.ricsubscription_delete_request());
       break;
     default:
       logger.error("Invalid E2AP initiating message type");

lib/e2/common/e2_impl.h

@@ -11,6 +11,7 @@
 #pragma once
 
 #include "procedures/e2_setup_procedure.h"
+#include "procedures/e2_subscription_delete_procedure.h"
 #include "procedures/e2_subscription_setup_procedure.h"
 #include "srsran/asn1/e2ap/e2ap.h"
 #include "srsran/e2/e2.h"
@@ -65,6 +66,10 @@ class e2_impl final : public e2_interface
   /// \param[in] msg The received ric subscription request message.
   void handle_ric_subscription_request(const asn1::e2ap::ricsubscription_request_s& msg);
 
+  /// \brief Notify about the reception of an ric subscription delete request message.
+  /// \param[in] msg The received ric subscription delete request message.
+  void handle_ric_subscription_delete_request(const asn1::e2ap::ricsubscription_delete_request_s& msg);
+
   /// \brief handle e2 setup response message from the ric interface.
   /// @param[in] msg  The received e2 setup response message.
   void handle_e2_setup_response(const e2_setup_response_message& msg);
@@ -86,6 +91,7 @@ class e2_impl final : public e2_interface
   std::map<std::string, std::unique_ptr<e2sm_handler>> e2sm_handlers;
   e2_subscriber_mgmt&                                  subscription_mngr;
   e2_subscription_setup_procedure                      subscribe_proc;
+  e2_subscription_delete_procedure                     subscribe_delete_proc;
   std::unique_ptr<e2_event_manager>                    events;
 
   unsigned current_transaction_id = 0; // store current E2AP transaction id

lib/e2/common/e2_subscription_manager_impl.cpp

@@ -29,6 +29,7 @@ e2_subscription_manager_impl::handle_subscription_setup(const asn1::e2ap::ricsub
   e2_subscribe_reponse_message outcome;
   subscription.subscription_info.request_id.ric_requestor_id = msg->ri_crequest_id.value.ric_requestor_id;
   subscription.subscription_info.ran_function_id             = msg->ra_nfunction_id->value;
+  subscription.subscription_info.request_id.ric_instance_id  = msg->ri_crequest_id.value.ric_instance_id;
   e2_sm_kpm_event_trigger_definition_s event_trigger_def;
 
   if (supported_ran_functions.count(msg->ra_nfunction_id.value)) {
@@ -61,6 +62,24 @@ e2_subscription_manager_impl::handle_subscription_setup(const asn1::e2ap::ricsub
   return outcome;
 }
 
+e2_subscribe_delete_response_message
+e2_subscription_manager_impl::handle_subscription_delete(const asn1::e2ap::ricsubscription_delete_request_s& msg)
+{
+  e2_subscribe_delete_response_message outcome;
+  outcome.request_id.ric_requestor_id     = msg->ri_crequest_id.value.ric_requestor_id;
+  outcome.request_id.ric_instance_id      = msg->ri_crequest_id.value.ric_instance_id;
+  outcome.response->ra_nfunction_id.value = msg->ra_nfunction_id.value;
+  outcome.response->ri_crequest_id.value  = msg->ri_crequest_id.value;
+  outcome.success                         = false;
+  if (subscriptions.count(outcome.request_id.ric_instance_id)) {
+    outcome.success = true;
+  } else {
+    outcome.failure->cause->set_misc();
+    logger.error("RIC instance ID not found");
+  }
+  return outcome;
+}
+
 void e2_subscription_manager_impl::start_subscription(int               ric_instance_id,
                                                       e2_event_manager& ev_mng,
                                                       uint16_t          ran_func_id)
@@ -73,6 +92,18 @@ void e2_subscription_manager_impl::start_subscription(int               ric_inst
                                             logger);
 }
 
+void e2_subscription_manager_impl::stop_subscription(int               ric_instance_id,
+                                                     e2_event_manager& ev_mng,
+                                                     const asn1::e2ap::ricsubscription_delete_request_s& msg)
+{
+  if (subscriptions.count(ric_instance_id)) {
+    ev_mng.sub_del_reqs[ric_instance_id]->set(msg);
+    subscriptions[ric_instance_id].indication_task.await_ready();
+    subscriptions.erase(ric_instance_id);
+  } else {
+    logger.error("RIC instance ID not found");
+  }
+}
 bool e2_subscription_manager_impl::action_supported(const ri_caction_to_be_setup_item_s& action,
                                                     uint16_t                             ran_func_id,
                                                     uint32_t                             ric_instance_id)

lib/e2/common/e2_subscription_manager_impl.h

@@ -29,11 +29,23 @@ class e2_subscription_manager_impl : public e2_subscription_manager
   /// \return The subscription response message.
   e2_subscribe_reponse_message handle_subscription_setup(const asn1::e2ap::ricsubscription_request_s& msg) override;
 
+  /// \brief  Handles the subscription delete request message.
+  /// \param[in] msg The subscription delete request message.
+  /// \return The subscription delete response message.
+  e2_subscribe_delete_response_message
+  handle_subscription_delete(const asn1::e2ap::ricsubscription_delete_request_s& msg) override;
+
   /// \brief  Starts the subscription procedure associated with the given ric instance id.
   /// \param[in] ric_instance_id  The ric instance id.
   /// \param[in] ev_mng The event manager that will be used to end the subscription procedure.
   void start_subscription(int ric_instance_id, e2_event_manager& ev_mng, uint16_t ran_func_id) override;
 
+  /// @brief  Stops the subscription procedure associated with the given ric instance id.
+  /// @param[in] ric_instance_id  The ric instance id.
+  void stop_subscription(int                                                 ric_instance_id,
+                         e2_event_manager&                                   ev_mng,
+                         const asn1::e2ap::ricsubscription_delete_request_s& msg) override;
+
   /// \brief checks whether the given action is supported.
   /// \param[in] action The action to check.
   /// \param[in] ran_func_id The ran function id.

lib/e2/procedures/e2_indication_procedure.cpp

@@ -29,8 +29,13 @@ void e2_indication_procedure::operator()(coro_context<eager_async_task<void>>& c
 {
   CORO_BEGIN(ctx);
   while (running) {
-    // request metrics from DU
-    transaction_sink.subscribe_to(ev_mng.sub_del_request, (std::chrono::milliseconds)1000);
+    if (!ev_mng.sub_del_reqs.count(subscription.request_id.ric_instance_id)) {
+      logger.error("No subscription delete request found for RIC instance ID {}",
+                   subscription.request_id.ric_instance_id);
+      break;
+    }
+    transaction_sink.subscribe_to(*ev_mng.sub_del_reqs[subscription.request_id.ric_instance_id].get(),
+                                  (std::chrono::milliseconds)1000);
     CORO_AWAIT(transaction_sink);
     if (!transaction_sink.timeout_expired()) {
       logger.info("Subscription deleted");

lib/e2/procedures/e2_subscription_delete_procedure.cpp

@@ -0,0 +1,56 @@
+/*
+ *
+ * Copyright 2021-2023 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#include "e2_subscription_delete_procedure.h"
+using namespace srsran;
+using namespace asn1::e2ap;
+
+e2_subscription_delete_procedure::e2_subscription_delete_procedure(e2_message_notifier&  ric_notif_,
+                                                                   e2_subscription_proc& subscription_mngr_,
+                                                                   timer_factory         timers_,
+                                                                   srslog::basic_logger& logger_) :
+  logger(logger_), ric_notif(ric_notif_), subscription_mngr(subscription_mngr_), timers(timers_)
+{
+}
+
+void e2_subscription_delete_procedure::run_subscription_delete_procedure(
+    const asn1::e2ap::ricsubscription_delete_request_s request_,
+    e2_event_manager&                                  event_manager)
+{
+  logger.info("E2AP: Received subscription delete request");
+  e2_subscribe_delete_response_message response;
+  response = subscription_mngr.handle_subscription_delete(request_);
+  if (response.success) {
+    subscription_mngr.stop_subscription(request_->ri_crequest_id.value.ric_instance_id, event_manager, request_);
+    send_e2_subscription_delete_response(response);
+  } else {
+    send_e2_subscription_delete_failure(response);
+  }
+}
+
+void e2_subscription_delete_procedure::send_e2_subscription_delete_response(
+    const e2_subscribe_delete_response_message& response)
+{
+  e2_message msg;
+  logger.info("E2AP: Sending subscription delete response");
+  msg.pdu.set_successful_outcome().load_info_obj(ASN1_E2AP_ID_RICSUBSCRIPTION_DELETE);
+  msg.pdu.successful_outcome().value.ricsubscription_delete_resp() = response.response;
+  ric_notif.on_new_message(msg);
+}
+
+void e2_subscription_delete_procedure::send_e2_subscription_delete_failure(
+    const e2_subscribe_delete_response_message& failure)
+{
+  e2_message msg;
+  msg.pdu.set_unsuccessful_outcome().load_info_obj(ASN1_E2AP_ID_RICSUBSCRIPTION_DELETE);
+  msg.pdu.unsuccessful_outcome().value.ricsubscription_delete_fail() = failure.failure;
+  ric_notif.on_new_message(msg);
+  logger.info("E2AP: Sending subscription delete failure");
+}