Merged in with changes from ssl

smacc2_client_library/http_client/CMakeLists.txt

@@ -21,21 +21,30 @@ include_directories(
 
 file(GLOB_RECURSE SRC_FILES src *.cpp)
 
+add_library(http_session
+  src/http_client/ssl_http_session.cpp
+  src/http_client/http_session.cpp
+)
+
 add_library(${PROJECT_NAME}
-  ${SRC_FILES}
+  src/http_client/http_client.cpp
 )
 
-target_link_libraries(${PROJECT_NAME} ${smacc2_LIBRARIES})
-ament_target_dependencies(${PROJECT_NAME} smacc2)
+target_link_libraries(${PROJECT_NAME}
+  http_session
+  ${smacc2_LIBRARIES}
+)
+ament_target_dependencies(${PROJECT_NAME} smacc2) 
 ament_export_include_directories(include)
-ament_export_libraries(${PROJECT_NAME})
+ament_export_libraries(${PROJECT_NAME} http_session)
 
 install(
   DIRECTORY include/
   DESTINATION include)
 
 install(TARGETS
   ${PROJECT_NAME}
+  http_session
   DESTINATION lib/)
 
 ament_package()

smacc2_client_library/http_client/include/http_client/http_client.hpp

@@ -24,7 +24,10 @@
 #include <boost/asio/strand.hpp>
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
+#include <boost/beast/ssl.hpp>
 #include <boost/beast/version.hpp>
+#include <http_client/http_session.hpp>
+#include <http_client/ssl_http_session.hpp>
 #include <iostream>
 #include <memory>
 #include <optional>
@@ -34,85 +37,80 @@
 #include <thread>
 #include <unordered_map>
 
-namespace cl_http {
-class ClHttp : public smacc2::ISmaccClient {
-  class http_session : public std::enable_shared_from_this<http_session> {
-   public:
-    using TResponse =
-        boost::beast::http::response<boost::beast::http::string_body>;
-
-    // Objects are constructed with a strand to
-    // ensure that handlers do not execute concurrently.
-    http_session(boost::asio::io_context &ioc,
-                 const std::function<void(const TResponse &)> response);
-
-    // Start the asynchronous operation
-    void run(const std::string &host, const std::string &target,
-             const std::string &port,
-             const boost::beast::http::verb http_method, const int &version);
-
-    void on_resolve(boost::beast::error_code ec,
-                    boost::asio::ip::tcp::resolver::results_type results);
-
-   private:
-    void fail(boost::beast::error_code ec, char const *what);
-    void on_connect(
-        boost::beast::error_code ec,
-        boost::asio::ip::tcp::resolver::results_type::endpoint_type);
-    void on_write(boost::beast::error_code ec, std::size_t bytes_transferred);
-    void on_read(boost::beast::error_code ec, std::size_t bytes_transferred);
-
-    std::function<void(const TResponse &)> onResponse;
-
-    boost::asio::ip::tcp::resolver resolver_;
-    boost::beast::tcp_stream stream_;
-    boost::beast::flat_buffer buffer_;  // (Must persist between reads)
-    boost::beast::http::request<boost::beast::http::empty_body> req_;
-    boost::beast::http::response<boost::beast::http::string_body> res_;
+namespace cl_http
+{
+class ClHttp : public smacc2::ISmaccClient
+{
+  class Server
+  {
+  public:
+    explicit Server(const std::string & server_name) : server_name_{server_name}, ssl_{true}
+    {
+      if (!server_name_.substr(0, 7).compare("http://"))
+      {
+        ssl_ = false;
+        server_name_.erase(0, 7);
+      }
+      else if (!server_name_.substr(0, 8).compare("https://"))
+      {
+        server_name_.erase(0, 8);
+        ssl_ = true;
+      }
+    }
+
+    bool isSSL() const { return ssl_; }
+
+    std::string getPort() const { return ssl_ ? "443" : "80"; }
+
+    std::string getServerName() const { return server_name_; }
+
+  private:
+    std::string server_name_;
+    bool ssl_;
   };
 
- public:
-  enum class kHttpRequestMethod {
+public:
+  enum class kHttpRequestMethod
+  {
     GET = static_cast<int>(boost::beast::http::verb::get),
     POST = static_cast<int>(boost::beast::http::verb::post),
     PUT = static_cast<int>(boost::beast::http::verb::put),
   };
 
-  using TResponse = http_session::TResponse;
+  using TResponse = http_session_base::TResponse;
 
   template <typename T>
-  boost::signals2::connection onResponseReceived(
-      void (T::*callback)(const TResponse&), T *object) {
-    return this->getStateMachine()->createSignalConnection(onResponseReceived_,
-                                                           callback, object);
+  boost::signals2::connection onResponseReceived(void (T::*callback)(const TResponse &), T * object)
+  {
+    return this->getStateMachine()->createSignalConnection(onResponseReceived_, callback, object);
   }
 
-  explicit ClHttp(const std::string &server, const int &timeout = 1500);
+  explicit ClHttp(const std::string & server, const int & timeout = 1500);
 
   virtual ~ClHttp();
 
   void onInitialize() override;
 
-  void makeRequest(const kHttpRequestMethod http_method,
-                   const std::string &path = "/");
+  void makeRequest(const kHttpRequestMethod http_method, const std::string & path = "/");
 
- private:
+private:
   const int HTTP_VERSION = 11;
 
   bool initialized_;
   bool is_ssl_;
   int timeout_;
-  std::string server_name_;
+
+  Server server_;
 
   boost::asio::io_context io_context_;
-  boost::asio::executor_work_guard<decltype(io_context_)::executor_type>
-      worker_guard_;
+  boost::asio::executor_work_guard<decltype(io_context_)::executor_type> worker_guard_;
   std::thread tcp_connection_runner_;
 
+  boost::asio::ssl::context ssl_context_;
+
   smacc2::SmaccSignal<void(const TResponse &)> onResponseReceived_;
 
-  std::function<void(TResponse)> callbackHandler = [&](const TResponse& res) {
-    onResponseReceived_(res);
-  };
+  std::function<void(TResponse)> callbackHandler = [&](const TResponse & res)
+  { onResponseReceived_(res); };
 };
 }  // namespace cl_http

smacc2_client_library/http_client/include/http_client/http_session.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <boost/asio/executor_work_guard.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/beast/version.hpp>
+#include <http_client/http_session_base.hpp>
+#include <iostream>
+#include <string>
+
+namespace cl_http
+{
+class http_session : public std::enable_shared_from_this<http_session>, public http_session_base
+{
+public:
+  // Objects are constructed with a strand to
+  // ensure that handlers do not execute concurrently.
+  http_session(
+    boost::asio::any_io_executor ioc, const std::function<void(const TResponse &)> response);
+
+  virtual ~http_session() {}
+
+  // Start the asynchronous operation
+  void run(
+    const std::string & host, const std::string & target,
+    const boost::beast::http::verb http_method, const int & version) override;
+
+  std::string getPort() override { return kPort; }
+
+private:
+  const std::string kPort = "80";
+
+  void on_resolve(
+    boost::beast::error_code ec, boost::asio::ip::tcp::resolver::results_type results) override;
+  void fail(boost::beast::error_code ec, const char * what) override;
+  void on_connect(
+    boost::beast::error_code ec,
+    boost::asio::ip::tcp::resolver::results_type::endpoint_type) override;
+  void on_write(boost::beast::error_code ec, std::size_t bytes_transferred) override;
+  void on_read(boost::beast::error_code ec, std::size_t bytes_transferred) override;
+
+  std::function<void(const TResponse &)> onResponse;
+
+  boost::asio::ip::tcp::resolver resolver_;
+  boost::beast::tcp_stream stream_;
+  boost::beast::flat_buffer buffer_;  // (Must persist between reads)
+  boost::beast::http::request<boost::beast::http::empty_body> req_;
+  boost::beast::http::response<boost::beast::http::string_body> res_;
+};
+}  // namespace cl_http

smacc2_client_library/http_client/include/http_client/http_session_base.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <boost/asio/executor_work_guard.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/beast/ssl.hpp>
+#include <boost/beast/version.hpp>
+#include <string>
+
+namespace cl_http
+{
+class http_session_base
+{
+public:
+  virtual ~http_session_base() {}
+
+  using TResponse = boost::beast::http::response<boost::beast::http::string_body>;
+
+  // Start the asynchronous operation
+  virtual void run(
+    const std::string & host, const std::string & target,
+    const boost::beast::http::verb http_method, const int & version) = 0;
+
+  virtual std::string getPort() = 0;
+
+protected:
+  virtual void on_resolve(
+    boost::beast::error_code ec, boost::asio::ip::tcp::resolver::results_type results) = 0;
+  virtual void fail(boost::beast::error_code ec, const char * what) = 0;
+  virtual void on_connect(
+    boost::beast::error_code ec, boost::asio::ip::tcp::resolver::results_type::endpoint_type) = 0;
+  virtual void on_write(boost::beast::error_code ec, std::size_t bytes_transferred) = 0;
+  virtual void on_read(boost::beast::error_code ec, std::size_t bytes_transferred) = 0;
+
+  // Optional, needed for SSL connections
+  virtual void on_handshake(boost::beast::error_code ec) {}
+  virtual void on_shutdown(boost::beast::error_code ec) {}
+};
+}  // namespace cl_http

smacc2_client_library/http_client/include/http_client/ssl_http_session.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <boost/asio/executor_work_guard.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/beast/ssl.hpp>
+#include <boost/beast/version.hpp>
+#include <http_client/http_session_base.hpp>
+#include <iostream>
+#include <string>
+
+namespace cl_http
+{
+class ssl_http_session : public std::enable_shared_from_this<ssl_http_session>,
+                         public http_session_base
+{
+public:
+  // Objects are constructed with a strand to
+  // ensure that handlers do not execute concurrently.
+  ssl_http_session(
+    boost::asio::any_io_executor ioc, boost::asio::ssl::context & ssl_context,
+    const std::function<void(const TResponse &)> response);
+
+  virtual ~ssl_http_session() {}
+
+  // Start the asynchronous operation
+  void run(
+    const std::string & host, const std::string & target,
+    const boost::beast::http::verb http_method, const int & version) override;
+
+  std::string getPort() override { return kPort; }
+
+private:
+  const std::string kPort = "443";
+
+  void on_resolve(
+    boost::beast::error_code ec, boost::asio::ip::tcp::resolver::results_type results) override;
+  void fail(boost::beast::error_code ec, const char * what) override;
+  void on_connect(
+    boost::beast::error_code ec,
+    boost::asio::ip::tcp::resolver::results_type::endpoint_type) override;
+  void on_handshake(boost::beast::error_code ec) override;
+  void on_write(boost::beast::error_code ec, std::size_t bytes_transferred) override;
+  void on_read(boost::beast::error_code ec, std::size_t bytes_transferred) override;
+  void on_shutdown(boost::beast::error_code ec) override;
+
+  std::function<void(const TResponse &)> onResponse;
+
+  boost::asio::ip::tcp::resolver resolver_;
+  // boost::beast::tcp_stream stream_;
+  boost::beast::ssl_stream<boost::beast::tcp_stream> stream_;
+  boost::beast::flat_buffer buffer_;  // (Must persist between reads)
+  boost::beast::http::request<boost::beast::http::empty_body> req_;
+  boost::beast::http::response<boost::beast::http::string_body> res_;
+};
+}  // namespace cl_http