server.hpp

Go to the documentation of this file.

#pragma once
 
#include <chrono>
using namespace std::chrono_literals;
 
#include "native.h"
#include <asio.hpp>
#include <asio/experimental/awaitable_operators.hpp>
using namespace asio::experimental::awaitable_operators;
 
#include <spdlog/spdlog.h>
 
#include "async.hpp"
#include "http.hpp"
#include "route.hpp"
 
namespace dcn::server
{
    using HandlerDefinition = std::function<asio::awaitable<dcn::http::Response>(const dcn::http::Request &, std::vector<RouteArg>, QueryArgsList)>;
 
    // TODO: Add a concept to check if the handler is callable with the expected arguments
    // template<class F, class ... Args>
    // concept HandlerCallable = requires(F handler, Args... args)
    // {
    //     { t(args...) } -> std::same_as<asio::awaitable<dcn::http::Response>>;
    // };
 
    class Server
    {
        public:
            Server(asio::io_context & io_context, asio::ip::tcp::endpoint endpoint);
            ~Server() = default;
 
            asio::awaitable<void> listen();
 
            template<class F>
            void addRoute(RouteKey route, F && handler)
            {
                _router.addRoute(std::move(route), RouteHandlerFunc(
                    HandlerDefinition(std::move(handler)))
                );
            }
 
            template<class F, class ... Args>
            void addRoute(RouteKey route, F && handler, Args&&... binded_args)
            {
                _router.addRoute(std::move(route), RouteHandlerFunc(
                    HandlerDefinition(
                        std::bind(handler, _1, _2, _3, std::forward<Args>(binded_args)...)
                    )
                ));
            }
 
            template<class F>
            void addStreamingRoute(RouteKey route, F && handler)
            {
                _router.addRoute(std::move(route), RouteHandlerFunc(
                    StreamingHandlerDefinition(std::move(handler))
                ));
            }
 
            template<class F, class ... Args>
            void addStreamingRoute(RouteKey route, F && handler, Args&&... binded_args)
            {
                _router.addRoute(std::move(route), RouteHandlerFunc(
                    StreamingHandlerDefinition(
                        std::bind(handler, _1, _2, _3, _4, _5, std::forward<Args>(binded_args)...)
                    )
                ));
            }
            
            void setIdleInterval(std::chrono::milliseconds idle_interval);
 
            asio::awaitable<void> close();
 
        protected:
 
            asio::awaitable<void> handleConnection(asio::ip::tcp::socket sock);
 
            asio::awaitable<void> readData(asio::ip::tcp::socket & sock, std::chrono::steady_clock::time_point & deadline);
 
            asio::awaitable<void> writeData(asio::ip::tcp::socket & sock, std::string message);
 
        private:
            asio::io_context & _io_context;
            asio::strand<asio::io_context::executor_type> _strand;
            bool _close;
 
            asio::ip::tcp::acceptor _acceptor;
            Router _router;
 
            std::chrono::milliseconds _idle_interval;
    };
}