kcenon::network::facade::quic_facade Class Reference

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

#include <quic_facade.h>

Collaboration diagram for kcenon::network::facade::quic_facade:

Classes
struct	client_config
	Configuration for creating a QUIC client. More...
struct	server_config
	Configuration for creating a QUIC server. More...

Public Member Functions
auto	create_client (const client_config &config) const -> Result< std::shared_ptr< interfaces::i_protocol_client > >
	Creates a QUIC client with the specified configuration.
auto	create_server (const server_config &config) const -> Result< std::shared_ptr< interfaces::i_protocol_server > >
	Creates a QUIC server 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 QUIC clients and servers.

This facade provides a simple, unified API for creating QUIC protocol clients and servers, hiding the complexity of experimental API opt-in, configuration details, and implementation specifics from the user.

Design Goals

• Simplicity: No template parameters or protocol tags
• Consistency: Same API pattern across all protocol facades
• Type Safety: Returns standard QUIC client/server types
• 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 QUIC client
quic_facade facade;
auto client = facade.create_client({
    .host = "127.0.0.1",
    .port = 4433,
    .client_id = "my-quic-client",
    .alpn = "h3"
});
 
// Create QUIC server
auto server = facade.create_server({
    .port = 4433,
    .server_id = "my-quic-server",
    .cert_path = "/path/to/cert.pem",
    .key_path = "/path/to/key.pem"
});

See also

core::messaging_quic_client

core::messaging_quic_server

Definition at line 80 of file quic_facade.h.

Member Function Documentation

create_client()

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

nodiscard

Creates a QUIC client with the specified configuration.

Parameters

config

Client configuration.

Returns

Result containing shared pointer to i_protocol_client, or error.

Behavior

• Creates a QUIC client adapter implementing i_protocol_client
• Client ID is auto-generated if not provided
• QUIC always uses TLS 1.3 encryption
• Client must be started manually using start() method

Error Conditions

• Returns error if host is empty
• Returns error if port is 0 or > 65535

Note

For QUIC-specific features (multi-stream, 0-RTT, ALPN), use messaging_quic_client directly instead of the facade.

Definition at line 93 of file quic_facade.cpp.

{
    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, "quic_facade");
    }
 
    const auto client_id = config.client_id.empty() ? generate_client_id() : config.client_id;
 
    auto adapter = std::make_shared<internal::adapters::quic_client_adapter>(client_id);
 
    // Configure QUIC-specific options
    if (!config.alpn.empty())
    {
        adapter->set_alpn_protocols({config.alpn});
    }
 
    if (config.ca_cert_path)
    {
        adapter->set_ca_cert_path(*config.ca_cert_path);
    }
 
    if (config.client_cert_path && config.client_key_path)
    {
        adapter->set_client_cert(*config.client_cert_path, *config.client_key_path);
    }
 
    adapter->set_verify_server(config.verify_server);
    adapter->set_max_idle_timeout(config.max_idle_timeout_ms);
 
    return ok(std::shared_ptr<interfaces::i_protocol_client>(adapter));
}

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

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

create_server()

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

nodiscard

Creates a QUIC server with the specified configuration.

Parameters

config

Server configuration.

Returns

Result containing shared pointer to i_protocol_server, or error.

Behavior

• Creates a QUIC server adapter implementing i_protocol_server
• Server ID is auto-generated if not provided
• QUIC always uses TLS 1.3 encryption
• Server must be started manually using start() method

Error Conditions

• Returns error if port is 0 or > 65535
• Returns error if cert_path is empty
• Returns error if key_path is empty

Note

For QUIC-specific features (multi-stream, broadcast), use messaging_quic_server directly instead of the facade.

Definition at line 129 of file quic_facade.cpp.

{
    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, "quic_facade");
    }
 
    const auto server_id = config.server_id.empty() ? generate_server_id() : config.server_id;
 
    auto adapter = std::make_shared<internal::adapters::quic_server_adapter>(server_id);
 
    // Configure TLS certificates (required for QUIC)
    adapter->set_cert_path(config.cert_path);
    adapter->set_key_path(config.key_path);
 
    // Configure QUIC-specific options
    if (!config.alpn.empty())
    {
        adapter->set_alpn_protocols({config.alpn});
    }
 
    if (config.ca_cert_path)
    {
        adapter->set_ca_cert_path(*config.ca_cert_path);
    }
 
    adapter->set_require_client_cert(config.require_client_cert);
    adapter->set_max_idle_timeout(config.max_idle_timeout_ms);
    adapter->set_max_connections(config.max_connections);
 
    return ok(std::shared_ptr<interfaces::i_protocol_server>(adapter));
}

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

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_client_id()

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

staticnodiscardprivate

Generates a unique client ID.

Definition at line 27 of file quic_facade.cpp.

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

generate_server_id()

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

staticnodiscardprivate

Generates a unique server ID.

Definition at line 35 of file quic_facade.cpp.

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

validate_client_config()

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

staticprivate

Validates client configuration.

Definition at line 43 of file quic_facade.cpp.

{
    if (config.host.empty())
    {
        return error_void(-1, "quic_facade: host cannot be empty", "quic_facade");
    }
 
    if (config.port == 0 || config.port > 65535)
    {
        return error_void(-1, "quic_facade: port must be between 1 and 65535", "quic_facade");
    }
 
    if (config.max_idle_timeout_ms == 0)
    {
        return error_void(-1, "quic_facade: max_idle_timeout_ms must be positive", "quic_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::quic_facade::validate_server_config ( const server_config & config ) -> VoidResult

staticprivate

Validates server configuration.

Definition at line 63 of file quic_facade.cpp.

{
    if (config.port == 0 || config.port > 65535)
    {
        return error_void(-1, "quic_facade: port must be between 1 and 65535", "quic_facade");
    }
 
    if (config.cert_path.empty())
    {
        return error_void(-1, "quic_facade: cert_path cannot be empty", "quic_facade");
    }
 
    if (config.key_path.empty())
    {
        return error_void(-1, "quic_facade: key_path cannot be empty", "quic_facade");
    }
 
    if (config.max_idle_timeout_ms == 0)
    {
        return error_void(-1, "quic_facade: max_idle_timeout_ms must be positive", "quic_facade");
    }
 
    if (config.max_connections == 0)
    {
        return error_void(-1, "quic_facade: max_connections must be positive", "quic_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/quic_facade.h
• src/facade/quic_facade.cpp