ADC/net/asio/adc_device_netserver_asio.h

#pragma once

#include <asio/io_context.hpp>
#include <asio/ip/tcp.hpp>
#include <asio/ip/udp.hpp>
#include <asio/local/seq_packet_protocol.hpp>
#include <asio/local/stream_protocol.hpp>
#include <asio/signal_set.hpp>

#include "../adc_device_netserver.h"
#include "../adc_endpoint.h"
#include "adc_netservice_asio.h"

namespace adc::impl
{

template <typename IdentT = std::string>
class AdcDeviceNetServerASIO : public AdcDeviceNetServer<IdentT>
{
    typedef AdcDeviceNetServer<IdentT> base_t;

public:
    using typename base_t::server_ident_t;
    typedef std::string session_ident_t;

    template <typename ServiceT>
    using Session = typename base_t::template Session<ServiceT, session_ident_t>;

    AdcDeviceNetServerASIO(const server_ident_t& id, asio::io_context& io_context)
        : base_t(id), _ioContext(io_context), _stopSignal(io_context), _restartSignal(io_context)
    {
    }


    template <interfaces::adc_netsession_proto_c SessProtoT, std::derived_from<AdcEndpoint> EptT>
#ifdef USE_OPENSSL_WITH_ASIO
    void start(const EptT& endpoint,
               asio::ssl::context tls_context = asio::ssl::context(asio::ssl::context::tlsv13_server),
               asio::ssl::verify_mode tls_verify_mode = asio::ssl::context_base::verify_peer)
#else
    void start(const EptT& endpoint)
#endif
    {
        if (!endpoint.isValid()) {
            return;
        }


        // may throw here!
        if (endpoint.isTCP()) {
            asio::ip::tcp::endpoint ept(asio::ip::make_address(endpoint.host()), endpoint.port());
            using srv_t = AdcNetServiceASIO<asio::ip::tcp, SessProtoT>;
            // base_t::template start<Session<srv_t>>("TCP", this, _ioContext, ept);
            base_t::template start<Session<srv_t>>("TCP", {this, _sessionRecvTimeout, _sessionSendTimeout}, _ioContext,
                                                   ept);
#ifdef USE_OPENSSL_WITH_ASIO
        } else if (endpoint.isTLS()) {
            asio::ip::tcp::endpoint ept(asio::ip::make_address(endpoint.host()), endpoint.port());
            using srv_t = AdcNetServiceASIOTLS<asio::ip::tcp, SessProtoT>;
            // base_t::template start<Session<srv_t>>("TLS", this, _ioContext, ept, std::move(tls_context),
            //                                        tls_verify_mode);
            base_t::template start<Session<srv_t>>("TLS", {this, _sessionRecvTimeout, _sessionSendTimeout}, _ioContext,
                                                   ept, std::move(tls_context), tls_verify_mode);
#endif
        } else if (endpoint.isLocal()) {
            if (endpoint.isLocalStream()) {
                asio::local::stream_protocol::endpoint ept(endpoint.template path<std::string>());
                using srv_t = AdcNetServiceASIO<asio::local::stream_protocol, SessProtoT>;
                // base_t::template start<Session<srv_t>>("LOCAL STREAM", this, _ioContext, ept);
                base_t::template start<Session<srv_t>>("LOCAL STREAM", {this, _sessionRecvTimeout, _sessionSendTimeout},
                                                       _ioContext, ept);
                // } else if (endpoint.isLocalDatagram()) {
                //     asio::local::datagram_protocol::endpoint ept(endpoint.template path<std::string>());
                //     using srv_t = AdcNetServiceASIO<asio::local::datagram_protocol, SessProtoT>;
                //     base_t::template start<Session<srv_t>>("LOCAL DGRAM", this, _ioContext, ept);
            } else if (endpoint.isLocalSeqpacket()) {
                asio::local::seq_packet_protocol::endpoint ept(endpoint.template path<std::string>());
                using srv_t = AdcNetServiceASIO<asio::local::seq_packet_protocol, SessProtoT>;
                // base_t::template start<Session<srv_t>>("LOCAL SEQPACK", this, _ioContext, ept);
                base_t::template start<Session<srv_t>>(
                    "LOCAL SEQPACK", {this, _sessionRecvTimeout, _sessionSendTimeout}, _ioContext, ept);
            }
        } else {
            throw std::system_error(std::make_error_code(std::errc::protocol_not_supported));
        }
    }

    // some default endpoint?!!
    void start() {}

    template <std::ranges::range RST = std::vector<int>, std::ranges::range RRT = std::vector<int>>
    void setupSignals(const RST& stop_sig_num = {SIGINT, SIGTERM}, const RRT& restart_sig_num = {SIGUSR1})
        requires(std::convertible_to<std::ranges::range_value_t<RST>, int> &&
                 std::convertible_to<std::ranges::range_value_t<RRT>, int>)
    {
        for (const int sig : stop_sig_num) {
            _stopSignal.add(sig);
        }

        _stopSignal.async_wait([this](std::error_code ec, int signo) {
            signalReceived(ec, signo);
            this->stop();
        });

        for (const int sig : restart_sig_num) {
            _restartSignal.add(sig);
        }

        _restartSignal.async_wait([this](std::error_code ec, int signo) {
            signalReceived(ec, signo);
            restart();
        });
    }

    template <traits::adc_time_duration_c RT, traits::adc_time_duration_c ST>
        requires(std::convertible_to<RT, std::chrono::milliseconds> &&
                 std::convertible_to<ST, std::chrono::milliseconds>)
    void setSessionTimeouts(const RT& recv_timeout, const ST& send_timeout)
    {
        _sessionRecvTimeout = recv_timeout;
        _sessionSendTimeout = send_timeout;
    }

protected:
    asio::io_context& _ioContext;

    asio::signal_set _stopSignal, _restartSignal;

    std::chrono::milliseconds _sessionRecvTimeout = std::chrono::hours(12);
    std::chrono::milliseconds _sessionSendTimeout = std::chrono::seconds(5);


    // demonizing ASIO-related methods
    virtual void daemonizePrepare()
    {
        _ioContext.notify_fork(asio::execution_context::fork_prepare);
    }

    virtual void daemonizeFinalize()
    {
        _ioContext.notify_fork(asio::io_context::fork_child);
    }

    virtual void signalReceived(std::error_code, int signo)
    {
        std::cout << "SIGNAL: " << signo << "\n";
    };

    virtual void restart()
    {
        this->stopAllSessions();

        _restartSignal.async_wait([this](std::error_code ec, int signo) {
            signalReceived(ec, signo);
            restart();
        });
    }
};

}  // namespace adc::impl