kcenon::network::session::quic_session Class Reference

Represents a single QUIC client session on the server side. More...

#include <quic_session.h>

Inheritance diagram for kcenon::network::session::quic_session:

Collaboration diagram for kcenon::network::session::quic_session:

Public Member Functions
	quic_session (std::shared_ptr< internal::quic_socket > socket, std::string_view session_id)
	Constructs a QUIC session with an existing socket.
	~quic_session () noexcept
	Destructor; closes the session if still active.
	quic_session (const quic_session &)=delete
quic_session &	operator= (const quic_session &)=delete
auto	session_id () const -> const std::string &
	Get the unique session identifier.
auto	remote_endpoint () const -> asio::ip::udp::endpoint
	Get the remote endpoint address.
auto	is_active () const noexcept -> bool
	Check if the session is currently active.
auto	send (std::string_view data) -> VoidResult
	Send string data on the default stream.
auto	close (uint64_t error_code) -> VoidResult
	Close the session gracefully with error code.
auto	stats () const -> core::quic_connection_stats
	Get connection statistics.
auto	set_receive_callback (std::function< void(const std::vector< uint8_t > &)> callback) -> void
	Set callback for received data on the default stream.
auto	set_stream_receive_callback (std::function< void(uint64_t, const std::vector< uint8_t > &, bool)> callback) -> void
	Set callback for stream data reception.
auto	set_close_callback (std::function< void()> callback) -> void
	Set callback when session closes.
auto	start_session () -> void
	Start receiving data (called by server).
auto	handle_packet (std::span< const uint8_t > data) -> void
	Handle incoming packet (called by server).
auto	matches_connection_id (const protocols::quic::connection_id &conn_id) const -> bool
	Check if this session matches a connection ID.
auto	id () const -> std::string_view override
	Gets the unique session identifier (interface version).
auto	is_connected () const -> bool override
	Checks if the session is currently connected (interface version).
auto	send (std::vector< uint8_t > &&data) -> VoidResult override
	Sends data to the client (interface version).
auto	close () -> void override
	Closes the session (interface version).
auto	create_stream () -> Result< uint64_t > override
	Creates a new bidirectional stream (interface version).
auto	create_unidirectional_stream () -> Result< uint64_t > override
	Creates a new unidirectional stream (interface version).
auto	send_on_stream (uint64_t stream_id, std::vector< uint8_t > &&data, bool fin=false) -> VoidResult override
	Sends data on a specific stream (interface version).
auto	close_stream (uint64_t stream_id) -> VoidResult override
	Closes a stream (interface version).
Public Member Functions inherited from kcenon::network::interfaces::i_quic_session
Public Member Functions inherited from kcenon::network::interfaces::i_session
virtual	~i_session ()=default
	Virtual destructor for proper cleanup.
	i_session (const i_session &)=delete
i_session &	operator= (const i_session &)=delete
	i_session (i_session &&)=delete
i_session &	operator= (i_session &&)=delete

Private Member Functions
auto	on_stream_data (uint64_t stream_id, std::span< const uint8_t > data, bool fin) -> void
auto	on_error (std::error_code ec) -> void
auto	on_close (uint64_t error_code, const std::string &reason) -> void

Private Attributes
std::string	session_id_
std::mutex	socket_mutex_
std::shared_ptr< internal::quic_socket >	socket_
std::atomic< bool >	is_active_ {true}
uint64_t	default_stream_id_ {0}
std::function< void(const std::vector< uint8_t > &)>	receive_callback_
std::function< void(uint64_t, const std::vector< uint8_t > &, bool)>	stream_receive_callback_
std::function< void()>	close_callback_
std::mutex	callback_mutex_

Additional Inherited Members
Protected Member Functions inherited from kcenon::network::interfaces::i_session
	i_session ()=default
	Default constructor (only for derived classes)

Detailed Description

Represents a single QUIC client session on the server side.

Overview

This class wraps a QUIC connection from a connected client, providing methods to send/receive data, manage streams, and handle session lifecycle.

Thread Safety

• All public methods are thread-safe.
• Session state is protected by atomic operations.
• Socket access is protected by internal mutex.
• Callbacks are invoked on I/O threads.

Key Features

• Manages a single client's QUIC connection
• Supports multiple concurrent streams (QUIC feature)
• Provides send/receive callbacks for data handling
• Thread-safe session management

Definition at line 69 of file quic_session.h.

Constructor & Destructor Documentation

quic_session() [1/2]

kcenon::network::session::quic_session::quic_session	(	std::shared_ptr< internal::quic_socket >	socket,
		std::string_view	session_id )

Constructs a QUIC session with an existing socket.

Parameters

socket	The QUIC socket for this session.
session_id	Unique identifier for this session.

Definition at line 14 of file quic_session.cpp.

        : session_id_(session_id), socket_(std::move(socket))
    {
        NETWORK_LOG_DEBUG("[quic_session] Created session: " + session_id_);
    }

References NETWORK_LOG_DEBUG, and session_id_.

~quic_session()

kcenon::network::session::quic_session::~quic_session ( )

noexcept

Destructor; closes the session if still active.

Definition at line 21 of file quic_session.cpp.

    {
        try
        {
            if (is_active_.load())
            {
                auto result = close(0);
                (void)result; // Ignore result in destructor
            }
        }
        catch (...)
        {
            // Destructor must not throw
        }
    }

References close(), and is_active_.

Here is the call graph for this function:

quic_session() [2/2]

kcenon::network::session::quic_session::quic_session ( const quic_session & )

delete

Member Function Documentation

close() [1/2]

auto kcenon::network::session::quic_session::close ( ) -> void

inlineoverridevirtual

Closes the session (interface version).

Implements i_session::close().

Implements kcenon::network::interfaces::i_session.

Definition at line 231 of file quic_session.h.

                                      {
            auto result = close(0);
            (void)result;
        }

References close().

Referenced by close(), and ~quic_session().

Here is the call graph for this function:

Here is the caller graph for this function:

close() [2/2]

auto kcenon::network::session::quic_session::close ( uint64_t error_code ) -> VoidResult

nodiscard

Close the session gracefully with error code.

Parameters

error_code

Application error code (0 for no error).

Returns

VoidResult indicating success or error.

Definition at line 170 of file quic_session.cpp.

    {
        if (!is_active_.exchange(false))
        {
            return ok();
        }
 
        NETWORK_LOG_INFO("[quic_session] Closing session: " + session_id_);
 
        VoidResult result = ok();
 
        {
            std::lock_guard<std::mutex> lock(socket_mutex_);
            if (socket_)
            {
                result = socket_->close(error_code, "Session closed");
            }
        }
 
        // Invoke close callback
        {
            std::lock_guard<std::mutex> lock(callback_mutex_);
            if (close_callback_)
            {
                try
                {
                    close_callback_();
                }
                catch (const std::exception& e)
                {
                    NETWORK_LOG_ERROR("[quic_session] Exception in close callback: "
                                      + std::string(e.what()));
                }
            }
        }
 
        return result;
    }

References NETWORK_LOG_ERROR, NETWORK_LOG_INFO, and kcenon::network::ok().

Here is the call graph for this function:

close_stream()

auto kcenon::network::session::quic_session::close_stream ( uint64_t stream_id ) -> VoidResult

nodiscardoverridevirtual

Closes a stream (interface version).

Parameters

stream_id

The stream to close.

Returns

VoidResult indicating success or failure.

Implements i_quic_session::close_stream().

Implements kcenon::network::interfaces::i_quic_session.

Definition at line 150 of file quic_session.cpp.

    {
        if (!is_active_.load())
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Session is not active",
                              "quic_session");
        }
 
        std::lock_guard<std::mutex> lock(socket_mutex_);
        if (!socket_)
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Socket is null",
                              "quic_session");
        }
 
        return socket_->close_stream(stream_id);
    }

References kcenon::network::error_codes::network_system::connection_closed, and kcenon::network::error_void().

Here is the call graph for this function:

create_stream()

auto kcenon::network::session::quic_session::create_stream ( ) -> Result<uint64_t>

nodiscardoverridevirtual

Creates a new bidirectional stream (interface version).

Returns

Stream ID or error.

Implements i_quic_session::create_stream().

Implements kcenon::network::interfaces::i_quic_session.

Definition at line 110 of file quic_session.cpp.

    {
        if (!is_active_.load())
        {
            return error<uint64_t>(error_codes::network_system::connection_closed,
                                   "Session is not active",
                                   "quic_session");
        }
 
        std::lock_guard<std::mutex> lock(socket_mutex_);
        if (!socket_)
        {
            return error<uint64_t>(error_codes::network_system::connection_closed,
                                   "Socket is null",
                                   "quic_session");
        }
 
        return socket_->create_stream(false);
    }

References kcenon::network::error_codes::network_system::connection_closed, and kcenon::network::error.

create_unidirectional_stream()

auto kcenon::network::session::quic_session::create_unidirectional_stream ( ) -> Result<uint64_t>

nodiscardoverridevirtual

Creates a new unidirectional stream (interface version).

Returns

Stream ID or error.

Implements i_quic_session::create_unidirectional_stream().

Implements kcenon::network::interfaces::i_quic_session.

Definition at line 130 of file quic_session.cpp.

    {
        if (!is_active_.load())
        {
            return error<uint64_t>(error_codes::network_system::connection_closed,
                                   "Session is not active",
                                   "quic_session");
        }
 
        std::lock_guard<std::mutex> lock(socket_mutex_);
        if (!socket_)
        {
            return error<uint64_t>(error_codes::network_system::connection_closed,
                                   "Socket is null",
                                   "quic_session");
        }
 
        return socket_->create_stream(true);
    }

References kcenon::network::error_codes::network_system::connection_closed, and kcenon::network::error.

handle_packet()

auto kcenon::network::session::quic_session::handle_packet

(

std::span< const uint8_t >

data

)

-> void

Handle incoming packet (called by server).

Parameters

data	Raw packet data.

Definition at line 283 of file quic_session.cpp.

    {
        // This is called by the server when a packet arrives for this session
        // The actual packet handling is done by quic_socket
        std::lock_guard<std::mutex> lock(socket_mutex_);
        if (socket_)
        {
            // The socket will process the packet internally
            // No direct call needed as socket handles its own receive loop
        }
    }

id()

auto kcenon::network::session::quic_session::id ( ) const -> std::string_view

inlinenodiscardoverridevirtual

Gets the unique session identifier (interface version).

Returns

A string view of the session ID.

Implements i_session::id().

Implements kcenon::network::interfaces::i_session.

Definition at line 203 of file quic_session.h.

                                                                 {
            return session_id_;
        }

References session_id_.

is_active()

auto kcenon::network::session::quic_session::is_active ( ) const -> bool

nodiscardnoexcept

Check if the session is currently active.

Returns

true if active, false if closed.

Definition at line 52 of file quic_session.cpp.

    {
        return is_active_.load(std::memory_order_relaxed);
    }

References is_active_.

Referenced by is_connected().

Here is the caller graph for this function:

is_connected()

auto kcenon::network::session::quic_session::is_connected ( ) const -> bool

inlinenodiscardoverridevirtual

Checks if the session is currently connected (interface version).

Returns

true if connected, false otherwise.

Implements i_session::is_connected().

Implements kcenon::network::interfaces::i_session.

Definition at line 213 of file quic_session.h.

                                                                 {
            return is_active();
        }

References is_active().

Here is the call graph for this function:

matches_connection_id()

auto kcenon::network::session::quic_session::matches_connection_id ( const protocols::quic::connection_id & conn_id ) const -> bool

nodiscard

Check if this session matches a connection ID.

Parameters

conn_id

Connection ID to match.

Returns

true if matches.

Definition at line 295 of file quic_session.cpp.

    {
        std::lock_guard<std::mutex> lock(socket_mutex_);
        if (!socket_)
        {
            return false;
        }
        return socket_->local_connection_id() == conn_id ||
               socket_->remote_connection_id() == conn_id;
    }

on_close()

auto kcenon::network::session::quic_session::on_close ( uint64_t error_code, const std::string & reason ) -> void

private

Definition at line 366 of file quic_session.cpp.

    {
        NETWORK_LOG_INFO("[quic_session] Session " + session_id_ + " closed: "
                         + reason + " (code: " + std::to_string(error_code) + ")");
 
        is_active_.store(false);
 
        // Invoke close callback
        {
            std::lock_guard<std::mutex> lock(callback_mutex_);
            if (close_callback_)
            {
                try
                {
                    close_callback_();
                }
                catch (const std::exception& e)
                {
                    NETWORK_LOG_ERROR("[quic_session] Exception in close callback: "
                                      + std::string(e.what()));
                }
            }
        }
    }

References NETWORK_LOG_ERROR, and NETWORK_LOG_INFO.

on_error()

auto kcenon::network::session::quic_session::on_error ( std::error_code ec ) -> void

private

Definition at line 356 of file quic_session.cpp.

    {
        NETWORK_LOG_ERROR("[quic_session] Error on session " + session_id_ + ": "
                          + ec.message());
 
        // Close the session on error
        auto result = close(1);
        (void)result;
    }

References NETWORK_LOG_ERROR.

on_stream_data()

auto kcenon::network::session::quic_session::on_stream_data ( uint64_t stream_id, std::span< const uint8_t > data, bool fin ) -> void

private

Definition at line 307 of file quic_session.cpp.

    {
        if (!is_active_.load())
        {
            return;
        }
 
        // Report bytes received metric
        metrics::metric_reporter::report_bytes_received(data.size());
 
        NETWORK_LOG_DEBUG("[quic_session] Received " + std::to_string(data.size())
                          + " bytes on stream " + std::to_string(stream_id));
 
        std::vector<uint8_t> data_copy(data.begin(), data.end());
 
        std::lock_guard<std::mutex> lock(callback_mutex_);
 
        // Call stream-specific callback if set
        if (stream_receive_callback_)
        {
            try
            {
                stream_receive_callback_(stream_id, data_copy, fin);
            }
            catch (const std::exception& e)
            {
                NETWORK_LOG_ERROR(
                    "[quic_session] Exception in stream receive callback: "
                    + std::string(e.what()));
            }
        }
 
        // Also call default receive callback for default stream
        if (stream_id == default_stream_id_ && receive_callback_)
        {
            try
            {
                receive_callback_(data_copy);
            }
            catch (const std::exception& e)
            {
                NETWORK_LOG_ERROR("[quic_session] Exception in receive callback: "
                                  + std::string(e.what()));
            }
        }
    }

References NETWORK_LOG_DEBUG, NETWORK_LOG_ERROR, and kcenon::network::metrics::metric_reporter::report_bytes_received().

Here is the call graph for this function:

operator=()

quic_session & kcenon::network::session::quic_session::operator= ( const quic_session & )

delete

remote_endpoint()

auto kcenon::network::session::quic_session::remote_endpoint ( ) const -> asio::ip::udp::endpoint

nodiscard

Get the remote endpoint address.

Returns

Remote UDP endpoint.

Definition at line 42 of file quic_session.cpp.

    {
        std::lock_guard<std::mutex> lock(socket_mutex_);
        if (socket_)
        {
            return socket_->remote_endpoint();
        }
        return {};
    }

References socket_, and socket_mutex_.

send() [1/2]

auto kcenon::network::session::quic_session::send ( std::string_view data ) -> VoidResult

nodiscard

Send string data on the default stream.

Parameters

data	String to send.

Returns

VoidResult indicating success or error.

Definition at line 80 of file quic_session.cpp.

    {
        std::vector<uint8_t> bytes(data.begin(), data.end());
        return send(std::move(bytes));
    }

send() [2/2]

auto kcenon::network::session::quic_session::send ( std::vector< uint8_t > && data ) -> VoidResult

nodiscardoverridevirtual

Sends data to the client (interface version).

Parameters

data	The data to send.

Returns

VoidResult indicating success or failure.

Implements i_session::send().

Implements kcenon::network::interfaces::i_session.

Definition at line 57 of file quic_session.cpp.

    {
        if (!is_active_.load())
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Session is not active",
                              "quic_session");
        }
 
        std::lock_guard<std::mutex> lock(socket_mutex_);
        if (!socket_)
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Socket is null",
                              "quic_session");
        }
 
        // Report bytes sent metric
        metrics::metric_reporter::report_bytes_sent(data.size());
 
        return socket_->send_stream_data(default_stream_id_, std::move(data), false);
    }

References kcenon::network::error_codes::network_system::connection_closed, kcenon::network::error_void(), and kcenon::network::metrics::metric_reporter::report_bytes_sent().

Here is the call graph for this function:

send_on_stream()

auto kcenon::network::session::quic_session::send_on_stream ( uint64_t stream_id, std::vector< uint8_t > && data, bool fin = false ) -> VoidResult

nodiscardoverridevirtual

Sends data on a specific stream (interface version).

Parameters

stream_id	The target stream ID.
data	The data to send.
fin	True if this is the final data on the stream.

Returns

VoidResult indicating success or failure.

Implements i_quic_session::send_on_stream().

Implements kcenon::network::interfaces::i_quic_session.

Definition at line 86 of file quic_session.cpp.

    {
        if (!is_active_.load())
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Session is not active",
                              "quic_session");
        }
 
        std::lock_guard<std::mutex> lock(socket_mutex_);
        if (!socket_)
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Socket is null",
                              "quic_session");
        }
 
        metrics::metric_reporter::report_bytes_sent(data.size());
 
        return socket_->send_stream_data(stream_id, std::move(data), fin);
    }

References kcenon::network::error_codes::network_system::connection_closed, kcenon::network::error_void(), and kcenon::network::metrics::metric_reporter::report_bytes_sent().

Here is the call graph for this function:

session_id()

auto kcenon::network::session::quic_session::session_id ( ) const -> const std::string&

nodiscard

Get the unique session identifier.

Returns

Session ID string.

Definition at line 37 of file quic_session.cpp.

    {
        return session_id_;
    }

References session_id_.

set_close_callback()

auto kcenon::network::session::quic_session::set_close_callback

(

std::function< void()>

callback

)

-> void

Set callback when session closes.

Parameters

callback

Function called on session close.

Definition at line 230 of file quic_session.cpp.

    {
        std::lock_guard<std::mutex> lock(callback_mutex_);
        close_callback_ = std::move(callback);
    }

set_receive_callback()

auto kcenon::network::session::quic_session::set_receive_callback

(

std::function< void(const std::vector< uint8_t > &)>

callback

)

-> void

Set callback for received data on the default stream.

Parameters

callback

Function called when data is received.

Definition at line 215 of file quic_session.cpp.

    {
        std::lock_guard<std::mutex> lock(callback_mutex_);
        receive_callback_ = std::move(callback);
    }

set_stream_receive_callback()

auto kcenon::network::session::quic_session::set_stream_receive_callback

(

std::function< void(uint64_t, const std::vector< uint8_t > &, bool)>

callback

)

-> void

Set callback for stream data reception.

Parameters

callback

Function with stream_id, data, and fin flag.

Definition at line 222 of file quic_session.cpp.

    {
        std::lock_guard<std::mutex> lock(callback_mutex_);
        stream_receive_callback_ = std::move(callback);
    }

start_session()

auto kcenon::network::session::quic_session::start_session

(

)

-> void

Start receiving data (called by server).

Definition at line 236 of file quic_session.cpp.

    {
        if (!is_active_.load())
        {
            return;
        }
 
        auto weak_self = weak_from_this();
 
        std::lock_guard<std::mutex> lock(socket_mutex_);
        if (!socket_)
        {
            return;
        }
 
        // Set up stream data callback
        socket_->set_stream_data_callback(
            [weak_self](uint64_t stream_id, std::span<const uint8_t> data, bool fin)
            {
                if (auto self = weak_self.lock())
                {
                    self->on_stream_data(stream_id, data, fin);
                }
            });
 
        // Set up error callback
        socket_->set_error_callback([weak_self](std::error_code ec)
                                    {
                                        if (auto self = weak_self.lock())
                                        {
                                            self->on_error(ec);
                                        }
                                    });
 
        // Set up close callback
        socket_->set_close_callback(
            [weak_self](uint64_t error_code, const std::string& reason)
            {
                if (auto self = weak_self.lock())
                {
                    self->on_close(error_code, reason);
                }
            });
 
        NETWORK_LOG_INFO("[quic_session] Started session: " + session_id_);
    }

References NETWORK_LOG_INFO.

stats()

auto kcenon::network::session::quic_session::stats ( ) const -> core::quic_connection_stats

nodiscard

Get connection statistics.

Returns

Current connection stats.

Definition at line 209 of file quic_session.cpp.

    {
        // Return empty stats for now - will be implemented with actual QUIC stats
        return core::quic_connection_stats{};
    }

Member Data Documentation

callback_mutex_

std::mutex kcenon::network::session::quic_session::callback_mutex_

mutableprivate

Definition at line 307 of file quic_session.h.

close_callback_

std::function<void()> kcenon::network::session::quic_session::close_callback_

private

Definition at line 305 of file quic_session.h.

default_stream_id_

uint64_t kcenon::network::session::quic_session::default_stream_id_ {0}

private

Definition at line 299 of file quic_session.h.

{0};

is_active_

std::atomic<bool> kcenon::network::session::quic_session::is_active_ {true}

private

Definition at line 297 of file quic_session.h.

{true};

Referenced by is_active(), and ~quic_session().

receive_callback_

std::function<void(const std::vector<uint8_t>&)> kcenon::network::session::quic_session::receive_callback_

private

Definition at line 302 of file quic_session.h.

session_id_

std::string kcenon::network::session::quic_session::session_id_

private

Definition at line 292 of file quic_session.h.

Referenced by id(), quic_session(), and session_id().

socket_

std::shared_ptr<internal::quic_socket> kcenon::network::session::quic_session::socket_

private

Definition at line 295 of file quic_session.h.

Referenced by remote_endpoint().

socket_mutex_

std::mutex kcenon::network::session::quic_session::socket_mutex_

mutableprivate

Definition at line 294 of file quic_session.h.

Referenced by remote_endpoint().

stream_receive_callback_

std::function<void(uint64_t, const std::vector<uint8_t>&, bool)> kcenon::network::session::quic_session::stream_receive_callback_

private

Definition at line 304 of file quic_session.h.

---

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

• include/kcenon/network/detail/session/quic_session.h
• src/session/quic_session.cpp