mirror of https://github.com/CrowCpp/Crow.git
777 lines
25 KiB
C++
777 lines
25 KiB
C++
/**
|
|
* \file crow/app.h
|
|
* \brief This file includes the definition of the crow::Crow class,
|
|
* the crow::App and crow::SimpleApp aliases, and some macros.
|
|
*
|
|
* In this file are defined:
|
|
* - crow::Crow
|
|
* - crow::App
|
|
* - crow::SimpleApp
|
|
* - \ref CROW_ROUTE
|
|
* - \ref CROW_BP_ROUTE
|
|
* - \ref CROW_WEBSOCKET_ROUTE
|
|
* - \ref CROW_MIDDLEWARES
|
|
* - \ref CROW_CATCHALL_ROUTE
|
|
* - \ref CROW_BP_CATCHALL_ROUTE
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <chrono>
|
|
#include <string>
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <future>
|
|
#include <cstdint>
|
|
#include <type_traits>
|
|
#include <thread>
|
|
#include <condition_variable>
|
|
|
|
#include "crow/version.h"
|
|
#include "crow/settings.h"
|
|
#include "crow/logging.h"
|
|
#include "crow/utility.h"
|
|
#include "crow/routing.h"
|
|
#include "crow/middleware_context.h"
|
|
#include "crow/http_request.h"
|
|
#include "crow/http_server.h"
|
|
#include "crow/task_timer.h"
|
|
#include "crow/websocket.h"
|
|
#ifdef CROW_ENABLE_COMPRESSION
|
|
#include "crow/compression.h"
|
|
#endif // #ifdef CROW_ENABLE_COMPRESSION
|
|
|
|
|
|
#ifdef CROW_MSVC_WORKAROUND
|
|
|
|
#define CROW_ROUTE(app, url) app.route_dynamic(url) // See the documentation in the comment below.
|
|
#define CROW_BP_ROUTE(blueprint, url) blueprint.new_rule_dynamic(url) // See the documentation in the comment below.
|
|
|
|
#else // #ifdef CROW_MSVC_WORKAROUND
|
|
|
|
/**
|
|
* \def CROW_ROUTE(app, url)
|
|
* \brief Creates a route for app using a rule.
|
|
*
|
|
* It use crow::Crow::route_dynamic or crow::Crow::route to define
|
|
* a rule for your application. It's usage is like this:
|
|
*
|
|
* ```cpp
|
|
* auto app = crow::SimpleApp(); // or crow::App()
|
|
* CROW_ROUTE(app, "/")
|
|
* ([](){
|
|
* return "<h1>Hello, world!</h1>";
|
|
* });
|
|
* ```
|
|
*
|
|
* This is the recommended way to define routes in a crow application.
|
|
* \see [Page of guide "Routes"](https://crowcpp.org/master/guides/routes/).
|
|
*/
|
|
#define CROW_ROUTE(app, url) app.template route<crow::black_magic::get_parameter_tag(url)>(url)
|
|
|
|
/**
|
|
* \def CROW_BP_ROUTE(blueprint, url)
|
|
* \brief Creates a route for a blueprint using a rule.
|
|
*
|
|
* It may use crow::Blueprint::new_rule_dynamic or
|
|
* crow::Blueprint::new_rule_tagged to define a new rule for
|
|
* an given blueprint. It's usage is similar
|
|
* to CROW_ROUTE macro:
|
|
*
|
|
* ```cpp
|
|
* crow::Blueprint my_bp();
|
|
* CROW_BP_ROUTE(my_bp, "/")
|
|
* ([](){
|
|
* return "<h1>Hello, world!</h1>";
|
|
* });
|
|
* ```
|
|
*
|
|
* This is the recommended way to define routes in a crow blueprint
|
|
* because of its compile-time capabilities.
|
|
*
|
|
* \see [Page of the guide "Blueprints"](https://crowcpp.org/master/guides/blueprints/).
|
|
*/
|
|
#define CROW_BP_ROUTE(blueprint, url) blueprint.new_rule_tagged<crow::black_magic::get_parameter_tag(url)>(url)
|
|
|
|
/**
|
|
* \def CROW_WEBSOCKET_ROUTE(app, url)
|
|
* \brief Defines WebSocket route for app.
|
|
*
|
|
* It binds a WebSocket route to app. Easy solution to implement
|
|
* WebSockets in your app. The usage syntax of this macro is
|
|
* like this:
|
|
*
|
|
* ```cpp
|
|
* auto app = crow::SimpleApp(); // or crow::App()
|
|
* CROW_WEBSOCKET_ROUTE(app, "/ws")
|
|
* .onopen([&](crow::websocket::connection& conn){
|
|
* do_something();
|
|
* })
|
|
* .onclose([&](crow::websocket::connection& conn, const std::string& reason){
|
|
* do_something();
|
|
* })
|
|
* .onmessage([&](crow::websocket::connection&, const std::string& data, bool is_binary){
|
|
* if (is_binary)
|
|
* do_something(data);
|
|
* else
|
|
* do_something_else(data);
|
|
* });
|
|
* ```
|
|
*
|
|
* \see [Page of the guide "WebSockets"](https://crowcpp.org/master/guides/websockets/).
|
|
*/
|
|
#define CROW_WEBSOCKET_ROUTE(app, url) app.route<crow::black_magic::get_parameter_tag(url)>(url).websocket<std::remove_reference<decltype(app)>::type>(&app)
|
|
|
|
/**
|
|
* \def CROW_MIDDLEWARES(app, ...)
|
|
* \brief Enable a Middleware for an specific route in app
|
|
* or blueprint.
|
|
*
|
|
* It defines the usage of a Middleware in one route. And it
|
|
* can be used in both crow::SimpleApp (and crow::App) instances and
|
|
* crow::Blueprint. Its usage syntax is like this:
|
|
*
|
|
* ```cpp
|
|
* auto app = crow::SimpleApp(); // or crow::App()
|
|
* CROW_ROUTE(app, "/with_middleware")
|
|
* .CROW_MIDDLEWARES(app, LocalMiddleware) // Can be used more than one
|
|
* ([]() { // middleware.
|
|
* return "Hello world!";
|
|
* });
|
|
* ```
|
|
*
|
|
* \see [Page of the guide "Middlewares"](https://crowcpp.org/master/guides/middleware/).
|
|
*/
|
|
#define CROW_MIDDLEWARES(app, ...) template middlewares<typename std::remove_reference<decltype(app)>::type, __VA_ARGS__>()
|
|
|
|
#endif // #ifdef CROW_MSVC_WORKAROUND
|
|
|
|
/**
|
|
* \def CROW_CATCHALL_ROUTE(app)
|
|
* \brief Defines a custom catchall route for app using a
|
|
* custom rule.
|
|
*
|
|
* It defines a handler when the client make a request for an
|
|
* undefined route. Instead of just reply with a `404` status
|
|
* code (default behavior), you can define a custom handler
|
|
* using this macro.
|
|
*
|
|
* \see [Page of the guide "Routes" (Catchall routes)](https://crowcpp.org/master/guides/routes/#catchall-routes).
|
|
*/
|
|
#define CROW_CATCHALL_ROUTE(app) app.catchall_route()
|
|
|
|
/**
|
|
* \def CROW_BP_CATCHALL_ROUTE(blueprint)
|
|
* \brief Defines a custom catchall route for blueprint
|
|
* using a custom rule.
|
|
*
|
|
* It defines a handler when the client make a request for an
|
|
* undefined route in the blueprint.
|
|
*
|
|
* \see [Page of the guide "Blueprint" (Define a custom Catchall route)](https://crowcpp.org/master/guides/blueprints/#define-a-custom-catchall-route).
|
|
*/
|
|
#define CROW_BP_CATCHALL_ROUTE(blueprint) blueprint.catchall_rule()
|
|
|
|
|
|
/**
|
|
* \namespace crow
|
|
* \brief The main namespace of the library. In this namespace
|
|
* is defined the most important classes and functions of the
|
|
* library.
|
|
*
|
|
* Within this namespace, the Crow class, Router class, Connection
|
|
* class, and other are defined.
|
|
*/
|
|
namespace crow
|
|
{
|
|
#ifdef CROW_ENABLE_SSL
|
|
using ssl_context_t = asio::ssl::context;
|
|
#endif
|
|
/**
|
|
* \class Crow
|
|
* \brief The main server application class.
|
|
*
|
|
* Use crow::SimpleApp or crow::App<Middleware1, Middleware2, etc...> instead of
|
|
* directly instantiate this class.
|
|
*/
|
|
template<typename... Middlewares>
|
|
class Crow
|
|
{
|
|
public:
|
|
/// \brief This is the crow application
|
|
using self_t = Crow;
|
|
|
|
/// \brief The HTTP server
|
|
using server_t = Server<Crow, SocketAdaptor, Middlewares...>;
|
|
|
|
#ifdef CROW_ENABLE_SSL
|
|
/// \brief An HTTP server that runs on SSL with an SSLAdaptor
|
|
using ssl_server_t = Server<Crow, SSLAdaptor, Middlewares...>;
|
|
#endif
|
|
Crow()
|
|
{}
|
|
|
|
/// \brief Construct Crow with a subset of middleware
|
|
template<typename... Ts>
|
|
Crow(Ts&&... ts):
|
|
middlewares_(make_middleware_tuple(std::forward<Ts>(ts)...))
|
|
{}
|
|
|
|
/// \brief Process an Upgrade request
|
|
///
|
|
/// Currently used to upgrade an HTTP connection to a WebSocket connection
|
|
template<typename Adaptor>
|
|
void handle_upgrade(const request& req, response& res, Adaptor&& adaptor)
|
|
{
|
|
router_.handle_upgrade(req, res, adaptor);
|
|
}
|
|
|
|
/// \brief Process only the method and URL of a request and provide a route (or an error response)
|
|
std::unique_ptr<routing_handle_result> handle_initial(request& req, response& res)
|
|
{
|
|
return router_.handle_initial(req, res);
|
|
}
|
|
|
|
/// \brief Process the fully parsed request and generate a response for it
|
|
void handle(request& req, response& res, std::unique_ptr<routing_handle_result>& found)
|
|
{
|
|
router_.handle<self_t>(req, res, *found);
|
|
}
|
|
|
|
/// \brief Process a fully parsed request from start to finish (primarily used for debugging)
|
|
void handle_full(request& req, response& res)
|
|
{
|
|
auto found = handle_initial(req, res);
|
|
if (found->rule_index)
|
|
handle(req, res, found);
|
|
}
|
|
|
|
/// \brief Create a dynamic route using a rule (**Use CROW_ROUTE instead**)
|
|
DynamicRule& route_dynamic(const std::string& rule)
|
|
{
|
|
return router_.new_rule_dynamic(rule);
|
|
}
|
|
|
|
/// \brief Create a route using a rule (**Use CROW_ROUTE instead**)
|
|
template<uint64_t Tag>
|
|
#ifdef CROW_GCC83_WORKAROUND
|
|
auto& route(const std::string& rule)
|
|
#else
|
|
auto route(const std::string& rule)
|
|
#endif
|
|
#if defined CROW_CAN_USE_CPP17 && !defined CROW_GCC83_WORKAROUND
|
|
-> typename std::invoke_result<decltype(&Router::new_rule_tagged<Tag>), Router, const std::string&>::type
|
|
#elif !defined CROW_GCC83_WORKAROUND
|
|
-> typename std::result_of<decltype (&Router::new_rule_tagged<Tag>)(Router, const std::string&)>::type
|
|
#endif
|
|
{
|
|
return router_.new_rule_tagged<Tag>(rule);
|
|
}
|
|
|
|
/// \brief Create a route for any requests without a proper route (**Use CROW_CATCHALL_ROUTE instead**)
|
|
CatchallRule& catchall_route()
|
|
{
|
|
return router_.catchall_rule();
|
|
}
|
|
|
|
/// \brief Set the default max payload size for websockets
|
|
self_t& websocket_max_payload(uint64_t max_payload)
|
|
{
|
|
max_payload_ = max_payload;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Get the default max payload size for websockets
|
|
uint64_t websocket_max_payload()
|
|
{
|
|
return max_payload_;
|
|
}
|
|
|
|
self_t& signal_clear()
|
|
{
|
|
signals_.clear();
|
|
return *this;
|
|
}
|
|
|
|
self_t& signal_add(int signal_number)
|
|
{
|
|
signals_.push_back(signal_number);
|
|
return *this;
|
|
}
|
|
|
|
std::vector<int> signals()
|
|
{
|
|
return signals_;
|
|
}
|
|
|
|
/// \brief Set the port that Crow will handle requests on
|
|
self_t& port(std::uint16_t port)
|
|
{
|
|
port_ = port;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Get the port that Crow will handle requests on
|
|
std::uint16_t port()
|
|
{
|
|
return port_;
|
|
}
|
|
|
|
/// \brief Set the connection timeout in seconds (default is 5)
|
|
self_t& timeout(std::uint8_t timeout)
|
|
{
|
|
timeout_ = timeout;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Set the server name
|
|
self_t& server_name(std::string server_name)
|
|
{
|
|
server_name_ = server_name;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief The IP address that Crow will handle requests on (default is 0.0.0.0)
|
|
self_t& bindaddr(std::string bindaddr)
|
|
{
|
|
bindaddr_ = bindaddr;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Get the address that Crow will handle requests on
|
|
std::string bindaddr()
|
|
{
|
|
return bindaddr_;
|
|
}
|
|
|
|
/// \brief Run the server on multiple threads using all available threads
|
|
self_t& multithreaded()
|
|
{
|
|
return concurrency(std::thread::hardware_concurrency());
|
|
}
|
|
|
|
/// \brief Run the server on multiple threads using a specific number
|
|
self_t& concurrency(std::uint16_t concurrency)
|
|
{
|
|
if (concurrency < 2) // Crow can have a minimum of 2 threads running
|
|
concurrency = 2;
|
|
concurrency_ = concurrency;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Get the number of threads that server is using
|
|
std::uint16_t concurrency()
|
|
{
|
|
return concurrency_;
|
|
}
|
|
|
|
/// \brief Set the server's log level
|
|
///
|
|
/// Possible values are:
|
|
/// - crow::LogLevel::Debug (0)
|
|
/// - crow::LogLevel::Info (1)
|
|
/// - crow::LogLevel::Warning (2)
|
|
/// - crow::LogLevel::Error (3)
|
|
/// - crow::LogLevel::Critical (4)
|
|
self_t& loglevel(LogLevel level)
|
|
{
|
|
crow::logger::setLogLevel(level);
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Set the response body size (in bytes) beyond which Crow automatically streams responses (Default is 1MiB)
|
|
///
|
|
/// Any streamed response is unaffected by Crow's timer, and therefore won't timeout before a response is fully sent.
|
|
self_t& stream_threshold(size_t threshold)
|
|
{
|
|
res_stream_threshold_ = threshold;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Get the response body size (in bytes) beyond which Crow automatically streams responses
|
|
size_t& stream_threshold()
|
|
{
|
|
return res_stream_threshold_;
|
|
}
|
|
|
|
|
|
self_t& register_blueprint(Blueprint& blueprint)
|
|
{
|
|
router_.register_blueprint(blueprint);
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Set the function to call to handle uncaught exceptions generated in routes (Default generates error 500).
|
|
///
|
|
/// The function must have the following signature: void(crow::response&).
|
|
/// It must set the response passed in argument to the function, which will be sent back to the client.
|
|
/// See Router::default_exception_handler() for the default implementation.
|
|
template<typename Func>
|
|
self_t& exception_handler(Func&& f)
|
|
{
|
|
router_.exception_handler() = std::forward<Func>(f);
|
|
return *this;
|
|
}
|
|
|
|
std::function<void(crow::response&)>& exception_handler()
|
|
{
|
|
return router_.exception_handler();
|
|
}
|
|
|
|
/// \brief Set a custom duration and function to run on every tick
|
|
template<typename Duration, typename Func>
|
|
self_t& tick(Duration d, Func f)
|
|
{
|
|
tick_interval_ = std::chrono::duration_cast<std::chrono::milliseconds>(d);
|
|
tick_function_ = f;
|
|
return *this;
|
|
}
|
|
|
|
#ifdef CROW_ENABLE_COMPRESSION
|
|
|
|
self_t& use_compression(compression::algorithm algorithm)
|
|
{
|
|
comp_algorithm_ = algorithm;
|
|
compression_used_ = true;
|
|
return *this;
|
|
}
|
|
|
|
compression::algorithm compression_algorithm()
|
|
{
|
|
return comp_algorithm_;
|
|
}
|
|
|
|
bool compression_used() const
|
|
{
|
|
return compression_used_;
|
|
}
|
|
#endif
|
|
|
|
/// \brief Apply blueprints
|
|
void add_blueprint()
|
|
{
|
|
#if defined(__APPLE__) || defined(__MACH__)
|
|
if (router_.blueprints().empty()) return;
|
|
#endif
|
|
|
|
for (Blueprint* bp : router_.blueprints())
|
|
{
|
|
if (bp->static_dir().empty()) continue;
|
|
|
|
auto static_dir_ = crow::utility::normalize_path(bp->static_dir());
|
|
|
|
bp->new_rule_tagged<crow::black_magic::get_parameter_tag(CROW_STATIC_ENDPOINT)>(CROW_STATIC_ENDPOINT)([static_dir_](crow::response& res, std::string file_path_partial) {
|
|
utility::sanitize_filename(file_path_partial);
|
|
res.set_static_file_info_unsafe(static_dir_ + file_path_partial);
|
|
res.end();
|
|
});
|
|
}
|
|
|
|
router_.validate_bp();
|
|
}
|
|
|
|
/// \brief Go through the rules, upgrade them if possible, and add them to the list of rules
|
|
void add_static_dir()
|
|
{
|
|
if (are_static_routes_added()) return;
|
|
auto static_dir_ = crow::utility::normalize_path(CROW_STATIC_DIRECTORY);
|
|
|
|
route<crow::black_magic::get_parameter_tag(CROW_STATIC_ENDPOINT)>(CROW_STATIC_ENDPOINT)([static_dir_](crow::response& res, std::string file_path_partial) {
|
|
utility::sanitize_filename(file_path_partial);
|
|
res.set_static_file_info_unsafe(static_dir_ + file_path_partial);
|
|
res.end();
|
|
});
|
|
set_static_routes_added();
|
|
}
|
|
|
|
/// \brief A wrapper for `validate()` in the router
|
|
void validate()
|
|
{
|
|
router_.validate();
|
|
}
|
|
|
|
/// \brief Run the server
|
|
void run()
|
|
{
|
|
#ifndef CROW_DISABLE_STATIC_DIR
|
|
add_blueprint();
|
|
add_static_dir();
|
|
#endif
|
|
validate();
|
|
|
|
#ifdef CROW_ENABLE_SSL
|
|
if (ssl_used_)
|
|
{
|
|
ssl_server_ = std::move(std::unique_ptr<ssl_server_t>(new ssl_server_t(this, bindaddr_, port_, server_name_, &middlewares_, concurrency_, timeout_, &ssl_context_)));
|
|
ssl_server_->set_tick_function(tick_interval_, tick_function_);
|
|
ssl_server_->signal_clear();
|
|
for (auto snum : signals_)
|
|
{
|
|
ssl_server_->signal_add(snum);
|
|
}
|
|
notify_server_start();
|
|
ssl_server_->run();
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
server_ = std::move(std::unique_ptr<server_t>(new server_t(this, bindaddr_, port_, server_name_, &middlewares_, concurrency_, timeout_, nullptr)));
|
|
server_->set_tick_function(tick_interval_, tick_function_);
|
|
for (auto snum : signals_)
|
|
{
|
|
server_->signal_add(snum);
|
|
}
|
|
notify_server_start();
|
|
server_->run();
|
|
}
|
|
}
|
|
|
|
/// \brief Non-blocking version of \ref run()
|
|
///
|
|
/// The output from this method needs to be saved into a variable!
|
|
/// Otherwise the call will be made on the same thread.
|
|
std::future<void> run_async()
|
|
{
|
|
return std::async(std::launch::async, [&] {
|
|
this->run();
|
|
});
|
|
}
|
|
|
|
/// \brief Stop the server
|
|
void stop()
|
|
{
|
|
#ifdef CROW_ENABLE_SSL
|
|
if (ssl_used_)
|
|
{
|
|
if (ssl_server_) { ssl_server_->stop(); }
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
// TODO(EDev): Move these 6 lines to a method in http_server.
|
|
std::vector<crow::websocket::connection*> websockets_to_close = websockets_;
|
|
for (auto websocket : websockets_to_close)
|
|
{
|
|
CROW_LOG_INFO << "Quitting Websocket: " << websocket;
|
|
websocket->close("Server Application Terminated");
|
|
}
|
|
if (server_) { server_->stop(); }
|
|
}
|
|
}
|
|
|
|
void add_websocket(crow::websocket::connection* conn)
|
|
{
|
|
websockets_.push_back(conn);
|
|
}
|
|
|
|
void remove_websocket(crow::websocket::connection* conn)
|
|
{
|
|
websockets_.erase(std::remove(websockets_.begin(), websockets_.end(), conn), websockets_.end());
|
|
}
|
|
|
|
/// \brief Print the routing paths defined for each HTTP method
|
|
void debug_print()
|
|
{
|
|
CROW_LOG_DEBUG << "Routing:";
|
|
router_.debug_print();
|
|
}
|
|
|
|
|
|
#ifdef CROW_ENABLE_SSL
|
|
|
|
/// \brief Use certificate and key files for SSL
|
|
self_t& ssl_file(const std::string& crt_filename, const std::string& key_filename)
|
|
{
|
|
ssl_used_ = true;
|
|
ssl_context_.set_verify_mode(asio::ssl::verify_peer);
|
|
ssl_context_.set_verify_mode(asio::ssl::verify_client_once);
|
|
ssl_context_.use_certificate_file(crt_filename, ssl_context_t::pem);
|
|
ssl_context_.use_private_key_file(key_filename, ssl_context_t::pem);
|
|
ssl_context_.set_options(
|
|
asio::ssl::context::default_workarounds | asio::ssl::context::no_sslv2 | asio::ssl::context::no_sslv3);
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Use `.pem` file for SSL
|
|
self_t& ssl_file(const std::string& pem_filename)
|
|
{
|
|
ssl_used_ = true;
|
|
ssl_context_.set_verify_mode(asio::ssl::verify_peer);
|
|
ssl_context_.set_verify_mode(asio::ssl::verify_client_once);
|
|
ssl_context_.load_verify_file(pem_filename);
|
|
ssl_context_.set_options(
|
|
asio::ssl::context::default_workarounds | asio::ssl::context::no_sslv2 | asio::ssl::context::no_sslv3);
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Use certificate chain and key files for SSL
|
|
self_t& ssl_chainfile(const std::string& crt_filename, const std::string& key_filename)
|
|
{
|
|
ssl_used_ = true;
|
|
ssl_context_.set_verify_mode(asio::ssl::verify_peer);
|
|
ssl_context_.set_verify_mode(asio::ssl::verify_client_once);
|
|
ssl_context_.use_certificate_chain_file(crt_filename);
|
|
ssl_context_.use_private_key_file(key_filename, ssl_context_t::pem);
|
|
ssl_context_.set_options(
|
|
asio::ssl::context::default_workarounds | asio::ssl::context::no_sslv2 | asio::ssl::context::no_sslv3);
|
|
return *this;
|
|
}
|
|
|
|
self_t& ssl(asio::ssl::context&& ctx)
|
|
{
|
|
ssl_used_ = true;
|
|
ssl_context_ = std::move(ctx);
|
|
return *this;
|
|
}
|
|
|
|
bool ssl_used() const
|
|
{
|
|
return ssl_used_;
|
|
}
|
|
#else
|
|
|
|
template<typename T, typename... Remain>
|
|
self_t& ssl_file(T&&, Remain&&...)
|
|
{
|
|
// We can't call .ssl() member function unless CROW_ENABLE_SSL is defined.
|
|
static_assert(
|
|
// make static_assert dependent to T; always false
|
|
std::is_base_of<T, void>::value,
|
|
"Define CROW_ENABLE_SSL to enable ssl support.");
|
|
return *this;
|
|
}
|
|
|
|
template<typename T, typename... Remain>
|
|
self_t& ssl_chainfile(T&&, Remain&&...)
|
|
{
|
|
// We can't call .ssl() member function unless CROW_ENABLE_SSL is defined.
|
|
static_assert(
|
|
// make static_assert dependent to T; always false
|
|
std::is_base_of<T, void>::value,
|
|
"Define CROW_ENABLE_SSL to enable ssl support.");
|
|
return *this;
|
|
}
|
|
|
|
template<typename T>
|
|
self_t& ssl(T&&)
|
|
{
|
|
// We can't call .ssl() member function unless CROW_ENABLE_SSL is defined.
|
|
static_assert(
|
|
// make static_assert dependent to T; always false
|
|
std::is_base_of<T, void>::value,
|
|
"Define CROW_ENABLE_SSL to enable ssl support.");
|
|
return *this;
|
|
}
|
|
|
|
bool ssl_used() const
|
|
{
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
// middleware
|
|
using context_t = detail::context<Middlewares...>;
|
|
using mw_container_t = std::tuple<Middlewares...>;
|
|
template<typename T>
|
|
typename T::context& get_context(const request& req)
|
|
{
|
|
static_assert(black_magic::contains<T, Middlewares...>::value, "App doesn't have the specified middleware type.");
|
|
auto& ctx = *reinterpret_cast<context_t*>(req.middleware_context);
|
|
return ctx.template get<T>();
|
|
}
|
|
|
|
template<typename T>
|
|
T& get_middleware()
|
|
{
|
|
return utility::get_element_by_type<T, Middlewares...>(middlewares_);
|
|
}
|
|
|
|
/// \brief Wait until the server has properly started
|
|
void wait_for_server_start()
|
|
{
|
|
{
|
|
std::unique_lock<std::mutex> lock(start_mutex_);
|
|
if (!server_started_)
|
|
cv_started_.wait(lock);
|
|
}
|
|
if (server_)
|
|
server_->wait_for_start();
|
|
#ifdef CROW_ENABLE_SSL
|
|
else if (ssl_server_)
|
|
ssl_server_->wait_for_start();
|
|
#endif
|
|
}
|
|
|
|
private:
|
|
template<typename... Ts>
|
|
std::tuple<Middlewares...> make_middleware_tuple(Ts&&... ts)
|
|
{
|
|
auto fwd = std::forward_as_tuple((ts)...);
|
|
return std::make_tuple(
|
|
std::forward<Middlewares>(
|
|
black_magic::tuple_extract<Middlewares, decltype(fwd)>(fwd))...);
|
|
}
|
|
|
|
/// \brief Notify anything using \ref wait_for_server_start() to proceed
|
|
void notify_server_start()
|
|
{
|
|
std::unique_lock<std::mutex> lock(start_mutex_);
|
|
server_started_ = true;
|
|
cv_started_.notify_all();
|
|
}
|
|
|
|
void set_static_routes_added() {
|
|
static_routes_added_ = true;
|
|
}
|
|
|
|
bool are_static_routes_added() {
|
|
return static_routes_added_;
|
|
}
|
|
|
|
private:
|
|
std::uint8_t timeout_{5};
|
|
uint16_t port_ = 80;
|
|
uint16_t concurrency_ = 2;
|
|
uint64_t max_payload_{UINT64_MAX};
|
|
std::string server_name_ = std::string("Crow/") + VERSION;
|
|
std::string bindaddr_ = "0.0.0.0";
|
|
size_t res_stream_threshold_ = 1048576;
|
|
Router router_;
|
|
bool static_routes_added_{false};
|
|
|
|
#ifdef CROW_ENABLE_COMPRESSION
|
|
compression::algorithm comp_algorithm_;
|
|
bool compression_used_{false};
|
|
#endif
|
|
|
|
std::chrono::milliseconds tick_interval_;
|
|
std::function<void()> tick_function_;
|
|
|
|
std::tuple<Middlewares...> middlewares_;
|
|
|
|
#ifdef CROW_ENABLE_SSL
|
|
std::unique_ptr<ssl_server_t> ssl_server_;
|
|
bool ssl_used_{false};
|
|
ssl_context_t ssl_context_{asio::ssl::context::sslv23};
|
|
#endif
|
|
|
|
std::unique_ptr<server_t> server_;
|
|
|
|
std::vector<int> signals_{SIGINT, SIGTERM};
|
|
|
|
bool server_started_{false};
|
|
std::condition_variable cv_started_;
|
|
std::mutex start_mutex_;
|
|
std::vector<crow::websocket::connection*> websockets_;
|
|
};
|
|
|
|
/// \brief Alias of Crow<Middlewares...>. Useful if you want
|
|
/// a instance of an Crow application that require Middlewares
|
|
template<typename... Middlewares>
|
|
using App = Crow<Middlewares...>;
|
|
|
|
/// \brief Alias of Crow<>. Useful if you want a instance of
|
|
/// an Crow application that doesn't require of Middlewares
|
|
using SimpleApp = Crow<>;
|
|
} // namespace crow
|