blue/pica
1
0
Fork 1
Code Issues 2 Pull Requests Packages Projects Releases Wiki Activity

testing and debugging

Browse Source
This commit is contained in:
Blue 2024-01-09 14:02:56 -03:00
parent 5d765958e5
commit a1ab1339e3
Signed by: blue
GPG Key ID: 9B203B252A63EE38
10 changed files with 38 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
database/mysql/mysql.cpp
View File

@ -305,6 +305,7 @@ DB::Session DB::MySQL::findSession(const std::string& accessToken) {
Statement session(con, selectSession);
session.bind(a.data(), MYSQL_TYPE_STRING);
session.execute();
std::vector<std::vector<std::any>> result = session.fetchResult();
if (result.empty())

8
database/mysql/statement.cpp
View File

@ -94,19 +94,19 @@ std::vector<std::vector<std::any>> DB::MySQL::Statement::fetchResult() {
} break;
case MYSQL_TYPE_TINY:
line[i] = uint8_t{0};
bind[i].buffer = &std::any_cast<std::string&>(line[i]);
bind[i].buffer = &std::any_cast<uint8_t&>(line[i]);
break;
case MYSQL_TYPE_SHORT:
line[i] = uint16_t{0};
bind[i].buffer = &std::any_cast<std::string&>(line[i]);
bind[i].buffer = &std::any_cast<uint16_t&>(line[i]);
break;
case MYSQL_TYPE_LONG:
line[i] = uint32_t{0};
bind[i].buffer = &std::any_cast<std::string&>(line[i]);
bind[i].buffer = &std::any_cast<uint32_t&>(line[i]);
break;
case MYSQL_TYPE_LONGLONG:
line[i] = uint64_t{0};
bind[i].buffer = &std::any_cast<std::string&>(line[i]);
bind[i].buffer = &std::any_cast<uint64_t&>(line[i]);
break;
default:
throw std::runtime_error("Unsupported data fetching statement result " + std::to_string(field->type));

10
handler/poll.cpp
View File

@ -8,8 +8,8 @@
#include "request/redirect.h"
#include "database/exceptions.h"
Handler::Poll::Poll (Server* server):
Handler("login", Request::Method::get),
Handler::Poll::Poll (std::weak_ptr<Server> server):
Handler("poll", Request::Method::get),
server(server)
{}
@ -21,8 +21,12 @@ void Handler::Poll::handle (Request& request) {
if (access.size() != 32)
return error(request, Result::tokenProblem, Response::Status::badRequest);
std::shared_ptr<Server> srv = server.lock();
if (!srv)
return error(request, Result::unknownError, Response::Status::internalError);
try {
Session& session = server->getSession(access);
Session& session = srv->getSession(access);
throw Redirect(&session);
} catch (const Redirect& r) {
throw r;

6
handler/poll.h
View File

@ -3,6 +3,8 @@
#pragma once
#include <memory>
#include "handler.h"
#include "request/request.h"
#include "response/response.h"
@ -12,7 +14,7 @@ namespace Handler {
class Poll : public Handler {
public:
Poll(Server* server);
Poll(std::weak_ptr<Server> server);
void handle(Request& request) override;
enum class Result {
@ -25,7 +27,7 @@ public:
static void error(Request& request, Result result, Response::Status status);
private:
Server* server;
std::weak_ptr<Server> server;
};

4
request/request.cpp
View File

@ -188,7 +188,7 @@ std::string Request::getServerName() const {
return FCGX_GetParam(SERVER_NAME, raw.envp);;
}
void Request::printEnvironment(std::ostream& out) {
void Request::printEnvironment(std::ostream& out) const {
if (!active())
throw std::runtime_error("An attempt to print environment of a request in a wrong state");
@ -198,7 +198,7 @@ void Request::printEnvironment(std::ostream& out) {
}
}
void Request::printEnvironment(nlohmann::json& out) {
void Request::printEnvironment(nlohmann::json& out) const {
if (!out.is_object())
return;

4
request/request.h
View File

@ -61,8 +61,8 @@ public:
std::string getPath() const;
std::string getServerName() const;
std::string getAuthorizationToken() const;
void printEnvironment(std::ostream& out);
void printEnvironment(nlohmann::json& out);
void printEnvironment(std::ostream& out) const;
void printEnvironment(nlohmann::json& out) const;
private:
OStream getOutputStream();

3
server/router.cpp
View File

@ -62,19 +62,16 @@ void Router::handleNotFound(std::unique_ptr<Request> request) {
std::string path = request->getPath();
notFound.setBody(std::string("Path \"") + path + "\" was not found");
notFound.send();
std::cerr << notFound.statusCode() << '\t' << request->methodName() << '\t' << path << std::endl;
}
void Router::handleInternalError(const std::exception& exception, std::unique_ptr<Request> request) {
Response& error = request->createResponse(Response::Status::internalError);
error.setBody(std::string(exception.what()));
error.send();
std::cerr << error.statusCode() << '\t' << request->methodName() << '\t' << request->getPath() << std::endl;
}
void Router::handleMethodNotAllowed(std::unique_ptr<Request> request) {
Response& error = request->createResponse(Response::Status::methodNotAllowed);
error.setBody(std::string("Method not allowed"));
error.send();
std::cerr << error.statusCode() << '\t' << request->methodName() << '\t' << request->getPath() << std::endl;
}

30
server/server.cpp
View File

@ -11,6 +11,7 @@
#include "handler/env.h"
#include "handler/register.h"
#include "handler/login.h"
#include "handler/poll.h"
#include "taskmanager/route.h"
@ -20,6 +21,7 @@ constexpr const char* dbPassword = "pica";
constexpr const char* dbName = "pica";
constexpr const char* dbPath = "/run/mysqld/mysqld.sock";
constexpr uint8_t dbConnectionsCount = 4;
constexpr uint32_t pollTimout = 10000;
constexpr const char* randomChars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
constexpr uint8_t saltSize = 16;
@ -64,31 +66,11 @@ void Server::run(int socketDescriptor) {
router->addRoute(std::make_unique<Handler::Env>());
router->addRoute(std::make_unique<Handler::Register>(shared_from_this()));
router->addRoute(std::make_unique<Handler::Login>(shared_from_this()));
router->addRoute(std::make_unique<Handler::Poll>(shared_from_this()));
taskManager->start();
scheduler->start();
scheduler->schedule([]() {
std::cout << "5000" << std::endl;
}, TM::Scheduler::Delay(5000));
scheduler->schedule([]() {
std::cout << "2000" << std::endl;
}, TM::Scheduler::Delay(2000));
scheduler->schedule([]() {
std::cout << "6000" << std::endl;
}, TM::Scheduler::Delay(6000));
std::this_thread::sleep_for(std::chrono::milliseconds(500));
scheduler->schedule([]() {
std::cout << "2000 + 500" << std::endl;
}, TM::Scheduler::Delay(2000));
std::this_thread::sleep_for(std::chrono::milliseconds(100));
scheduler->schedule([]() {
std::cout << "1000 + 600" << std::endl;
}, TM::Scheduler::Delay(1000));
while (!terminating) {
std::unique_ptr<Request> request = std::make_unique<Request>();
bool result = request->wait(socketDescriptor);
@ -192,7 +174,8 @@ Session& Server::openSession(const std::string& login) {
if (sessionId == 0)
throw std::runtime_error("Couldn't create session, ran out of attempts");
std::unique_ptr<Session>& session = sessions[accessToken] = std::make_unique<Session>(scheduler, sessionId, accessToken, renewToken);
std::unique_ptr<Session>& session = sessions[accessToken]
= std::make_unique<Session>(scheduler, sessionId, accessToken, renewToken, pollTimout);
return *session.get();
}
@ -207,7 +190,8 @@ Session& Server::getSession (const std::string& accessToken) {
scheduler,
s.id,
s.accessToken,
s.renewToken
s.renewToken,
pollTimout
);
return *session.get();
}

13
server/session.cpp
View File

@ -9,14 +9,16 @@ Session::Session(
std::weak_ptr<TM::Scheduler> scheduler,
unsigned int id,
const std::string& access,
const std::string& renew
const std::string& renew,
unsigned int timeout
):
scheduler(scheduler),
id(id),
access(access),
renew(renew),
polling(nullptr),
timeoutId(TM::Scheduler::none)
timeoutId(TM::Scheduler::none),
timeout(timeout)
{}
Session::~Session () {
@ -37,14 +39,14 @@ std::string Session::getRenewToken() const {
void Session::accept(std::unique_ptr<Request> request) {
std::shared_ptr<TM::Scheduler> sch = scheduler.lock();
if (polling) {
Handler::Poll::error(*request.get(), Handler::Poll::Result::replace, Response::Status::ok);
if (timeoutId != TM::Scheduler::none) {
if (sch)
sch->cancel(timeoutId);
timeoutId = TM::Scheduler::none;
}
//TODO unschedule
Handler::Poll::error(*polling.get(), Handler::Poll::Result::replace, Response::Status::ok);
polling.reset();
}
if (!sch) {
@ -52,8 +54,7 @@ void Session::accept(std::unique_ptr<Request> request) {
Handler::Poll::error(*request.get(), Handler::Poll::Result::unknownError, Response::Status::internalError);
return;
}
timeoutId = sch->schedule(std::bind(&Session::onTimeout, this), TM::Scheduler::Delay(5000));
timeoutId = sch->schedule(std::bind(&Session::onTimeout, this), timeout);
polling = std::move(request);
}

4
server/session.h
View File

@ -14,7 +14,8 @@ public:
std::weak_ptr<TM::Scheduler> scheduler,
unsigned int id,
const std::string& access,
const std::string& renew
const std::string& renew,
unsigned int timeout
);
Session(const Session&) = delete;
Session(Session&& other);
@ -36,4 +37,5 @@ private:
std::string renew;
std::unique_ptr<Request> polling;
TM::Record::ID timeoutId;
TM::Scheduler::Delay timeout;
};