kcenon::pacs::network::detail::accept_worker Class Reference

#include <accept_worker.h>

Inheritance diagram for kcenon::pacs::network::detail::accept_worker:

Collaboration diagram for kcenon::pacs::network::detail::accept_worker:

Public Types
using	result_void = common::VoidResult
using	connection_callback = std::function<void(uint64_t session_id)>
	Callback type for new connection events.
using	maintenance_callback = std::function<void()>
	Callback type for periodic maintenance tasks.

Public Member Functions
	accept_worker (uint16_t port, connection_callback on_connection, maintenance_callback on_maintenance=nullptr)
	Constructs an accept_worker with the specified configuration.
	~accept_worker () override
	Destructor.
	accept_worker (const accept_worker &)=delete
accept_worker &	operator= (const accept_worker &)=delete
	accept_worker (accept_worker &&)=delete
accept_worker &	operator= (accept_worker &&)=delete
void	set_max_pending_connections (int backlog)
	Sets the maximum number of pending connections in the listen queue.
uint16_t	port () const noexcept
	Gets the configured port number.
int	max_pending_connections () const noexcept
	Gets the current backlog setting.
bool	is_accepting () const noexcept
	Checks if the worker is actively accepting connections.
std::string	to_string () const override
	Gets a string representation of the worker state.

Protected Member Functions
result_void	before_start () override
	Initializes resources before the worker thread starts.
result_void	do_work () override
	Main work routine - checks for incoming connections.
result_void	after_stop () override
	Cleans up resources after the worker thread stops.
bool	should_continue_work () const override
	Determines whether there is pending work that must complete.
void	on_stop_requested () override
	Called when stop() is requested.

Private Member Functions
uint64_t	next_session_id ()
	Generates a unique session ID for new connections.

Private Attributes
uint16_t	port_
	TCP port to listen on.
connection_callback	on_connection_
	Callback for new connections.
maintenance_callback	on_maintenance_
	Optional callback for maintenance tasks.
int	backlog_ {128}
	Maximum pending connections in listen queue.
std::atomic< uint64_t >	session_id_counter_ {0}
	Session ID counter for unique connection identification.
std::atomic< bool >	accepting_ {false}
	Flag indicating if actively accepting connections.
int	listen_socket_ {-1}
	Listen socket file descriptor (POSIX)

Detailed Description

Definition at line 80 of file accept_worker.h.

Member Typedef Documentation

connection_callback

using kcenon::pacs::network::detail::accept_worker::connection_callback = std::function<void(uint64_t session_id)>

Callback type for new connection events.

Parameters

session_id

Unique identifier for the new session

Definition at line 90 of file accept_worker.h.

maintenance_callback

using kcenon::pacs::network::detail::accept_worker::maintenance_callback = std::function<void()>

Callback type for periodic maintenance tasks.

Definition at line 93 of file accept_worker.h.

result_void

using kcenon::pacs::network::detail::accept_worker::result_void = common::VoidResult

Definition at line 86 of file accept_worker.h.

Constructor & Destructor Documentation

accept_worker() [1/3]

kcenon::pacs::network::detail::accept_worker::accept_worker ( uint16_t port, connection_callback on_connection, maintenance_callback on_maintenance = nullptr )

explicit

Constructs an accept_worker with the specified configuration.

Parameters

port	The TCP port to listen on for incoming connections
on_connection	Callback invoked when a new connection is accepted
on_maintenance	Optional callback for periodic maintenance tasks (e.g., idle timeout checks)

Note

The on_connection callback is invoked from the worker thread. Implementations must be thread-safe.

Definition at line 28 of file accept_worker.cpp.

    : thread_base("accept_worker")
    , port_(port)
    , on_connection_(std::move(on_connection))
    , on_maintenance_(std::move(on_maintenance)) {
}

~accept_worker()

kcenon::pacs::network::detail::accept_worker::~accept_worker ( )

override

Destructor.

Ensures graceful shutdown by calling stop() if still running.

Definition at line 38 of file accept_worker.cpp.

                              {
    // Ensure graceful shutdown if still running
    if (is_running()) {
        stop();
    }
}

accept_worker() [2/3]

kcenon::pacs::network::detail::accept_worker::accept_worker ( const accept_worker & )

delete

accept_worker() [3/3]

kcenon::pacs::network::detail::accept_worker::accept_worker ( accept_worker && )

delete

Member Function Documentation

after_stop()

accept_worker::result_void kcenon::pacs::network::detail::accept_worker::after_stop ( )

overrideprotected

Cleans up resources after the worker thread stops.

Currently a placeholder. Will close TCP acceptor when network_system integration is complete.

Returns

Success or error with description

Definition at line 276 of file accept_worker.cpp.

                                                   {
    // Clean up resources after the accept loop stops
 
    accepting_.store(false, std::memory_order_release);
 
#ifdef _WIN32
    if (listen_socket_ != INVALID_SOCKET) {
        closesocket(listen_socket_);
        listen_socket_ = INVALID_SOCKET;
    }
    if (wsa_initialized_) {
        WSACleanup();
        wsa_initialized_ = false;
    }
#else
    if (listen_socket_ >= 0) {
        close(listen_socket_);
        listen_socket_ = -1;
    }
#endif
 
    return kcenon::common::ok();
}

References accepting_, and listen_socket_.

before_start()

accept_worker::result_void kcenon::pacs::network::detail::accept_worker::before_start ( )

overrideprotected

Initializes resources before the worker thread starts.

Currently a placeholder. Will initialize TCP acceptor when network_system integration is complete.

Returns

Success or error with description

Definition at line 85 of file accept_worker.cpp.

                                                     {
    // Initialize TCP socket for accepting connections
 
#ifdef _WIN32
    // Initialize Winsock
    WSADATA wsa_data;
    int wsa_result = WSAStartup(MAKEWORD(2, 2), &wsa_data);
    if (wsa_result != 0) {
        return kcenon::common::error_info("WSAStartup failed: " + std::to_string(wsa_result));
    }
    wsa_initialized_ = true;
 
    // Create socket
    listen_socket_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (listen_socket_ == INVALID_SOCKET) {
        int err = WSAGetLastError();
        WSACleanup();
        wsa_initialized_ = false;
        return kcenon::common::error_info("Failed to create socket: " + std::to_string(err));
    }
 
    // Set socket options
    int opt = 1;
    setsockopt(listen_socket_, SOL_SOCKET, SO_REUSEADDR,
               reinterpret_cast<const char*>(&opt), sizeof(opt));
 
    // Set non-blocking mode
    u_long mode = 1;
    ioctlsocket(listen_socket_, FIONBIO, &mode);
 
    // Bind
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(port_);
 
    if (bind(listen_socket_, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == SOCKET_ERROR) {
        int err = WSAGetLastError();
        closesocket(listen_socket_);
        listen_socket_ = INVALID_SOCKET;
        WSACleanup();
        wsa_initialized_ = false;
        return kcenon::common::error_info("Failed to bind to port " +
                                          std::to_string(port_) + ": " + std::to_string(err));
    }
 
    // Listen
    if (listen(listen_socket_, backlog_) == SOCKET_ERROR) {
        int err = WSAGetLastError();
        closesocket(listen_socket_);
        listen_socket_ = INVALID_SOCKET;
        WSACleanup();
        wsa_initialized_ = false;
        return kcenon::common::error_info("Failed to listen: " + std::to_string(err));
    }
#else
    // Create socket
    listen_socket_ = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_socket_ < 0) {
        return kcenon::common::error_info("Failed to create socket: " +
                                          std::string(std::strerror(errno)));
    }
 
    // Set socket options
    int opt = 1;
    setsockopt(listen_socket_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 
    // Set non-blocking mode
    int flags = fcntl(listen_socket_, F_GETFL, 0);
    if (flags >= 0) {
        fcntl(listen_socket_, F_SETFL, flags | O_NONBLOCK);
    }
 
    // Bind
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(port_);
 
    if (bind(listen_socket_, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
        std::string err_msg = std::strerror(errno);
        close(listen_socket_);
        listen_socket_ = -1;
        return kcenon::common::error_info("Failed to bind to port " +
                                          std::to_string(port_) + ": " + err_msg);
    }
 
    // Listen
    if (listen(listen_socket_, backlog_) < 0) {
        std::string err_msg = std::strerror(errno);
        close(listen_socket_);
        listen_socket_ = -1;
        return kcenon::common::error_info("Failed to listen: " + err_msg);
    }
#endif
 
    accepting_.store(true, std::memory_order_release);
    return kcenon::common::ok();
}

References accepting_, backlog_, listen_socket_, and port_.

do_work()

accept_worker::result_void kcenon::pacs::network::detail::accept_worker::do_work ( )

overrideprotected

Main work routine - checks for incoming connections.

This method is called repeatedly by the thread_base framework. Currently implements placeholder logic that:

• Waits for wake interval or shutdown signal
• Invokes maintenance callback if set

Future implementation will:

• Poll TCP acceptor for incoming connections
• Accept connections and invoke connection callback
• Handle connection errors gracefully

Returns

Success or error with description

Definition at line 185 of file accept_worker.cpp.

                                                {
    // Main work routine for the accept loop
 
#ifdef _WIN32
    if (listen_socket_ == INVALID_SOCKET) {
        return kcenon::common::ok();
    }
 
    // Use select with short timeout to check for incoming connections
    fd_set readfds;
    FD_ZERO(&readfds);
    FD_SET(listen_socket_, &readfds);
 
    timeval tv{};
    tv.tv_sec = 0;
    tv.tv_usec = 10000;  // 10ms timeout for responsive maintenance callbacks
 
    int result = select(0, &readfds, nullptr, nullptr, &tv);
 
    if (result > 0 && FD_ISSET(listen_socket_, &readfds)) {
        sockaddr_in client_addr{};
        int addr_len = sizeof(client_addr);
 
        SOCKET client_socket = accept(listen_socket_,
                                       reinterpret_cast<sockaddr*>(&client_addr),
                                       &addr_len);
 
        if (client_socket != INVALID_SOCKET) {
            // Generate session ID and invoke callback
            uint64_t session_id = next_session_id();
 
            if (on_connection_) {
                on_connection_(session_id);
            }
 
            // Note: For now, we accept and immediately close the connection
            // since association doesn't support real network I/O yet.
            // The connection callback can be extended to handle the socket
            // when network_system integration is complete.
            closesocket(client_socket);
        }
    }
#else
    if (listen_socket_ < 0) {
        return kcenon::common::ok();
    }
 
    // Use select with short timeout to check for incoming connections
    fd_set readfds;
    FD_ZERO(&readfds);
    FD_SET(listen_socket_, &readfds);
 
    timeval tv{};
    tv.tv_sec = 0;
    tv.tv_usec = 10000;  // 10ms timeout for responsive maintenance callbacks
 
    int result = select(listen_socket_ + 1, &readfds, nullptr, nullptr, &tv);
 
    if (result > 0 && FD_ISSET(listen_socket_, &readfds)) {
        sockaddr_in client_addr{};
        socklen_t addr_len = sizeof(client_addr);
 
        int client_socket = accept(listen_socket_,
                                    reinterpret_cast<sockaddr*>(&client_addr),
                                    &addr_len);
 
        if (client_socket >= 0) {
            // Generate session ID and invoke callback
            uint64_t session_id = next_session_id();
 
            if (on_connection_) {
                on_connection_(session_id);
            }
 
            // Note: For now, we accept and immediately close the connection
            // since association doesn't support real network I/O yet.
            // The connection callback can be extended to handle the socket
            // when network_system integration is complete.
            close(client_socket);
        }
    }
#endif
 
    // Invoke maintenance callback for periodic tasks (e.g., idle timeout checks)
    if (on_maintenance_) {
        on_maintenance_();
    }
 
    return kcenon::common::ok();
}

References listen_socket_, next_session_id(), on_connection_, and on_maintenance_.

Here is the call graph for this function:

is_accepting()

bool kcenon::pacs::network::detail::accept_worker::is_accepting ( ) const

nodiscardnoexcept

Checks if the worker is actively accepting connections.

Returns

true if accepting connections, false otherwise

Definition at line 65 of file accept_worker.cpp.

                                                {
    return accepting_.load(std::memory_order_acquire);
}

References accepting_.

Referenced by to_string().

Here is the caller graph for this function:

max_pending_connections()

int kcenon::pacs::network::detail::accept_worker::max_pending_connections ( ) const

nodiscardnoexcept

Gets the current backlog setting.

Returns

Maximum pending connections in listen queue

Definition at line 57 of file accept_worker.cpp.

                                                          {
    return backlog_;
}

References backlog_.

next_session_id()

uint64_t kcenon::pacs::network::detail::accept_worker::next_session_id ( )

nodiscardprivate

Generates a unique session ID for new connections.

Returns

Unique session identifier

Definition at line 328 of file accept_worker.cpp.

                                        {
    return session_id_counter_.fetch_add(1, std::memory_order_relaxed);
}

References session_id_counter_.

Referenced by do_work().

Here is the caller graph for this function:

on_stop_requested()

void kcenon::pacs::network::detail::accept_worker::on_stop_requested ( )

overrideprotected

Called when stop() is requested.

This hook is called from the thread calling stop() before the worker thread actually stops. Currently a no-op as the base class handles waking up the worker thread.

Future implementation will:

• Cancel any pending async accept operations
• Close the acceptor to unblock accept calls

Definition at line 307 of file accept_worker.cpp.

                                      {
    // Called when stop() is requested, before thread actually stops.
    // Close the socket to unblock any pending accept operations.
 
#ifdef _WIN32
    if (listen_socket_ != INVALID_SOCKET) {
        closesocket(listen_socket_);
        listen_socket_ = INVALID_SOCKET;
    }
#else
    if (listen_socket_ >= 0) {
        close(listen_socket_);
        listen_socket_ = -1;
    }
#endif
}

References listen_socket_.

operator=() [1/2]

accept_worker & kcenon::pacs::network::detail::accept_worker::operator= ( accept_worker && )

delete

operator=() [2/2]

accept_worker & kcenon::pacs::network::detail::accept_worker::operator= ( const accept_worker & )

delete

port()

uint16_t kcenon::pacs::network::detail::accept_worker::port ( ) const

nodiscardnoexcept

Gets the configured port number.

Returns

The TCP port this worker listens on

Definition at line 53 of file accept_worker.cpp.

                                            {
    return port_;
}

References port_.

set_max_pending_connections()

void kcenon::pacs::network::detail::accept_worker::set_max_pending_connections

(

int

backlog

)

Sets the maximum number of pending connections in the listen queue.

Parameters

backlog

Maximum pending connections (default: 128)

Note

Must be called before start()

Definition at line 49 of file accept_worker.cpp.

                                                           {
    backlog_ = backlog;
}

References backlog_.

should_continue_work()

bool kcenon::pacs::network::detail::accept_worker::should_continue_work ( ) const

nodiscardoverrideprotected

Determines whether there is pending work that must complete.

Returns false because the accept worker has no pending work items that must complete before shutdown. This allows graceful shutdown when stop() is called.

Returns

false (no pending work requiring completion)

Definition at line 300 of file accept_worker.cpp.

                                               {
    // Return false to indicate no pending work that must complete before shutdown.
    // The accept loop will exit promptly when stop() is called.
    // Note: returning true here would prevent graceful shutdown.
    return false;
}

to_string()

std::string kcenon::pacs::network::detail::accept_worker::to_string ( ) const

nodiscardoverride

Gets a string representation of the worker state.

Returns

Human-readable status string

Definition at line 69 of file accept_worker.cpp.

                                         {
    std::ostringstream oss;
    oss << "accept_worker{"
        << "port=" << port_
        << ", backlog=" << backlog_
        << ", accepting=" << (is_accepting() ? "true" : "false")
        << ", running=" << (is_running() ? "true" : "false")
        << ", sessions=" << session_id_counter_.load(std::memory_order_relaxed)
        << "}";
    return oss.str();
}

References backlog_, is_accepting(), port_, and session_id_counter_.

Here is the call graph for this function:

Member Data Documentation

accepting_

std::atomic<bool> kcenon::pacs::network::detail::accept_worker::accepting_ {false}

private

Flag indicating if actively accepting connections.

Definition at line 265 of file accept_worker.h.

{false};

Referenced by after_stop(), before_start(), and is_accepting().

backlog_

int kcenon::pacs::network::detail::accept_worker::backlog_ {128}

private

Maximum pending connections in listen queue.

Definition at line 259 of file accept_worker.h.

{128};

Referenced by before_start(), max_pending_connections(), set_max_pending_connections(), and to_string().

listen_socket_

int kcenon::pacs::network::detail::accept_worker::listen_socket_ {-1}

private

Listen socket file descriptor (POSIX)

Definition at line 275 of file accept_worker.h.

{-1};

Referenced by after_stop(), before_start(), do_work(), and on_stop_requested().

on_connection_

connection_callback kcenon::pacs::network::detail::accept_worker::on_connection_

private

Callback for new connections.

Definition at line 253 of file accept_worker.h.

Referenced by do_work().

on_maintenance_

maintenance_callback kcenon::pacs::network::detail::accept_worker::on_maintenance_

private

Optional callback for maintenance tasks.

Definition at line 256 of file accept_worker.h.

Referenced by do_work().

port_

uint16_t kcenon::pacs::network::detail::accept_worker::port_

private

TCP port to listen on.

Definition at line 250 of file accept_worker.h.

Referenced by before_start(), port(), and to_string().

session_id_counter_

std::atomic<uint64_t> kcenon::pacs::network::detail::accept_worker::session_id_counter_ {0}

private

Session ID counter for unique connection identification.

Definition at line 262 of file accept_worker.h.

{0};

Referenced by next_session_id(), and to_string().

---

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

• include/kcenon/pacs/network/detail/accept_worker.h
• src/network/detail/accept_worker.cpp