app.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "irsol/camera/interface.hpp"
#include "irsol/server/acceptor.hpp"
#include "irsol/server/client.hpp"
#include "irsol/server/handlers/factory.hpp"
#include "irsol/server/image_collector.hpp"
#include "irsol/server/message_handler.hpp"
#include "irsol/types.hpp"
 
#include <atomic>
#include <mutex>
#include <thread>
#include <unordered_map>
 
namespace irsol {
namespace server {
 
// Forward declaration
class ClientSession;
 
class App
{
  using client_map_t =
    std::unordered_map<irsol::types::client_id_t, std::shared_ptr<ClientSession>>;
 
public:
  explicit App(irsol::types::port_t port);
 
  bool start();
 
  void stop();
 
  std::shared_ptr<ClientSession> getClientSession(const irsol::types::client_id_t& clientId);
 
  void broadcastMessage(
    protocol::OutMessage&&                          message,
    const std::optional<irsol::types::client_id_t>& excludeClient = std::nullopt);
 
  camera::Interface& camera()
  {
    return *m_cameraInterface;
  };
 
  frame_collector::FrameCollector& frameCollector()
  {
    return *m_frameCollector;
  }
 
  const handlers::MessageHandler& messageHandler() const
  {
    return *m_messageHandler;
  }
 
private:
  const irsol::types::port_t m_port;
 
  irsol::server::internal::ClientSessionAcceptor m_acceptor;
 
  std::thread m_acceptThread;
 
  std::mutex m_clientsMutex;
 
  client_map_t m_clients;
 
  std::unique_ptr<camera::Interface> m_cameraInterface;
 
  std::unique_ptr<frame_collector::FrameCollector> m_frameCollector;
 
  std::unique_ptr<handlers::MessageHandler> m_messageHandler;
 
  void addClient(const irsol::types::client_id_t& clientId, irsol::types::socket_t&& sock);
 
  void removeClient(const irsol::types::client_id_t& clientId);
 
  void registerMessageHandlers();
 
  template<typename InMessageT, typename HandlerT, typename... Args>
  void registerMessageHandler(const std::string& identifier, Args&&... args)
  {
    auto  handler        = handlers::makeHandler<HandlerT>(std::forward<Args>(args)...);
    auto& messageHandler = *m_messageHandler;
 
    if(!messageHandler.template registerHandler<InMessageT>(identifier, handler)) {
      IRSOL_LOG_FATAL("Failed to register handler for identifier {}", identifier);
      throw std::runtime_error("Failed to register handler for identifier '" + identifier + "'");
    }
  }
 
  template<typename InMessageT, typename LambdaT>
  void registerLambdaHandler(
    const std::string&                 identifier,
    std::shared_ptr<handlers::Context> ctx,
    LambdaT&&                          lambda)
  {
    auto  handler = handlers::makeLambdaHandler<InMessageT>(ctx, std::forward<LambdaT>(lambda));
    auto& messageHandler = *m_messageHandler;
 
    if(!messageHandler.template registerHandler<InMessageT>(identifier, handler)) {
      IRSOL_LOG_FATAL("Failed to register lambda handler for identifier {}", identifier);
      throw std::runtime_error(
        "Failed to register lambda handler for identifier '" + identifier + "'");
    }
  }
};
 
}  // namespace server
}  // namespace irsol