Main server application that manages client connections and camera streaming. More...

#include <app.hpp>

Public Member Functions
	App (irsol::types::port_t port)
	Constructs the App.

bool	start ()
	Starts the server.

void	stop ()
	Stops the server.

std::shared_ptr< ClientSession >	getClientSession (const irsol::types::client_id_t &clientId)
	Retrieves an active client session.

void	broadcastMessage (protocol::OutMessage &&message, const std::optional< irsol::types::client_id_t > &excludeClient=std::nullopt)
	Broadcasts a message to all connected clients.

camera::Interface &	camera ()
	Accessor for the camera interface.

frame_collector::FrameCollector &	frameCollector ()
	Accessor for the frame collector.

const handlers::MessageHandler &	messageHandler () const
	Accessor for the message handler.

Private Types
using	client_map_t = std::unordered_map< irsol::types::client_id_t, std::shared_ptr< ClientSession > >

Private Member Functions
void	addClient (const irsol::types::client_id_t &clientId, irsol::types::socket_t &&sock)
	Adds a new client session.

void	removeClient (const irsol::types::client_id_t &clientId)
	Removes a client session.

void	registerMessageHandlers ()
	Registers standard message handlers.

template<typename InMessageT , typename HandlerT , typename... Args>
void	registerMessageHandler (const std::string &identifier, Args &&... args)
	Registers a message handler by type.

template<typename InMessageT , typename LambdaT >
void	registerLambdaHandler (const std::string &identifier, std::shared_ptr< handlers::Context > ctx, LambdaT &&lambda)
	Registers a lambda-based message handler.

Private Attributes
const irsol::types::port_t	m_port
	TCP port on which the server listens.

irsol::server::internal::ClientSessionAcceptor	m_acceptor
	Acceptor that handles incoming client connections.

std::thread	m_acceptThread
	Thread running the connection acceptor loop.

std::mutex	m_clientsMutex
	Mutex for protecting access to m_clients.

client_map_t	m_clients
	Map of connected clients.

std::unique_ptr< camera::Interface >	m_cameraInterface
	Interface to the camera.

std::unique_ptr< frame_collector::FrameCollector >	m_frameCollector
	Frame collector for capturing and broadcasting camera frames.

std::unique_ptr< handlers::MessageHandler >	m_messageHandler
	Central handler for processing protocol messages.

Detailed Description

Main server application that manages client connections and camera streaming.

The App class starts the TCP server, listens for new connections, instantiates a new irsol::server::ClientSession per client, and coordinates the camera interface, frame collection, and message dispatching.

Definition at line 45 of file app.hpp.

Member Typedef Documentation

◆ client_map_t

using irsol::server::App::client_map_t = std::unordered_map<irsol::types::client_id_t, std::shared_ptr<ClientSession> >

private

Definition at line 47 of file app.hpp.

Constructor & Destructor Documentation

◆ App()

irsol::server::App::App ( irsol::types::port_t port )

explicit

Constructs the App.

Parameters

port	The TCP port on which the server will listen for client connections.

Definition at line 13 of file app.cpp.

  : m_port(port)
  , m_acceptor(
      m_port,
      std::bind(&App::addClient, this, std::placeholders::_1, std::placeholders::_2))
  , m_cameraInterface(std::make_unique<camera::Interface>(camera::Interface::HalfResolution()))
  , m_frameCollector(std::make_unique<frame_collector::FrameCollector>(*m_cameraInterface.get()))
  , m_messageHandler(std::make_unique<handlers::MessageHandler>())
{
  registerMessageHandlers();
}

Member Function Documentation

◆ addClient()

void irsol::server::App::addClient	(	const irsol::types::client_id_t &	clientId,
		irsol::types::socket_t &&	sock
	)

private

Adds a new client session.

Parameters

clientId	Unique ID for the client.
sock	TCP socket for communication with the client.

Note: The new session is started on a separate thread.

Definition at line 85 of file app.cpp.

{
  auto session = std::make_shared<ClientSession>(clientId, std::move(sock), *this);
  std::scoped_lock<std::mutex> lock(m_clientsMutex);
  IRSOL_LOG_INFO(
    "Registering new client connection from {} with id {}",
    session->socket().address().to_string(),
    clientId);
  {
    m_clients.insert({clientId, session});
    IRSOL_LOG_DEBUG(
      "Client {} added to session list, total clients: {}", clientId, m_clients.size());
  }
 
  IRSOL_LOG_INFO("Starting client session thread for client with id {}", clientId);
  std::thread([session, this]() {
    IRSOL_LOG_DEBUG("Thread for client with ID {} started", session->id());
 
    try {
      session->run();
    } catch(std::exception& e) {
      IRSOL_LOG_ERROR(
        "Error in client session thread for client with id {}: {}", session->id(), e.what());
    }
    IRSOL_LOG_DEBUG("Thread for client with ID {} finished", session->id());
    removeClient(session->id());
  })
    .detach();
}

◆ broadcastMessage()

void irsol::server::App::broadcastMessage	(	protocol::OutMessage &&	message,
		const std::optional< irsol::types::client_id_t > &	excludeClient = `std::nullopt`
	)

Broadcasts a message to all connected clients.

Parameters

message	The message to send.
excludeClient	Optional client to exclude (e.g., the sender).

This method is thread-safe and will skip the excluded client if specified.

Definition at line 61 of file app.cpp.

{
  // Serialize the message only once, and distribute to all clients
  auto serializedMessage = irsol::protocol::Serializer::serialize(std::move(message));
  IRSOL_LOG_DEBUG("Broadcasting serialized message {}", serializedMessage.toString());
  std::scoped_lock<std::mutex> lock(m_clientsMutex);
 
  for(const auto& [clientId, session] : m_clients) {
    if(excludeClient && clientId == *excludeClient) {
      continue;  // Skip the sender if specified
    }
    try {
      std::scoped_lock<std::mutex> sessionLock(session->socketMutex());
      session->handleSerializedMessage(serializedMessage);
    } catch(const std::exception& ex) {
      IRSOL_LOG_WARN("Failed to send broadcast to client {}: {}", clientId, ex.what());
    }
  }
  IRSOL_LOG_DEBUG("Broadcasting complete.");
}

◆ camera()

camera::Interface & irsol::server::App::camera ( )

inline

Accessor for the camera interface.

Returns: Reference to the owned camera interface.

Definition at line 96 of file app.hpp.

  {
    return *m_cameraInterface;
  };

◆ frameCollector()

frame_collector::FrameCollector & irsol::server::App::frameCollector ( )

inline

Accessor for the frame collector.

Returns: Reference to the owned frame collector.

Definition at line 105 of file app.hpp.

  {
    return *m_frameCollector;
  }

◆ getClientSession()

std::shared_ptr< ClientSession > irsol::server::App::getClientSession ( const irsol::types::client_id_t & clientId )

Retrieves an active client session.

Parameters

clientId The unique ID of the client.

Returns: Shared pointer to the client session, or nullptr if not found.

Definition at line 53 of file app.cpp.

{
  std::scoped_lock<std::mutex> lock(m_clientsMutex);
  auto                         it = m_clients.find(clientId);
  return it != m_clients.end() ? it->second : nullptr;
}

◆ messageHandler()

const handlers::MessageHandler & irsol::server::App::messageHandler ( ) const

inline

Accessor for the message handler.

Returns: Const reference to the owned message handler.

Definition at line 114 of file app.hpp.

  {
    return *m_messageHandler;
  }

◆ registerLambdaHandler()

template<typename InMessageT , typename LambdaT >

void irsol::server::App::registerLambdaHandler	(	const std::string &	identifier,
		std::shared_ptr< handlers::Context >	ctx,
		LambdaT &&	lambda
	)

inlineprivate

Registers a lambda-based message handler.

Template Parameters

InMessageT	Incoming message type.
LambdaT	Type of the lambda handler.

Parameters

identifier	Handler identifier.
ctx	Handler context.
lambda	Lambda function to invoke for the message.

Example:

registerLambdaHandler<protocol::Command>(
  "custom_cmd",
  ctx,
  [](std::shared_ptr<handlers::Context> ctx, const irsol::types::client_id_t& clientId,
protocol::Command&& cmd) { return std::vector<protocol::OutMessage>{...};
  }
);

Definition at line 213 of file app.hpp.

  {
    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 + "'");
    }
  }

◆ registerMessageHandler()

template<typename InMessageT , typename HandlerT , typename... Args>

void irsol::server::App::registerMessageHandler	(	const std::string &	identifier,
		Args &&...	args
	)

inlineprivate

Registers a message handler by type.

Template Parameters

InMessageT	Incoming message type.
HandlerT	Handler class for the message.
Args	Constructor arguments for the handler.

Parameters

identifier	Message handler identifier string.
args	Arguments to construct the handler.

Example:

registerMessageHandler<protocol::Command, handlers::CommandFRHandler>("fr", ctx);

Definition at line 182 of file app.hpp.

  {
    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 + "'");
    }
  }

◆ registerMessageHandlers()

void irsol::server::App::registerMessageHandlers ( )

private

Registers standard message handlers.

Sets up the message handler registry with known message-handler mappings.

Definition at line 132 of file app.cpp.

{
  // Build a context to pass to all handlers
  auto ctx = std::make_shared<irsol::server::handlers::Context>(*this);
 
  // Register message handlers for specific message types
  registerMessageHandler<protocol::Inquiry, handlers::InquiryFrameRateHandler>("fr", ctx);
  registerMessageHandler<protocol::Assignment, handlers::AssignmentFrameRateHandler>("fr", ctx);
  registerMessageHandler<protocol::Assignment, handlers::AssignmentInputSequenceLengthHandler>(
    "isl", ctx);
  registerMessageHandler<protocol::Assignment, handlers::AssignmentIntegrationTimeHandler>(
    "it", ctx);
  registerMessageHandler<protocol::Inquiry, handlers::InquiryIntegrationTimeHandler>("it", ctx);
  registerMessageHandler<protocol::Inquiry, handlers::InquiryInputSequenceLengthHandler>(
    "isl", ctx);
  registerMessageHandler<protocol::Command, handlers::CommandAbortHandler>("abort", ctx);
  registerMessageHandler<protocol::Command, handlers::CommandGIHandler>("gi", ctx);
  registerMessageHandler<protocol::Command, handlers::CommandGISHandler>("gis", ctx);
  registerMessageHandler<protocol::Inquiry, handlers::InquiryImgLeftHandler>("img_l", ctx);
  registerMessageHandler<protocol::Inquiry, handlers::InquiryImgTopHandler>("img_t", ctx);
  registerMessageHandler<protocol::Inquiry, handlers::InquiryImgWidthHandler>("img_w", ctx);
  registerMessageHandler<protocol::Inquiry, handlers::InquiryImgHeightHandler>("img_h", ctx);
  registerMessageHandler<protocol::Assignment, handlers::AssignmentImgLeftHandler>("img_l", ctx);
  registerMessageHandler<protocol::Assignment, handlers::AssignmentImgTopHandler>("img_t", ctx);
  registerMessageHandler<protocol::Assignment, handlers::AssignmentImgWidthHandler>("img_w", ctx);
  registerMessageHandler<protocol::Assignment, handlers::AssignmentImgHeightHandler>("img_h", ctx);
 
  registerLambdaHandler<protocol::Command>(
    "image_data",
    ctx,
    [](
      std::shared_ptr<handlers::Context>            ctx,
      std::shared_ptr<irsol::server::ClientSession> client,
      protocol::Command&&                           cmd) -> std::vector<protocol::OutMessage> {
      std::vector<protocol::OutMessage> result;
      auto&                             cam = ctx->app.camera();
      auto                              img = cam.captureImage(std::chrono::milliseconds(10000));
 
      if(img.IsEmpty()) {
        IRSOL_NAMED_LOG_ERROR(client->id(), "Failed to capture image.");
        result.emplace_back(irsol::protocol::Error::from(cmd, "Failed to capture image"));
        return result;
      }
 
      uint32_t width    = static_cast<uint32_t>(img.GetWidth());
      uint32_t height   = static_cast<uint32_t>(img.GetHeight());
      size_t   dataSize = img.GetSize();
 
      const void*                       imageBuffer = img.GetImageData();
      std::vector<irsol::types::byte_t> rawData(dataSize);
      memcpy(rawData.data(), imageBuffer, dataSize);
 
      result.emplace_back(
        irsol::protocol::ImageBinaryData(std::move(rawData), {height, width}, {}));
      return result;
    });
}

◆ removeClient()

void irsol::server::App::removeClient ( const irsol::types::client_id_t & clientId )

private

Removes a client session.

Parameters

clientId ID of the client to disconnect and clean up.

This is typically called automatically when the client disconnects or times out.

Definition at line 116 of file app.cpp.

{
  std::scoped_lock<std::mutex> lock(m_clientsMutex);
  auto                         clientIt = m_clients.find(clientId);
  if(clientIt == m_clients.end()) {
    IRSOL_LOG_ERROR("Client '{}' not found in session list", clientId);
  } else {
    auto client = clientIt->second;
    m_frameCollector->deregisterClient(client->id());
    m_clients.erase(clientIt);
    IRSOL_LOG_DEBUG(
      "Client {} removed from session list, remaining clients: {}", clientId, m_clients.size());
  }
}

◆ start()

bool irsol::server::App::start ( )

Starts the server.

Returns: True if the server starts successfully, false otherwise.

This starts the acceptor thread, initializes camera and message handlers, and prepares the system for client interaction.

Definition at line 26 of file app.cpp.

{
  if(!m_acceptor.isOpen()) {
    IRSOL_LOG_ERROR("Failed to open acceptor on port {}: {}", m_port, m_acceptor.error());
    return false;
  }
  IRSOL_LOG_DEBUG("Starting accept thread");
  m_acceptThread = std::thread(&internal::ClientSessionAcceptor::run, &m_acceptor);
  IRSOL_LOG_INFO("Server started successfully");
  return true;
}

◆ stop()

void irsol::server::App::stop ( )

Stops the server.

Gracefully shuts down client sessions, stops the frame collector, and joins the acceptor thread.

Definition at line 39 of file app.cpp.

{
  IRSOL_LOG_INFO("Stopping server");
  m_acceptor.stop();
 
  if(m_acceptThread.joinable()) {
    IRSOL_LOG_DEBUG("Joining accept thread");
    m_acceptThread.join();
  }
  m_frameCollector->stop();
  IRSOL_LOG_INFO("Server stopped");
}

Member Data Documentation

◆ m_acceptor

irsol::server::internal::ClientSessionAcceptor irsol::server::App::m_acceptor

private

Acceptor that handles incoming client connections.

Definition at line 124 of file app.hpp.

◆ m_acceptThread

std::thread irsol::server::App::m_acceptThread

private

Thread running the connection acceptor loop.

Definition at line 127 of file app.hpp.

◆ m_cameraInterface

std::unique_ptr<camera::Interface> irsol::server::App::m_cameraInterface

private

Interface to the camera.

Definition at line 136 of file app.hpp.

◆ m_clients

client_map_t irsol::server::App::m_clients

private

Map of connected clients.

Definition at line 133 of file app.hpp.

◆ m_clientsMutex

std::mutex irsol::server::App::m_clientsMutex

private

Mutex for protecting access to m_clients.

Definition at line 130 of file app.hpp.

◆ m_frameCollector

std::unique_ptr<frame_collector::FrameCollector> irsol::server::App::m_frameCollector

private

Frame collector for capturing and broadcasting camera frames.

Definition at line 139 of file app.hpp.

◆ m_messageHandler

std::unique_ptr<handlers::MessageHandler> irsol::server::App::m_messageHandler

private

Central handler for processing protocol messages.

Definition at line 142 of file app.hpp.

◆ m_port

const irsol::types::port_t irsol::server::App::m_port

private

TCP port on which the server listens.

Definition at line 121 of file app.hpp.

The documentation for this class was generated from the following files:

src/irsol/include/irsol/server/app.hpp
src/irsol/lib/irsol/server/app.cpp

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ client_map_t

Constructor & Destructor Documentation

◆ App()

Member Function Documentation

◆ addClient()

◆ broadcastMessage()

◆ camera()

◆ frameCollector()

◆ getClientSession()

◆ messageHandler()

◆ registerLambdaHandler()

◆ registerMessageHandler()

◆ registerMessageHandlers()

◆ removeClient()

◆ start()

◆ stop()

Member Data Documentation

◆ m_acceptor

◆ m_acceptThread

◆ m_cameraInterface

◆ m_clients

◆ m_clientsMutex

◆ m_frameCollector

◆ m_messageHandler

◆ m_port