irsol::server::internal::ClientSessionAcceptor Class Reference

Accepts incoming TCP connections and triggers a callback for each new client. More...

#include <acceptor.hpp>

Public Member Functions
	ClientSessionAcceptor (irsol::types::port_t port, OnNewClientCallback_t onNewClientCallback)
	Constructs the acceptor.
void	run ()
	Starts the accept loop.
void	stop ()
	Stops the accept loop.
std::string	error () const
	Gets the current error message, if any.
bool	isOpen () const
	Checks if the acceptor is actively listening.

Private Attributes
std::atomic< bool >	m_running {false}
	Flag indicating whether the acceptor should continue running.
const irsol::types::port_t	m_port
	Port on which to accept incoming TCP connections.
OnNewClientCallback_t	m_onNewClientCallback
	Callback to handle accepted client connections.
irsol::types::acceptor_t	m_acceptor
	TCP acceptor socket bound to m_port.
irsol::types::connection_result_t	m_isOpen {}
	Result of attempting to bind and open the acceptor socket.

Detailed Description

Accepts incoming TCP connections and triggers a callback for each new client.

The ClientSessionAcceptor listens on a given TCP port and forwards each accepted socket to the provided callback, enabling session initialization for each client.

Definition at line 48 of file acceptor.hpp.

Constructor & Destructor Documentation

ClientSessionAcceptor()

irsol::server::internal::ClientSessionAcceptor::ClientSessionAcceptor	(	irsol::types::port_t	port,
		OnNewClientCallback_t	onNewClientCallback
	)

Constructs the acceptor.

Parameters

port	TCP port to bind and listen on.
onNewClientCallback	Function to call when a new client connects.

Definition at line 11 of file acceptor.cpp.

  : m_port(port), m_onNewClientCallback(onNewClientCallback)
{
  m_isOpen = m_acceptor.open(irsol::types::inet_address_t(m_port));
}

Member Function Documentation

error()

std::string irsol::server::internal::ClientSessionAcceptor::error

(

)

const

Gets the current error message, if any.

Returns

A string describing the most recent error that might have been raised while trying to bind to the TCP port.

Exceptions

irsol::AssertionException

in case the acceptor it not in error mode.

Definition at line 20 of file acceptor.cpp.

{
  IRSOL_ASSERT_ERROR(!isOpen(), "Acceptor is not in error mode");
  return m_isOpen.error().message();
}

isOpen()

bool irsol::server::internal::ClientSessionAcceptor::isOpen

(

)

const

Checks if the acceptor is actively listening.

Returns

True if the socket is open and accepting connections.

Definition at line 27 of file acceptor.cpp.

{
  return bool(m_isOpen);
}

run()

void irsol::server::internal::ClientSessionAcceptor::run

(

)

Starts the accept loop.

This method enters a blocking loop accepting client connections and invoking the callback for each. It is typically run in a dedicated thread.

Definition at line 44 of file acceptor.cpp.

{
  if(!isOpen()) {
    IRSOL_LOG_ERROR("Failed to open acceptor on port {}: {}", m_port, error());
    throw std::runtime_error("Failed to open acceptor");
  }
  if(m_running) {
    IRSOL_LOG_ERROR("Accept loop already running");
    return;
  }
  m_running.store(true);
 
  IRSOL_LOG_INFO("Accept loop started");
  while(m_running) {
 
    // Set non-blocking mode to avoid blocking indefinitely on accept
    m_acceptor.set_non_blocking(true);
 
    auto sockResult = m_acceptor.accept();
 
    // Check if we should exit the loop
    if(!m_running) {
      IRSOL_LOG_DEBUG("Accept loop stopped");
      break;
    }
 
    if(!sockResult) {
      if(m_running) {
        sockpp::error_code err{sockResult.error()};
        // These errors are expected in non-blocking mode when no connection is available
        bool isExpectedError =
          (err == std::errc::resource_unavailable_try_again ||
           err == std::errc::operation_would_block || err == std::errc::timed_out);
 
        if(isExpectedError) {
          // Sleep for a short time to avoid busy waiting when no connections are available
          std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        } else {
          // Log unexpected errors
          IRSOL_LOG_WARN("Failed to accept connection: {}", sockResult.error_message());
        }
      }
      continue;
    }
 
    // Generate a unique ID for this client session
    irsol::types::client_id_t clientId = irsol::utils::uuid();
    IRSOL_LOG_DEBUG("Generated client ID: {}", clientId);
    m_onNewClientCallback(clientId, sockResult.release());
  }
  IRSOL_LOG_INFO("Accept loop ended");
}

stop()

void irsol::server::internal::ClientSessionAcceptor::stop

(

)

Stops the accept loop.

Calling this method will cause run() to return and stop accepting new connections.

Definition at line 33 of file acceptor.cpp.

{
  if(!m_running) {
    IRSOL_LOG_DEBUG("Accept loop already stopped");
    return;
  }
  m_running.store(false);
  m_acceptor.close();
}

Member Data Documentation

m_acceptor

irsol::types::acceptor_t irsol::server::internal::ClientSessionAcceptor::m_acceptor

private

TCP acceptor socket bound to m_port.

Definition at line 108 of file acceptor.hpp.

m_isOpen

irsol::types::connection_result_t irsol::server::internal::ClientSessionAcceptor::m_isOpen {}

private

Result of attempting to bind and open the acceptor socket.

Definition at line 113 of file acceptor.hpp.

{};

m_onNewClientCallback

OnNewClientCallback_t irsol::server::internal::ClientSessionAcceptor::m_onNewClientCallback

private

Callback to handle accepted client connections.

Definition at line 103 of file acceptor.hpp.

m_port

const irsol::types::port_t irsol::server::internal::ClientSessionAcceptor::m_port

private

Port on which to accept incoming TCP connections.

Definition at line 98 of file acceptor.hpp.

m_running

std::atomic<bool> irsol::server::internal::ClientSessionAcceptor::m_running {false}

private

Flag indicating whether the acceptor should continue running.

Note

This is usually set by the irsol::server::App (or the main thread that manages the acceptor thread) for shut-down operations.

Definition at line 93 of file acceptor.hpp.

{false};

---

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

• src/irsol/include/irsol/server/acceptor.hpp
• src/irsol/lib/irsol/server/acceptor.cpp