166 lines
7.8 KiB
C++
166 lines
7.8 KiB
C++
#include "actions.h"
|
|
|
|
#include <engine_engine_number_9/baza_throw.h>
|
|
#include <engine_engine_number_9/os_utils.h>
|
|
#include <engine_engine_number_9/connecting_assets/static_asset_manager.h>
|
|
#include "find_db.h"
|
|
#include <engine_engine_number_9/running_mainloop.h>
|
|
#include <signal.h>
|
|
#include "str_fields.h"
|
|
#include "backend_logic/client_server_interact.h"
|
|
|
|
namespace iu9cawebchat {
|
|
bool termination = false;
|
|
|
|
void sigterm_action(int) {
|
|
termination = true;
|
|
}
|
|
|
|
void run_website(const json::JSON& config) {
|
|
een9_ASSERT(config["assets"].g().isString(), "config[\"assets\"] is not string");
|
|
std::string assets_dir = config["assets"].g().asString();
|
|
een9_ASSERT(een9::isDirectory(assets_dir), "\"" + assets_dir + "\" is not a directory");
|
|
|
|
een9::StaticAssetManagerSlaveModule samI;
|
|
samI.update({
|
|
een9::StaticAssetManagerRule{assets_dir + "/css", "/assets/css", {{".css", "text/css"}} },
|
|
een9::StaticAssetManagerRule{assets_dir + "/js", "/assets/js", {{".js", "text/javascript"}} },
|
|
een9::StaticAssetManagerRule{assets_dir + "/img", "/assets/img", {
|
|
{".jpg", "image/jpg"}, {".png", "image/png"}, {".svg", "image/svg+xml"}
|
|
} },
|
|
});
|
|
|
|
const json::JSON& config_presentation = config["presentation"].g();
|
|
int64_t slave_number = config["server"]["workers"].g().asInteger().get_int();
|
|
een9_ASSERT(slave_number > 0 && slave_number <= 200, "E");
|
|
|
|
std::string sqlite_db_path;
|
|
int ret = find_db_sqlite_file_path(config, sqlite_db_path);
|
|
een9_ASSERT(ret == 0, "Can't find database file");
|
|
|
|
std::vector<WorkerGuestData> worker_guest_data(slave_number);
|
|
for (int i = 0; i < slave_number; i++) {
|
|
worker_guest_data[i].templater = std::make_unique<nytl::Templater>(
|
|
nytl::TemplaterSettings{nytl::TemplaterDetourRules{assets_dir + "/HypertextPages"}});
|
|
worker_guest_data[i].templater->update();
|
|
worker_guest_data[i].db = std::make_unique<SqliteConnection>(sqlite_db_path);
|
|
}
|
|
|
|
een9::MainloopParameters params;
|
|
params.guest_core = [&samI, &worker_guest_data, config_presentation]
|
|
(const een9::SlaveTask& task, const een9::ClientRequest& req, een9::worker_id_t worker_id) -> std::string {
|
|
een9_ASSERT_pl(0 <= worker_id && worker_id < worker_guest_data.size());
|
|
WorkerGuestData& wgd = worker_guest_data[worker_id];
|
|
een9::StaticAsset sa;
|
|
sqlite_nooutput(*wgd.db, "BEGIN", {}, {});
|
|
struct guard {SqliteConnection& conn; bool rollback = false; ~guard() {
|
|
if (rollback)
|
|
sqlite_nooutput(conn, "ROLLBACK", {}, {});
|
|
else
|
|
sqlite_nooutput(conn, "END", {}, {});
|
|
}} guard_{*wgd.db};
|
|
try {
|
|
std::vector<std::pair<std::string, std::string>> cookies;
|
|
std::vector<LoginCookie> login_cookies;
|
|
json::JSON userinfo;
|
|
int64_t logged_in_user = -1;
|
|
initial_extraction_of_all_the_useful_info_from_cookies(*wgd.db, req, cookies, login_cookies, userinfo, logged_in_user);
|
|
|
|
if (req.uri_path == "/" || req.uri_path == "/list-rooms") {
|
|
return when_page_list_rooms(wgd, config_presentation, req, userinfo);
|
|
}
|
|
if (req.uri_path == "/login") {
|
|
return when_page_login(wgd, config_presentation, req, login_cookies, userinfo);
|
|
}
|
|
if (een9::beginsWith(req.uri_path, "/chat")) {
|
|
return when_page_chat(wgd, config_presentation, req, userinfo);
|
|
}
|
|
if (req.uri_path == "/user") {
|
|
return when_page_user(wgd, config_presentation, req, userinfo);
|
|
}
|
|
if (req.uri_path == "/internalapi/pollEvents") {
|
|
return when_internalapi_pollevents(wgd, req, logged_in_user);
|
|
}
|
|
if (req.uri_path == "/internalapi/getChatList") {
|
|
return when_internalapi_getchatlist(wgd, req, logged_in_user);
|
|
}
|
|
if (req.uri_path == "/internalapi/getChatInfo") {
|
|
return when_internalapi_getchatinfo(wgd, req, logged_in_user);
|
|
}
|
|
if (req.uri_path == "/internalapi/getChatMemberList") {
|
|
return when_internalapi_getchatmemberlist(wgd, req, logged_in_user);
|
|
}
|
|
if (req.uri_path == "/internalapi/getUserInfo") {
|
|
return when_internalapi_getuserinfo(wgd, req, logged_in_user);
|
|
}
|
|
if (req.uri_path == "/internalapi/getMessageInfo") {
|
|
return when_internalapi_getmessageinfo(wgd, req, logged_in_user);
|
|
}
|
|
// if (req.uri_path == "/internalapi/getMessageNeighbours") {
|
|
// return when
|
|
// }
|
|
// todo: write all the other interfaces
|
|
} catch (const std::exception& e) {
|
|
guard_.rollback = true;
|
|
throw;
|
|
}
|
|
/* Trying to interpret request as asset lookup */
|
|
int rets = samI.get_asset(req.uri_path, sa);
|
|
if (rets >= 0) {
|
|
return een9::form_http_server_response_200(sa.type, sa.content);
|
|
}
|
|
return een9::form_http_server_response_404("text/html", "<h1> Not found! </h1>");
|
|
};
|
|
|
|
params.guest_core_admin_control = [&worker_guest_data]
|
|
(const een9::SlaveTask& task, const std::string& req, een9::worker_id_t worker_id) -> std::string {
|
|
een9_ASSERT_pl(0 <= worker_id && worker_id < worker_guest_data.size());
|
|
WorkerGuestData& wgd = worker_guest_data[worker_id];
|
|
try {
|
|
if (req == "hello") {
|
|
return ":0 omg! hiii!! Hewwou :3 !!!!\n";
|
|
}
|
|
if (req == "8") {
|
|
termination = true;
|
|
return "Bye\n";
|
|
}
|
|
std::string updaterootpw_pref = "updaterootpw";
|
|
if (een9::beginsWith(req, "updaterootpw")) {
|
|
size_t nid = updaterootpw_pref.size();
|
|
if (nid >= req.size() || !isSPACE(req[nid]))
|
|
return "Bad command syntax. Missing whitespace\n";
|
|
std::string new_password = req.substr(nid + 1);
|
|
if (!check_password(new_password))
|
|
een9_THROW("Bad password");
|
|
sqlite_nooutput(*wgd.db,
|
|
"UPDATE `user` SET `password` = ?1 WHERE `id` = 0 ",
|
|
{}, {{1, new_password}});
|
|
return "Successul update\n";
|
|
}
|
|
return "Incorrect command\n";
|
|
} catch (std::exception& e) {
|
|
return std::string("Server error\n") + e.what();
|
|
}
|
|
};
|
|
|
|
params.slave_number = slave_number;
|
|
|
|
een9::SocketAddressParser sap;
|
|
auto translate_addr_list_conf = [&sap](std::vector<een9::SocketAddress>& dest, const std::vector<json::JSON>& source) {
|
|
size_t N = source.size();
|
|
dest.resize(N);
|
|
for (size_t i = 0; i < N; i++) {
|
|
int ret = een9::parse_socket_address(source[i].asString(), dest[i], sap);
|
|
een9_ASSERT(ret == 0, "Incorrect ear address: " + source[i].asString());
|
|
}
|
|
};
|
|
translate_addr_list_conf(params.client_regular_listened, config["server"]["http-listen"].g().asArray());
|
|
translate_addr_list_conf(params.admin_control_listened, config["server"]["admin-command-listen"].g().asArray());
|
|
|
|
signal(SIGINT, sigterm_action);
|
|
signal(SIGTERM, sigterm_action);
|
|
|
|
een9::electric_boogaloo(params, termination);
|
|
}
|
|
}
|