HttpServer.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2017 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER__HTTP_SERVER
#define COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER__HTTP_SERVER

#include <Balau/Network/Http/Server/HttpServerConfiguration.hpp>
#include <Balau/Network/Http/Server/HttpWebApps/RoutingHttpWebApp.hpp>
#include <Balau/Network/Http/Server/WsWebApps/RoutingWsWebApp.hpp>
#include <Balau/Resource/File.hpp>
#include <Balau/System/Clock.hpp>
#include <Balau/Application/Injectable.hpp>

#include <boost/asio/signal_set.hpp>

#include <condition_variable>
#include <mutex>
#include <thread>

// Avoid false positive (due to make_shared).
#pragma clang diagnostic push
#pragma ide diagnostic ignored "OCUnusedGlobalDeclarationInspection"

namespace Balau {

class Logger;

namespace Network::Http {

namespace Impl {

class Listener;

}

class HttpServer {
    BalauInjectNamedTypes(
          HttpServer
        , std::shared_ptr<System::Clock>,         ""
        , std::shared_ptr<EnvironmentProperties>, "http.server"
        , bool,                                   "http.server.register.signal.handler"
    );


    public: HttpServer(std::shared_ptr<System::Clock> clock,
                       const std::shared_ptr<EnvironmentProperties>& configuration,
                       bool registerSignalHandler = true);

    public: HttpServer(std::shared_ptr<System::Clock> clock,
                       const std::string & serverIdentification,
                       const TCP::endpoint & endpoint,
                       std::string threadNamePrefix_,
                       size_t workerCount_,
                       std::shared_ptr<HttpWebApp> httpHandler,
                       std::shared_ptr<WsWebApp> wsHandler = std::shared_ptr<WsWebApp>(nullptr),
                       const std::string & loggingNamespace = "balau.network.server",
                       std::string sessionCookieName = "session",
                       std::shared_ptr<MimeTypes> mimeTypes = MimeTypes::defaultMimeTypes,
                       bool registerSignalHandler = true);

    public: HttpServer(std::shared_ptr<System::Clock> clock,
                       const std::string & serverIdentification,
                       const TCP::endpoint & endpoint,
                       std::string threadNamePrefix_,
                       size_t workerCount_,
                       const Resource::File & documentRoot,
                       const std::string & defaultFile = "index.html",
                       const std::string & loggingNamespace = "balau.network.server",
                       std::string sessionCookieName = "session",
                       std::shared_ptr<MimeTypes> mimeTypes = MimeTypes::defaultMimeTypes,
                       bool registerSignalHandler = true);

    public: ~HttpServer();


    public: void startAsync();

    public: void startSync();

    public: bool isRunning();

    public: void stop(bool warn = false);

    public: std::string getAddress() const {
        return toString(state->endpoint.address());
    }

    public: unsigned short getPort() const {
        return state->endpoint.port();
    }


    // Used for injection for compilers without guaranteed copy elision.
    private: HttpServer(HttpServer && rhs) noexcept
        : state(std::move(rhs.state))
        , threadNamePrefix(rhs.threadNamePrefix)
        , workerCount(rhs.workerCount)
        , workers(std::move(rhs.workers))
        , launched(std::move(rhs.launched))
        , listener(std::move(rhs.listener))
        , ioContext(std::move(rhs.ioContext))
        , mutex(std::move(rhs.mutex))
        , signalSet(std::move(rhs.signalSet)) {}

    //
    // Create the HTTP server configuration object.
    //
    private: static std::shared_ptr<HttpServerConfiguration> createState(std::shared_ptr<System::Clock> clock,
                                                                         const std::shared_ptr<EnvironmentProperties> & configuration);

    //
    // Create a mime type map from the environment configuration if one is
    // supplied, otherwise use the default mime type map that is hard coded.
    //
    private: static std::shared_ptr<MimeTypes> createMimeTypes(const std::shared_ptr<EnvironmentProperties> & configuration,
                                                               BalauLogger & logger);

    //
    // Create the HTTP handler, consisting of a HTTP routing handle at the base
    // and other HTTP handlers at the leaves.
    //
    private: static std::shared_ptr<HttpWebApp> createHttpHandler(const std::shared_ptr<EnvironmentProperties> & configuration,
                                                                  BalauLogger & logger);

    //
    // Create the WebSocket handler, consisting of a WebSocket routing handle at the base
    // and other WebSocket handlers at the leaves.
    //
    private: static std::shared_ptr<WsWebApp> createWsHandler(const std::shared_ptr<EnvironmentProperties> & configuration,
                                                              BalauLogger & logger);

    //
    // Helper function that adds the HTTP web application to the supplied routing
    // trie in the location(s) specified in the location string.
    //
    // An exception will be thrown a location is specified that already has a web
    // application defined for it.
    //
    private: static void addToHttpRoutingTrie(HttpWebApps::RoutingHttpWebApp::Routing & routing,
                                              const std::string & locationStr,
                                              std::shared_ptr<HttpWebApp> & webApp);

    private: void launchListener();
    private: void workerThreadFunction(size_t workerIndex);
    private: void doRegisterSignalHandler();
    private: void handleSignal(const boost::system::error_code & error, int sig);

    private: std::shared_ptr<HttpServerConfiguration> state;
    private: const std::string threadNamePrefix;
    private: const size_t workerCount;
    private: std::vector<std::thread> workers;
    private: std::unique_ptr<std::atomic_uint> launched;
    private: std::shared_ptr<Impl::Listener> listener;
    private: std::unique_ptr<boost::asio::io_context> ioContext;
    private: std::unique_ptr<std::mutex> mutex;
    private: std::unique_ptr<boost::asio::signal_set> signalSet;
};

} // namespace Network::Http

} // namespace Balau

#pragma clang diagnostic pop

#endif // COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER__HTTP_SERVER