QuicServerDemo Class Reference

Simple QUIC server demo. More...

Collaboration diagram for QuicServerDemo:

Public Member Functions
	QuicServerDemo (unsigned short port)
bool	run ()

Private Member Functions
void	setup_callbacks ()
void	handle_command (std::shared_ptr< quic_session > session, const std::string &msg)
void	demo_broadcast ()
void	print_status ()

Private Attributes
unsigned short	port_
std::shared_ptr< core::messaging_quic_server >	server_

Detailed Description

Simple QUIC server demo.

Definition at line 56 of file quic_server_example.cpp.

Constructor & Destructor Documentation

QuicServerDemo()

QuicServerDemo::QuicServerDemo ( unsigned short port )

inlineexplicit

Definition at line 59 of file quic_server_example.cpp.

        : port_(port)
    {
    }

Member Function Documentation

demo_broadcast()

void QuicServerDemo::demo_broadcast ( )

inlineprivate

Definition at line 226 of file quic_server_example.cpp.

    {
        std::cout << "\n=== Broadcasting to All Clients ===" << std::endl;
 
        std::string broadcast_msg = "Broadcast: Hello everyone!";
        auto result = server_->broadcast(
            std::vector<uint8_t>(broadcast_msg.begin(), broadcast_msg.end()));
 
        if (result.is_ok())
        {
            std::cout << "Broadcast sent to " << server_->session_count()
                      << " clients" << std::endl;
        }
        else
        {
            std::cerr << "Broadcast failed: " << result.error().message
                      << std::endl;
        }
    }

References kcenon::network::core::messaging_quic_server::broadcast(), server_, and kcenon::network::core::messaging_quic_server::session_count().

Referenced by handle_command().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_command()

void QuicServerDemo::handle_command ( std::shared_ptr< quic_session > session, const std::string & msg )

inlineprivate

Definition at line 197 of file quic_server_example.cpp.

    {
        if (msg == "/status")
        {
            // Send server status
            std::string status = "Server status: " +
                                 std::to_string(server_->session_count()) +
                                 " clients connected";
            (void)session->send(
                std::vector<uint8_t>(status.begin(), status.end()));
        }
        else if (msg == "/broadcast")
        {
            // Broadcast to all clients
            demo_broadcast();
        }
        else if (msg.substr(0, 5) == "/list")
        {
            // List all connected clients
            std::string list = "Connected clients:\n";
            for (const auto& s : server_->sessions())
            {
                list += "  - " + s->session_id() + "\n";
            }
            (void)session->send(std::vector<uint8_t>(list.begin(), list.end()));
        }
    }

References demo_broadcast(), server_, kcenon::network::core::messaging_quic_server::session_count(), and kcenon::network::core::messaging_quic_server::sessions().

Referenced by setup_callbacks().

Here is the call graph for this function:

Here is the caller graph for this function:

print_status()

void QuicServerDemo::print_status ( )

inlineprivate

Definition at line 246 of file quic_server_example.cpp.

    {
        std::cout << "\n--- Server Status ---" << std::endl;
        std::cout << "Running: " << (server_->is_running() ? "Yes" : "No")
                  << std::endl;
        std::cout << "Connected clients: " << server_->session_count()
                  << std::endl;
 
        auto sessions = server_->sessions();
        if (!sessions.empty())
        {
            std::cout << "Sessions:" << std::endl;
            for (const auto& session : sessions)
            {
                if (session && session->is_active())
                {
                    auto stats = session->stats();
                    std::cout << "  " << session->session_id()
                              << " - Bytes: sent=" << stats.bytes_sent
                              << ", recv=" << stats.bytes_received << std::endl;
                }
            }
        }
        std::cout << "---------------------" << std::endl;
    }

References kcenon::network::core::messaging_quic_server::is_running(), server_, kcenon::network::core::messaging_quic_server::session_count(), and kcenon::network::core::messaging_quic_server::sessions().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

bool QuicServerDemo::run ( )

inline

Definition at line 64 of file quic_server_example.cpp.

    {
        std::cout << "=== QUIC Server Example ===" << std::endl;
        std::cout << "Starting server on port " << port_ << std::endl;
 
        // Create QUIC server directly for QUIC-specific features
        server_ = std::make_shared<core::messaging_quic_server>("quic_demo_server");
 
        // Set up callbacks
        setup_callbacks();
 
        // Create configuration for start_server
        core::quic_server_config config;
        config.max_idle_timeout_ms = 30000;
        config.max_connections = 100;
        config.alpn_protocols = {"h3", "hq-interop"};
 
        // Start the server
        auto result = server_->start_server(port_, config);
        if (result.is_err())
        {
            std::cerr << "Failed to start server: " << result.error().message
                      << std::endl;
            return false;
        }
 
        std::cout << "Server started successfully!" << std::endl;
        std::cout << "Press Ctrl+C to stop the server..." << std::endl;
        std::cout << std::endl;
 
        // Main loop - print statistics periodically
        while (g_running.load())
        {
            std::this_thread::sleep_for(std::chrono::seconds(5));
 
            if (g_running.load())
            {
                print_status();
            }
        }
 
        // Graceful shutdown
        std::cout << "\n=== Shutting Down ===" << std::endl;
 
        // Disconnect all clients
        std::cout << "Disconnecting " << server_->session_count()
                  << " clients..." << std::endl;
        server_->disconnect_all(0);
 
        // Stop the server
        std::cout << "Stopping server..." << std::endl;
        (void)server_->stop_server();
        server_->wait_for_stop();
 
        std::cout << "Server stopped." << std::endl;
        return true;
    }

References config, kcenon::network::core::messaging_quic_server::disconnect_all(), g_running, port_, print_status(), server_, kcenon::network::core::messaging_quic_server::session_count(), setup_callbacks(), kcenon::network::core::messaging_quic_server::start_server(), kcenon::network::core::messaging_quic_server::stop_server(), and kcenon::network::core::messaging_quic_server::wait_for_stop().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_callbacks()

void QuicServerDemo::setup_callbacks ( )

inlineprivate

Definition at line 123 of file quic_server_example.cpp.

    {
        // Connection callback - called when a new client connects
        server_->set_connection_callback(
            [](std::shared_ptr<quic_session> session)
            {
                std::cout << "[Connect] New client: " << session->session_id()
                          << " from " << session->remote_endpoint().address()
                          << std::endl;
 
                // Send welcome message
                std::string welcome = "Welcome to QUIC server!";
                auto result = session->send(
                    std::vector<uint8_t>(welcome.begin(), welcome.end()));
                if (result.is_err())
                {
                    std::cerr << "  Failed to send welcome: "
                              << result.error().message << std::endl;
                }
            });
 
        // Disconnection callback - called when a client disconnects
        server_->set_disconnection_callback(
            [](std::shared_ptr<quic_session> session)
            {
                std::cout << "[Disconnect] Client left: "
                          << session->session_id() << std::endl;
            });
 
        // Receive callback - called when data is received
        server_->set_receive_callback(
            [this](std::shared_ptr<quic_session> session,
                   const std::vector<uint8_t>& data)
            {
                std::string msg(data.begin(), data.end());
                std::cout << "[Receive] From " << session->session_id() << ": "
                          << msg << std::endl;
 
                // Echo the message back
                std::string response = "Echo: " + msg;
                auto result = session->send(
                    std::vector<uint8_t>(response.begin(), response.end()));
                if (result.is_err())
                {
                    std::cerr << "  Failed to echo: " << result.error().message
                              << std::endl;
                }
 
                // Handle special commands
                handle_command(session, msg);
            });
 
        // Stream receive callback - called for stream-specific data
        server_->set_stream_receive_callback(
            [](std::shared_ptr<quic_session> session,
               uint64_t stream_id,
               const std::vector<uint8_t>& data,
               bool fin)
            {
                std::cout << "[Stream] From " << session->session_id()
                          << " on stream " << stream_id << ": "
                          << data.size() << " bytes"
                          << (fin ? " (FIN)" : "") << std::endl;
            });
 
        // Error callback
        server_->set_error_callback(
            [](std::error_code ec)
            {
                std::cerr << "[Error] Server error: " << ec.message()
                          << std::endl;
            });
    }

References handle_command(), server_, kcenon::network::core::messaging_quic_server::set_connection_callback(), kcenon::network::core::messaging_quic_server::set_disconnection_callback(), kcenon::network::core::messaging_quic_server::set_error_callback(), kcenon::network::core::messaging_quic_server::set_receive_callback(), and kcenon::network::core::messaging_quic_server::set_stream_receive_callback().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

port_

unsigned short QuicServerDemo::port_

private

Definition at line 272 of file quic_server_example.cpp.

Referenced by run().

server_

std::shared_ptr<core::messaging_quic_server> QuicServerDemo::server_

private

Definition at line 273 of file quic_server_example.cpp.

Referenced by demo_broadcast(), handle_command(), print_status(), run(), and setup_callbacks().

---

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

• examples/quic_server_example.cpp