routing_context.hpp

#pragma once
 
#include "../core/controller.hpp"
#include "../core/detail/controller_run_result.hpp"
#include "../server/listener.hpp"
#include "../server/routing/router.hpp"
 
#include <memory>
#include <filesystem>
#include <string>
 
namespace boost::asio::ssl
{
    class context;
}
 
namespace malloy::server
{
 
    class router;
    class listener;

    class routing_context
    {
    public:
        using session = malloy::detail::controller_run_result<std::shared_ptr<malloy::server::listener>>;

        struct config :
            malloy::controller::config
        {
            std::shared_ptr<spdlog::logger> connection_logger;

            std::string interface = "127.0.0.1";

            std::uint16_t port = 8080;

            std::filesystem::path doc_root = ".";

            std::string agent_string{"malloy"};
        };
 
        explicit routing_context(config cfg);
        routing_context(const routing_context& other) = delete;
        routing_context(routing_context&& other) noexcept = default;
        ~routing_context() = default;
 
        routing_context& operator=(const routing_context& rhs) = delete;
        routing_context& operator=(routing_context&& rhs) noexcept = default;
 
        #if MALLOY_FEATURE_TLS
            bool
            init_tls(const std::filesystem::path& cert_path, const std::filesystem::path& key_path);

            bool
            init_tls(const std::string& cert, const std::string& key);
        #endif

        [[nodiscard]]
        constexpr
        const malloy::server::router&
        router() const noexcept
        {
            return m_router;
        }

        [[nodiscard]]
        constexpr
        malloy::server::router&
        router() noexcept
        {
            return m_router;
        }
 
    private:
        config m_cfg;
        malloy::server::router m_router;
        #if MALLOY_FEATURE_TLS
            std::unique_ptr<boost::asio::ssl::context> m_tls_ctx;
        #endif
 
        [[nodiscard("ignoring result will cause the server to instantly stop")]]
        friend
        session
        start(routing_context&& ctrl)
        {
            // Log
            ctrl.m_cfg.logger->debug("starting server.");
            auto ioc = std::make_unique<boost::asio::io_context>();
 
            // Create the listener
            auto l = std::make_shared<malloy::server::listener>(
                ctrl.m_cfg.logger->clone("listener"),
                ctrl.m_cfg.connection_logger,
                *ioc,
#if MALLOY_FEATURE_TLS
                std::move(ctrl.m_tls_ctx),
#else
                nullptr,
#endif
                boost::asio::ip::tcp::endpoint{boost::asio::ip::make_address(ctrl.m_cfg.interface), ctrl.m_cfg.port},
                std::make_shared<class router>(std::move(ctrl.m_router)),
                std::make_shared<std::filesystem::path>(ctrl.m_cfg.doc_root),
                ctrl.m_cfg.agent_string);
 
            // Run the listener
            l->run();
 
            return session{ctrl.m_cfg, std::move(l), std::move(ioc)};
        }
    };
 
    auto start(routing_context&&) -> routing_context::session;
 
}