Merge pull request #90 from G-Epitech/rtp-104-mnt

RTP-104 - Monitor

Author: TekMath

libs/abra/dependencies.cmake

@@ -1,9 +1,9 @@
 # External dependencies
-find_package(Boost REQUIRED COMPONENTS system mysql)
+find_package(Boost REQUIRED COMPONENTS system mysql json beast)
 
 IF(Boost_FOUND)
     include_directories(${Boost_INCLUDE_DIRS})
     link_directories(${Boost_LIBRARY_DIRS})
 ENDIF(Boost_FOUND)
 
-target_link_libraries(abra PUBLIC Boost::system Boost::mysql)
+target_link_libraries(abra PUBLIC Boost::system Boost::mysql Boost::json Boost::beast)

libs/abra/includes/network.hpp

@@ -11,5 +11,7 @@
 #include "libs/abra/src/client/udp/client_udp.hpp"
 #include "libs/abra/src/server/tcp/server_tcp.hpp"
 #include "libs/abra/src/server/tcp/session/session_tcp.hpp"
+#include "libs/abra/src/server/websocket/server_websocket.hpp"
+#include "libs/abra/src/server/websocket/session/session_websocket.hpp"
 #include "libs/abra/src/server/udp/server_udp.hpp"
 #include "libs/abra/src/tools/logger/logger.hpp"

libs/abra/src/server/CMakeLists.txt

@@ -1,2 +1,3 @@
 add_subdirectory(tcp)
 add_subdirectory(udp)
+add_subdirectory(websocket)

libs/abra/src/server/websocket/CMakeLists.txt

@@ -0,0 +1,6 @@
+target_sources(abra PRIVATE
+        server_websocket.cpp
+        server_websocket.hpp
+)
+
+add_subdirectory(session)

libs/abra/src/server/websocket/server_websocket.cpp

@@ -0,0 +1,95 @@
+/*
+** EPITECH PROJECT, 2024
+** server_tcp.cpp
+** File description:
+** ServerTCP class
+*/
+
+#include "./server_websocket.hpp"
+
+#include <iostream>
+
+using namespace abra::server;
+using namespace boost::asio;
+
+ServerWebsocket::ServerWebsocket(
+    const int &port,
+    const std::function<void(std::pair<std::uint64_t, const boost::json::object &>)> &handler)
+    : acceptor_(ioc_, ip::tcp::endpoint(ip::tcp::v4(), port)),
+      lastClientId_(0),
+      handler_(handler),
+      logger_("websocket") {}
+
+ServerWebsocket::~ServerWebsocket() {
+  this->Close();
+}
+
+void ServerWebsocket::Start() {
+  AcceptNewConnection();
+
+  logger_.Info("Websocket started on port " + std::to_string(acceptor_.local_endpoint().port()));
+  ioc_.run();
+}
+
+void ServerWebsocket::AcceptNewConnection() {
+  acceptor_.async_accept([this](boost::system::error_code error, ip::tcp::socket socket) {
+    if (!error) {
+      std::uint64_t clientId = lastClientId_;
+      lastClientId_++;
+
+      logger_.Info("New connection accepted");
+      auto clientSession = std::make_shared<SessionWebsocket>(
+          std::move(socket), clientId, handler_,
+          [this](std::uint64_t clientId) { this->OnSessionClose(clientId); });
+
+      clientSession->Start();
+      logger_.Info("Session started with clientID " + std::to_string(clientId));
+
+      RegisterNewClient(clientSession, clientId);
+    } else {
+      logger_.Error("Error while accepting new connection: " + error.message());
+    }
+
+    AcceptNewConnection();
+  });
+}
+
+void ServerWebsocket::RegisterNewClient(std::shared_ptr<SessionWebsocket> client,
+                                        const std::uint64_t &clientId) {
+  clients_[clientId] = std::move(client);
+}
+
+void ServerWebsocket::Close() {
+  if (!acceptor_.is_open() || ioc_.stopped()) {
+    return;
+  }
+
+  this->logger_.Info("Closing session");
+
+  for (auto &client : clients_) {
+    client.second->Close();
+  }
+  ioc_.stop();
+
+  this->logger_.Info("Session closed");
+}
+
+void ServerWebsocket::SendToClient(const std::uint64_t &clientId,
+                                   const boost::json::object &message) {
+  if (clients_.find(clientId) == clients_.end() || !clients_[clientId]) {
+    logger_.Error("Client not found");
+    return;
+  }
+
+  clients_[clientId]->Send(message);
+}
+
+void ServerWebsocket::OnSessionClose(const std::uint64_t &clientId) {
+  if (clients_.find(clientId) == clients_.end()) {
+    logger_.Error("Client not found");
+    return;
+  }
+
+  clients_.erase(clientId);
+  logger_.Info("Client " + std::to_string(clientId) + " disconnected");
+}

libs/abra/src/server/websocket/server_websocket.hpp

@@ -0,0 +1,89 @@
+/*
+** EPITECH PROJECT, 2024
+** server_tcp.hpp
+** File description:
+** ServerTCP class
+*/
+
+#pragma once
+
+#include <boost/asio.hpp>
+#include <boost/json.hpp>
+#include <cstdint>
+#include <map>
+#include <queue>
+
+#include "./session/session_websocket.hpp"
+#include "libs/abra/src/core.hpp"
+#include "libs/abra/src/tools/logger/logger.hpp"
+
+namespace abra::server {
+class EXPORT_NETWORK_SDK_API ServerWebsocket;
+}
+
+class abra::server::ServerWebsocket {
+ public:
+  /**
+   * @brief Construct a new ServerTCP instance
+   * @param port The TCP port
+   * @param middleware The middleware to catch messages from listeners
+   */
+  ServerWebsocket(
+      const int &port,
+      const std::function<void(std::pair<std::uint64_t, const boost::json::object &>)> &handler);
+
+  ~ServerWebsocket();
+
+  /**
+   * @brief Start the server
+   */
+  void Start();
+
+  /**
+   * @brief Send a message to a client
+   * @param clientId The client id
+   * @param message The message to send
+   */
+  void SendToClient(const std::uint64_t &clientId, const boost::json::object &message);
+
+  /**
+   * @brief Close the server
+   */
+  void Close();
+
+ private:
+  /**
+   * @brief Accept a new connection
+   */
+  void AcceptNewConnection();
+
+  /**
+   * @brief Register a new client
+   * @param client
+   */
+  void RegisterNewClient(std::shared_ptr<SessionWebsocket> client, const std::uint64_t &clientId);
+
+  /**
+   * @brief Handle the session close
+   * @param clientId The client id
+   */
+  void OnSessionClose(const std::uint64_t &clientId);
+
+  /// @brief Input Output Context
+  boost::asio::io_context ioc_;
+
+  /// @brief Acceptor of sockets (TCP protocol)
+  boost::asio::ip::tcp::acceptor acceptor_;
+
+  /// @brief Clients map
+  std::map<std::uint64_t, std::shared_ptr<SessionWebsocket>> clients_;
+
+  /// @brief Last client id
+  std::uint64_t lastClientId_;
+
+  /// @brief Handler of websocket messages
+  std::function<void(std::pair<std::uint64_t, const boost::json::object &>)> handler_;
+
+  /// @brief Logger
+  tools::Logger logger_;
+};

libs/abra/src/server/websocket/session/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(abra PRIVATE
+        session_websocket.cpp
+        session_websocket.hpp
+)

libs/abra/src/server/websocket/session/session_websocket.cpp

@@ -0,0 +1,83 @@
+/*
+** EPITECH PROJECT, 2024
+** session_tcp.cpp
+** File description:
+** SessionTCP class
+*/
+
+#include "./session_websocket.hpp"
+
+#include <utility>
+
+#include "libs/abra/src/tools/packet/packet_utils.hpp"
+
+using namespace abra::server;
+using namespace boost;
+
+SessionWebsocket::SessionWebsocket(
+    boost::asio::ip::tcp::socket socket, std::uint64_t clientId,
+    const std::function<void(std::pair<std::uint64_t, const boost::json::object &>)> &handler,
+    const std::function<void(std::uint64_t)> &onClose)
+    : ws_(std::move(socket)),
+      buffer_(),
+      clientId_(clientId),
+      handler_(handler),
+      onClose_(onClose),
+      logger_("session_websocket_" + std::to_string(clientId)) {}
+
+SessionWebsocket::~SessionWebsocket() {
+  this->Close();
+}
+
+void SessionWebsocket::Start() {
+  auto self(shared_from_this());
+
+  ws_.async_accept([self](beast::error_code ec) {
+    if (!ec) {
+      self->ListenNewRequest();
+    } else {
+      return;
+    }
+  });
+}
+
+void SessionWebsocket::ListenNewRequest() {
+  auto self(shared_from_this());
+
+  ws_.async_read(buffer_, [self](beast::error_code ec, std::size_t bytes_transferred) {
+    boost::ignore_unused(bytes_transferred);
+
+    if (!ec) {
+      auto message = beast::buffers_to_string(self->buffer_.data());
+      self->HandleRequest(message);
+      self->buffer_.consume(self->buffer_.size());
+      self->ListenNewRequest();
+    } else {
+      self->onClose_(self->clientId_);
+      return;
+    }
+  });
+}
+
+void SessionWebsocket::HandleRequest(const std::string &message) {
+  logger_.Info("Received message: " + std::to_string(message.size()));
+
+  auto json = boost::json::parse(message);
+  handler_(std::make_pair(this->clientId_, json.as_object()));
+}
+
+void SessionWebsocket::Close() {
+  if (!this->ws_.is_open()) {
+    return;
+  }
+
+  this->logger_.Info("Closing session");
+  this->ws_.close(beast::websocket::close_code::normal);
+  this->logger_.Info("Session closed");
+}
+
+void SessionWebsocket::Send(const boost::json::object &message) {
+  auto json = boost::json::serialize(message);
+
+  ws_.write(boost::asio::buffer(json));
+}

libs/abra/src/server/websocket/session/session_websocket.hpp

@@ -0,0 +1,89 @@
+/*
+** EPITECH PROJECT, 2024
+** session_tcp.hpp
+** File description:
+** SessionTCP class
+*/
+
+#pragma once
+
+#include <boost/array.hpp>
+#include <boost/asio.hpp>
+#include <boost/beast.hpp>
+#include <boost/json.hpp>
+#include <memory>
+#include <queue>
+
+#include "libs/abra/src/core.hpp"
+#include "libs/abra/src/server/tcp/props/message.hpp"
+#include "libs/abra/src/tools/logger/logger.hpp"
+#include "libs/abra/src/tools/message/message.hpp"
+#include "libs/abra/src/tools/packet/packet.hpp"
+#include "libs/abra/src/tools/packet/props/props.hpp"
+
+namespace abra::server {
+class EXPORT_NETWORK_SDK_API SessionWebsocket;
+}  // namespace abra::server
+
+class abra::server::SessionWebsocket : public std::enable_shared_from_this<SessionWebsocket> {
+ public:
+  /**
+   * @brief Construct a new SessionTCP. This session will handle incoming data
+   * @param socket Client socket
+   */
+  SessionWebsocket(
+      boost::asio::ip::tcp::socket socket, std::uint64_t clientId,
+      const std::function<void(std::pair<std::uint64_t, const boost::json::object &>)> &handler_,
+      const std::function<void(std::uint64_t)> &onClose);
+
+  /**
+   * @brief Destroy the SessionTCP object
+   */
+  ~SessionWebsocket();
+
+  /**
+   * @brief Start the client session
+   */
+  void Start();
+
+  /**
+   * @brief Close the connection
+   */
+  void Close();
+
+  /**
+   * @brief Send a message to the client
+   * @param message The message to send
+   */
+  void Send(const boost::json::object &message);
+
+ private:
+  /**
+   * @brief Listen the new request of the client
+   */
+  void ListenNewRequest();
+
+  /**
+   * @brief Handle the request of the client
+   * @param message The message received
+   */
+  void HandleRequest(const std::string &message);
+
+  /// @brief The socket of the client
+  boost::beast::websocket::stream<boost::asio::ip::tcp::socket> ws_;
+
+  /// @brief The buffer of the client
+  boost::beast::flat_buffer buffer_;
+
+  /// @brief Client id
+  std::uint64_t clientId_;
+
+  /// @brief Handler
+  std::function<void(std::pair<std::uint64_t, const boost::json::object &>)> handler_;
+
+  /// @brief On close callback
+  std::function<void(std::uint64_t)> onClose_;
+
+  /// @brief Logger
+  tools::Logger logger_;
+};