async-server-rooms example added

Author: lganzzzo

async-server-rooms/CMakeLists.txt

@@ -0,0 +1,54 @@
+cmake_minimum_required(VERSION 3.1)
+
+set(project_name async-server-rooms) ## rename your project here
+
+project(${project_name})
+
+set(CMAKE_CXX_STANDARD 11)
+
+include_directories(src)
+
+add_library(${project_name}-lib
+        src/AppComponent.hpp
+        src/controller/RoomsController.hpp
+        src/rooms/Peer.cpp
+        src/rooms/Peer.hpp
+        src/rooms/Room.cpp
+        src/rooms/Room.hpp
+        src/rooms/Lobby.cpp
+        src/rooms/Lobby.hpp
+)
+
+## link libs
+
+find_package(oatpp              0.19.4 REQUIRED)
+find_package(oatpp-websocket    0.19.4 REQUIRED)
+
+target_link_libraries(${project_name}-lib
+        PUBLIC oatpp::oatpp
+        PUBLIC oatpp::oatpp-test
+        PUBLIC oatpp::oatpp-websocket
+)
+
+## add executables
+
+add_executable(${project_name}-exe
+        src/App.cpp
+)
+target_link_libraries(${project_name}-exe ${project_name}-lib)
+add_dependencies(${project_name}-exe ${project_name}-lib)
+
+add_executable(${project_name}-test
+        test/tests.cpp
+        test/WSTest.cpp
+        test/WSTest.hpp
+)
+target_link_libraries(${project_name}-test ${project_name}-lib)
+add_dependencies(${project_name}-test ${project_name}-lib)
+
+set_target_properties(${project_name}-lib ${project_name}-exe ${project_name}-test PROPERTIES
+        CXX_STANDARD 11
+        CXX_EXTENSIONS OFF
+        CXX_STANDARD_REQUIRED ON
+        LINKER_LANGUAGE CXX
+)

async-server-rooms/src/App.cpp

@@ -0,0 +1,46 @@
+#include "controller/RoomsController.hpp"
+#include "./AppComponent.hpp"
+
+#include "oatpp/network/server/Server.hpp"
+
+#include <iostream>
+
+void run() {
+
+  /* Register Components in scope of run() method */
+  AppComponent components;
+
+  /* Get router component */
+  OATPP_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, router);
+
+  /* Create RoomsController and add all of its endpoints to router */
+  auto myController = std::make_shared<RoomsController>();
+  myController->addEndpointsToRouter(router);
+
+  /* Get connection handler component */
+  OATPP_COMPONENT(std::shared_ptr<oatpp::network::server::ConnectionHandler>, connectionHandler, "http");
+
+  /* Get connection provider component */
+  OATPP_COMPONENT(std::shared_ptr<oatpp::network::ServerConnectionProvider>, connectionProvider);
+
+  /* Create server which takes provided TCP connections and passes them to HTTP connection handler */
+  oatpp::network::server::Server server(connectionProvider, connectionHandler);
+
+  /* Priny info about server port */
+  OATPP_LOGI("MyApp", "Server running on port %s", connectionProvider->getProperty("port").getData());
+
+  /* Run server */
+  server.run();
+
+}
+
+int main(int argc, const char * argv[]) {
+
+  oatpp::base::Environment::init();
+
+  run();
+
+  oatpp::base::Environment::destroy();
+
+  return 0;
+}

async-server-rooms/src/AppComponent.hpp

@@ -0,0 +1,74 @@
+#ifndef AppComponent_hpp
+#define AppComponent_hpp
+
+#include "rooms/Lobby.hpp"
+
+#include "oatpp/web/server/AsyncHttpConnectionHandler.hpp"
+#include "oatpp/web/server/HttpRouter.hpp"
+#include "oatpp/network/server/SimpleTCPConnectionProvider.hpp"
+
+#include "oatpp/parser/json/mapping/ObjectMapper.hpp"
+
+#include "oatpp/core/macro/component.hpp"
+
+/**
+ *  Class which creates and holds Application components and registers components in oatpp::base::Environment
+ *  Order of components initialization is from top to bottom
+ */
+class AppComponent {
+public:
+
+  /**
+   * Create Async Executor
+   */
+  OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::async::Executor>, executor)([] {
+    return std::make_shared<oatpp::async::Executor>(
+      4 /* Data-Processing threads */,
+      1 /* I/O threads */,
+      1 /* Timer threads */
+    );
+  }());
+
+  /**
+   *  Create ConnectionProvider component which listens on the port
+   */
+  OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::ServerConnectionProvider>, serverConnectionProvider)([] {
+    return oatpp::network::server::SimpleTCPConnectionProvider::createShared(8000);
+  }());
+
+  /**
+   *  Create Router component
+   */
+  OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, httpRouter)([] {
+    return oatpp::web::server::HttpRouter::createShared();
+  }());
+
+  /**
+   *  Create ConnectionHandler component which uses Router component to route requests
+   */
+  OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::server::ConnectionHandler>, serverConnectionHandler)("http", [] {
+    OATPP_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, router); // get Router component
+    OATPP_COMPONENT(std::shared_ptr<oatpp::async::Executor>, executor); // get Async executor component
+    return oatpp::web::server::AsyncHttpConnectionHandler::createShared(router, executor);
+  }());
+
+  /**
+   *  Create ObjectMapper component to serialize/deserialize DTOs in Contoller's API
+   */
+  OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::data::mapping::ObjectMapper>, apiObjectMapper)([] {
+    return oatpp::parser::json::mapping::ObjectMapper::createShared();
+  }());
+
+  /**
+   *  Create websocket connection handler
+   */
+  OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::server::ConnectionHandler>, websocketConnectionHandler)("websocket", [] {
+    OATPP_COMPONENT(std::shared_ptr<oatpp::async::Executor>, executor);
+    auto connectionHandler = oatpp::websocket::AsyncConnectionHandler::createShared(executor);
+    connectionHandler->setSocketInstanceListener(std::make_shared<Lobby>());
+    return connectionHandler;
+  }());
+
+};
+
+#endif /* AppComponent_hpp */

async-server-rooms/src/controller/RoomsController.hpp

@@ -0,0 +1,92 @@
+
+#ifndef RoomsController_hpp
+#define RoomsController_hpp
+
+#include "oatpp-websocket/Handshaker.hpp"
+
+#include "oatpp/web/server/api/ApiController.hpp"
+
+#include "oatpp/network/server/ConnectionHandler.hpp"
+
+#include "oatpp/core/macro/codegen.hpp"
+#include "oatpp/core/macro/component.hpp"
+
+/**
+ * Controller with WebSocket-connect endpoint.
+ */
+class RoomsController : public oatpp::web::server::api::ApiController {
+private:
+  typedef RoomsController __ControllerType;
+private:
+  OATPP_COMPONENT(std::shared_ptr<oatpp::network::server::ConnectionHandler>, websocketConnectionHandler, "websocket");
+public:
+  RoomsController(OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
+    : oatpp::web::server::api::ApiController(objectMapper)
+  {}
+public:
+  
+/**
+ *  Begin ENDPOINTs generation ('ApiController' codegen)
+ */
+#include OATPP_CODEGEN_BEGIN(ApiController)
+  
+  ENDPOINT_ASYNC("GET", "/", Root) {
+    
+    ENDPOINT_ASYNC_INIT(Root)
+
+    const char* pageTemplate =
+      "<html lang='en'>"
+        "<head>"
+          "<meta charset=utf-8/>"
+        "</head>"
+        "<body>"
+          "<p>Hello Async WebSocket Rooms Server!</p>"
+          "<p>Connect to chat room:</p>"
+          "<code>localhost:8000/ws/chat/{room_name}/?nickname={nickname}</code>"
+        "</body>"
+      "</html>";
+
+    Action act() override {
+      return _return(controller->createResponse(Status::CODE_200, pageTemplate));
+    }
+    
+  };
+
+  ENDPOINT_ASYNC("GET", "ws/chat/{room-name}/*", WS) {
+
+    ENDPOINT_ASYNC_INIT(WS)
+
+    Action act() override {
+
+      auto roomName = request->getPathVariable("room-name");
+      auto nickname = request->getQueryParameter("nickname");
+
+      OATPP_ASSERT_HTTP(nickname, Status::CODE_400, "No nickname specified.");
+
+      /* Websocket handshake */
+      auto response = oatpp::websocket::Handshaker::serversideHandshake(request->getHeaders(), controller->websocketConnectionHandler);
+
+      auto parameters = std::make_shared<oatpp::network::server::ConnectionHandler::ParameterMap>();
+
+      (*parameters)["roomName"] = roomName;
+      (*parameters)["nickname"] = nickname;
+
+      /* Set connection upgrade params */
+      response->setConnectionUpgradeParameters(parameters);
+
+      return _return(response);
+
+    }
+
+  };
+  
+  // TODO Insert Your endpoints here !!!
+  
+/**
+ *  Finish ENDPOINTs generation ('ApiController' codegen)
+ */
+#include OATPP_CODEGEN_END(ApiController)
+  
+};
+
+#endif /* RoomsController_hpp */

async-server-rooms/src/rooms/Lobby.cpp

@@ -0,0 +1,44 @@
+
+#include "Lobby.hpp"
+
+v_int32 Lobby::obtainNewUserId() {
+  return m_userIdCounter ++;
+}
+
+std::shared_ptr<Room> Lobby::getOrCreateRoom(const oatpp::String& roomName) {
+  std::lock_guard<std::mutex> lock(m_roomsMutex);
+  std::shared_ptr<Room>& room = m_rooms[roomName];
+  if(!room) {
+    room = std::make_shared<Room>(roomName);
+  }
+  return room;
+}
+
+void Lobby::onAfterCreate_NonBlocking(const std::shared_ptr<AsyncWebSocket>& socket, const std::shared_ptr<const ParameterMap>& params) {
+
+  auto roomName = params->find("roomName")->second;
+  auto nickname = params->find("nickname")->second;
+  auto room = getOrCreateRoom(roomName);
+
+  auto peer = std::make_shared<Peer>(socket, room, nickname, obtainNewUserId());
+  socket->setListener(peer);
+
+  room->addPeer(peer);
+  room->sendMessage(nickname + " joined " + roomName);
+
+}
+
+void Lobby::onBeforeDestroy_NonBlocking(const std::shared_ptr<AsyncWebSocket>& socket) {
+
+  auto peer = std::static_pointer_cast<Peer>(socket->getListener());
+  auto nickname = peer->getNickname();
+  auto room = peer->getRoom();
+
+  room->removePeerByUserId(peer->getUserId());
+
+  room->sendMessage(nickname + " left the room");
+
+  /* Remove circle `std::shared_ptr` dependencies */
+  socket->setListener(nullptr);
+
+}

async-server-rooms/src/rooms/Lobby.hpp

@@ -0,0 +1,51 @@
+
+#ifndef ASYNC_SERVER_ROOMS_LOBBY_HPP
+#define ASYNC_SERVER_ROOMS_LOBBY_HPP
+
+#include "./Room.hpp"
+
+#include "oatpp-websocket/AsyncConnectionHandler.hpp"
+
+#include <unordered_map>
+#include <mutex>
+
+class Lobby : public oatpp::websocket::AsyncConnectionHandler::SocketInstanceListener {
+public:
+  std::atomic<v_int32> m_userIdCounter;
+  std::unordered_map<oatpp::String, std::shared_ptr<Room>> m_rooms;
+  std::mutex m_roomsMutex;
+public:
+
+  Lobby()
+    : m_userIdCounter(0)
+  {}
+
+  /**
+   * Generate id for new user
+   * @return
+   */
+  v_int32 obtainNewUserId();
+
+  /**
+   * Get room by name or create new one if not exists.
+   * @param roomName
+   * @return
+   */
+  std::shared_ptr<Room> getOrCreateRoom(const oatpp::String& roomName);
+
+public:
+
+  /**
+   *  Called when socket is created
+   */
+  void onAfterCreate_NonBlocking(const std::shared_ptr<AsyncWebSocket>& socket, const std::shared_ptr<const ParameterMap>& params) override;
+
+  /**
+   *  Called before socket instance is destroyed.
+   */
+  void onBeforeDestroy_NonBlocking(const std::shared_ptr<AsyncWebSocket>& socket) override;
+
+};
+
+
+#endif //ASYNC_SERVER_ROOMS_LOBBY_HPP