Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2025-01-30 21:09:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

Bindings, and an another round of cleanups for WebRoot.

Browse Source
This commit is contained in:
Relintai 2022-06-27 13:52:33 +02:00
parent 3d9e615a51
commit c530aa2c41
2 changed files with 115 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
modules/web/http/web_root.cpp
View File

@ -1,36 +1,47 @@
#include "web_root.h" #include "web_root.h"
#include "core/object.h"
#include "modules/web/http/http_server_enums.h"
#include "web_server_request.h" #include "web_server_request.h"
#include "../file_cache.h" #include "../file_cache.h"
#include "web_permission.h" #include "web_permission.h"
String WebRoot::get_default_error_404_body() { String WebRoot::get_www_root_path() {
return default_error_404_body; return _www_root_path;
}
void WebRoot::set_www_root_path(const String &val) {
_www_root_path = val;
if (val == "") {
_www_root_file_cache->clear();
} else {
_www_root_file_cache->wwwroot_evaluate_dir(val);
} }
void WebRoot::set_default_error_404_body(const String &val) {
default_error_404_body = val;
} }
String WebRoot::get_default_generic_error_body() { Ref<FileCache> WebRoot::get_www_root_file_cache() {
return default_generic_error_body; return _www_root_file_cache;
}
void WebRoot::set_default_generic_error_body(const String &val) {
default_generic_error_body = val;
} }
void WebRoot::setup() { Vector<Variant> WebRoot::get_middlewares() {
setup_error_handlers(); Vector<Variant> r;
setup_middleware(); for (int i = 0; i < _middlewares.size(); i++) {
r.push_back(_middlewares[i].get_ref_ptr());
}
return r;
} }
void WebRoot::setup_error_handlers() { void WebRoot::set_middlewares(const Vector<Variant> &data) {
default_error_handler_func = WebRoot::default_fallback_error_handler; _middlewares.clear();
error_handler_map[404] = WebRoot::default_404_error_handler; for (int i = 0; i < data.size(); i++) {
Ref<WebServerMiddleware> e = Ref<WebServerMiddleware>(data[i]);
_middlewares.push_back(e);
}
} }
void WebRoot::setup_middleware() { //void WebRoot::setup_middleware() {
// WebServerMiddlewares get processed in the order they are in the _middlewares array // WebServerMiddlewares get processed in the order they are in the _middlewares array
// ------- Built in middleware selection ------- // ------- Built in middleware selection -------
@ -63,19 +74,9 @@ void WebRoot::setup_middleware() {
// csrf_middleware->ignored_urls.push_back("/user/login"); // csrf_middleware->ignored_urls.push_back("/user/login");
// csrf_middleware->ignored_urls.push_back("/user/register"); // csrf_middleware->ignored_urls.push_back("/user/register");
// _middlewares.push_back(csrf_middleware); // _middlewares.push_back(csrf_middleware);
} //}
void WebRoot::default_fallback_error_handler(Ref<WebServerRequest> request, int error_code) { void WebRoot::_handle_request_main(Ref<WebServerRequest> request) {
request->compiled_body = default_generic_error_body;
request->send();
}
void WebRoot::default_404_error_handler(Ref<WebServerRequest> request, int error_code) {
request->compiled_body = default_error_404_body;
request->send();
}
void WebRoot::handle_request_main(Ref<WebServerRequest> request) {
if (process_middlewares(request)) { if (process_middlewares(request)) {
return; return;
} }
@ -102,25 +103,27 @@ void WebRoot::handle_request_main(Ref<WebServerRequest> request) {
} }
} }
void WebRoot::handle_error_send_request(Ref<WebServerRequest> request, const int error_code) { void WebRoot::_handle_error_send_request(Ref<WebServerRequest> request, const int error_code) {
void (*func)(Ref<WebServerRequest>, int) = error_handler_map[error_code]; if (error_code == HTTPServerEnums::HTTP_STATUS_CODE_404_NOT_FOUND) {
request->compiled_body = "<html><body>404 :(</body></html>";
if (!func) { request->send();
if (!default_error_handler_func) {
WebNode::handle_error_send_request(request, error_code);
return; return;
} }
default_error_handler_func(request, error_code); request->compiled_body = "<html><body>Internal server error! :(</body></html>";
return; request->send();
}
func(request, error_code);
} }
bool WebRoot::process_middlewares(Ref<WebServerRequest> request) { bool WebRoot::process_middlewares(Ref<WebServerRequest> request) {
for (int i = 0; i < _middlewares.size(); ++i) { for (int i = 0; i < _middlewares.size(); ++i) {
if (_middlewares.write[i]->on_before_handle_request_main(request)) { Ref<WebServerMiddleware> m = _middlewares[i];
if (!m.is_valid()) {
continue;
}
if (m->on_before_handle_request_main(request)) {
// handled // handled
return true; return true;
} }
@ -132,7 +135,7 @@ bool WebRoot::process_middlewares(Ref<WebServerRequest> request) {
bool WebRoot::try_send_wwwroot_file(Ref<WebServerRequest> request) { bool WebRoot::try_send_wwwroot_file(Ref<WebServerRequest> request) {
const String &path = request->get_path_full(); const String &path = request->get_path_full();
if (FileCache::get_singleton()->wwwroot_has_file(path)) { if (_www_root_file_cache->wwwroot_has_file(path)) {
send_file(path, request); send_file(path, request);
return true; return true;
@ -142,7 +145,7 @@ bool WebRoot::try_send_wwwroot_file(Ref<WebServerRequest> request) {
} }
void WebRoot::send_file(const String &path, Ref<WebServerRequest> request) { void WebRoot::send_file(const String &path, Ref<WebServerRequest> request) {
String fp = FileCache::get_singleton()->wwwroot + path; String fp = _www_root_file_cache->wwwroot + path;
request->send_file(fp); request->send_file(fp);
} }
@ -169,22 +172,40 @@ void WebRoot::unregister_request_update(Ref<WebServerRequest> request) {
_update_registered_requests_mutex.unlock(); _update_registered_requests_mutex.unlock();
} }
void WebRoot::update() { WebRoot::WebRoot() {
for (std::size_t i = 0; i < _update_registered_requests.size(); ++i) { _www_root_file_cache.instance();
set_process_internal(true);
}
WebRoot::~WebRoot() {
}
void WebRoot::_notification(int p_what) {
if (p_what == NOTIFICATION_INTERNAL_PROCESS) {
for (int i = 0; i < _update_registered_requests.size(); ++i) {
Ref<WebServerRequest> r = _update_registered_requests[i]; Ref<WebServerRequest> r = _update_registered_requests[i];
r->update(); r->update();
} }
} }
WebRoot::WebRoot() {
default_error_handler_func = nullptr;
} }
WebRoot::~WebRoot() { void WebRoot::_bind_methods() {
error_handler_map.clear(); ClassDB::bind_method(D_METHOD("get_www_root_path"), &WebRoot::get_www_root_path);
_middlewares.clear(); ClassDB::bind_method(D_METHOD("set_www_root_path", "val"), &WebRoot::set_www_root_path);
} ADD_PROPERTY(PropertyInfo(Variant::STRING, "www_root_path"), "set_www_root_path", "get_www_root_path");
String WebRoot::default_error_404_body = "<html><body>404 :(</body></html>"; ClassDB::bind_method(D_METHOD("get_www_root_file_cache"), &WebRoot::get_www_root_file_cache);
String WebRoot::default_generic_error_body = "<html><body>Internal server error! :(</body></html>"; ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "www_root_file_cache", PROPERTY_HINT_RESOURCE_TYPE, "FileCache", 0), "", "get_www_root_file_cache");
ClassDB::bind_method(D_METHOD("get_middlewares"), &WebRoot::get_middlewares);
ClassDB::bind_method(D_METHOD("set_middlewares", "data"), &WebRoot::set_middlewares);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "middlewares", PROPERTY_HINT_NONE, "17/17:WebServerRequest", PROPERTY_USAGE_DEFAULT, "WebServerRequest"), "set_middlewares", "get_middlewares");
ClassDB::bind_method(D_METHOD("process_middlewares", "request"), &WebRoot::process_middlewares);
ClassDB::bind_method(D_METHOD("try_send_wwwroot_file", "request"), &WebRoot::try_send_wwwroot_file);
ClassDB::bind_method(D_METHOD("send_file", "path", "request"), &WebRoot::send_file);
ClassDB::bind_method(D_METHOD("register_request_update", "request"), &WebRoot::register_request_update);
ClassDB::bind_method(D_METHOD("unregister_request_update", "request"), &WebRoot::unregister_request_update);
}

42
modules/web/http/web_root.h
View File

@ -11,54 +11,46 @@
#include "web_server_middleware.h" #include "web_server_middleware.h"
class WebServerRequest; class WebServerRequest;
class FileCache;
// TODO FileCache -> set up, for this webroot, don't use singleton
class WebRoot : public WebNode { class WebRoot : public WebNode {
GDCLASS(WebRoot, WebNode); GDCLASS(WebRoot, WebNode);
public: public:
String get_default_error_404_body(); String get_www_root_path();
void set_default_error_404_body(const String &val); void set_www_root_path(const String &val);
String get_default_generic_error_body(); Ref<FileCache> get_www_root_file_cache();
void set_default_generic_error_body(const String &val);
void handle_request_main(Ref<WebServerRequest> request); Vector<Variant> get_middlewares();
void handle_error_send_request(Ref<WebServerRequest> request, const int error_code); void set_middlewares(const Vector<Variant> &data);
void _handle_request_main(Ref<WebServerRequest> request);
void _handle_error_send_request(Ref<WebServerRequest> request, const int error_code);
bool process_middlewares(Ref<WebServerRequest> request); bool process_middlewares(Ref<WebServerRequest> request);
bool try_send_wwwroot_file(Ref<WebServerRequest> request); bool try_send_wwwroot_file(Ref<WebServerRequest> request);
void send_file(const String &path, Ref<WebServerRequest> request); void send_file(const String &path, Ref<WebServerRequest> request);
static void default_fallback_error_handler(Ref<WebServerRequest> request, int error_code);
static void default_404_error_handler(Ref<WebServerRequest> request, int error_code);
virtual void setup();
virtual void setup_error_handlers();
virtual void setup_middleware();
void default_routing_middleware(Object *instance, Ref<WebServerRequest> request);
void register_request_update(Ref<WebServerRequest> request); void register_request_update(Ref<WebServerRequest> request);
void unregister_request_update(Ref<WebServerRequest> request); void unregister_request_update(Ref<WebServerRequest> request);
void update();
WebRoot(); WebRoot();
~WebRoot(); ~WebRoot();
static String default_error_404_body;
static String default_generic_error_body;
public:
Vector<Ref<WebServerMiddleware>> _middlewares; Vector<Ref<WebServerMiddleware>> _middlewares;
HashMap<int, void (*)(Ref<WebServerRequest>, int)> error_handler_map;
void (*default_error_handler_func)(Ref<WebServerRequest>, int);
protected: protected:
void _notification(int p_what);
static void _bind_methods();
Mutex _update_registered_requests_mutex; Mutex _update_registered_requests_mutex;
Vector<Ref<WebServerRequest>> _update_registered_requests; Vector<Ref<WebServerRequest>> _update_registered_requests;
String _www_root_path;
Ref<FileCache> _www_root_file_cache;
}; };
#endif #endif