quic_server_example.cpp File Reference

#include "internal/experimental/quic_server.h"
#include <kcenon/network/detail/session/quic_session.h>
#include <iostream>
#include <string>
#include <memory>
#include <thread>
#include <chrono>
#include <vector>
#include <atomic>
#include <signal.h>

Include dependency graph for quic_server_example.cpp:

Go to the source code of this file.

Classes
class	QuicServerDemo
	Simple QUIC server demo. More...

Macros
#define	NETWORK_USE_EXPERIMENTAL

Functions
void	signal_handler (int)
void	demo_multicast (std::shared_ptr< core::messaging_quic_server > server)
	Example showing multicast functionality.
void	simple_server_example ()
	Example with minimal setup.
int	main (int argc, char *argv[])

Variables
std::atomic< bool >	g_running {true}

Macro Definition Documentation

NETWORK_USE_EXPERIMENTAL

#define NETWORK_USE_EXPERIMENTAL

BSD 3-Clause License Copyright (c) 2024, Network System Project

QUIC Server Example

This example demonstrates how to create a QUIC server that accepts client connections and handles data transmission.

Note: This sample uses messaging_quic_server directly instead of quic_facade because it needs QUIC-specific features like broadcasting, multicasting, and session management. The quic_facade returns i_protocol_server which provides a unified interface but doesn't expose QUIC-specific methods.

Key features demonstrated:

• Starting and stopping the server
• Handling client connections and disconnections
• Receiving data from clients
• Broadcasting to all connected clients
• Multicasting to specific clients
• Session management

Definition at line 26 of file quic_server_example.cpp.

Function Documentation

demo_multicast()

void demo_multicast

(

std::shared_ptr< core::messaging_quic_server >

server

)

Example showing multicast functionality.

Definition at line 279 of file quic_server_example.cpp.

{
    std::cout << "\n=== Multicast Demo ===" << std::endl;
 
    auto sessions = server->sessions();
    if (sessions.size() < 2)
    {
        std::cout << "Need at least 2 clients for multicast demo" << std::endl;
        return;
    }
 
    // Get first two session IDs
    std::vector<std::string> target_ids;
    target_ids.push_back(sessions[0]->session_id());
    target_ids.push_back(sessions[1]->session_id());
 
    std::string multicast_msg = "Multicast: Selected clients only!";
    auto result = server->multicast(
        target_ids,
        std::vector<uint8_t>(multicast_msg.begin(), multicast_msg.end()));
 
    if (result.is_ok())
    {
        std::cout << "Multicast sent to " << target_ids.size() << " clients"
                  << std::endl;
    }
    else
    {
        std::cerr << "Multicast failed: " << result.error().message
                  << std::endl;
    }
}

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 345 of file quic_server_example.cpp.

{
    // Set up signal handler for graceful shutdown
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
 
    unsigned short port = 4433;
 
    if (argc >= 2)
    {
        port = static_cast<unsigned short>(std::stoi(argv[1]));
    }
 
    std::cout << "QUIC Server Example" << std::endl;
    std::cout << "===================" << std::endl;
    std::cout << std::endl;
 
    // Run the main demo
    QuicServerDemo demo(port);
    bool success = demo.run();
 
    return success ? 0 : 1;
}

References QuicServerDemo::run(), and signal_handler().

Here is the call graph for this function:

signal_handler()

void signal_handler

(

int

)

Examples

tcp_echo_server.cpp.

Definition at line 47 of file quic_server_example.cpp.

{
    std::cout << "\nShutdown signal received..." << std::endl;
    g_running.store(false);
}

References g_running.

Referenced by main(), and main().

Here is the caller graph for this function:

simple_server_example()

void simple_server_example

(

)

Example with minimal setup.

Definition at line 315 of file quic_server_example.cpp.

{
    std::cout << "\n=== Simple QUIC Server ===" << std::endl;
 
    // Create server directly for QUIC-specific features
    auto server = std::make_shared<core::messaging_quic_server>("simple_server");
 
    // Minimal setup - just echo received messages
    server->set_receive_callback(
        [](std::shared_ptr<quic_session> session,
           const std::vector<uint8_t>& data)
        {
            // Echo back
            std::vector<uint8_t> response(data);
            (void)session->send(std::move(response));
        });
 
    core::quic_server_config config;
    config.cert_file = "/path/to/server.crt";
    config.key_file = "/path/to/server.key";
 
    auto result = server->start_server(4434, config);
    if (result.is_ok())
    {
        std::cout << "Simple server started on port 4434" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(5));
        (void)server->stop_server();
    }
}

References config.

Variable Documentation

g_running

std::atomic<bool> g_running {true}

Examples

tcp_echo_server.cpp.

Definition at line 45 of file quic_server_example.cpp.

{true};

Referenced by main(), QuicServerDemo::run(), and signal_handler().