373 lines
12 KiB
C++
373 lines
12 KiB
C++
/**
|
|
* bserv - Boost-based HTTP Server
|
|
*
|
|
* reference:
|
|
* https://www.boost.org/doc/libs/1_75_0/libs/beast/example/http/server/async/http_server_async.cpp
|
|
* https://www.boost.org/doc/libs/1_75_0/libs/beast/example/advanced/server/advanced_server.cpp
|
|
*
|
|
*/
|
|
|
|
#ifndef _SERVER_HPP
|
|
#define _SERVER_HPP
|
|
|
|
#include <boost/beast.hpp>
|
|
#include <boost/asio.hpp>
|
|
#include <boost/optional.hpp>
|
|
#include <boost/json/src.hpp>
|
|
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <cstddef>
|
|
#include <cstdlib>
|
|
#include <vector>
|
|
#include <optional>
|
|
#include <memory>
|
|
#include <thread>
|
|
#include <chrono>
|
|
|
|
#include "config.hpp"
|
|
#include "logging.hpp"
|
|
#include "utils.hpp"
|
|
#include "router.hpp"
|
|
#include "database.hpp"
|
|
#include "session.hpp"
|
|
#include "client.hpp"
|
|
|
|
namespace bserv {
|
|
|
|
namespace beast = boost::beast;
|
|
namespace http = beast::http;
|
|
namespace asio = boost::asio;
|
|
namespace json = boost::json;
|
|
using asio::ip::tcp;
|
|
|
|
// this function produces an HTTP response for the given
|
|
// request. The type of the response object depends on the
|
|
// contents of the request, so the interface requires the
|
|
// caller to pass a generic lambda for receiving the response.
|
|
// NOTE: `send` should be called only once!
|
|
template <class Body, class Allocator, class Send>
|
|
void handle_request(
|
|
http::request<Body, http::basic_fields<Allocator>>&& req,
|
|
Send&& send, router& routes) {
|
|
|
|
const auto bad_request = [&req](beast::string_view why) {
|
|
http::response<http::string_body> res{
|
|
http::status::bad_request, req.version()};
|
|
res.set(http::field::server, NAME);
|
|
res.set(http::field::content_type, "text/html");
|
|
res.keep_alive(req.keep_alive());
|
|
res.body() = std::string{why};
|
|
res.prepare_payload();
|
|
return res;
|
|
};
|
|
|
|
const auto not_found = [&req](beast::string_view target) {
|
|
http::response<http::string_body> res{
|
|
http::status::not_found, req.version()};
|
|
res.set(http::field::server, NAME);
|
|
res.set(http::field::content_type, "text/html");
|
|
res.keep_alive(req.keep_alive());
|
|
res.body() = "The requested url '"
|
|
+ std::string{target} + "' does not exist.";
|
|
res.prepare_payload();
|
|
return res;
|
|
};
|
|
|
|
const auto server_error = [&req](beast::string_view what) {
|
|
http::response<http::string_body> res{
|
|
http::status::internal_server_error, req.version()};
|
|
res.set(http::field::server, NAME);
|
|
res.set(http::field::content_type, "text/html");
|
|
res.keep_alive(req.keep_alive());
|
|
res.body() = "Internal server error: " + std::string{what};
|
|
res.prepare_payload();
|
|
return res;
|
|
};
|
|
|
|
boost::string_view target = req.target();
|
|
auto pos = target.find('?');
|
|
boost::string_view url;
|
|
if (pos == boost::string_view::npos) url = target;
|
|
else url = target.substr(0, pos);
|
|
|
|
http::response<http::string_body> res{
|
|
http::status::ok, req.version()};
|
|
res.set(http::field::server, NAME);
|
|
res.set(http::field::content_type, "application/json");
|
|
res.keep_alive(req.keep_alive());
|
|
|
|
std::optional<boost::json::value> val;
|
|
try {
|
|
val = routes(std::string{url}, req, res);
|
|
} catch (const url_not_found_exception& e) {
|
|
send(not_found(url));
|
|
return;
|
|
} catch (const bad_request_exception& e) {
|
|
send(bad_request("Request body is not a valid JSON string."));
|
|
return;
|
|
} catch (const std::exception& e) {
|
|
send(server_error(e.what()));
|
|
return;
|
|
} catch (...) {
|
|
send(server_error("Unknown exception."));
|
|
return;
|
|
}
|
|
|
|
if (val.has_value()) {
|
|
res.body() = json::serialize(val.value());
|
|
res.prepare_payload();
|
|
}
|
|
|
|
send(std::move(res));
|
|
}
|
|
|
|
std::string get_address(const tcp::socket& socket) {
|
|
tcp::endpoint end_point = socket.remote_endpoint();
|
|
std::string addr = end_point.address().to_string()
|
|
+ ':' + std::to_string(end_point.port());
|
|
return addr;
|
|
}
|
|
|
|
// handles an HTTP server connection
|
|
class http_session
|
|
: public std::enable_shared_from_this<http_session> {
|
|
private:
|
|
// the function object is used to send an HTTP message.
|
|
class send_lambda {
|
|
private:
|
|
http_session& self_;
|
|
public:
|
|
send_lambda(http_session& self)
|
|
: self_{self} {}
|
|
template <bool isRequest, class Body, class Fields>
|
|
void operator()(
|
|
http::message<isRequest, Body, Fields>&& msg) const {
|
|
// the lifetime of the message has to extend
|
|
// for the duration of the async operation so
|
|
// we use a shared_ptr to manage it.
|
|
auto sp = std::make_shared<
|
|
http::message<isRequest, Body, Fields>>(
|
|
std::move(msg));
|
|
// stores a type-erased version of the shared
|
|
// pointer in the class to keep it alive.
|
|
self_.res_ = sp;
|
|
// writes the response
|
|
http::async_write(
|
|
self_.stream_, *sp,
|
|
beast::bind_front_handler(
|
|
&http_session::on_write,
|
|
self_.shared_from_this(),
|
|
sp->need_eof()));
|
|
}
|
|
} lambda_;
|
|
beast::tcp_stream stream_;
|
|
beast::flat_buffer buffer_;
|
|
boost::optional<
|
|
http::request_parser<http::string_body>> parser_;
|
|
std::shared_ptr<void> res_;
|
|
router& routes_;
|
|
const std::string address_;
|
|
void do_read() {
|
|
// constructs a new parser for each message
|
|
parser_.emplace();
|
|
// applies a reasonable limit to the allowed size
|
|
// of the body in bytes to prevent abuse.
|
|
parser_->body_limit(PAYLOAD_LIMIT);
|
|
// sets the timeout.
|
|
stream_.expires_after(std::chrono::seconds(EXPIRY_TIME));
|
|
// reads a request using the parser-oriented interface
|
|
http::async_read(
|
|
stream_, buffer_, *parser_,
|
|
beast::bind_front_handler(
|
|
&http_session::on_read,
|
|
shared_from_this()));
|
|
}
|
|
void on_read(
|
|
beast::error_code ec,
|
|
std::size_t bytes_transferred) {
|
|
boost::ignore_unused(bytes_transferred);
|
|
lgtrace << "received " << bytes_transferred << " byte(s) from: " << address_;
|
|
// this means they closed the connection
|
|
if (ec == http::error::end_of_stream) {
|
|
do_close();
|
|
return;
|
|
}
|
|
if (ec) {
|
|
fail(ec, "http_session async_read");
|
|
return;
|
|
}
|
|
// handles the request and sends the response
|
|
handle_request(parser_->release(), lambda_, routes_);
|
|
// at this point the parser can be reset
|
|
}
|
|
void on_write(
|
|
bool close, beast::error_code ec,
|
|
std::size_t bytes_transferred) {
|
|
boost::ignore_unused(bytes_transferred);
|
|
// we're done with the response so delete it
|
|
res_.reset();
|
|
if (ec) {
|
|
fail(ec, "http_session async_write");
|
|
return;
|
|
}
|
|
lgtrace << "sent " << bytes_transferred << " byte(s) to: " << address_;
|
|
if (close) {
|
|
// this means we should close the connection, usually because
|
|
// the response indicated the "Connection: close" semantic.
|
|
do_close();
|
|
return;
|
|
}
|
|
// reads another request
|
|
do_read();
|
|
}
|
|
void do_close() {
|
|
// sends a TCP shutdown
|
|
beast::error_code ec;
|
|
stream_.socket().shutdown(tcp::socket::shutdown_send, ec);
|
|
// at this point the connection is closed gracefully
|
|
lgtrace << "socket connection closed: " << address_;
|
|
}
|
|
public:
|
|
http_session(tcp::socket&& socket, router& routes)
|
|
: lambda_{*this}, stream_{std::move(socket)}, routes_{routes},
|
|
address_{get_address(stream_.socket())} {
|
|
lgtrace << "http session opened: " << address_;
|
|
}
|
|
~http_session() {
|
|
lgtrace << "http session closed: " << address_;
|
|
}
|
|
void run() {
|
|
asio::dispatch(
|
|
stream_.get_executor(),
|
|
beast::bind_front_handler(
|
|
&http_session::do_read,
|
|
shared_from_this()));
|
|
}
|
|
};
|
|
|
|
// accepts incoming connections and launches the sessions
|
|
class listener
|
|
: public std::enable_shared_from_this<listener> {
|
|
private:
|
|
asio::io_context& ioc_;
|
|
tcp::acceptor acceptor_;
|
|
router& routes_;
|
|
void do_accept() {
|
|
acceptor_.async_accept(
|
|
asio::make_strand(ioc_),
|
|
beast::bind_front_handler(
|
|
&listener::on_accept,
|
|
shared_from_this()));
|
|
}
|
|
void on_accept(beast::error_code ec, tcp::socket socket) {
|
|
if (ec) {
|
|
fail(ec, "listener::acceptor async_accept");
|
|
} else {
|
|
lgtrace << "listener accepts: " << get_address(socket);
|
|
std::make_shared<http_session>(
|
|
std::move(socket), routes_)->run();
|
|
}
|
|
do_accept();
|
|
}
|
|
public:
|
|
listener(
|
|
asio::io_context& ioc,
|
|
tcp::endpoint endpoint,
|
|
router& routes)
|
|
: ioc_{ioc},
|
|
acceptor_{asio::make_strand(ioc)},
|
|
routes_{routes} {
|
|
beast::error_code ec;
|
|
acceptor_.open(endpoint.protocol(), ec);
|
|
if (ec) {
|
|
fail(ec, "listener::acceptor open");
|
|
exit(EXIT_FAILURE);
|
|
return;
|
|
}
|
|
acceptor_.set_option(
|
|
asio::socket_base::reuse_address(true), ec);
|
|
if (ec) {
|
|
fail(ec, "listener::acceptor set_option");
|
|
exit(EXIT_FAILURE);
|
|
return;
|
|
}
|
|
acceptor_.bind(endpoint, ec);
|
|
if (ec) {
|
|
fail(ec, "listener::acceptor bind");
|
|
exit(EXIT_FAILURE);
|
|
return;
|
|
}
|
|
acceptor_.listen(
|
|
asio::socket_base::max_listen_connections, ec);
|
|
if (ec) {
|
|
fail(ec, "listener::acceptor listen");
|
|
exit(EXIT_FAILURE);
|
|
return;
|
|
}
|
|
}
|
|
void run() {
|
|
asio::dispatch(
|
|
acceptor_.get_executor(),
|
|
beast::bind_front_handler(
|
|
&listener::do_accept,
|
|
shared_from_this()));
|
|
}
|
|
};
|
|
|
|
class server {
|
|
private:
|
|
// io_context for all I/O
|
|
asio::io_context ioc_;
|
|
router routes_;
|
|
public:
|
|
server(const server_config& config, router&& routes)
|
|
: ioc_{config.get_num_threads()}, routes_{routes} {
|
|
init_logging(config);
|
|
|
|
// database connection
|
|
try {
|
|
db_conn_mgr = std::make_shared<
|
|
db_connection_manager>(config.get_db_conn_str(), config.get_num_db_conn());
|
|
} catch (const std::exception& e) {
|
|
lgfatal << "db connection initialization failed: " << e.what() << std::endl;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
session_mgr = std::make_shared<memory_session>();
|
|
|
|
client_ptr = std::make_shared<client>(ioc_);
|
|
|
|
// creates and launches a listening port
|
|
std::make_shared<listener>(
|
|
ioc_, tcp::endpoint{tcp::v4(), config.get_port()}, routes_)->run();
|
|
|
|
// captures SIGINT and SIGTERM to perform a clean shutdown
|
|
asio::signal_set signals{ioc_, SIGINT, SIGTERM};
|
|
signals.async_wait(
|
|
[&](const boost::system::error_code&, int) {
|
|
// stops the `io_context`. This will cause `run()`
|
|
// to return immediately, eventually destroying the
|
|
// `io_context` and all of the sockets in it.
|
|
ioc_.stop();
|
|
});
|
|
|
|
lginfo << config.get_name() << " started";
|
|
|
|
// runs the I/O service on the requested number of threads
|
|
std::vector<std::thread> v;
|
|
v.reserve(config.get_num_threads() - 1);
|
|
for (int i = 1; i < config.get_num_threads(); ++i)
|
|
v.emplace_back([&]{ ioc_.run(); });
|
|
ioc_.run();
|
|
|
|
// if we get here, it means we got a SIGINT or SIGTERM
|
|
lginfo << "exiting " << config.get_name();
|
|
|
|
// blocks until all the threads exit
|
|
for (auto & t : v) t.join();
|
|
}
|
|
};
|
|
|
|
} // bserv
|
|
|
|
#endif // _SERVER_HPP
|