257 lines
9.1 KiB
C++
257 lines
9.1 KiB
C++
#include "WebServer.h"
|
|
#include "ApiGateway.h"
|
|
#include "lib/utils/Dispatcher.h"
|
|
#include "lib/api/core/ApiClientInterop.h"
|
|
#include "lib/api/apigateway.pb.h"
|
|
#include "lib/logging/logging.h"
|
|
#include "lib/os/os.h"
|
|
|
|
#include <websocketpp/config/asio_no_tls.hpp>
|
|
#include <websocketpp/server.hpp>
|
|
|
|
#include <boost/algorithm/string.hpp>
|
|
#include <boost/filesystem.hpp>
|
|
|
|
#include <vector>
|
|
#include <unordered_map>
|
|
#include <map>
|
|
#include <tuple>
|
|
#include <mutex>
|
|
#include <fstream>
|
|
#include <string>
|
|
|
|
typedef websocketpp::server<websocketpp::config::asio> WsServer;
|
|
typedef WsServer::endpoint::connection_ptr connection_ptr;
|
|
using websocketpp::connection_hdl;
|
|
using websocketpp::lib::placeholders::_1;
|
|
using websocketpp::lib::placeholders::_2;
|
|
using websocketpp::lib::bind;
|
|
|
|
using namespace bts::api::gateway;
|
|
|
|
std::string read_file(const std::string& path) {
|
|
std::ifstream f{ path };
|
|
auto sz = boost::filesystem::file_size(path);
|
|
std::string contents(sz, ' ');
|
|
f.read(&contents[0], sz);
|
|
return contents;
|
|
}
|
|
|
|
namespace bts {
|
|
namespace http {
|
|
|
|
struct ServerState {
|
|
std::mutex _m;
|
|
utils::Dispatcher& _dispatcher;
|
|
std::map<connection_hdl, ApiGatewaySession, std::owner_less<connection_hdl>> _session;
|
|
WsServer _server;
|
|
int _port;
|
|
std::string _www;
|
|
std::string _conf;
|
|
const api::ServiceContext& _ctx;
|
|
|
|
ServerState(const api::ServiceContext& ctx, int port) :
|
|
_m(),
|
|
_dispatcher(utils::Dispatcher::get_named("Webserver")),
|
|
_session(),
|
|
_server(),
|
|
_port(port),
|
|
_www(),
|
|
_ctx(ctx)
|
|
{
|
|
_www = os::sparkdata_path("www");
|
|
_conf = os::sparkdata_path("conf");
|
|
|
|
_server.init_asio(_dispatcher.io_service());
|
|
_server.set_open_handler(bind(&ServerState::on_open, this, ::_1));
|
|
_server.set_close_handler(bind(&ServerState::on_close, this, ::_1));
|
|
_server.set_message_handler(bind(&ServerState::on_message, this, ::_1, ::_2));
|
|
_server.set_http_handler(bind(&ServerState::on_http, this, ::_1));
|
|
run();
|
|
}
|
|
|
|
// starts listening
|
|
void run() {
|
|
_server.set_reuse_addr(true);
|
|
_server.listen(_port);
|
|
_server.start_accept();
|
|
}
|
|
|
|
void on_open(connection_hdl hdl) {
|
|
auto con = _server.get_con_from_hdl(hdl);
|
|
if (con) {
|
|
LOG(Api,Info, "Web client connection from {}", con->get_remote_endpoint());
|
|
std::lock_guard<std::mutex> lock(_m);
|
|
_session[hdl] = ApiGatewaySession(_ctx);
|
|
}
|
|
}
|
|
|
|
void on_close(connection_hdl hdl) {
|
|
auto con = _server.get_con_from_hdl(hdl);
|
|
if (con) {
|
|
LOG(Api,Info, "Web client disconnected: {}", con->get_remote_endpoint());
|
|
std::lock_guard<std::mutex> lock(_m);
|
|
_session.erase(hdl);
|
|
}
|
|
}
|
|
|
|
void on_message(connection_hdl hdl, WsServer::message_ptr msg) {
|
|
std::lock_guard<std::mutex> lock(_m);
|
|
auto iter = _session.find(hdl);
|
|
if (iter != _session.end()) {
|
|
GatewayRequest request;
|
|
if(request.ParseFromString(msg->get_payload())) {
|
|
iter->second.handle(request, [this,hdl](const GatewayResponse& response) {
|
|
_server.send(hdl, response.SerializeAsString(), websocketpp::frame::opcode::binary);
|
|
});
|
|
}
|
|
else {
|
|
LOG(Api,Info, "Could not parse request as GatewayRequest: {}", msg->get_payload());
|
|
}
|
|
}
|
|
}
|
|
|
|
void return_dotall(connection_ptr& con) {
|
|
std::vector<boost::filesystem::path> files;
|
|
auto iter = boost::filesystem::directory_iterator(_conf);
|
|
auto end = boost::filesystem::directory_iterator();
|
|
// Collect all .conf file
|
|
for (; iter != end; ++iter) {
|
|
auto ext = iter->path().filename().string().substr(iter->path().filename().stem().size());
|
|
if(boost::iequals(ext, ".conf")) {
|
|
files.push_back(iter->path());
|
|
}
|
|
}
|
|
// Sort them so we at least it's stable
|
|
std::sort(files.begin(), files.end());
|
|
// Concatanate
|
|
std::string body;
|
|
for (const auto& p : files) {
|
|
body += "##########################\n";
|
|
body += "## " + p.filename().string();
|
|
body += "\n##########################\n";
|
|
body += read_file(p.string());
|
|
}
|
|
|
|
con->set_body(body);
|
|
con->set_status(websocketpp::http::status_code::ok);
|
|
}
|
|
|
|
void directory_index(connection_ptr& con, const std::string& resource, const boost::filesystem::path& path) {
|
|
// directory listing
|
|
std::string body = "<!doctype html>\n";
|
|
body += "<head>";
|
|
body += "<script defer src=\"https://use.fontawesome.com/releases/v5.0.10/js/all.js\" integrity=\"sha384-slN8GvtUJGnv6ca26v8EzVaR9DC58QEwsIk9q1QXdCU8Yu8ck/tL/5szYlBbqmS+\" crossorigin=\"anonymous\"></script>\n";
|
|
body += "</head>\n";
|
|
body += "<body>\n";
|
|
body += "<h1>Index of " + resource + "</h1>\n";
|
|
auto iter = boost::filesystem::directory_iterator(path);
|
|
auto end = boost::filesystem::directory_iterator();
|
|
body += "<ul style=\"list-style-type: none;\">\n";
|
|
for (; iter != end; ++iter) {
|
|
auto x = iter->path();
|
|
body += "<li>";
|
|
if (boost::filesystem::is_regular_file(x)) {
|
|
body += "<i class=\"far fa-file\"></i> ";
|
|
}
|
|
else if (boost::filesystem::is_directory(x)) {
|
|
body += "<i class=\"far fa-folder\"></i> ";
|
|
}
|
|
if (resource == "/") {
|
|
body += "<a href=" + x.filename().string() + ">";
|
|
}
|
|
else {
|
|
body += "<a href=" + resource + "/" + x.filename().string() + ">";
|
|
}
|
|
body += x.filename().string();
|
|
body += "</a></li>\n";
|
|
}
|
|
body += "</ul>\n";
|
|
body += "</body></html>\n";
|
|
con->set_status(websocketpp::http::status_code::ok);
|
|
con->set_body(body);
|
|
}
|
|
|
|
boost::filesystem::path web_ui_path(const boost::filesystem::path& root) {
|
|
auto reldir = root / "web/ui";
|
|
if (boost::filesystem::exists(reldir)) return reldir;
|
|
reldir = root / "ui";
|
|
if (boost::filesystem::exists(reldir)) return reldir;
|
|
if (root.has_parent_path()) return web_ui_path(root.parent_path());
|
|
return _www;
|
|
}
|
|
|
|
boost::filesystem::path map_path_to_filesystem(const std::string& resource) {
|
|
std::string config = "/config";
|
|
std::string files = "/files";
|
|
|
|
if (resource.compare(0, config.size(), config) == 0) {
|
|
return _conf;
|
|
}
|
|
else if (resource.compare(0, files.size(), files) == 0) {
|
|
return _www + resource.substr(files.size());
|
|
}
|
|
return web_ui_path(os::get_install_path()) / resource;
|
|
}
|
|
|
|
void return_file(connection_ptr& con, const boost::filesystem::path& path) {
|
|
con->set_body(read_file(path.string()));
|
|
con->set_status(websocketpp::http::status_code::ok);
|
|
}
|
|
|
|
std::string strip_query_str(const std::string& request) {
|
|
auto position = request.find("?");
|
|
if (position != std::string::npos) {
|
|
return request.substr(0, position);
|
|
}
|
|
return request;
|
|
}
|
|
|
|
void on_http(connection_hdl hdl) {
|
|
auto con = _server.get_con_from_hdl(hdl);
|
|
auto resource = strip_query_str(con->get_resource());
|
|
LOG(Api,Info, "REQUEST: {}", resource);
|
|
if (boost::iequals(resource, "/config/.all")) {
|
|
return_dotall(con);
|
|
}
|
|
else if (boost::iequals(resource, "/bts_installer.exe") && boost::filesystem::is_regular_file(_www+"/bts_installer.exe")) {
|
|
return_file(con, _www + "/bts_installer.exe");
|
|
}
|
|
else if (boost::iequals(resource, "/robots.txt")) {
|
|
con->set_status(websocketpp::http::status_code::ok);
|
|
std::string body = "User-agent: *\nDisallow: /";
|
|
con->set_body(body);
|
|
}
|
|
else {
|
|
auto path = map_path_to_filesystem(resource);
|
|
if (boost::filesystem::is_directory(path)) {
|
|
auto index = path / "index.html";
|
|
if (boost::filesystem::is_regular_file(index)) {
|
|
return_file(con, index);
|
|
}
|
|
else {
|
|
directory_index(con, resource, path);
|
|
}
|
|
}
|
|
else if (boost::filesystem::is_regular_file(path)) {
|
|
return_file(con, path);
|
|
}
|
|
else {
|
|
con->set_status(websocketpp::http::status_code::not_found);
|
|
con->set_body("Cannot find " + resource);
|
|
}
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
SparkWebServer::SparkWebServer(const api::ServiceContext& ctx, int port) :
|
|
_me(std::make_shared<ServerState>(ctx, port))
|
|
{
|
|
}
|
|
|
|
|
|
}}
|