feat(pcf): created SM association is stored in hashmap with uid

Signed-off-by: Stefan Spettel <stefan.spettel@eurecom.fr>

src/api-server/impl/SMPoliciesCollectionApiImpl.cpp

@@ -41,14 +41,19 @@ void SMPoliciesCollectionApiImpl::create_sm_policy(
   ProblemDetails problem_details;
   SmPolicyDecision decision;
   std::string details_string = "";
+  std::string association_id = "";
+  std::string location       = "";
+  std::string content_type   = "application/problem+json";
 
   pcf_smpc_error_code res = smpc_service->create_sm_policy_handler(
-      smPolicyContextData, decision, details_string);
+      smPolicyContextData, decision, association_id, details_string);
   nlohmann::json json_data;
 
   switch (res) {
     case pcf_smpc_error_code::Created:
-      http_code = HTTP_STATUS_CODE_201_CREATED;
+      http_code    = HTTP_STATUS_CODE_201_CREATED;
+      location     = m_address + base + "/sm-policies/" + association_id;
+      content_type = "application/json";
       break;
 
     case pcf_smpc_error_code::UserUnknown:
@@ -68,6 +73,7 @@ void SMPoliciesCollectionApiImpl::create_sm_policy(
       problem_details.setDetail(details_string);
       http_code = HTTP_STATUS_CODE_403_FORBIDDEN;
       break;
+
     default:
       Logger::pcf_app().error("Unknown error code");
       http_code = HTTP_STATUS_CODE_500_INTERNAL_SERVER_ERROR;
@@ -79,7 +85,12 @@ void SMPoliciesCollectionApiImpl::create_sm_policy(
     to_json(json_data, problem_details);
   } else {
     to_json(json_data, decision);
+    response.headers().add<Pistache::Http::Header::Location>(location);
   }
+
+  response.headers().add<Pistache::Http::Header::ContentType>(
+      Pistache::Http::Mime::MediaType(content_type));
+
   response.send(Pistache::Http::Code(http_code), json_data.dump().c_str());
 }
 

src/api-server/pcf-api-server.h

@@ -53,8 +53,9 @@ class PCFApiServer {
  public:
   PCFApiServer(Pistache::Address address, pcf_app* pcf_app_inst)
       : m_httpEndpoint(std::make_shared<Pistache::Http::Endpoint>(address)) {
-    m_router  = std::make_shared<Pistache::Rest::Router>();
-    m_address = address.host() + ":" + (address.port()).toString();
+    m_router = std::make_shared<Pistache::Rest::Router>();
+    // TODO hardcode http string, how to handle https
+    m_address = "http://" + address.host() + ":" + (address.port()).toString();
 
     m_smPoliciesCollectionApi =
         std::make_shared<oai::pcf::api::SMPoliciesCollectionApiImpl>(

src/pcf_app/CMakeLists.txt

@@ -39,7 +39,7 @@ add_library (PCF STATIC
   pcf_event.cpp 
   pcf_sm_policy_control.cpp
   task_manager.cpp
-  #sm_policy/individual_sm_association.cpp
+  sm_policy/individual_sm_association.cpp
   sm_policy/policy_decision.cpp
   sm_policy/slice_policy_decision.cpp
   sm_policy/supi_policy_decision.cpp

src/pcf_app/pcf_sm_policy_control.cpp

@@ -34,11 +34,6 @@
 #include "pcf_config.hpp"
 #include "pcf_client.hpp"
 #include "Snssai.h"
-//#include "individual_sm_association.hpp"
-#include "slice_policy_decision.hpp"
-#include "supi_policy_decision.hpp"
-#include "dnn_policy_decision.hpp"
-#include "policy_decision.hpp"
 
 #include <boost/uuid/random_generator.hpp>
 #include <boost/uuid/uuid_io.hpp>
@@ -147,7 +142,7 @@ bool pcf_smpc::find_policy(
 //------------------------------------------------------------------------------
 pcf_smpc_error_code pcf_smpc::create_sm_policy_handler(
     const SmPolicyContextData& context, SmPolicyDecision& decision,
-    std::string& problem_details) {
+    std::string& association_id, std::string& problem_details) {
   std::shared_lock lock_supi(m_supi_policy_decisions_mutex);
   std::shared_lock lock_dnn(m_dnn_policy_decisions_mutex);
   std::shared_lock lock_slice(m_slice_policy_decisions_mutex);
@@ -172,8 +167,16 @@ pcf_smpc_error_code pcf_smpc::create_sm_policy_handler(
         "SM Policy request from SUPI {}: Invalid policy decision provisioned",
         context.getSupi());
   } else {
-    Logger::pcf_app().info(
-        fmt::format("Created Policy Decision for SUPI {}", context.getSupi()));
+    association_id = std::to_string(m_association_id_generator.get_uid());
+
+    individual_sm_association assoc(context, decision, association_id);
+
+    std::unique_lock lock_assocations(m_associations_mutex);
+    m_associations.insert(std::make_pair(association_id, assoc));
+
+    Logger::pcf_app().info(fmt::format(
+        "Created Policy Decision for SUPI {} with ID {}", context.getSupi(),
+        association_id));
   }
   return res;
 }

src/pcf_app/pcf_sm_policy_control.hpp

@@ -49,13 +49,14 @@
 #include "SmPolicyDeleteData.h"
 #include "SmPolicyUpdateContextData.h"
 #include "sm_policy/pcf_sm_policy_control_errors.hpp"
-//#include "sm_policy/individual_sm_association.hpp"
+#include "sm_policy/individual_sm_association.hpp"
 #include "sm_policy/policy_decision.hpp"
 #include "sm_policy/slice_policy_decision.hpp"
 #include "sm_policy/supi_policy_decision.hpp"
 #include "sm_policy/dnn_policy_decision.hpp"
 
 #include "sm_policy/snssai_hasher.hpp"
+#include "uint_generator.hpp"
 
 namespace oai::pcf::app {
 
@@ -81,7 +82,7 @@ class pcf_smpc {
    */
   sm_policy::pcf_smpc_error_code create_sm_policy_handler(
       const oai::pcf::model::SmPolicyContextData& context,
-      oai::pcf::model::SmPolicyDecision& decision,
+      oai::pcf::model::SmPolicyDecision& decision, std::string& association_id,
       std::string& problem_details);
 
  private:
@@ -100,9 +101,11 @@ class pcf_smpc {
       const oai::pcf::model::SmPolicyContextData& context,
       oai::pcf::app::sm_policy::policy_decision** chosen_decision);
 
-  // std::unordered_map<
-  //    std::string, oai::pcf::app::sm_policy::individual_sm_association>
-  //    m_associations;
+  util::uint_generator<uint32_t> m_association_id_generator;
+
+  std::unordered_map<
+      std::string, oai::pcf::app::sm_policy::individual_sm_association>
+      m_associations;
   std::unordered_map<
       oai::pcf::model::Snssai, oai::pcf::app::sm_policy::slice_policy_decision,
       oai::pcf::app::sm_policy::snssai_hasher>

src/pcf_app/sm_policy/individual_sm_association.cpp

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the
+ * License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file individual_sm_association.cpp
+ \brief
+ \author  Stefan Spettel
+ \company Openairinterface Software Allianse
+ \date 2022
+ \email: stefan.spettel@eurecom.fr
+ */
+
+#include "individual_sm_association.hpp"
+
+using namespace oai::pcf::model;
+using namespace oai::pcf::app::sm_policy;
+
+SmPolicyContextData individual_sm_association::get_sm_policy_context_data()
+    const {
+  return m_context;
+}
+
+SmPolicyDecision individual_sm_association::get_sm_policy_decision() const {
+  return m_decision;
+}
+
+void individual_sm_association::set_sm_policy_context_data(
+    SmPolicyContextData& context) {
+  m_context = context;
+}
+
+void individual_sm_association::set_sm_policy_decision(
+    SmPolicyDecision& decision) {
+  m_decision = decision;
+}
+
+std::string individual_sm_association::get_id() const {
+  return m_id;
+}

src/pcf_app/sm_policy/individual_sm_association.hpp

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the
+ * License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file individual_sm_association.hpp
+ \brief
+ \author  Stefan Spettel
+ \company Openairinterface Software Allianse
+ \date 2022
+ \email: stefan.spettel@eurecom.fr
+ */
+
+#ifndef FILE_INDIVIDUAL_SM_ASSOCIATION_SEEN
+#define FILE_INDIVIDUAL_SM_ASSOCIATION_SEEN
+
+#include "SmPolicyContextData.h"
+#include "SmPolicyDecision.h"
+
+#include <memory.h>
+
+namespace oai::pcf::app::sm_policy {
+
+class individual_sm_association {
+ public:
+  explicit individual_sm_association(
+      oai::pcf::model::SmPolicyContextData context,
+      oai::pcf::model::SmPolicyDecision decision, std::string id) {
+    m_decision = decision;
+    m_context  = context;
+    m_id       = id;
+  }
+
+  virtual ~individual_sm_association() = default;
+
+  oai::pcf::model::SmPolicyContextData get_sm_policy_context_data() const;
+  oai::pcf::model::SmPolicyDecision get_sm_policy_decision() const;
+
+  void set_sm_policy_context_data(
+      oai::pcf::model::SmPolicyContextData& context);
+  void set_sm_policy_decision(oai::pcf::model::SmPolicyDecision& decision);
+
+  std::string get_id() const;
+
+ private:
+  oai::pcf::model::SmPolicyContextData m_context;
+  oai::pcf::model::SmPolicyDecision m_decision;
+  std::string m_id;
+};
+}  // namespace oai::pcf::app::sm_policy
+#endif