server.hpp

Go to the documentation of this file.

#pragma once
 
#include <roar/directory_server/directory_server.hpp>
#include <roar/beast/forward.hpp>
#include <roar/routing/proto_route.hpp>
#include <roar/error.hpp>
#include <roar/session/session.hpp>
#include <roar/request.hpp>
#include <roar/routing/request_listener.hpp>
#include <roar/standard_response_provider.hpp>
#include <roar/standard_text_response_provider.hpp>
#include <roar/ssl/make_ssl_context.hpp>
#include <roar/filesystem/jail.hpp>
 
#include <boost/describe/modifiers.hpp>
#include <boost/asio/ssl/context.hpp>
#include <boost/describe/members.hpp>
#include <boost/leaf.hpp>
#include <boost/mp11/algorithm.hpp>
#include <boost/beast/http/verb.hpp>
 
#include <memory>
#include <string>
#include <tuple>
#include <unordered_map>
#include <functional>
#include <iterator>
#include <variant>
 
namespace Roar
{
    class RequestListener;
    class Server
    {
      public:
        struct ConstructionArguments
        {
            boost::asio::any_io_executor executor;
 
            std::optional<std::variant<SslServerContext, boost::asio::ssl::context>> sslContext;
 
            std::function<void(Error&&)> onError = [](auto&&) {};
 
            std::function<void(boost::system::error_code)> onAcceptAbort = [](auto) {};
 
            std::unique_ptr<StandardResponseProvider> standardResponseProvider =
                std::make_unique<StandardTextResponseProvider>();
        };
 
        Server(ConstructionArguments constructionArgs);
 
        ~Server();
        Server(Server const&) = delete;
        Server(Server&&);
        Server& operator=(Server const&) = delete;
        Server& operator=(Server&&);
 
        boost::leaf::result<void> start(unsigned short port = 0, std::string const& host = "::");
 
        boost::leaf::result<void> start(boost::asio::ip::basic_endpoint<boost::asio::ip::tcp> const& bindEndpoint);
 
        boost::asio::ip::basic_endpoint<boost::asio::ip::tcp> const& getLocalEndpoint() const;
 
        void stop();
 
        template <typename RequestListenerT, typename... ConstructionArgsT>
        std::shared_ptr<RequestListenerT> installRequestListener(ConstructionArgsT&&... args)
        {
            auto listener = std::make_shared<RequestListenerT>(std::forward<ConstructionArgsT>(args)...);
            using routes = boost::describe::
                describe_members<RequestListenerT, boost::describe::mod_any_access | boost::describe::mod_static>;
            std::unordered_multimap<boost::beast::http::verb, ProtoRoute> extractedRoutes;
            boost::mp11::mp_for_each<routes>([&extractedRoutes, &listener, this]<typename T>(T route) {
                this->addRoute(listener, extractedRoutes, *route.pointer);
            });
            addRequestListenerToRouter(std::move(extractedRoutes));
            return listener;
        }
 
        bool isSecure() const;
 
        boost::asio::any_io_executor getExecutor() const;
 
      private:
        template <typename RequestListenerT>
        void addRoute(
            std::shared_ptr<RequestListenerT> listener,
            std::unordered_multimap<boost::beast::http::verb, ProtoRoute>& extractedRoutes,
            RouteInfo<RequestListenerT> const& info)
        {
            ProtoRoute protoRoute{};
            switch (info.pathType)
            {
                case (RoutePathType::RegularString):
                {
                    protoRoute.path = std::string{info.path};
                    protoRoute.matches = [p = info.path](std::string const& path, std::vector<std::string>&) {
                        return path == p;
                    };
                    break;
                }
                case (RoutePathType::Regex):
                {
                    protoRoute.path = std::regex{info.path};
                    protoRoute.matches =
                        [p = info.path](std::string const& path, std::vector<std::string>& regexMatches) {
                            std::smatch smatch;
                            auto result = std::regex_match(path, smatch, std::regex{p});
                            regexMatches.reserve(smatch.size());
                            for (auto submatch = std::next(std::begin(smatch)), end = std::end(smatch); submatch < end;
                                 ++submatch)
                                regexMatches.push_back(submatch->str());
                            return result;
                        };
                    break;
                }
                default:
                    throw std::runtime_error("Invalid path type for route.");
            }
            protoRoute.routeOptions = info.routeOptions;
            protoRoute.callRoute = [serverIsSecure = isSecure(),
                                    listener,
                                    handler = info.handler,
                                    allowUnsecure = protoRoute.routeOptions.allowUnsecure](
                                       Session& session, Request<boost::beast::http::empty_body> req) {
                if (serverIsSecure && !session.isSecure() && !allowUnsecure)
                    return session.sendStrictTransportSecurityResponse();
                std::invoke(handler, *listener, session, std::move(req));
            };
            extractedRoutes.emplace(*info.verb, protoRoute);
 
            if (protoRoute.routeOptions.cors && protoRoute.routeOptions.cors->generatePreflightOptionsRoute)
            {
                auto preflightRoute = protoRoute;
                protoRoute.callRoute = [serverIsSecure = isSecure(),
                                        allowUnsecure = protoRoute.routeOptions.allowUnsecure](
                                           Session& session, Request<boost::beast::http::empty_body> const& req) {
                    if (serverIsSecure && !session.isSecure() && !allowUnsecure)
                        return session.sendStrictTransportSecurityResponse();
                    session.send<boost::beast::http::empty_body>(session.prepareResponse(req))->commit();
                };
                extractedRoutes.emplace(boost::beast::http::verb::options, preflightRoute);
            }
        }
 
        template <typename RequestListenerT>
        void addRoute(
            std::shared_ptr<RequestListenerT> listener,
            std::unordered_multimap<boost::beast::http::verb, ProtoRoute>& extractedRoutes,
            ServeInfo<RequestListenerT> const& info)
        {
            namespace http = boost::beast::http;
 
            ProtoRoute protoRoute{};
            protoRoute.path = Detail::ServedPath{std::string{info.path}};
            protoRoute.routeOptions = info.routeOptions;
            protoRoute.callRoute = [dserver = Detail::DirectoryServer<RequestListenerT>{{
                                        .serverIsSecure_ = isSecure(),
                                        .serveInfo_ = info,
                                        .listener_ = listener,
                                    }}](Session& session, Request<http::empty_body> const& req) {
                auto dserverCpy = dserver;
                dserverCpy(session, req);
            };
            protoRoute.matches = [p = info.path](std::string const& path, std::vector<std::string>&) {
                return path.starts_with(p);
            };
            // Add the all regardeless of allowed or not, to give a proper response.
            extractedRoutes.emplace(http::verb::options, protoRoute);
            extractedRoutes.emplace(http::verb::head, protoRoute);
            extractedRoutes.emplace(http::verb::get, protoRoute);
            extractedRoutes.emplace(http::verb::put, protoRoute);
            extractedRoutes.emplace(http::verb::delete_, protoRoute);
        }
 
        void addRequestListenerToRouter(std::unordered_multimap<boost::beast::http::verb, ProtoRoute>&& routes);
 
      private:
        struct Implementation;
        std::shared_ptr<Implementation> impl_;
    };
}