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

Database Pool

Browse source
This commit is contained in:
Blue 2023-12-29 14:40:00 -03:00
parent 59c1ffd027
commit fe2fbb9ad0
Signed by: blue
GPG key ID: 9B203B252A63EE38
23 changed files with 268 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

8
database/CMakeLists.txt
View file

@ -1,11 +1,15 @@
set(HEADERS
dbinterface.h
interface.h
exceptions.h
pool.h
resource.h
)
set(SOURCES
dbinterface.cpp
interface.cpp
exceptions.cpp
pool.cpp
resource.cpp
)
target_sources(${PROJECT_NAME} PRIVATE ${SOURCES})

8
database/exceptions.cpp
View file

@ -3,18 +3,18 @@
#include "exceptions.h"
DBInterface::Duplicate::Duplicate(const std::string& text):
DB::Duplicate::Duplicate(const std::string& text):
std::runtime_error(text)
{}
DBInterface::DuplicateLogin::DuplicateLogin(const std::string& text):
DB::DuplicateLogin::DuplicateLogin(const std::string& text):
Duplicate(text)
{}
DBInterface::EmptyResult::EmptyResult(const std::string& text):
DB::EmptyResult::EmptyResult(const std::string& text):
std::runtime_error(text)
{}
DBInterface::NoLogin::NoLogin(const std::string& text):
DB::NoLogin::NoLogin(const std::string& text):
EmptyResult(text)
{}

13
database/exceptions.h
View file

@ -3,24 +3,27 @@
#pragma once
#include "dbinterface.h"
#include <string>
#include <stdexcept>
class DBInterface::Duplicate : public std::runtime_error {
namespace DB {
class Duplicate : public std::runtime_error {
public:
explicit Duplicate(const std::string& text);
};
class DBInterface::DuplicateLogin : public DBInterface::Duplicate {
class DuplicateLogin : public Duplicate {
public:
explicit DuplicateLogin(const std::string& text);
};
class DBInterface::EmptyResult : public std::runtime_error {
class EmptyResult : public std::runtime_error {
public:
explicit EmptyResult(const std::string& text);
};
class DBInterface::NoLogin : public DBInterface::EmptyResult {
class NoLogin : public EmptyResult {
public:
explicit NoLogin(const std::string& text);
};
}

10
database/dbinterface.cpp → database/interface.cpp
View file

@ -1,18 +1,18 @@
// SPDX-FileCopyrightText: 2023 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#include "dbinterface.h"
#include "interface.h"
#include "mysql/mysql.h"
DBInterface::DBInterface(Type type):
DB::Interface::Interface(Type type):
type(type),
state(State::disconnected)
{}
DBInterface::~DBInterface() {}
DB::Interface::~Interface() {}
std::unique_ptr<DBInterface> DBInterface::create(Type type) {
std::unique_ptr<DB::Interface> DB::Interface::create(Type type) {
switch (type) {
case Type::mysql:
return std::make_unique<MySQL>();
@ -21,6 +21,6 @@ std::unique_ptr<DBInterface> DBInterface::create(Type type) {
throw std::runtime_error("Unexpected database type: " + std::to_string((uint8_t)type));
}
DBInterface::State DBInterface::currentState() const {
DB::Interface::State DB::Interface::currentState() const {
return state;
}

15
database/dbinterface.h → database/interface.h
View file

@ -8,7 +8,8 @@
#include <memory>
#include <stdint.h>
class DBInterface {
namespace DB {
class Interface {
public:
enum class Type {
mysql
@ -18,19 +19,14 @@ public:
connecting,
connected
};
static std::unique_ptr<DBInterface> create(Type type);
static std::unique_ptr<Interface> create(Type type);
virtual ~DBInterface();
virtual ~Interface();
State currentState() const;
const Type type;
class Duplicate;
class DuplicateLogin;
class EmptyResult;
class NoLogin;
public:
virtual void connect(const std::string& path) = 0;
virtual void disconnect() = 0;
@ -46,8 +42,9 @@ public:
virtual unsigned int createSession(const std::string& login, const std::string& access, const std::string& renew) = 0;
protected:
DBInterface(Type type);
Interface(Type type);
protected:
State state;
};
}

32
database/mysql/mysql.cpp
View file

@ -23,8 +23,8 @@ constexpr const char* createSessionQuery = "INSERT INTO sessions (`owner`, `acce
static const std::filesystem::path buildSQLPath = "database";
MySQL::MySQL():
DBInterface(Type::mysql),
DB::MySQL::MySQL():
Interface(Type::mysql),
connection(),
login(),
password(),
@ -33,11 +33,11 @@ MySQL::MySQL():
mysql_init(&connection);
}
MySQL::~MySQL() {
DB::MySQL::~MySQL() {
mysql_close(&connection);
}
void MySQL::connect(const std::string& path) {
void DB::MySQL::connect(const std::string& path) {
if (state != State::disconnected)
return;
@ -59,7 +59,7 @@ void MySQL::connect(const std::string& path) {
state = State::connected;
}
void MySQL::setCredentials(const std::string& login, const std::string& password) {
void DB::MySQL::setCredentials(const std::string& login, const std::string& password) {
if (MySQL::login == login && MySQL::password == password)
return;
@ -81,7 +81,7 @@ void MySQL::setCredentials(const std::string& login, const std::string& password
throw std::runtime_error(std::string("Error changing credetials: ") + mysql_error(con));
}
void MySQL::setDatabase(const std::string& database) {
void DB::MySQL::setDatabase(const std::string& database) {
if (MySQL::database == database)
return;
@ -97,7 +97,7 @@ void MySQL::setDatabase(const std::string& database) {
throw std::runtime_error(std::string("Error changing db: ") + mysql_error(con));
}
void MySQL::disconnect() {
void DB::MySQL::disconnect() {
if (state == State::disconnected)
return;
@ -106,7 +106,7 @@ void MySQL::disconnect() {
mysql_init(con); //this is ridiculous!
}
void MySQL::executeFile(const std::filesystem::path& relativePath) {
void DB::MySQL::executeFile(const std::filesystem::path& relativePath) {
MYSQL* con = &connection;
std::filesystem::path path = sharedPath() / relativePath;
if (!std::filesystem::exists(path))
@ -138,7 +138,7 @@ void MySQL::executeFile(const std::filesystem::path& relativePath) {
}
}
uint8_t MySQL::getVersion() {
uint8_t DB::MySQL::getVersion() {
MYSQL* con = &connection;
int result = mysql_query(con, versionQuery);
@ -161,14 +161,14 @@ uint8_t MySQL::getVersion() {
return 0;
}
void MySQL::setVersion(uint8_t version) {
void DB::MySQL::setVersion(uint8_t version) {
std::string strVersion = std::to_string(version);
Statement statement(&connection, updateQuery);
statement.bind(strVersion.data(), MYSQL_TYPE_VAR_STRING);
statement.execute();
}
void MySQL::migrate(uint8_t targetVersion) {
void DB::MySQL::migrate(uint8_t targetVersion) {
uint8_t currentVersion = getVersion();
while (currentVersion < targetVersion) {
@ -190,7 +190,7 @@ void MySQL::migrate(uint8_t targetVersion) {
std::cout << "Database is now on actual version " << std::to_string(targetVersion) << std::endl;
}
std::optional<std::string> MySQL::getComment(std::string& string) {
std::optional<std::string> DB::MySQL::getComment(std::string& string) {
ltrim(string);
if (string.length() < 2)
return std::nullopt;
@ -218,7 +218,7 @@ std::optional<std::string> MySQL::getComment(std::string& string) {
return std::nullopt;
}
unsigned int MySQL::registerAccount(const std::string& login, const std::string& hash) {
unsigned int DB::MySQL::registerAccount(const std::string& login, const std::string& hash) {
//TODO validate filed lengths!
MYSQL* con = &connection;
MySQL::Transaction txn(con);
@ -247,7 +247,7 @@ unsigned int MySQL::registerAccount(const std::string& login, const std::string&
return id;
}
std::string MySQL::getAccountHash(const std::string& login) {
std::string DB::MySQL::getAccountHash(const std::string& login) {
std::string l = login;
MYSQL* con = &connection;
@ -265,7 +265,7 @@ std::string MySQL::getAccountHash(const std::string& login) {
return std::any_cast<const std::string&>(result[0][0]);
}
unsigned int MySQL::createSession(const std::string& login, const std::string& access, const std::string& renew) {
unsigned int DB::MySQL::createSession(const std::string& login, const std::string& access, const std::string& renew) {
std::string l = login, a = access, r = renew;
static std::string testingDevice("Testing...");
@ -281,7 +281,7 @@ unsigned int MySQL::createSession(const std::string& login, const std::string& a
return lastInsertedId();
}
unsigned int MySQL::lastInsertedId() {
unsigned int DB::MySQL::lastInsertedId() {
MYSQL* con = &connection;
int result = mysql_query(con, lastIdQuery);

6
database/mysql/mysql.h
View file

@ -9,10 +9,11 @@
#include <mysql.h>
#include "database/dbinterface.h"
#include "database/interface.h"
#include "utils/helpers.h"
class MySQL : public DBInterface {
namespace DB {
class MySQL : public Interface {
class Statement;
class Transaction;
@ -51,3 +52,4 @@ struct ResDeleter {
}
};
};
}

8
database/mysql/statement.cpp
View file

@ -9,7 +9,7 @@
static uint64_t TIME_LENGTH = sizeof(MYSQL_TIME);
MySQL::Statement::Statement(MYSQL* connection, const char* statement):
DB::MySQL::Statement::Statement(MYSQL* connection, const char* statement):
stmt(mysql_stmt_init(connection)),
param()
{
@ -18,7 +18,7 @@ MySQL::Statement::Statement(MYSQL* connection, const char* statement):
throw std::runtime_error(std::string("Error preparing statement: ") + mysql_stmt_error(stmt.get()));
}
void MySQL::Statement::bind(void* value, enum_field_types type, bool usigned) {
void DB::MySQL::Statement::bind(void* value, enum_field_types type, bool usigned) {
MYSQL_BIND& result = param.emplace_back();
std::memset(&result, 0, sizeof(result));
@ -45,7 +45,7 @@ void MySQL::Statement::bind(void* value, enum_field_types type, bool usigned) {
}
}
void MySQL::Statement::execute() {
void DB::MySQL::Statement::execute() {
MYSQL_STMT* raw = stmt.get();
int result = mysql_stmt_bind_param(raw, param.data());
if (result != 0)
@ -64,7 +64,7 @@ void MySQL::Statement::execute() {
}
}
std::vector<std::vector<std::any>> MySQL::Statement::fetchResult() {
std::vector<std::vector<std::any>> DB::MySQL::Statement::fetchResult() {
MYSQL_STMT* raw = stmt.get();
if (mysql_stmt_store_result(raw) != 0)
throw std::runtime_error(std::string("Error fetching statement result: ") + mysql_stmt_error(raw)); //TODO not sure if it's valid here

2
database/mysql/statement.h
View file

@ -10,6 +10,7 @@
#include "mysql.h"
namespace DB {
class MySQL::Statement {
struct STMTDeleter {
void operator () (MYSQL_STMT* stmt) {
@ -27,3 +28,4 @@ private:
std::unique_ptr<MYSQL_STMT, STMTDeleter> stmt;
std::vector<MYSQL_BIND> param;
};
}

8
database/mysql/transaction.cpp
View file

@ -3,7 +3,7 @@
#include "transaction.h"
MySQL::Transaction::Transaction(MYSQL* connection):
DB::MySQL::Transaction::Transaction(MYSQL* connection):
con(connection),
opened(false)
{
@ -13,12 +13,12 @@ MySQL::Transaction::Transaction(MYSQL* connection):
opened = true;
}
MySQL::Transaction::~Transaction() {
DB::MySQL::Transaction::~Transaction() {
if (opened)
abort();
}
void MySQL::Transaction::commit() {
void DB::MySQL::Transaction::commit() {
if (mysql_commit(con) != 0)
throw std::runtime_error(std::string("Failed to commit transaction") + mysql_error(con));
@ -27,7 +27,7 @@ void MySQL::Transaction::commit() {
throw std::runtime_error(std::string("Failed to return autocommit") + mysql_error(con));
}
void MySQL::Transaction::abort() {
void DB::MySQL::Transaction::abort() {
opened = false;
if (mysql_rollback(con) != 0)
throw std::runtime_error(std::string("Failed to rollback transaction") + mysql_error(con));

2
database/mysql/transaction.h
View file

@ -5,6 +5,7 @@
#include "mysql.h"
namespace DB {
class MySQL::Transaction {
public:
Transaction(MYSQL* connection);
@ -17,3 +18,4 @@ private:
MYSQL* con;
bool opened;
};
}

57
database/pool.cpp Normal file
View file

@ -0,0 +1,57 @@
// SPDX-FileCopyrightText: 2023 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#include "pool.h"
DB::Pool::Pool (Private):
std::enable_shared_from_this<Pool>(),
mutex(),
conditional(),
interfaces()
{}
DB::Pool::~Pool () {
}
std::shared_ptr<DB::Pool> DB::Pool::create () {
return std::make_shared<Pool>(Private());
}
void DB::Pool::addInterfaces (
Interface::Type type,
std::size_t amount,
const std::string & login,
const std::string & password,
const std::string & database,
const std::string& path
) {
std::unique_lock lock(mutex);
for (std::size_t i = 0; i < amount; ++i) {
const std::unique_ptr<Interface>& ref = interfaces.emplace(Interface::create(type));
ref->setCredentials(login, password);
ref->setDatabase(database);
ref->connect(path);
}
lock.unlock();
conditional.notify_all();
}
DB::Resource DB::Pool::request () {
std::unique_lock lock(mutex);
while (interfaces.empty())
conditional.wait(lock);
std::unique_ptr<Interface> interface = std::move(interfaces.front());
interfaces.pop();
return Resource(std::move(interface), shared_from_this());
}
void DB::Pool::free (std::unique_ptr<Interface> interface) {
std::unique_lock lock(mutex);
interfaces.push(std::move(interface));
lock.unlock();
conditional.notify_one();
}

47
database/pool.h Normal file
View file

@ -0,0 +1,47 @@
// SPDX-FileCopyrightText: 2023 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include <string>
#include <memory>
#include <queue>
#include <mutex>
#include <condition_variable>
#include "interface.h"
#include "resource.h"
namespace DB {
class Pool : public std::enable_shared_from_this<Pool> {
struct Private {};
friend class Resource;
void free(std::unique_ptr<Interface> interface);
public:
Pool(Private);
Pool(const Pool&) = delete;
Pool(Pool&&) = delete;
~Pool();
Pool& operator = (const Pool&) = delete;
Pool& operator = (Pool&&) = delete;
static std::shared_ptr<Pool> create();
Resource request();
void addInterfaces(
Interface::Type type,
std::size_t amount,
const std::string& login,
const std::string& password,
const std::string& database,
const std::string& path
);
private:
std::mutex mutex;
std::condition_variable conditional;
std::queue<std::unique_ptr<Interface>> interfaces;
};
}

38
database/resource.cpp Normal file
View file

@ -0,0 +1,38 @@
// SPDX-FileCopyrightText: 2023 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#include "resource.h"
#include "pool.h"
DB::Resource::Resource (
std::unique_ptr<Interface> interface,
std::weak_ptr<Pool> parent
):
parent(parent),
interface(std::move(interface))
{}
DB::Resource::Resource(Resource&& other):
parent(other.parent),
interface(std::move(other.interface))
{}
DB::Resource::~Resource() {
if (!interface)
return;
if (std::shared_ptr<Pool> p = parent.lock())
p->free(std::move(interface));
}
DB::Resource& DB::Resource::operator = (Resource&& other) {
parent = other.parent;
interface = std::move(other.interface);
return *this;
}
DB::Interface* DB::Resource::operator -> () {
return interface.get();
}

31
database/resource.h Normal file
View file

@ -0,0 +1,31 @@
// SPDX-FileCopyrightText: 2023 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include <memory>
#include "interface.h"
namespace DB {
class Pool;
class Resource {
friend class Pool;
Resource(std::unique_ptr<Interface> interface, std::weak_ptr<Pool> parent);
public:
Resource(const Resource&) = delete;
Resource(Resource&& other);
~Resource();
Resource& operator = (const Resource&) = delete;
Resource& operator = (Resource&& other);
Interface* operator -> ();
private:
std::weak_ptr<Pool> parent;
std::unique_ptr<Interface> interface;
};
}