kcenon::network::facade::tcp_facade Class Reference

Simplified facade for creating TCP clients and servers. More...

#include <tcp_facade.h>

Collaboration diagram for kcenon::network::facade::tcp_facade:

Classes
struct	client_config
	Configuration for creating a TCP client. More...
struct	pool_config
	Configuration for creating a TCP connection pool. More...
struct	server_config
	Configuration for creating a TCP server. More...

Public Member Functions
auto	create_client (const client_config &config) const -> Result< std::shared_ptr< interfaces::i_protocol_client > >
	Creates a TCP client with the specified configuration.
auto	create_server (const server_config &config) const -> Result< std::shared_ptr< interfaces::i_protocol_server > >
	Creates a TCP server with the specified configuration.
auto	create_connection_pool (const pool_config &config) const -> Result< std::shared_ptr< core::connection_pool > >
	Creates a TCP connection pool with the specified configuration.

Static Private Member Functions
static auto	generate_client_id () -> std::string
	Generates a unique client ID.
static auto	generate_server_id () -> std::string
	Generates a unique server ID.
static auto	validate_client_config (const client_config &config) -> VoidResult
	Validates client configuration.
static auto	validate_server_config (const server_config &config) -> VoidResult
	Validates server configuration.

Detailed Description

Simplified facade for creating TCP clients and servers.

This facade provides a simple, unified API for creating TCP protocol clients and servers, hiding the complexity of template parameters, protocol tags, and TLS policies from the user.

Design Goals

• Simplicity: No template parameters or protocol tags
• Consistency: Same API pattern across all protocol facades
• Type Safety: Returns standard IProtocolClient/IProtocolServer interfaces
• Zero Cost: No performance overhead compared to direct instantiation

Thread Safety

All methods are thread-safe and can be called concurrently.

Usage Example

using namespace kcenon::network::facade;
 
// Create plain TCP client
tcp_facade facade;
auto client = facade.create_client({
    .host = "127.0.0.1",
    .port = 8080,
    .client_id = "my-client"
});
 
// Create secure TCP client
auto secure_client = facade.create_client({
    .host = "example.com",
    .port = 8443,
    .use_ssl = true,
    .client_id = "secure-client"
});
 
// Create TCP server
auto server = facade.create_server({
    .port = 8080
});
 
// Create secure TCP server
auto secure_server = facade.create_server({
    .port = 8443,
    .use_ssl = true,
    .cert_path = "/path/to/cert.pem",
    .key_path = "/path/to/key.pem"
});

See also

interfaces::i_protocol_client

interfaces::i_protocol_server

Examples

connection_pool.cpp, observer_pattern.cpp, tcp_client.cpp, and tcp_echo_server.cpp.

Definition at line 94 of file tcp_facade.h.

Member Function Documentation

create_client()

auto kcenon::network::facade::tcp_facade::create_client ( const client_config & config ) const -> Result<std::shared_ptr<interfaces::i_protocol_client>>

nodiscard

Creates a TCP client with the specified configuration.

Parameters

config

Client configuration.

Returns

Shared pointer to IProtocolClient interface.

Result containing shared pointer to IProtocolClient, or error.

Behavior

• Creates appropriate client type based on use_ssl flag
• Plain TCP client if use_ssl=false
• Secure TCP client if use_ssl=true
• Client ID is auto-generated if not provided

Error Conditions

• Returns error if host is empty
• Returns error if port is 0 or > 65535
• Returns error if use_ssl=true but SSL support not compiled in

Definition at line 90 of file tcp_facade.cpp.

{
    // Validate configuration
    auto validation = validate_client_config(config);
    if (validation.is_err())
    {
        return error<std::shared_ptr<interfaces::i_protocol_client>>(
            validation.error().code, validation.error().message, "tcp_facade");
    }
 
    // Generate client ID if not provided
    const std::string client_id = config.client_id.empty() ? generate_client_id() : config.client_id;
 
    // SSL support not yet implemented
    if (config.use_ssl)
    {
        return error<std::shared_ptr<interfaces::i_protocol_client>>(
            -6, "tcp_facade: SSL/TLS support not yet implemented", "tcp_facade");
    }
 
    auto client = std::make_shared<core::messaging_client>(client_id);
 
    // Start the client and connect
    auto result = client->start(config.host, config.port);
    if (result.is_err())
    {
        return error<std::shared_ptr<interfaces::i_protocol_client>>(
            -600, "tcp_facade: failed to start client: " + result.error().message, "tcp_facade");
    }
 
    return ok(std::shared_ptr<interfaces::i_protocol_client>(client));
}

References config, kcenon::network::error, kcenon::network::message, and kcenon::network::ok().

Here is the call graph for this function:

create_connection_pool()

auto kcenon::network::facade::tcp_facade::create_connection_pool ( const pool_config & config ) const -> Result<std::shared_ptr<core::connection_pool>>

nodiscard

Creates a TCP connection pool with the specified configuration.

Parameters

config

Pool configuration.

Returns

Shared pointer to connection_pool.

Behavior

• Creates a connection pool that manages multiple reusable connections
• Pool is not initialized; call initialize() before use
• Thread-safe for concurrent acquire/release operations

Usage Example

tcp_facade facade;
auto pool = facade.create_connection_pool({
    .host = "127.0.0.1",
    .port = 5555,
    .pool_size = 10
});
auto result = pool->initialize();
if (result.is_ok()) {
    auto client = pool->acquire();
    client->send_packet(data);
    pool->release(std::move(client));
}

Definition at line 151 of file tcp_facade.cpp.

{
    if (config.host.empty())
    {
        return error<std::shared_ptr<core::connection_pool>>(
            -1, "tcp_facade: host cannot be empty", "tcp_facade");
    }
 
    if (config.port == 0 || config.port > 65535)
    {
        return error<std::shared_ptr<core::connection_pool>>(
            -1, "tcp_facade: port must be between 1 and 65535", "tcp_facade");
    }
 
    if (config.pool_size == 0)
    {
        return error<std::shared_ptr<core::connection_pool>>(
            -1, "tcp_facade: pool_size must be greater than 0", "tcp_facade");
    }
 
    return ok(std::make_shared<core::connection_pool>(
        config.host,
        config.port,
        config.pool_size,
        config.acquire_timeout));
}

References config, kcenon::network::error, and kcenon::network::ok().

Here is the call graph for this function:

create_server()

auto kcenon::network::facade::tcp_facade::create_server ( const server_config & config ) const -> Result<std::shared_ptr<interfaces::i_protocol_server>>

nodiscard

Creates a TCP server with the specified configuration.

Parameters

config

Server configuration.

Returns

Shared pointer to IProtocolServer interface.

Result containing shared pointer to IProtocolServer, or error.

Behavior

• Creates appropriate server type based on use_ssl flag
• Plain TCP server if use_ssl=false
• Secure TCP server if use_ssl=true
• Server ID is auto-generated if not provided

Error Conditions

• Returns error if port is 0 or > 65535
• Returns error if use_ssl=true but cert_path or key_path not provided
• Returns error if use_ssl=true but SSL support not compiled in

Definition at line 124 of file tcp_facade.cpp.

{
    // Validate configuration
    auto validation = validate_server_config(config);
    if (validation.is_err())
    {
        return error<std::shared_ptr<interfaces::i_protocol_server>>(
            validation.error().code, validation.error().message, "tcp_facade");
    }
 
    // Generate server ID if not provided
    const std::string server_id = config.server_id.empty() ? generate_server_id() : config.server_id;
 
    // SSL support not yet implemented
    if (config.use_ssl)
    {
        return error<std::shared_ptr<interfaces::i_protocol_server>>(
            -6, "tcp_facade: SSL/TLS support not yet implemented", "tcp_facade");
    }
 
    // Create adapter wrapping messaging_server
    auto server = std::make_shared<internal::adapters::tcp_server_adapter>(server_id);
 
    return ok(std::shared_ptr<interfaces::i_protocol_server>(server));
}

References config, kcenon::network::error, and kcenon::network::ok().

Here is the call graph for this function:

generate_client_id()

auto kcenon::network::facade::tcp_facade::generate_client_id ( ) -> std::string

staticnodiscardprivate

Generates a unique client ID.

Definition at line 31 of file tcp_facade.cpp.

{
    const auto id = g_client_id_counter.fetch_add(1, std::memory_order_relaxed);
    std::ostringstream oss;
    oss << "tcp_client_" << std::setfill('0') << std::setw(8) << id;
    return oss.str();
}

generate_server_id()

auto kcenon::network::facade::tcp_facade::generate_server_id ( ) -> std::string

staticnodiscardprivate

Generates a unique server ID.

Definition at line 39 of file tcp_facade.cpp.

{
    const auto id = g_server_id_counter.fetch_add(1, std::memory_order_relaxed);
    std::ostringstream oss;
    oss << "tcp_server_" << std::setfill('0') << std::setw(8) << id;
    return oss.str();
}

validate_client_config()

auto kcenon::network::facade::tcp_facade::validate_client_config ( const client_config & config ) -> VoidResult

staticprivate

Validates client configuration.

Definition at line 47 of file tcp_facade.cpp.

{
    if (config.host.empty())
    {
        return error_void(-1, "tcp_facade: host cannot be empty", "tcp_facade");
    }
 
    if (config.port == 0 || config.port > 65535)
    {
        return error_void(-1, "tcp_facade: port must be between 1 and 65535", "tcp_facade");
    }
 
    if (config.timeout.count() <= 0)
    {
        return error_void(-1, "tcp_facade: timeout must be positive", "tcp_facade");
    }
 
    return ok();
}

References config, kcenon::network::error_void(), and kcenon::network::ok().

Here is the call graph for this function:

validate_server_config()

auto kcenon::network::facade::tcp_facade::validate_server_config ( const server_config & config ) -> VoidResult

staticprivate

Validates server configuration.

Definition at line 67 of file tcp_facade.cpp.

{
    if (config.port == 0 || config.port > 65535)
    {
        return error_void(-1, "tcp_facade: port must be between 1 and 65535", "tcp_facade");
    }
 
    if (config.use_ssl)
    {
        if (!config.cert_path.has_value() || config.cert_path->empty())
        {
            return error_void(-1, "tcp_facade: cert_path required when use_ssl=true", "tcp_facade");
        }
 
        if (!config.key_path.has_value() || config.key_path->empty())
        {
            return error_void(-1, "tcp_facade: key_path required when use_ssl=true", "tcp_facade");
        }
    }
 
    return ok();
}

References config, kcenon::network::error_void(), and kcenon::network::ok().

Here is the call graph for this function:

---

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

• include/kcenon/network/facade/tcp_facade.h
• src/facade/tcp_facade.cpp