Relintai/rcpp_framework
1
0
Fork 0
mirror of https://github.com/Relintai/rcpp_framework.git synced 2024-11-14 04:57:21 +01:00
Code Issues Packages Projects Releases Wiki Activity
c5ea34afdc
rcpp_framework/core/request.cpp

305 lines
5.8 KiB
C++
Raw Normal View History

Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
#include "request.h"
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
#include "application.h"
Added a head and body string to Request, and removed themes. I think themes added unnecessary complexity, and code non-locality (The view methods would have been in a different class.). I think in a language which have headers this is unwanted (The code will be broken up with the mvc pattern, but the methods don't need to be in separate classes.). Themes are still easily implementable by either adding different css links to the new head variable, or by inheritance.
2020-12-11 16:54:41 +01:00
void Request::compile_body() {
compiled_body.reserve(body.size() + head.size() + 13 + 14 + 15);
//13
compiled_body += "<html>"
Added a url stack to Request, for easier route handling. Also made the main routing middleware use it.
2020-12-28 19:15:27 +01:00
"<head>";
Added a head and body string to Request, and removed themes. I think themes added unnecessary complexity, and code non-locality (The view methods would have been in a different class.). I think in a language which have headers this is unwanted (The code will be broken up with the mvc pattern, but the methods don't need to be in separate classes.). Themes are still easily implementable by either adding different css links to the new head variable, or by inheritance.
2020-12-11 16:54:41 +01:00
compiled_body += head;
//14
compiled_body += "</head>"
Added a url stack to Request, for easier route handling. Also made the main routing middleware use it.
2020-12-28 19:15:27 +01:00
"<body>";
Added a head and body string to Request, and removed themes. I think themes added unnecessary complexity, and code non-locality (The view methods would have been in a different class.). I think in a language which have headers this is unwanted (The code will be broken up with the mvc pattern, but the methods don't need to be in separate classes.). Themes are still easily implementable by either adding different css links to the new head variable, or by inheritance.
2020-12-11 16:54:41 +01:00
compiled_body += body;
Add footer string into request.
2020-12-26 00:17:36 +01:00
compiled_body += footer;
Added a head and body string to Request, and removed themes. I think themes added unnecessary complexity, and code non-locality (The view methods would have been in a different class.). I think in a language which have headers this is unwanted (The code will be broken up with the mvc pattern, but the methods don't need to be in separate classes.). Themes are still easily implementable by either adding different css links to the new head variable, or by inheritance.
2020-12-11 16:54:41 +01:00
//15
compiled_body += "</body>"
Added a url stack to Request, for easier route handling. Also made the main routing middleware use it.
2020-12-28 19:15:27 +01:00
"</html>";
Added a head and body string to Request, and removed themes. I think themes added unnecessary complexity, and code non-locality (The view methods would have been in a different class.). I think in a language which have headers this is unwanted (The code will be broken up with the mvc pattern, but the methods don't need to be in separate classes.). Themes are still easily implementable by either adding different css links to the new head variable, or by inheritance.
2020-12-11 16:54:41 +01:00
response->setBody(compiled_body);
}
void Request::compile_and_send_body() {
compile_body();
send();
}
Now the request handling/middlewares work in a fully async way.
2020-11-26 12:02:58 +01:00
void Request::next_stage() {
if (current_middleware_index == (*middleware_stack).size()) {
Now handlers need to have a new Object* parameter, this can be used to optionally carry class instances. (think of it as self in python object methods, except it can be null).
2020-12-01 12:56:04 +01:00
handler_instance.handler_func(handler_instance.instance, this);
Now the request handling/middlewares work in a fully async way.
2020-11-26 12:02:58 +01:00
return;
}
Now handlers need to have a new Object* parameter, this can be used to optionally carry class instances. (think of it as self in python object methods, except it can be null).
2020-12-01 12:56:04 +01:00
const HandlerInstance &hi = (*middleware_stack)[current_middleware_index++];
hi.handler_func(hi.instance, this);
Now the request handling/middlewares work in a fully async way.
2020-11-26 12:02:58 +01:00
}
Now requests have to be sent manually, with a new send() method. This makes it possible to handle requests in a full on async callback-like way.
2020-11-26 11:26:02 +01:00
void Request::send() {
Don't check for connection closed in send and send_file. Sometimes the connection closed callback gets called before send, but the connection still seems to be alive. Will work on it later.
2021-04-28 21:48:34 +02:00
//if (connection_closed) {
// RequestPool::return_request(this);
// return;
//}
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
Now requests have to be sent manually, with a new send() method. This makes it possible to handle requests in a full on async callback-like way.
2020-11-26 11:26:02 +01:00
if (http_parser->isKeepAlive()) {
response->addHeadValue("Connection", "Keep-Alive");
std::string result = response->getResult();
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
session->send(result.c_str(), result.size());
Now requests have to be sent manually, with a new send() method. This makes it possible to handle requests in a full on async callback-like way.
2020-11-26 11:26:02 +01:00
} else {
response->addHeadValue("Connection", "Close");
std::string result = response->getResult();
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
HttpSession::Ptr lsession = session;
Now requests have to be sent manually, with a new send() method. This makes it possible to handle requests in a full on async callback-like way.
2020-11-26 11:26:02 +01:00
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
session->send(result.c_str(), result.size(), [lsession]() { lsession->postShutdown(); });
Now requests have to be sent manually, with a new send() method. This makes it possible to handle requests in a full on async callback-like way.
2020-11-26 11:26:02 +01:00
}
RequestPool::return_request(this);
}
Implemented chunked file downloads. For some reason if a file is too big and has to be sent in more that 43 chunks it crashes, it might be a bug in brynet (it always crashes at the 43th chunk, with every file and chunk size setting.), will figure out the problem later.
2021-01-08 02:55:41 +01:00
void Request::send_file(const std::string &p_file_path) {
Don't check for connection closed in send and send_file. Sometimes the connection closed callback gets called before send, but the connection still seems to be alive. Will work on it later.
2021-04-28 21:48:34 +02:00
//if (connection_closed) {
// RequestPool::return_request(this);
// return;
//}
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
Implemented chunked file downloads. For some reason if a file is too big and has to be sent in more that 43 chunks it crashes, it might be a bug in brynet (it always crashes at the 43th chunk, with every file and chunk size setting.), will figure out the problem later.
2021-01-08 02:55:41 +01:00
file_path = p_file_path;
FILE *f = fopen(file_path.c_str(), "rb");
if (!f) {
printf("send_file: Error: Download: file doesn't exists! %s\n", file_path.c_str());
return;
}
fseek(f, 0, SEEK_END);
file_size = ftell(f);
fclose(f);
response->addHeadValue("Connection", "Close");
std::string result = "HTTP/1.1 200 OK\r\nConnection: Close\r\n\r\n";
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
Application::register_request_update(this);
session->send(result.c_str(), result.size(), [this]() { this->_file_chunk_sent(); });
Implemented chunked file downloads. For some reason if a file is too big and has to be sent in more that 43 chunks it crashes, it might be a bug in brynet (it always crashes at the 43th chunk, with every file and chunk size setting.), will figure out the problem later.
2021-01-08 02:55:41 +01:00
}
Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
void Request::reset() {
http_parser = nullptr;
session = nullptr;
Now the request handling/middlewares work in a fully async way.
2020-11-26 12:02:58 +01:00
current_middleware_index = 0;
middleware_stack = nullptr;
Added a url stack to Request, for easier route handling. Also made the main routing middleware use it.
2020-12-28 19:15:27 +01:00
_path_stack.clear();
_path_stack_pointer = 0;
Implemented chunked file downloads. For some reason if a file is too big and has to be sent in more that 43 chunks it crashes, it might be a bug in brynet (it always crashes at the 43th chunk, with every file and chunk size setting.), will figure out the problem later.
2021-01-08 02:55:41 +01:00
file_size = 0;
current_file_progress = 0;
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
connection_closed = false;
Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
Added a head and body string to Request, and removed themes. I think themes added unnecessary complexity, and code non-locality (The view methods would have been in a different class.). I think in a language which have headers this is unwanted (The code will be broken up with the mvc pattern, but the methods don't need to be in separate classes.). Themes are still easily implementable by either adding different css links to the new head variable, or by inheritance.
2020-12-11 16:54:41 +01:00
head.clear();
body.clear();
Add footer string into request.
2020-12-26 00:17:36 +01:00
footer.clear();
Added a head and body string to Request, and removed themes. I think themes added unnecessary complexity, and code non-locality (The view methods would have been in a different class.). I think in a language which have headers this is unwanted (The code will be broken up with the mvc pattern, but the methods don't need to be in separate classes.). Themes are still easily implementable by either adding different css links to the new head variable, or by inheritance.
2020-12-11 16:54:41 +01:00
compiled_body.clear();
Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
if (response)
delete response;
Revert everything back to bf688577fb932e7e04764694ca8a6b08e431b275 .
2021-02-08 11:01:15 +01:00
response = new HttpResponse();
Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
}
Added a url stack to Request, for easier route handling. Also made the main routing middleware use it.
2020-12-28 19:15:27 +01:00
void Request::setup_url_stack() {
std::string path = http_parser->getPath();
size_t pos = 0;
std::string st;
while ((pos = path.find("/")) != std::string::npos) {
st = path.substr(0, pos);
if (st.size() != 0)
_path_stack.push_back(st);
path.erase(0, pos + 1);
}
if (path.size() != 0)
_path_stack.push_back(path);
}
std::string Request::get_path() const {
std::string path = "";
for (uint32_t i = _path_stack_pointer; i < _path_stack.size(); ++i) {
path += _path_stack[i];
path += "/";
}
return path;
}
const std::string &Request::get_path_full() const {
return http_parser->getPath();
}
const std::string &Request::get_path_segment(const uint32_t i) const {
return _path_stack[i];
}
const std::string &Request::get_current_path_segment() const {
if (_path_stack_pointer >= _path_stack.size()) {
//for convenience
static const std::string e_str = "";
return e_str;
}
return _path_stack[_path_stack_pointer];
}
uint32_t Request::get_path_segment_count() const {
return _path_stack.size();
}
uint32_t Request::get_current_segment_index() const {
return _path_stack_pointer;
}
uint32_t Request::get_remaining_segment_count() const {
if (_path_stack_pointer > _path_stack.size()) {
return 0;
}
return _path_stack.size() - _path_stack_pointer;
}
void Request::pop_path() {
_path_stack_pointer -= 1;
}
void Request::push_path() {
_path_stack_pointer += 1;
}
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
void Request::update() {
if (file_next) {
file_next = false;
_progress_send_file();
}
}
Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
Request::Request() {
Now requests have to be sent manually, with a new send() method. This makes it possible to handle requests in a full on async callback-like way.
2020-11-26 11:26:02 +01:00
response = nullptr;
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
//This value will need benchmarks, 2 MB seems to be just as fast for me as 4 MB, but 1MB is slower
//It is a tradeoff on server memory though, as every active download will consume this amount of memory
//where the file is bigger than this number
file_chunk_size = 1 << 21; //2MB
Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
reset();
}
Request::~Request() {
delete response;
}
Implemented chunked file downloads. For some reason if a file is too big and has to be sent in more that 43 chunks it crashes, it might be a bug in brynet (it always crashes at the 43th chunk, with every file and chunk size setting.), will figure out the problem later.
2021-01-08 02:55:41 +01:00
void Request::_progress_send_file() {
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
if (connection_closed) {
RequestPool::return_request(this);
return;
}
Implemented chunked file downloads. For some reason if a file is too big and has to be sent in more that 43 chunks it crashes, it might be a bug in brynet (it always crashes at the 43th chunk, with every file and chunk size setting.), will figure out the problem later.
2021-01-08 02:55:41 +01:00
if (current_file_progress >= file_size) {
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
session->postShutdown();
Implemented chunked file downloads. For some reason if a file is too big and has to be sent in more that 43 chunks it crashes, it might be a bug in brynet (it always crashes at the 43th chunk, with every file and chunk size setting.), will figure out the problem later.
2021-01-08 02:55:41 +01:00
RequestPool::return_request(this);
return;
}
FILE *f = fopen(file_path.c_str(), "rb");
if (!f) {
printf("Error: Download: In progress file doesn't exists anymore! %s\n", file_path.c_str());
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
Application::unregister_request_update(this);
session->postShutdown();
Implemented chunked file downloads. For some reason if a file is too big and has to be sent in more that 43 chunks it crashes, it might be a bug in brynet (it always crashes at the 43th chunk, with every file and chunk size setting.), will figure out the problem later.
2021-01-08 02:55:41 +01:00
RequestPool::return_request(this);
return;
}
fseek(f, current_file_progress, SEEK_SET);
long nfp = current_file_progress + file_chunk_size;
long csize = file_chunk_size;
if (nfp >= file_size) {
csize = (file_size - current_file_progress);
}
body.resize(csize);
fread(&body[0], 1, csize, f);
fclose(f);
current_file_progress = nfp;
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
session->send(body.c_str(), body.size(), [this]() { this->_file_chunk_sent(); });
}
void Request::_file_chunk_sent() {
file_next = true;
Implemented chunked file downloads. For some reason if a file is too big and has to be sent in more that 43 chunks it crashes, it might be a bug in brynet (it always crashes at the 43th chunk, with every file and chunk size setting.), will figure out the problem later.
2021-01-08 02:55:41 +01:00
}
Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
Request *RequestPool::get_request() {
_mutex.lock();
Request *request;
if (_requests.size() == 0) {
_mutex.unlock();
request = new Request();
return request;
}
request = _requests[_requests.size() - 1];
_requests.pop_back();
_mutex.unlock();
Fix file chunking with downloads. Also fixed a bunch of std::shared_ptr misuses, and made Application::send_file use Request's file chunking. Also the framework will properly handle client disconnects now.
2021-02-09 01:25:24 +01:00
request->reset();
Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
return request;
}
void RequestPool::return_request(Request *request) {
Now requests have to be sent manually, with a new send() method. This makes it possible to handle requests in a full on async callback-like way.
2020-11-26 11:26:02 +01:00
_mutex.lock();
Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
_requests.push_back(request);
Now requests have to be sent manually, with a new send() method. This makes it possible to handle requests in a full on async callback-like way.
2020-11-26 11:26:02 +01:00
_mutex.unlock();
Basic structure. Also added tinydir.
2020-11-25 00:20:41 +01:00
}
RequestPool::RequestPool() {
}
RequestPool::~RequestPool() {
for (uint32_t i = 0; i < _requests.size(); ++i) {
delete _requests[i];
}
_requests.clear();
}
std::mutex RequestPool::_mutex;
std::vector<Request *> RequestPool::_requests;
Reference in New Issue Copy Permalink