Merge branch 'httpv2_support' into 'develop'

httpv2 support

See merge request oai/cn5g/oai-cn5g-nrf!19

src/api-server/CMakeLists.txt

@@ -32,6 +32,7 @@ include_directories(${SRC_TOP_DIR}/../build/ext/spdlog/include)
 
 file(GLOB NRF_API_SERVER_src_files
     ${NRF_API_SERVER_DIR}/nrf-api-server.cpp
+    ${NRF_API_SERVER_DIR}/nrf-http2-server.cpp
     ${NRF_API_SERVER_DIR}/model/*.cpp
     ${NRF_API_SERVER_DIR}/api/*.cpp
     ${NRF_API_SERVER_DIR}/impl/*.cpp

src/api-server/nrf-http2-server.h

+/*
+ * 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 smf_http2-server.h
+ \brief
+ \author  Tien-Thinh NGUYEN
+ \company Eurecom
+ \date 2020
+ \email: tien-thinh.nguyen@eurecom.fr
+ */
+
+#ifndef FILE_NRF_HTTP2_SERVER_SEEN
+#define FILE_NRF_HTTP2_SERVER_SEEN
+
+#include "conversions.hpp"
+
+//#include "nrf.h"
+#include "nrf_app.hpp"
+#include "uint_generator.hpp"
+#include <nghttp2/asio_http2_server.h>
+
+using namespace nghttp2::asio_http2;
+using namespace nghttp2::asio_http2::server;
+using namespace oai::nrf::model;
+using namespace oai::nrf::app;
+
+class nrf_http2_server {
+ public:
+  nrf_http2_server(std::string addr, uint32_t port, nrf_app* nrf_app_inst)
+      : m_address(addr), m_port(port), server(), m_nrf_app(nrf_app_inst) {}
+  void start();
+  void init(size_t thr) {}
+  void register_nf_instance_handler(
+      const NFProfile& NFProfiledata, const response& response);
+  void deregister_nf_instance_handler(
+      const std::string& nfInstanceID, const response& response);
+  void get_nf_instance_handler(
+      const std::string& nfInstanceID, const response& response);
+  void get_nf_instances_handler(
+      const std::string& nf_type, const std::string& limit_nfs,
+      const response& response);
+  void update_instance_handler(
+      const std::string& nfInstanceID, const std::vector<PatchItem>& patchItem,
+      const response& response);
+  void create_subscription_handler(
+      const SubscriptionData& subscriptionData, const response& response);
+  void update_subscription_handler(
+      const std::string& subscriptionID,
+      const std::vector<PatchItem>& patchItem, const response& response);
+  void remove_subscription_handler(
+      const std::string& subscriptionID, const response& response);
+  void search_nf_instances_handler(
+      const std::string& target_nf_type, const std::string& requester_nf_type,
+      const std::string& requester_nf_instance_id, const std::string& limit_nfs,
+      const response& response);
+
+  void access_token_request_handler(
+      const SubscriptionData& subscriptionData, const response& response);
+  void stop();
+
+ private:
+  util::uint_generator<uint32_t> m_promise_id_generator;
+  std::string m_address;
+  uint32_t m_port;
+  http2 server;
+  nrf_app* m_nrf_app;
+
+ protected:
+  static uint64_t generate_promise_id() {
+    return util::uint_uid_generator<uint64_t>::get_instance().get_uid();
+  }
+};
+
+#endif

src/common/nrf.h

@@ -77,7 +77,9 @@ typedef uint32_t evsub_id_t;
 #define UNASSIGNED_EVSUB_ID ((evsub_id_t) 0x00000000)
 
 #define NNRF_NFM_BASE "/nnrf-nfm/"
-#define NNRF_NFM_NF_INSTANCE "/nf-instances/"
+#define NNRF_DISC_BASE "/nnrf-disc/"
+#define NNRF_NFM_NF_INSTANCES "/nf-instances/"
+#define NNRF_NFM_STATUS_SUBSCRIBE_URL "/subscriptions"
 
 #define NF_CURL_TIMEOUT_MS 1000L
 

src/common/utils/conversions.cpp

@@ -92,3 +92,15 @@ int conv::ascii_to_hex(uint8_t* dst, const char* h) {
     dst[i++] = (high << 4) | low;
   }
 }
+
+std::string conv::toString(const struct in_addr& inaddr) {
+  std::string s              = {};
+  char str[INET6_ADDRSTRLEN] = {};
+  if (inet_ntop(AF_INET, (const void*) &inaddr, str, INET6_ADDRSTRLEN) ==
+      NULL) {
+    s.append("Error in_addr");
+  } else {
+    s.append(str);
+  }
+  return s;
+}
\ No newline at end of file

src/common/utils/string.cpp

@@ -19,12 +19,14 @@
  *      contact@openairinterface.org
  */
 #include "string.hpp"
+#include <iostream>
 
 #include <algorithm>
 #include <functional>
 #include <cctype>
 #include <locale>
 #include <stdarg.h>
+#include <regex>
 
 template<class T>
 class Buffer {
@@ -86,3 +88,20 @@ std::string& util::rtrim(std::string& s) {
 std::string& util::trim(std::string& s) {
   return util::ltrim(util::rtrim(s));
 }
+
+// extract query param from given querystring
+std::string query_param_tmp;
+//
+std::string util::get_query_param(std::string querystring, std::string param) {
+  std::regex reList("([^=]*)=([^&]*)&?");
+  query_param_tmp.clear();
+  std::for_each(
+      std::sregex_iterator(querystring.begin(), querystring.end(), reList),
+      std::sregex_iterator(), [param](std::smatch match) {
+        if (match[1] == param) {
+          query_param_tmp = match[2].str().c_str();
+          return;
+        }
+      });
+  return query_param_tmp;
+}
\ No newline at end of file

src/common/utils/string.hpp

@@ -39,5 +39,7 @@ std::string& ltrim(std::string& s);
 std::string& rtrim(std::string& s);
 // trim from both ends
 std::string& trim(std::string& s);
+// extract query param from given querystring
+std::string get_query_param(std::string querystring, std::string param);
 }  // namespace util
 #endif

src/nrf_app/nrf_app.cpp

@@ -436,7 +436,7 @@ void nrf_app::handle_create_subscription(
       // generate a subscription ID
       generate_ev_subscription_id(evsub_id);
       ss.get()->set_subscription_id(evsub_id);
-
+      ss.get()->set_http_version(http_version);
       // subscribe to NF status registered
       // subscribe_nf_status(evsub_id);  // from nrf_app
       // subscribe to NF status
@@ -475,7 +475,8 @@ void nrf_app::handle_create_subscription(
         for (auto p : profiles) {
           // send notifications
           nrf_client_inst->notify_subscribed_event(
-              p, NOTIFICATION_TYPE_NF_REGISTERED, notification_uris);
+              p, NOTIFICATION_TYPE_NF_REGISTERED, notification_uris,
+              http_version);
         }
       }
 
@@ -1029,12 +1030,15 @@ void nrf_app::handle_nf_status_registered(const std::string& profile_id) {
   find_nf_profile(profile_id, profile);
   if (profile.get() != nullptr) {
     std::vector<std::string> notification_uris = {};
+    uint8_t httpVersion                        = 1;
     get_subscription_list(
-        profile_id, NOTIFICATION_TYPE_NF_REGISTERED, notification_uris);
+        profile_id, NOTIFICATION_TYPE_NF_REGISTERED, notification_uris,
+        httpVersion);
     // send notifications
     if (notification_uris.size() > 0)
       nrf_client_inst->notify_subscribed_event(
-          profile, NOTIFICATION_TYPE_NF_REGISTERED, notification_uris);
+          profile, NOTIFICATION_TYPE_NF_REGISTERED, notification_uris,
+          httpVersion);
     else
       Logger::nrf_app().debug("\tNo subscription found");
 
@@ -1060,13 +1064,14 @@ void nrf_app::handle_nf_status_deregistered(
       p.get()->get_nf_instance_id().c_str());
 
   std::vector<std::string> notification_uris = {};
+  uint8_t http_version                       = 1;
   get_subscription_list(
       p.get()->get_nf_instance_id(), NOTIFICATION_TYPE_NF_DEREGISTERED,
-      notification_uris);
+      notification_uris, http_version);
   // send notifications
   if (notification_uris.size() > 0)
     nrf_client_inst->notify_subscribed_event(
-        p, NOTIFICATION_TYPE_NF_DEREGISTERED, notification_uris);
+        p, NOTIFICATION_TYPE_NF_DEREGISTERED, notification_uris, http_version);
   else
     Logger::nrf_app().debug("\tNo subscription found");
 }
@@ -1089,14 +1094,17 @@ void nrf_app::handle_nf_status_profile_changed(const std::string& profile_id) {
   find_nf_profile(profile_id, profile);
   if (profile.get() != nullptr) {
     std::vector<std::string> notification_uris = {};
+    uint8_t http_version                       = 1;
     get_subscription_list(
-        profile_id, NOTIFICATION_TYPE_NF_PROFILE_CHANGED, notification_uris);
+        profile_id, NOTIFICATION_TYPE_NF_PROFILE_CHANGED, notification_uris,
+        http_version);
     // Notification data includes NF profile (other alternative, includes
     // profile_changes)
     // send notifications
     if (notification_uris.size() > 0)
       nrf_client_inst->notify_subscribed_event(
-          profile, NOTIFICATION_TYPE_NF_PROFILE_CHANGED, notification_uris);
+          profile, NOTIFICATION_TYPE_NF_PROFILE_CHANGED, notification_uris,
+          http_version);
     else
       Logger::nrf_app().debug("\tNo subscription found");
   } else {
@@ -1108,7 +1116,7 @@ void nrf_app::handle_nf_status_profile_changed(const std::string& profile_id) {
 //------------------------------------------------------------------------------
 void nrf_app::get_subscription_list(
     const std::string& profile_id, const uint8_t& notification_type,
-    std::vector<std::string>& uris) const {
+    std::vector<std::string>& uris, uint8_t& http_version) const {
   Logger::nrf_app().info(
       "\tGet the list of subscriptions related to this profile, profile id %s",
       profile_id.c_str());
@@ -1127,6 +1135,8 @@ void nrf_app::get_subscription_list(
     std::string uri;
     s.second.get()->get_notification_uri(uri);
 
+    http_version = s.second.get()->get_http_version();
+
     // check notification event type
     bool match_notif_type = false;
     for (auto i : s.second.get()->get_notif_events()) {

src/nrf_app/nrf_app.hpp

@@ -409,7 +409,7 @@ class nrf_app {
    */
   void get_subscription_list(
       const std::string& profile_id, const uint8_t& notification_type,
-      std::vector<std::string>& uris) const;
+      std::vector<std::string>& uris, uint8_t& http_version) const;
 
   /*
    * Verify whether the requester is allowed to discover the NF services

src/nrf_app/nrf_client.cpp

@@ -88,8 +88,8 @@ nrf_client::~nrf_client() {
 
 //------------------------------------------------------------------------------
 CURL* nrf_client::curl_create_handle(
-    const std::string& uri, const std::string& data,
-    std::string& response_data) {
+    const std::string& uri, const std::string& data, std::string& response_data,
+    uint8_t http_version) {
   // create handle for a curl request
   CURL* curl = curl_easy_init();
 
@@ -106,17 +106,26 @@ CURL* nrf_client::curl_create_handle(
     curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
     curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, data.length());
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data.c_str());
+    if (http_version == 2) {
+      curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+      // curl_easy_setopt(curl, CURLOPT_PORT, 8080);
+      // We use a self-signed test server, skip verification during debugging
+      curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+      curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
+      curl_easy_setopt(
+          curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE);
+    }
   }
   return curl;
 }
 
 //------------------------------------------------------------------------------
 void nrf_client::send_curl_multi(
-    const std::string& uri, const std::string& data,
-    std::string& response_data) {
+    const std::string& uri, const std::string& data, std::string& response_data,
+    uint8_t http_version) {
   // create a new handle and add to the multi handle
   // the curl will actually be sent in perform_curl_multi
-  CURL* tmp = curl_create_handle(uri, data, response_data);
+  CURL* tmp = curl_create_handle(uri, data, response_data, http_version);
   curl_multi_add_handle(curl_multi, tmp);
   handles.push_back(tmp);
 }
@@ -209,9 +218,11 @@ void nrf_client::curl_release_handles() {
 //------------------------------------------------------------------------------
 void nrf_client::notify_subscribed_event(
     const std::shared_ptr<nrf_profile>& profile, const uint8_t& event_type,
-    const std::vector<std::string>& uris) {
+    const std::vector<std::string>& uris, uint8_t http_version) {
   Logger::nrf_app().debug(
-      "Send notification for the subscribed event to the subscriptions");
+      "Send notification for the subscribed event to the subscriptions (HTTP "
+      "VERSION %d)",
+      http_version);
 
   std::map<std::string, std::string> responses = {};
   // Fill the json part
@@ -259,7 +270,7 @@ void nrf_client::notify_subscribed_event(
   for (auto uri : uris) {
     responses[uri] = "";
     std::unique_ptr<std::string> httpData(new std::string());
-    send_curl_multi(uri, body, responses[uri]);
+    send_curl_multi(uri, body, responses[uri], http_version);
   }
 
   perform_curl_multi(

src/nrf_app/nrf_client.hpp

@@ -64,7 +64,7 @@ class nrf_client {
    */
   void notify_subscribed_event(
       const std::shared_ptr<nrf_profile>& profile, const uint8_t& event_type,
-      const std::vector<std::string>& uris);
+      const std::vector<std::string>& uris, uint8_t http_version);
 
   /*
    * Create Curl handle for multi curl
@@ -75,7 +75,7 @@ class nrf_client {
    */
   CURL* curl_create_handle(
       const std::string& uri, const std::string& data,
-      std::string& response_data);
+      std::string& response_data, uint8_t http_version);
 
   /*
    * Prepare to send a request using curl multi
@@ -86,7 +86,7 @@ class nrf_client {
    */
   void send_curl_multi(
       const std::string& uri, const std::string& data,
-      std::string& response_data);
+      std::string& response_data, uint8_t http_version);
 
   /*
    * Perform curl multi to actually process the available data

src/nrf_app/nrf_subscription.cpp

@@ -115,6 +115,16 @@ boost::posix_time::ptime nrf_subscription::get_validity_time() const {
   return validity_time;
 }
 
+//------------------------------------------------------------------------------
+void nrf_subscription::set_http_version(const uint8_t& httpVersion) {
+  http_version = httpVersion;
+}
+
+//------------------------------------------------------------------------------
+uint8_t nrf_subscription::get_http_version() const {
+  return http_version;
+}
+
 //------------------------------------------------------------------------------
 void nrf_subscription::display() {
   Logger::nrf_app().debug("Subscription information");

src/nrf_app/nrf_subscription.hpp

@@ -157,7 +157,19 @@ class nrf_subscription {
    * @return [boost::posix_time::ptime &] validity time
    */
   boost::posix_time::ptime get_validity_time() const;
+  /*
+   * Set the http_version
+   * @param [uint8_t&]: http_version: http_version
+   * @return void
+   */
+  void set_http_version(const uint8_t& http_version);
 
+  /*
+   * Get the http_version
+   * @param [void]
+   * @return http_version
+   */
+  uint8_t get_http_version() const;
   /*
    * Subscribe to be notified when a new NF registered to the NRF
    * @param void
@@ -188,6 +200,7 @@ class nrf_subscription {
   nrf_event& m_event_sub;
   bs2::connection ev_connection;
   boost::posix_time::ptime validity_time;
+  uint8_t http_version = 1;
 };
 }  // namespace app
 }  // namespace nrf

src/oai-nrf/main.cpp

@@ -16,10 +16,12 @@
 
 #include "logger.hpp"
 #include "nrf-api-server.h"
+#include "nrf-http2-server.h"
 #include "nrf_app.hpp"
 #include "nrf_client.hpp"
 #include "options.hpp"
 #include "pid_file.hpp"
+#include "conversions.hpp"
 
 #include "pistache/endpoint.h"
 #include "pistache/http.h"
@@ -39,6 +41,7 @@ using namespace std;
 nrf_app* nrf_app_inst = nullptr;
 nrf_config nrf_cfg;
 NRFApiServer* api_server           = nullptr;
+nrf_http2_server* nrf_api_server_2 = nullptr;
 
 //------------------------------------------------------------------------------
 void my_app_signal_handler(int s) {
@@ -112,7 +115,14 @@ int main(int argc, char** argv) {
   api_server = new NRFApiServer(addr, nrf_app_inst);
   api_server->init(2);
   std::thread nrf_manager(&NRFApiServer::start, api_server);
+
+  // NRF NGHTTP API server (HTTP2)
+  nrf_api_server_2 = new nrf_http2_server(
+      conv::toString(nrf_cfg.sbi.addr4), nrf_cfg.sbi_http2_port, nrf_app_inst);
+  std::thread nrf_http2_manager(&nrf_http2_server::start, nrf_api_server_2);
+
   nrf_manager.join();
+  nrf_http2_manager.join();
 
   FILE* fp             = NULL;
   std::string filename = fmt::format("/tmp/nrf_{}.status", getpid());