Represents a single connected client session. More...

#include <session.hpp>

Public Member Functions
	ClientSession (const irsol::types::client_id_t &id, irsol::types::socket_t &&sock, App &app)
	Constructs a new ClientSession.

void	run ()
	Starts the client's session logic.

void	handleOutMessages (std::vector< protocol::OutMessage > &&messages)
	Handles multiple outbound messages to the client.

void	handleOutMessage (protocol::OutMessage &&message)
	Handles a single outbound message to the client.

void	handleSerializedMessage (const protocol::internal::SerializedMessage &serializedMessage)
	Sends an already-serialized message to the client.

const App &	app () const
	Returns a const reference to the owning App instance.

App &	app ()
	Returns a mutable reference to the owning App instance.

const irsol::types::client_id_t &	id () const
	Returns the unique client identifier.

const irsol::types::socket_t &	socket () const
	Returns a const reference to the client socket.

irsol::types::socket_t &	socket ()
	Returns a mutable reference to the client socket.

std::mutex &	socketMutex ()
	Returns a reference to the socket mutex used for synchronization.

const irsol::server::internal::UserSessionData &	userData () const
	Returns a const reference to client-specific session state.

irsol::server::internal::UserSessionData &	userData ()
	Returns a mutable reference to client-specific session state.

Private Member Functions
void	processInMessageBuffer (std::string &messageBuffer)
	Processes accumulated raw data into complete protocol messages.

void	processInRawMessage (const std::string &rawMessage)
	Parses and processes a complete incoming raw message.

void	send (const std::string &message)
	Sends a text message over the socket to the client.

void	send (const irsol::types::byte_t *const data, size_t size)
	Sends binary data over the socket.

Private Attributes
irsol::types::client_id_t	m_id
	Unique ID identifying this session (maps to client_id_t).

irsol::types::socket_t	m_socket
	Socket used for communication with the client.

std::mutex	m_socketMutex {}
	Mutex to synchronize socket access from multiple threads.

irsol::server::internal::UserSessionData	m_sessionData {}
	Session-specific data (e.g., stream rate, frame subscriptions).

App &	m_app
	Reference to the central App instance for server-wide coordination.

Detailed Description

Represents a single connected client session.

Each instance of ClientSession corresponds to exactly one connected client. It owns the socket connection, manages message transmission and reception, and encapsulates session-specific state (e.g., frame stream preferences).

The class is responsible for all communication with the client: reading inbound messages from the socket, parsing and dispatching them, and sending outbound messages. All session-specific state is stored here, including a irsol::server::internal::UserSessionData structure.

In addition, the session holds a reference to the central irsol::server::App instance, which enables it to interact with the global server context (e.g., for broadcasting).

Definition at line 43 of file session.hpp.

Constructor & Destructor Documentation

◆ ClientSession()

irsol::server::ClientSession::ClientSession	(	const irsol::types::client_id_t &	id,
		irsol::types::socket_t &&	sock,
		App &	app
	)

Constructs a new ClientSession.

Parameters

id	Unique client identifier (e.g., UUID or socket-derived).
sock	Already-established TCP socket to the client.
app	Reference to the server application instance.

Definition at line 16 of file session.cpp.

17 : m_id(id), m_socket(std::move(sock)), m_app(app)

18{}

irsol::server::ClientSession::m_socket

irsol::types::socket_t m_socket

Socket used for communication with the client.

Definition session.hpp:198

irsol::server::ClientSession::m_id

irsol::types::client_id_t m_id

Unique ID identifying this session (maps to client_id_t).

Definition session.hpp:195

irsol::server::ClientSession::app

const App & app() const

Returns a const reference to the owning App instance.

Definition session.hpp:104

irsol::server::ClientSession::m_app

App & m_app

Reference to the central App instance for server-wide coordination.

Definition session.hpp:207

Member Function Documentation

◆ app() [1/2]

App & irsol::server::ClientSession::app ( )

inline

Returns a mutable reference to the owning App instance.

Definition at line 110 of file session.hpp.

  {
    return m_app;
  }

◆ app() [2/2]

const App & irsol::server::ClientSession::app ( ) const

inline

Returns a const reference to the owning App instance.

Definition at line 104 of file session.hpp.

  {
    return m_app;
  }

◆ handleOutMessage()

void irsol::server::ClientSession::handleOutMessage ( protocol::OutMessage && message )

Handles a single outbound message to the client.

Serializes and sends one message through the socket.

Note: This method is not thread-safe; users must ensure mutual exclusion externally.

See also: irsol::protocol::Serializer; ClientSession::send

Parameters

message The message to transmit.

Definition at line 77 of file session.cpp.

{
  IRSOL_NAMED_LOG_DEBUG(m_id, "Serializing message: '{}'", irsol::protocol::toString(message));
  auto serializedMessage = irsol::protocol::Serializer::serialize(std::move(message));
  IRSOL_NAMED_LOG_DEBUG(m_id, "Serialized message: '{}'", serializedMessage.toString());
 
  handleSerializedMessage(serializedMessage);
}

◆ handleOutMessages()

void irsol::server::ClientSession::handleOutMessages ( std::vector< protocol::OutMessage > && messages )

Handles multiple outbound messages to the client.

Serializes and sends a vector of outbound messages through the socket.

Note: This method is not thread-safe; users must ensure mutual exclusion externally.

See also: irsol::protocol::Serializer; ClientSession::send

Parameters

messages The list of messages to transmit.

Definition at line 68 of file session.cpp.

{
  IRSOL_NAMED_LOG_DEBUG(m_id, "Serializing {} messages", messages.size());
  for(auto& message : messages) {
    handleOutMessage(std::move(message));
  }
}

◆ handleSerializedMessage()

void irsol::server::ClientSession::handleSerializedMessage ( const protocol::internal::SerializedMessage & serializedMessage )

Sends an already-serialized message to the client.

Note: This method is not thread-safe; users must ensure mutual exclusion externally.

See also: irsol::protocol::Serializer; ClientSession::send

Parameters

serializedMessage Message that is already serialized to text or binary form.

Definition at line 87 of file session.cpp.

{
  // Send the serialized message to the client
  if(serializedMessage.hasHeader()) {
    send(serializedMessage.header);
  }
  if(serializedMessage.hasPayload()) {
    send(serializedMessage.payload.data(), serializedMessage.payloadSize());
  }
}

◆ id()

const irsol::types::client_id_t & irsol::server::ClientSession::id ( ) const

inline

Returns the unique client identifier.

Definition at line 116 of file session.hpp.

  {
    return m_id;
  }

◆ processInMessageBuffer()

void irsol::server::ClientSession::processInMessageBuffer ( std::string & messageBuffer )

private

Processes accumulated raw data into complete protocol messages.

Splits the incoming input buffer into individual protocol messages and dispatches each one for parsing and handling.

Invokes ClientSession::processInRawMessage.

Parameters

messageBuffer Text buffer containing raw data received from the client's socket.

Definition at line 100 of file session.cpp.

{
  size_t newlinePos;
 
  // Process all complete messages (ending with newline)
  while((newlinePos = messageBuffer.find('\n')) != std::string::npos) {
    // Extract the complete message
    std::string rawMessage = messageBuffer.substr(0, newlinePos);
 
    // Remove the processed message from the buffer
    messageBuffer.erase(0, newlinePos + 1);
 
    // Process the extracted message
    processInRawMessage(rawMessage);
  }
}

◆ processInRawMessage()

void irsol::server::ClientSession::processInRawMessage ( const std::string & rawMessage )

private

Parses and processes a complete incoming raw message.

Invokes the registered message handler for the message type.

Parameters

rawMessage Complete raw protocol message string.

Definition at line 118 of file session.cpp.

{
  IRSOL_NAMED_LOG_DEBUG(m_id, "Processing raw message: '{}'", rawMessage);
 
  // Strip the prefix 'bypass ' from the message
  std::string processedMessage = utils::stripString(rawMessage, "bypass ");
 
  // Extract the parsed message
  std::optional<irsol::protocol::InMessage> optionalParsedMessage =
    irsol::protocol::Parser::parse(processedMessage);
  if(!optionalParsedMessage) {
    IRSOL_NAMED_LOG_ERROR(m_id, "Failed to parse message: '{}'", rawMessage);
    // TODO: ability to create error message without identifier for failed parsing
    // handleOutMessage(irsol::protocol::Error());
    return;
  }
 
  // Extract the InMessage from the optional wrapper and submit it the the message handler
  auto result = app().messageHandler().handle(m_id, std::move(*optionalParsedMessage));
  IRSOL_NAMED_LOG_DEBUG(m_id, "Received {} response(s)", result.size());
 
  // lock the session's mutex to prevent race conditions
  std::scoped_lock<std::mutex> lock(m_socketMutex);
  for(auto& message : result) {
    handleOutMessage(std::move(message));
  }
  IRSOL_NAMED_LOG_DEBUG(m_id, "Sent {} response(s) to client", result.size());
}

◆ run()

void irsol::server::ClientSession::run ( )

Starts the client's session logic.

Initiates the processing loop for the session, including reading incoming messages from the socket and handling disconnections.

Definition at line 21 of file session.cpp.

{
  constexpr size_t  INITIAL_BUFFER_SIZE = 1024;
  std::vector<char> buffer(INITIAL_BUFFER_SIZE);
  std::string       messageBuffer;
 
  IRSOL_NAMED_LOG_DEBUG(m_id, "Client session started running");
 
  while(true) {
    // Read data from socket
    auto readResult = m_socket.read(buffer.data(), buffer.size());
 
    // Handle read errors or connection closure
    if(!readResult) {
      IRSOL_NAMED_LOG_ERROR(m_id, "Socket read error: {}", readResult.error().message());
      break;
    }
 
    size_t bytesRead = readResult.value();
    if(bytesRead == 0) {
      IRSOL_NAMED_LOG_INFO(m_id, "Connection closed by client");
      break;
    }
 
    // Append received data to message buffer
    messageBuffer.append(buffer.data(), bytesRead);
    IRSOL_NAMED_LOG_TRACE(
      m_id,
      "Read {} bytes: '{}'",
      bytesRead,
      messageBuffer.substr(messageBuffer.size() - bytesRead));
 
    // Process all complete messages in the buffer
    processInMessageBuffer(messageBuffer);
 
    // Dynamically resize buffer if it was filled completely
    if(bytesRead == buffer.size()) {
      IRSOL_NAMED_LOG_DEBUG(m_id, "Increasing buffer size to {}", buffer.size());
      buffer.resize(buffer.size() * 2);
    }
  }
 
  m_socket.close();
  IRSOL_NAMED_LOG_INFO(m_id, "Client session terminated");
}

◆ send() [1/2]

void irsol::server::ClientSession::send	(	const irsol::types::byte_t *const	data,
		size_t	size
	)

private

Sends binary data over the socket.

Warning: This function is not thread-safe. Caller must lock m_socketMutex.

Parameters

data	Pointer to binary data buffer.
size	Size of the data in bytes.

Definition at line 169 of file session.cpp.

{
  IRSOL_NAMED_LOG_TRACE(m_id, "Sending binary data of size {}", size);
  if(!m_socket) {
    IRSOL_NAMED_LOG_ERROR(
      m_id, "Socket seems to be closed, this is unexpected. Ignoring send request.");
    return;
  }
 
  auto result = m_socket.write_n(data, size);
  if(!result) {
    IRSOL_NAMED_LOG_ERROR(m_id, "Failed to send binary data: {}", result.error().message());
  } else if(result.value() != size) {
    IRSOL_NAMED_LOG_WARN(m_id, "Incomplete binary data sent: {} of {} bytes", result.value(), size);
  }
}

◆ send() [2/2]

void irsol::server::ClientSession::send ( const std::string & message )

private

Sends a text message over the socket to the client.

This is the way the server communicates to the client.

Warning: This function is not thread-safe. Caller must lock m_socketMutex.

Parameters

message The message string to send.

Definition at line 148 of file session.cpp.

{
  std::string preparedMessage = msg;
 
  IRSOL_NAMED_LOG_TRACE(m_id, "Sending message of size {}", preparedMessage.size());
  if(!m_socket) {
    IRSOL_NAMED_LOG_ERROR(
      m_id, "Socket seems to be closed, this is unexpected. Ignoring send request.");
    return;
  }
 
  auto result = m_socket.write(preparedMessage);
  if(!result) {
    IRSOL_NAMED_LOG_ERROR(m_id, "Failed to send message: {}", result.error().message());
  } else if(result.value() != preparedMessage.size()) {
    IRSOL_NAMED_LOG_WARN(
      m_id, "Incomplete message sent: {} of {} bytes", result.value(), preparedMessage.size());
  }
}

◆ socket() [1/2]

irsol::types::socket_t & irsol::server::ClientSession::socket ( )

inline

Returns a mutable reference to the client socket.

Definition at line 128 of file session.hpp.

  {
    return m_socket;
  }

◆ socket() [2/2]

const irsol::types::socket_t & irsol::server::ClientSession::socket ( ) const

inline

Returns a const reference to the client socket.

Definition at line 122 of file session.hpp.

  {
    return m_socket;
  }

◆ socketMutex()

std::mutex & irsol::server::ClientSession::socketMutex ( )

inline

Returns a reference to the socket mutex used for synchronization.

Definition at line 134 of file session.hpp.

  {
    return m_socketMutex;
  }

◆ userData() [1/2]

irsol::server::internal::UserSessionData & irsol::server::ClientSession::userData ( )

inline

Returns a mutable reference to client-specific session state.

Definition at line 146 of file session.hpp.

  {
    return m_sessionData;
  }

◆ userData() [2/2]

const irsol::server::internal::UserSessionData & irsol::server::ClientSession::userData ( ) const

inline

Returns a const reference to client-specific session state.

Definition at line 140 of file session.hpp.

  {
    return m_sessionData;
  }

Member Data Documentation

◆ m_app

App& irsol::server::ClientSession::m_app

private

Reference to the central App instance for server-wide coordination.

Definition at line 207 of file session.hpp.

◆ m_id

irsol::types::client_id_t irsol::server::ClientSession::m_id

private

Unique ID identifying this session (maps to client_id_t).

Definition at line 195 of file session.hpp.

◆ m_sessionData

irsol::server::internal::UserSessionData irsol::server::ClientSession::m_sessionData {}

private

Session-specific data (e.g., stream rate, frame subscriptions).

Definition at line 204 of file session.hpp.

204{};

◆ m_socket

irsol::types::socket_t irsol::server::ClientSession::m_socket

private

Socket used for communication with the client.

Definition at line 198 of file session.hpp.

◆ m_socketMutex

std::mutex irsol::server::ClientSession::m_socketMutex {}

private

Mutex to synchronize socket access from multiple threads.

Definition at line 201 of file session.hpp.

201{};

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

src/irsol/include/irsol/server/client/session.hpp
src/irsol/lib/irsol/server/client/session.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ClientSession()

Member Function Documentation

◆ app() [1/2]

◆ app() [2/2]

◆ handleOutMessage()

◆ handleOutMessages()

◆ handleSerializedMessage()

◆ id()

◆ processInMessageBuffer()

◆ processInRawMessage()

◆ run()

◆ send() [1/2]

◆ send() [2/2]

◆ socket() [1/2]

◆ socket() [2/2]

◆ socketMutex()

◆ userData() [1/2]

◆ userData() [2/2]

Member Data Documentation

◆ m_app

◆ m_id

◆ m_sessionData

◆ m_socket

◆ m_socketMutex