arcanis/queued
1
0
Fork 0
mirror of https://github.com/arcan1s/queued.git synced 2025-06-29 15:05:50 +00:00
Code Issues Projects Releases Wiki Activity

use 100 symbols (2)

Browse Source
This commit is contained in:
Evgenii Alekseev
2018-01-06 17:12:23 +03:00
parent 2b885ebee5
commit ba9a1c5cdd
90 changed files with 1331 additions and 1963 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
sources/.clang-format
View File

@ -21,7 +21,7 @@ BreakBeforeBinaryOperators: All
BreakBeforeBraces: Linux
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: true
ColumnLimit: 80
ColumnLimit: 100
CommentPragmas: '^ IWYU pragma:'
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4

9
sources/plugins/emailnotify/QueuedEmailNotify.cpp
View File

@ -29,8 +29,7 @@ void QueuedEmailNotify::init(const QVariantHash &_settings)
m_helper->setInsecureCurl(_settings.value("InsecureCurl", false).toBool());
m_helper->setPassword(_settings.value("Password", "").toString());
m_helper->setPort(_settings.value("Port", 465).toInt());
m_helper->setServer(
_settings.value("Server", "smtp://smtp.example.com").toString());
m_helper->setServer(_settings.value("Server", "smtp://smtp.example.com").toString());
m_helper->setSslEnabled(_settings.value("UseSSL", false).toBool());
m_helper->setUsername(_settings.value("Username", "").toString());
}
@ -50,14 +49,12 @@ void QueuedEmailNotify::setup(const QueuedPluginManagerInterface *_manager)
}
void QueuedEmailNotify::updateSettings(const QString &_key,
const QVariant &_value)
void QueuedEmailNotify::updateSettings(const QString &_key, const QVariant &_value)
{
qCDebug(LOG_PL) << "Update settings for" << _key;
if (!m_helper) {
qCWarning(LOG_PL)
<< "Helper is not initialized. Did you forget to call ::init()?";
qCWarning(LOG_PL) << "Helper is not initialized. Did you forget to call ::init()?";
return;
}

19
sources/plugins/emailnotify/QueuedEmailNotifyHelper.cpp
View File

@ -44,8 +44,8 @@ char *QueuedEmailNotifyHelper::curlString(const QString &_source)
}
size_t QueuedEmailNotifyHelper::curlReadCallback(char *buffer, size_t size,
size_t nitems, void *instream)
size_t QueuedEmailNotifyHelper::curlReadCallback(char *buffer, size_t size, size_t nitems,
void *instream)
{
// FIXME not really best choice to use here
auto text = reinterpret_cast<MailBody *>(instream);
@ -206,16 +206,14 @@ void QueuedEmailNotifyHelper::sendEmail(const long long _id)
curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
// mail body
curl_easy_setopt(curl, CURLOPT_READFUNCTION,
&QueuedEmailNotifyHelper::curlReadCallback);
curl_easy_setopt(curl, CURLOPT_READFUNCTION, &QueuedEmailNotifyHelper::curlReadCallback);
curl_easy_setopt(curl, CURLOPT_READDATA, &text);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
// send
auto res = curl_easy_perform(curl);
if (res != CURLE_OK)
qCWarning(LOG_PL) << "Could not perform curl action"
<< curl_easy_strerror(res);
qCWarning(LOG_PL) << "Could not perform curl action" << curl_easy_strerror(res);
// cleanup
curl_slist_free_all(recipients);
@ -244,16 +242,13 @@ QString QueuedEmailNotifyHelper::getEmail(const long long _id) const
}
QStringList QueuedEmailNotifyHelper::getEmailText(const long long _id,
const QString &_to) const
QStringList QueuedEmailNotifyHelper::getEmailText(const long long _id, const QString &_to) const
{
qCDebug(LOG_PL) << "Get email text for user" << _to << "for task" << _id;
auto now
= QDateTime::currentDateTimeUtc().toString(Qt::DateFormat::RFC2822Date);
auto now = QDateTime::currentDateTimeUtc().toString(Qt::DateFormat::RFC2822Date);
return {QString("Date: %1\r\n").arg(now),
QString("To: %1\r\n").arg(curlEmail(_to)),
return {QString("Date: %1\r\n").arg(now), QString("To: %1\r\n").arg(curlEmail(_to)),
QString("From: %1\r\n").arg(curlEmail(from())),
// message-id?
QString("Subject: %1\r\n").arg("Job %1 done").arg(_id), "\r\n",

3
sources/plugins/emailnotify/QueuedEmailNotifyHelper.h
View File

@ -42,8 +42,7 @@ public:
virtual ~QueuedEmailNotifyHelper() = default;
static QString curlEmail(const QString &_from);
static char *curlString(const QString &_source);
static size_t curlReadCallback(char *buffer, size_t size, size_t nitems,
void *instream);
static size_t curlReadCallback(char *buffer, size_t size, size_t nitems, void *instream);
// properties
QString from() const;
bool isInsecureCurl() const;

7
sources/queued-daemon/src/QueuedApplication.cpp
View File

@ -41,8 +41,7 @@ QueuedApplication::~QueuedApplication()
{
qCDebug(LOG_APP) << __PRETTY_FUNCTION__;
QDBusConnection::sessionBus().unregisterObject(
QueuedConfig::DBUS_APPLICATION_PATH);
QDBusConnection::sessionBus().unregisterObject(QueuedConfig::DBUS_APPLICATION_PATH);
m_core->deleteLater();
}
@ -61,8 +60,8 @@ void QueuedApplication::initDBus()
if (!bus.registerObject(QueuedConfig::DBUS_APPLICATION_PATH,
new QueuedApplicationInterface(this),
QDBusConnection::ExportAllContents)) {
QString message = QString("Could not register application object %1")
.arg(bus.lastError().message());
QString message
= QString("Could not register application object %1").arg(bus.lastError().message());
qCCritical(LOG_DBUS) << message;
throw QueuedDBusException(message);
}

3
sources/queued-daemon/src/QueuedApplicationInterface.cpp
View File

@ -28,8 +28,7 @@ extern "C" {
}
QueuedApplicationInterface::QueuedApplicationInterface(
QueuedApplication *parent)
QueuedApplicationInterface::QueuedApplicationInterface(QueuedApplication *parent)
: QDBusAbstractAdaptor(parent)
, m_application(parent)
{

10
sources/queued-daemon/src/main.cpp
View File

@ -36,8 +36,8 @@ QueuedApplication *instance = nullptr;
bool existingSessionOperation(const QString &operation)
{
auto res = QueuedCoreAdaptor::sendRequest<bool>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_APPLICATION_PATH,
QueuedConfig::DBUS_SERVICE, operation, QVariantList());
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_APPLICATION_PATH, QueuedConfig::DBUS_SERVICE,
operation, QVariantList());
return ((res.type() == Result::Content::Value) && res.get());
}
@ -60,8 +60,7 @@ int main(int argc, char *argv[])
// parser
QCommandLineParser parser;
parser.setApplicationDescription(
"Daemon for starting jobs to queue of calculations");
parser.setApplicationDescription("Daemon for starting jobs to queue of calculations");
parser.addHelpOption();
parser.addVersionOption();
// info
@ -69,8 +68,7 @@ int main(int argc, char *argv[])
parser.addOption(infoOption);
// configuration option
QCommandLineOption configOption({"c", "config"},
"Read initial configuration from file.",
QCommandLineOption configOption({"c", "config"}, "Read initial configuration from file.",
"config", QueuedSettings::defaultPath());
parser.addOption(configOption);

21
sources/queued-server/src/QueuedServer.cpp
View File

@ -46,33 +46,26 @@ QueuedServer::~QueuedServer()
void QueuedServer::init()
{
while (QueuedCoreAdaptor::getStatus().type() != Result::Content::Value) {
qCWarning(LOG_SERV)
<< "Daemon seems to be unavailable wait" << WAIT_FOR_DAEMON;
qCWarning(LOG_SERV) << "Daemon seems to be unavailable wait" << WAIT_FOR_DAEMON;
QTime timer = QTime::currentTime().addMSecs(WAIT_FOR_DAEMON);
while (QTime::currentTime() < timer)
QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
}
m_server->init(QueuedCoreAdaptor::getOption(
QueuedConfig::QueuedSettings::ServerTimeout, "")
m_server->init(QueuedCoreAdaptor::getOption(QueuedConfig::QueuedSettings::ServerTimeout, "")
.get()
.toInt());
QString address = QueuedCoreAdaptor::getOption(
QueuedConfig::QueuedSettings::ServerAddress, "")
QString address = QueuedCoreAdaptor::getOption(QueuedConfig::QueuedSettings::ServerAddress, "")
.get()
.toString();
ushort port = QueuedCoreAdaptor::getOption(
QueuedConfig::QueuedSettings::ServerPort, "")
.get()
.toUInt();
ushort port
= QueuedCoreAdaptor::getOption(QueuedConfig::QueuedSettings::ServerPort, "").get().toUInt();
m_server->listen(QHostAddress(address), port);
m_server->setMaxPendingConnections(
QueuedCoreAdaptor::getOption(
QueuedConfig::QueuedSettings::ServerMaxConnections, "")
QueuedCoreAdaptor::getOption(QueuedConfig::QueuedSettings::ServerMaxConnections, "")
.get()
.toInt());
qCInfo(LOG_SERV) << "Server listen on" << m_server->serverAddress()
<< m_server->serverPort();
qCInfo(LOG_SERV) << "Server listen on" << m_server->serverAddress() << m_server->serverPort();
}

12
sources/queued-server/src/QueuedTcpServerResponseHelper.cpp
View File

@ -27,14 +27,13 @@ QVariantHash QueuedTcpServerResponseHelper::getData(const Request &_request,
const QVariantHash &_data,
const QString &_token)
{
qCDebug(LOG_SERV) << "Get data for request"
<< static_cast<int>(_request.path) << _request.apiVersion
<< _request.arg << "with data" << _data;
qCDebug(LOG_SERV) << "Get data for request" << static_cast<int>(_request.path)
<< _request.apiVersion << _request.arg << "with data" << _data;
QVariantHash output;
if (_request.apiVersion == 1)
output = QueuedTcpServerResponseHelperApi1::getData(
_request.path, _request.arg, _request.type, _data, _token);
output = QueuedTcpServerResponseHelperApi1::getData(_request.path, _request.arg,
_request.type, _data, _token);
return output;
}
@ -64,8 +63,7 @@ QueuedTcpServerResponseHelper::parsePath(const QString &_path)
// check if request is valid
request.valid = (request.path != RequestPath::Unknown)
&& (std::find(std::begin(QueuedConfig::WEBAPI_VERSIONS),
std::end(QueuedConfig::WEBAPI_VERSIONS),
request.apiVersion)
std::end(QueuedConfig::WEBAPI_VERSIONS), request.apiVersion)
!= std::end(QueuedConfig::WEBAPI_VERSIONS));
}

84
sources/queued-server/src/QueuedTcpServerResponseHelper.h
View File

@ -43,49 +43,47 @@ typedef struct {
QString type;
bool valid;
} Request;
static const QHash<int, QByteArray> HTTPCodeMap
= {{100, "Continue"},
{101, "Switching Protocols"},
{200, "OK"},
{201, "Created"},
{202, "Accepted"},
{203, "Non-Authoritative Information"},
{204, "No Content"},
{205, "Reset Content"},
{206, "Partial Content"},
{300, "Multiple Choices"},
{301, "Moved Permanently"},
{302, "Found"},
{303, "See Other"},
{304, "Not Modified"},
{305, "Use Proxy"},
{307, "Temporary Redirect"},
{400, "Bad Request"},
{401, "Unauthorized"},
{402, "Payment Required"},
{403, "Forbidden"},
{404, "Not Found"},
{405, "Method Not Allowed"},
{406, "Not Acceptable"},
{407, "Proxy Authentication Required"},
{408, "Request Time-out"},
{409, "Conflict"},
{410, "Gone"},
{411, "Length Required"},
{412, "Precondition Failed"},
{413, "Request Entity Too Large"},
{414, "Request-URI Too Large"},
{415, "Unsupported Media Type"},
{416, "Requested range not satisfiable"},
{417, "Expectation Failed"},
{500, "Internal Server Error"},
{501, "Not Implemented"},
{502, "Bad Gateway"},
{503, "Service Unavailable"},
{504, "Gateway Time-out"},
{505, "HTTP Version not supported"}};
QVariantHash getData(const Request &_request, const QVariantHash &_data,
const QString &_token);
static const QHash<int, QByteArray> HTTPCodeMap = {{100, "Continue"},
{101, "Switching Protocols"},
{200, "OK"},
{201, "Created"},
{202, "Accepted"},
{203, "Non-Authoritative Information"},
{204, "No Content"},
{205, "Reset Content"},
{206, "Partial Content"},
{300, "Multiple Choices"},
{301, "Moved Permanently"},
{302, "Found"},
{303, "See Other"},
{304, "Not Modified"},
{305, "Use Proxy"},
{307, "Temporary Redirect"},
{400, "Bad Request"},
{401, "Unauthorized"},
{402, "Payment Required"},
{403, "Forbidden"},
{404, "Not Found"},
{405, "Method Not Allowed"},
{406, "Not Acceptable"},
{407, "Proxy Authentication Required"},
{408, "Request Time-out"},
{409, "Conflict"},
{410, "Gone"},
{411, "Length Required"},
{412, "Precondition Failed"},
{413, "Request Entity Too Large"},
{414, "Request-URI Too Large"},
{415, "Unsupported Media Type"},
{416, "Requested range not satisfiable"},
{417, "Expectation Failed"},
{500, "Internal Server Error"},
{501, "Not Implemented"},
{502, "Bad Gateway"},
{503, "Service Unavailable"},
{504, "Gateway Time-out"},
{505, "HTTP Version not supported"}};
QVariantHash getData(const Request &_request, const QVariantHash &_data, const QString &_token);
Request parsePath(const QString &_path);
RequestPath pathToEnum(const QString &_path);
};

51
sources/queued-server/src/QueuedTcpServerResponseHelperApi1.cpp
View File

@ -27,12 +27,11 @@
QVariantHash QueuedTcpServerResponseHelperApi1::getData(
const QueuedTcpServerResponseHelper::RequestPath _request,
const QString &_arg, const QString &_type, const QVariantHash &_data,
const QString &_token)
const QueuedTcpServerResponseHelper::RequestPath _request, const QString &_arg,
const QString &_type, const QVariantHash &_data, const QString &_token)
{
qCDebug(LOG_SERV) << "Get data for" << static_cast<int>(_request)
<< "with arg" << _arg << "with data" << _data;
qCDebug(LOG_SERV) << "Get data for" << static_cast<int>(_request) << "with arg" << _arg
<< "with data" << _data;
QVariantHash output;
if ((_request != QueuedTcpServerResponseHelper::RequestPath::Auth)
@ -50,47 +49,41 @@ QVariantHash QueuedTcpServerResponseHelperApi1::getData(
break;
case QueuedTcpServerResponseHelper::RequestPath::Option:
if (_type == "GET")
output
= QueuedTcpServerResponseHelperOption::getOption(_arg, _token);
output = QueuedTcpServerResponseHelperOption::getOption(_arg, _token);
else if (_type == "POST")
output = QueuedTcpServerResponseHelperOption::setOption(_arg, _data,
_token);
output = QueuedTcpServerResponseHelperOption::setOption(_arg, _data, _token);
else
output = {{"code", 405}};
break;
case QueuedTcpServerResponseHelper::RequestPath::Permissions:
if (_type == "DELETE")
output = QueuedTcpServerResponseHelperPermissions::removePermission(
_arg.toLongLong(), _data, _token);
output = QueuedTcpServerResponseHelperPermissions::removePermission(_arg.toLongLong(),
_data, _token);
else if (_type == "POST")
output = QueuedTcpServerResponseHelperPermissions::addPermission(
_arg.toLongLong(), _data, _token);
output = QueuedTcpServerResponseHelperPermissions::addPermission(_arg.toLongLong(),
_data, _token);
else
output = {{"code", 405}};
break;
case QueuedTcpServerResponseHelper::RequestPath::Plugin:
if (_type == "GET")
output
= QueuedTcpServerResponseHelperPlugins::getPlugin(_arg, _token);
output = QueuedTcpServerResponseHelperPlugins::getPlugin(_arg, _token);
else
output = {{"code", 405}};
break;
case QueuedTcpServerResponseHelper::RequestPath::Plugins:
if (_type == "DELETE")
output = QueuedTcpServerResponseHelperPlugins::removePlugin(_arg,
_token);
output = QueuedTcpServerResponseHelperPlugins::removePlugin(_arg, _token);
else if (_type == "GET")
output = QueuedTcpServerResponseHelperPlugins::listPlugins();
else if (_type == "POST")
output
= QueuedTcpServerResponseHelperPlugins::addPlugin(_arg, _token);
output = QueuedTcpServerResponseHelperPlugins::addPlugin(_arg, _token);
else
output = {{"code", 405}};
break;
case QueuedTcpServerResponseHelper::RequestPath::Reports:
if (_type == "GET")
output
= QueuedTcpServerResponseHelperUser::getReport(_data, _token);
output = QueuedTcpServerResponseHelperUser::getReport(_data, _token);
else
output = {{"code", 405}};
break;
@ -102,14 +95,12 @@ QVariantHash QueuedTcpServerResponseHelperApi1::getData(
break;
case QueuedTcpServerResponseHelper::RequestPath::Task:
if (_type == "GET")
output = QueuedTcpServerResponseHelperTask::getTask(
_arg.toLongLong(), _data, _token);
output = QueuedTcpServerResponseHelperTask::getTask(_arg.toLongLong(), _data, _token);
else if (_type == "POST")
output = QueuedTcpServerResponseHelperTask::addOrEditTask(
_arg.toLongLong(), _data, _token);
output = QueuedTcpServerResponseHelperTask::addOrEditTask(_arg.toLongLong(), _data,
_token);
else if (_type == "PUT")
output = QueuedTcpServerResponseHelperTask::startOrStopTask(
_arg.toLongLong(), _token);
output = QueuedTcpServerResponseHelperTask::startOrStopTask(_arg.toLongLong(), _token);
else
output = {{"code", 405}};
break;
@ -121,11 +112,9 @@ QVariantHash QueuedTcpServerResponseHelperApi1::getData(
break;
case QueuedTcpServerResponseHelper::RequestPath::User:
if (_type == "GET")
output = QueuedTcpServerResponseHelperUser::getUser(_arg, _data,
_token);
output = QueuedTcpServerResponseHelperUser::getUser(_arg, _data, _token);
else if (_type == "POST")
output = QueuedTcpServerResponseHelperUser::addOrEditUser(
_arg, _data, _token);
output = QueuedTcpServerResponseHelperUser::addOrEditUser(_arg, _data, _token);
else
output = {{"code", 405}};
break;

5
sources/queued-server/src/QueuedTcpServerResponseHelperApi1.h
View File

@ -24,9 +24,8 @@
namespace QueuedTcpServerResponseHelperApi1
{
QVariantHash getData(const QueuedTcpServerResponseHelper::RequestPath _request,
const QString &_arg, const QString &_type,
const QVariantHash &_data, const QString &_token);
QVariantHash getData(const QueuedTcpServerResponseHelper::RequestPath _request, const QString &_arg,
const QString &_type, const QVariantHash &_data, const QString &_token);
QVariantHash getStatus();
};

3
sources/queued-server/src/QueuedTcpServerResponseHelperAuth.cpp
View File

@ -25,8 +25,7 @@ QVariantHash QueuedTcpServerResponseHelperAuth::auth(const QVariantHash &_data)
QVariantHash output;
if (_data.contains("user") && _data.contains("password")) {
auto res = QueuedCoreAdaptor::auth(_data["user"].toString(),
_data["password"].toString());
auto res = QueuedCoreAdaptor::auth(_data["user"].toString(), _data["password"].toString());
res.match(
[&output](const QString &val) {

13
sources/queued-server/src/QueuedTcpServerResponseHelperOption.cpp
View File

@ -19,9 +19,8 @@
#include <queued/Queued.h>
QVariantHash
QueuedTcpServerResponseHelperOption::getOption(const QString &_option,
const QString &_token)
QVariantHash QueuedTcpServerResponseHelperOption::getOption(const QString &_option,
const QString &_token)
{
qCDebug(LOG_SERV) << "Get option" << _option;
@ -41,16 +40,16 @@ QueuedTcpServerResponseHelperOption::getOption(const QString &_option,
}
QVariantHash QueuedTcpServerResponseHelperOption::setOption(
const QString &_option, const QVariantHash &_value, const QString &_token)
QVariantHash QueuedTcpServerResponseHelperOption::setOption(const QString &_option,
const QVariantHash &_value,
const QString &_token)
{
qCDebug(LOG_SERV) << "Set option" << _option << "to" << _value;
if (!_value.contains("value"))
return {{"code", 400}, {"message", "No required fields found"}};
auto res
= QueuedCoreAdaptor::sendOptionEdit(_option, _value["value"], _token);
auto res = QueuedCoreAdaptor::sendOptionEdit(_option, _value["value"], _token);
QVariantHash output;
res.match(

3
sources/queued-server/src/QueuedTcpServerResponseHelperOption.h
View File

@ -23,8 +23,7 @@
namespace QueuedTcpServerResponseHelperOption
{
QVariantHash getOption(const QString &_option, const QString &_token);
QVariantHash setOption(const QString &_option, const QVariantHash &_value,
const QString &_token);
QVariantHash setOption(const QString &_option, const QVariantHash &_value, const QString &_token);
};

22
sources/queued-server/src/QueuedTcpServerResponseHelperPermissions.cpp
View File

@ -19,21 +19,20 @@
#include <queued/Queued.h>
QVariantHash QueuedTcpServerResponseHelperPermissions::addPermission(
const long long _id, const QVariantHash &_value, const QString &_token)
QVariantHash QueuedTcpServerResponseHelperPermissions::addPermission(const long long _id,
const QVariantHash &_value,
const QString &_token)
{
qCDebug(LOG_SERV) << "Add permission for" << _id << _value;
if (!_value.contains("permission"))
return {{"code", 400}, {"message", "No required fields found"}};
auto permission
= QueuedEnums::stringToPermission(_value["permission"].toString());
auto permission = QueuedEnums::stringToPermission(_value["permission"].toString());
if (permission == QueuedEnums::Permission::Invalid)
return {{"code", 400}, {"message", "Invalid permission"}};
auto res
= QueuedCoreAdaptor::sendUserPermissionAdd(_id, permission, _token);
auto res = QueuedCoreAdaptor::sendUserPermissionAdd(_id, permission, _token);
QVariantHash output;
res.match(
@ -48,21 +47,20 @@ QVariantHash QueuedTcpServerResponseHelperPermissions::addPermission(
}
QVariantHash QueuedTcpServerResponseHelperPermissions::removePermission(
const long long _id, const QVariantHash &_value, const QString &_token)
QVariantHash QueuedTcpServerResponseHelperPermissions::removePermission(const long long _id,
const QVariantHash &_value,
const QString &_token)
{
qCDebug(LOG_SERV) << "Remove permission for" << _id << _value;
if (!_value.contains("permission"))
return {{"code", 400}, {"message", "No required fields found"}};
auto permission
= QueuedEnums::stringToPermission(_value["permission"].toString());
auto permission = QueuedEnums::stringToPermission(_value["permission"].toString());
if (permission == QueuedEnums::Permission::Invalid)
return {{"code", 400}, {"message", "Invalid permission"}};
auto res
= QueuedCoreAdaptor::sendUserPermissionRemove(_id, permission, _token);
auto res = QueuedCoreAdaptor::sendUserPermissionRemove(_id, permission, _token);
QVariantHash output;
res.match(

3
sources/queued-server/src/QueuedTcpServerResponseHelperPermissions.h
View File

@ -22,8 +22,7 @@
namespace QueuedTcpServerResponseHelperPermissions
{
QVariantHash addPermission(const long long _id, const QVariantHash &_value,
const QString &_token);
QVariantHash addPermission(const long long _id, const QVariantHash &_value, const QString &_token);
QVariantHash removePermission(const long long _id, const QVariantHash &_value,
const QString &_token);
};

18
sources/queued-server/src/QueuedTcpServerResponseHelperPlugins.cpp
View File

@ -19,9 +19,8 @@
#include <queued/Queued.h>
QVariantHash
QueuedTcpServerResponseHelperPlugins::addPlugin(const QString &_name,
const QString &_token)
QVariantHash QueuedTcpServerResponseHelperPlugins::addPlugin(const QString &_name,
const QString &_token)
{
qCDebug(LOG_SERV) << "Add plugin" << _name;
@ -40,9 +39,8 @@ QueuedTcpServerResponseHelperPlugins::addPlugin(const QString &_name,
}
QVariantHash
QueuedTcpServerResponseHelperPlugins::getPlugin(const QString &_name,
const QString &_token)
QVariantHash QueuedTcpServerResponseHelperPlugins::getPlugin(const QString &_name,
const QString &_token)
{
qCDebug(LOG_SERV) << "Get plugin" << _name;
@ -65,8 +63,7 @@ QueuedTcpServerResponseHelperPlugins::getPlugin(const QString &_name,
QVariantHash QueuedTcpServerResponseHelperPlugins::listPlugins()
{
auto res = QueuedCoreAdaptor::getOption(
QueuedConfig::QueuedSettings::Plugins, "");
auto res = QueuedCoreAdaptor::getOption(QueuedConfig::QueuedSettings::Plugins, "");
QVariantHash output;
res.match(
@ -81,9 +78,8 @@ QVariantHash QueuedTcpServerResponseHelperPlugins::listPlugins()
}
QVariantHash
QueuedTcpServerResponseHelperPlugins::removePlugin(const QString &_name,
const QString &_token)
QVariantHash QueuedTcpServerResponseHelperPlugins::removePlugin(const QString &_name,
const QString &_token)
{
qCDebug(LOG_SERV) << "Remove plugin" << _name;

47
sources/queued-server/src/QueuedTcpServerResponseHelperTask.cpp
View File

@ -19,8 +19,9 @@
#include <queued/Queued.h>
QVariantHash QueuedTcpServerResponseHelperTask::addOrEditTask(
const long long _id, const QVariantHash &_data, const QString &_token)
QVariantHash QueuedTcpServerResponseHelperTask::addOrEditTask(const long long _id,
const QVariantHash &_data,
const QString &_token)
{
qCDebug(LOG_SERV) << "Add or edit task" << _id << "with data" << _data;
@ -63,12 +64,10 @@ QueuedTcpServerResponseHelperTask::getDefinitions(const QVariantHash &_data)
for (auto &arg : args)
defs.arguments.append(arg.toString());
defs.command = _data["command"].toString();
defs.endTime
= QDateTime::fromString(_data["end"].toString(), Qt::ISODateWithMs);
defs.endTime = QDateTime::fromString(_data["end"].toString(), Qt::ISODateWithMs);
defs.gid = _data["gid"].toUInt();
defs.nice = _data["nice"].toUInt();
defs.startTime
= QDateTime::fromString(_data["start"].toString(), Qt::ISODateWithMs);
defs.startTime = QDateTime::fromString(_data["start"].toString(), Qt::ISODateWithMs);
defs.uid = _data["uid"].toUInt();
defs.user = _data["user"].toLongLong();
defs.workingDirectory = _data["workingDirectory"].toString();
@ -85,8 +84,9 @@ QueuedTcpServerResponseHelperTask::getDefinitions(const QVariantHash &_data)
}
QVariantHash QueuedTcpServerResponseHelperTask::getTask(
const long long _id, const QVariantHash &_data, const QString &_token)
QVariantHash QueuedTcpServerResponseHelperTask::getTask(const long long _id,
const QVariantHash &_data,
const QString &_token)
{
qCDebug(LOG_SERV) << "Get task" << _id << _data;
@ -95,11 +95,10 @@ QVariantHash QueuedTcpServerResponseHelperTask::getTask(
QVariantHash output = {{"code", 200}};
if (property.isEmpty()) {
auto res = QueuedCoreAdaptor::getTask(_id, _token);
res.match(
[&output](const QVariantHash &val) { output["properties"] = val; },
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
res.match([&output](const QVariantHash &val) { output["properties"] = val; },
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
} else {
auto res = QueuedCoreAdaptor::getTask(_id, property);
res.match(
@ -115,17 +114,14 @@ QVariantHash QueuedTcpServerResponseHelperTask::getTask(
}
QVariantHash
QueuedTcpServerResponseHelperTask::getTasks(const QVariantHash &_data,
const QString &_token)
QVariantHash QueuedTcpServerResponseHelperTask::getTasks(const QVariantHash &_data,
const QString &_token)
{
qCDebug(LOG_SERV) << "Get tasks" << _data;
long long userId = _data.value("userId").toLongLong();
QDateTime start
= QDateTime::fromString(_data["start"].toString(), Qt::ISODateWithMs);
QDateTime stop
= QDateTime::fromString(_data["stop"].toString(), Qt::ISODateWithMs);
QDateTime start = QDateTime::fromString(_data["start"].toString(), Qt::ISODateWithMs);
QDateTime stop = QDateTime::fromString(_data["stop"].toString(), Qt::ISODateWithMs);
QVariantHash output;
// some conversion magic
@ -145,9 +141,8 @@ QueuedTcpServerResponseHelperTask::getTasks(const QVariantHash &_data,
}
QVariantHash
QueuedTcpServerResponseHelperTask::startOrStopTask(const long long _id,
const QString &_token)
QVariantHash QueuedTcpServerResponseHelperTask::startOrStopTask(const long long _id,
const QString &_token)
{
qCDebug(LOG_SERV) << "Change task state" << _id;
@ -156,8 +151,7 @@ QueuedTcpServerResponseHelperTask::startOrStopTask(const long long _id,
QVariantHash output;
res.match(
[&output, &_id, &_token](const QVariantHash &val) {
if (val["startTime"].toString().isEmpty()
|| !val["endTime"].toString().isEmpty())
if (val["startTime"].toString().isEmpty() || !val["endTime"].toString().isEmpty())
output = startTask(_id, _token);
else
output = stopTask(_id, _token);
@ -190,8 +184,7 @@ QVariantHash QueuedTcpServerResponseHelperTask::startTask(const long long _id,
}
QVariantHash QueuedTcpServerResponseHelperTask::stopTask(const long long _id,
const QString &_token)
QVariantHash QueuedTcpServerResponseHelperTask::stopTask(const long long _id, const QString &_token)
{
qCDebug(LOG_SERV) << "Stop task" << _id;

9
sources/queued-server/src/QueuedTcpServerResponseHelperTask.h
View File

@ -24,12 +24,9 @@
namespace QueuedTcpServerResponseHelperTask
{
QVariantHash addOrEditTask(const long long _id, const QVariantHash &_data,
const QString &_token);
QueuedProcess::QueuedProcessDefinitions
getDefinitions(const QVariantHash &_data);
QVariantHash getTask(const long long _id, const QVariantHash &_data,
const QString &_token);
QVariantHash addOrEditTask(const long long _id, const QVariantHash &_data, const QString &_token);
QueuedProcess::QueuedProcessDefinitions getDefinitions(const QVariantHash &_data);
QVariantHash getTask(const long long _id, const QVariantHash &_data, const QString &_token);
QVariantHash getTasks(const QVariantHash &_data, const QString &_token);
QVariantHash startOrStopTask(const long long _id, const QString &_token);
QVariantHash startTask(const long long _id, const QString &_token);

50
sources/queued-server/src/QueuedTcpServerResponseHelperUser.cpp
View File

@ -20,8 +20,9 @@
#include <queued/QueuedUser.h>
QVariantHash QueuedTcpServerResponseHelperUser::addOrEditUser(
const QString &_user, const QVariantHash &_data, const QString &_token)
QVariantHash QueuedTcpServerResponseHelperUser::addOrEditUser(const QString &_user,
const QVariantHash &_data,
const QString &_token)
{
qCDebug(LOG_SERV) << "Add user" << _user << "with data" << _data;
@ -68,10 +69,8 @@ QueuedTcpServerResponseHelperUser::getDefinitions(const QVariantHash &_data)
QueuedUser::QueuedUserDefinitions defs;
defs.email = _data["email"].toString();
auto res
= QueuedCoreAdaptor::sendPasswordHash(_data["password"].toString());
res.match([&defs](const QString &val) { defs.password = val; },
[](const QueuedError &) {});
auto res = QueuedCoreAdaptor::sendPasswordHash(_data["password"].toString());
res.match([&defs](const QString &val) { defs.password = val; }, [](const QueuedError &) {});
defs.permissions = _data["permissions"].toUInt();
defs.priority = _data["priority"].toUInt();
// limits
@ -87,16 +86,13 @@ QueuedTcpServerResponseHelperUser::getDefinitions(const QVariantHash &_data)
}
QVariantHash
QueuedTcpServerResponseHelperUser::getReport(const QVariantHash &_data,
const QString &_token)
QVariantHash QueuedTcpServerResponseHelperUser::getReport(const QVariantHash &_data,
const QString &_token)
{
qCDebug(LOG_SERV) << "Get report using payload" << _data;
QDateTime stop
= QDateTime::fromString(_data["stop"].toString(), Qt::ISODateWithMs);
QDateTime start
= QDateTime::fromString(_data["start"].toString(), Qt::ISODateWithMs);
QDateTime stop = QDateTime::fromString(_data["stop"].toString(), Qt::ISODateWithMs);
QDateTime start = QDateTime::fromString(_data["start"].toString(), Qt::ISODateWithMs);
QVariantHash output = {{"code", 200}};
// some conversion magic
@ -116,15 +112,15 @@ QueuedTcpServerResponseHelperUser::getReport(const QVariantHash &_data,
}
QVariantHash QueuedTcpServerResponseHelperUser::getUser(
const QString &_user, const QVariantHash &_data, const QString &_token)
QVariantHash QueuedTcpServerResponseHelperUser::getUser(const QString &_user,
const QVariantHash &_data,
const QString &_token)
{
qCDebug(LOG_SERV) << "Get user data for" << _user << _data;
auto userIdRes = QueuedCoreAdaptor::getUserId(_user, _token);
long long userId = -1;
userIdRes.match([&userId](const long long val) { userId = val; },
[](const QueuedError &) {});
userIdRes.match([&userId](const long long val) { userId = val; }, [](const QueuedError &) {});
if (userId == -1)
return {{"code", 500}};
@ -133,11 +129,10 @@ QVariantHash QueuedTcpServerResponseHelperUser::getUser(
QVariantHash output = {{"code", 200}};
if (property.isEmpty()) {
auto res = QueuedCoreAdaptor::getUser(userId, _token);
res.match(
[&output](const QVariantHash &val) { output["properties"] = val; },
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
res.match([&output](const QVariantHash &val) { output["properties"] = val; },
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
} else {
auto res = QueuedCoreAdaptor::getUser(userId, property);
res.match(
@ -153,16 +148,13 @@ QVariantHash QueuedTcpServerResponseHelperUser::getUser(
}
QVariantHash
QueuedTcpServerResponseHelperUser::getUsers(const QVariantHash &_data,
const QString &_token)
QVariantHash QueuedTcpServerResponseHelperUser::getUsers(const QVariantHash &_data,
const QString &_token)
{
qCDebug(LOG_SERV) << "Get users" << _data;
QDateTime lastLogin = QDateTime::fromString(_data["lastLogged"].toString(),
Qt::ISODateWithMs);
auto permission
= QueuedEnums::stringToPermission(_data["permission"].toString());
QDateTime lastLogin = QDateTime::fromString(_data["lastLogged"].toString(), Qt::ISODateWithMs);
auto permission = QueuedEnums::stringToPermission(_data["permission"].toString());
QVariantHash output = {{"code", 200}};
// some conversion magic

6
sources/queued-server/src/QueuedTcpServerResponseHelperUser.h
View File

@ -24,12 +24,10 @@
namespace QueuedTcpServerResponseHelperUser
{
QVariantHash addOrEditUser(const QString &_user, const QVariantHash &_data,
const QString &_token);
QVariantHash addOrEditUser(const QString &_user, const QVariantHash &_data, const QString &_token);
QueuedUser::QueuedUserDefinitions getDefinitions(const QVariantHash &_data);
QVariantHash getReport(const QVariantHash &_data, const QString &_token);
QVariantHash getUser(const QString &_user, const QVariantHash &_data,
const QString &_token);
QVariantHash getUser(const QString &_user, const QVariantHash &_data, const QString &_token);
QVariantHash getUsers(const QVariantHash &_data, const QString &_token);
};

37
sources/queued-server/src/QueuedTcpServerThread.cpp
View File

@ -27,8 +27,8 @@
#include "QueuedTcpServerResponseHelper.h"
QueuedTcpServerThread::QueuedTcpServerThread(int socketDescriptor,
const int timeout, QObject *parent)
QueuedTcpServerThread::QueuedTcpServerThread(int socketDescriptor, const int timeout,
QObject *parent)
: QThread(parent)
, m_socketDescriptor(socketDescriptor)
, m_timeout(timeout)
@ -46,11 +46,9 @@ QueuedTcpServerThread::~QueuedTcpServerThread()
}
QByteArrayList QueuedTcpServerThread::defaultResponse(const int code,
const QVariantHash &json)
QByteArrayList QueuedTcpServerThread::defaultResponse(const int code, const QVariantHash &json)
{
qCDebug(LOG_SERV) << "Build server response with code" << code
<< "and json";
qCDebug(LOG_SERV) << "Build server response with code" << code << "and json";
QList<QByteArray> output;
output += "HTTP/1.1 " + QByteArray::number(code) + " "
@ -58,8 +56,7 @@ QByteArrayList QueuedTcpServerThread::defaultResponse(const int code,
output += "Server: QueuedServer/Qt" + QByteArray(qVersion()) + "\r\n";
output += "Date: "
+ QLocale::c()
.toString(QDateTime::currentDateTimeUtc(),
"ddd, d MMM yyyy HH:mm:dd t")
.toString(QDateTime::currentDateTimeUtc(), "ddd, d MMM yyyy HH:mm:dd t")
.toUtf8()
+ "\r\n";
output += "Content-Type: application/json\r\n";
@ -68,8 +65,7 @@ QByteArrayList QueuedTcpServerThread::defaultResponse(const int code,
// json response
if (!json.isEmpty()) {
auto jsonObj = QJsonObject::fromVariantHash(json);
auto jsonByte
= QJsonDocument(jsonObj).toJson(QJsonDocument::JsonFormat::Compact);
auto jsonByte = QJsonDocument(jsonObj).toJson(QJsonDocument::JsonFormat::Compact);
output += jsonByte;
}
@ -97,17 +93,16 @@ QueuedTcpServerThread::getHeaders(const QStringList &headers)
if (parsed.count() < 2)
continue;
headersObj.headers += QPair<QByteArray, QByteArray>(
{parsed.first().toUtf8().toLower(),
parsed.mid(1).join(": ").toUtf8()});
{parsed.first().toUtf8().toLower(), parsed.mid(1).join(": ").toUtf8()});
}
return headersObj;
}
QueuedTcpServerThread::QueuedTcpServerRequest QueuedTcpServerThread::getRequest(
const QByteArray &body,
const QueuedTcpServerThread::QueuedTcpServerHeaders &headers)
QueuedTcpServerThread::QueuedTcpServerRequest
QueuedTcpServerThread::getRequest(const QByteArray &body,
const QueuedTcpServerThread::QueuedTcpServerHeaders &headers)
{
qCDebug(LOG_SERV) << "Get request object from body" << body;
@ -159,8 +154,7 @@ QueuedTcpServerThread::response(const QueuedTcpServerRequest &request) const
netRequest.setRawHeader(headers.first, headers.second);
// prepend code
if (netRequest.header(QNetworkRequest::KnownHeaders::ContentTypeHeader)
.toString()
if (netRequest.header(QNetworkRequest::KnownHeaders::ContentTypeHeader).toString()
!= "application/json")
response.code = 415;
else
@ -169,12 +163,10 @@ QueuedTcpServerThread::response(const QueuedTcpServerRequest &request) const
// json data
if (response.code == 200) {
auto req = QueuedTcpServerResponseHelper::parsePath(
request.headers.query.path());
auto req = QueuedTcpServerResponseHelper::parsePath(request.headers.query.path());
req.type = request.headers.request;
if (req.valid) {
response.data = QueuedTcpServerResponseHelper::getData(
req, request.data, token);
response.data = QueuedTcpServerResponseHelper::getData(req, request.data, token);
response.code = response.data["code"].toInt();
} else {
response.code = 404;
@ -193,8 +185,7 @@ void QueuedTcpServerThread::run()
return;
}
connect(m_socket, SIGNAL(readyRead()), this, SLOT(readyRead()),
Qt::DirectConnection);
connect(m_socket, SIGNAL(readyRead()), this, SLOT(readyRead()), Qt::DirectConnection);
exec();
}

13
sources/queued-server/src/QueuedTcpServerThread.h
View File

@ -44,16 +44,13 @@ public:
QVariantHash data;
} QueuedTcpServerResponse;
explicit QueuedTcpServerThread(int socketDescriptor, const int timeout,
QObject *parent);
explicit QueuedTcpServerThread(int socketDescriptor, const int timeout, QObject *parent);
virtual ~QueuedTcpServerThread();
static QByteArrayList defaultResponse(const int code,
const QVariantHash &json);
static QByteArrayList defaultResponse(const int code, const QVariantHash &json);
static QueuedTcpServerHeaders getHeaders(const QStringList &headers);
static QueuedTcpServerRequest
getRequest(const QByteArray &body, const QueuedTcpServerHeaders &headers);
QueuedTcpServerResponse
response(const QueuedTcpServerRequest &request) const;
static QueuedTcpServerRequest getRequest(const QByteArray &body,
const QueuedTcpServerHeaders &headers);
QueuedTcpServerResponse response(const QueuedTcpServerRequest &request) const;
void run() override;
private slots:

3
sources/queued-server/src/main.cpp
View File

@ -50,8 +50,7 @@ int main(int argc, char *argv[])
// parser
QCommandLineParser parser;
parser.setApplicationDescription(
"Daemon for starting jobs to queue of calculations");
parser.setApplicationDescription("Daemon for starting jobs to queue of calculations");
parser.addHelpOption();
parser.addVersionOption();
// info

3
sources/queued/QueuedConfig.h.in
View File

@ -114,8 +114,7 @@ static const char CG_FS_PATH[] = "/sys/fs/cgroup";
* @brief plugin interface name
* @remark required by Qt macro
*/
#define PLUGIN_INTERFACE_NAME \
"org.queued.plugin/@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@"
#define PLUGIN_INTERFACE_NAME "org.queued.plugin/@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@"
/**
* @brief plugin interface name
*/

4
sources/queued/include/queued/QueuedAdvancedSettings.h
View File

@ -130,8 +130,8 @@ signals:
* @param _value
* changed value
*/
void valueUpdated(const QueuedConfig::QueuedSettings _id,
const QString &_key, const QVariant &_value);
void valueUpdated(const QueuedConfig::QueuedSettings _id, const QString &_key,
const QVariant &_value);
private:
/**

56
sources/queued/include/queued/QueuedCore.h
View File

@ -90,11 +90,9 @@ public:
* user auth token
* @return task ID or -1 if no task added
*/
QueuedResult<long long> addTask(const QString &_command,
const QStringList &_arguments,
const QString &_workingDirectory,
const long long _userId, const uint _nice,
const QueuedLimits::Limits &_limits,
QueuedResult<long long> addTask(const QString &_command, const QStringList &_arguments,
const QString &_workingDirectory, const long long _userId,
const uint _nice, const QueuedLimits::Limits &_limits,
const QString &_token);
/**
* @brief add new user
@ -115,10 +113,8 @@ public:
* @return user ID or -1 if no user created
*/
QueuedResult<long long> addUser(const QString &_name, const QString &_email,
const QString &_password,
const uint _permissions,
const uint _priority,
const QueuedLimits::Limits &_limits,
const QString &_password, const uint _permissions,
const uint _priority, const QueuedLimits::Limits &_limits,
const QString &_token);
/**
* @brief try to authorize by given token
@ -135,8 +131,7 @@ public:
* user password
* @return token. It will be empty if authorization error occurs
*/
QueuedResult<QString> authorization(const QString &_name,
const QString &_password);
QueuedResult<QString> authorization(const QString &_name, const QString &_password);
/**
* @brief edit advanced settings
* @param _key
@ -161,8 +156,7 @@ public:
* fields will be ignored. No need to pass all properties here
* @return true on successful task edition
*/
QueuedResult<bool> editTask(const long long _id,
const QVariantHash &_taskData,
QueuedResult<bool> editTask(const long long _id, const QVariantHash &_taskData,
const QString &_token);
/**
* @brief edit user
@ -176,8 +170,7 @@ public:
* fields will be ignored. No need to pass all properties here
* @return true on successful user edition
*/
QueuedResult<bool> editUser(const long long _id,
const QVariantHash &_userData,
QueuedResult<bool> editUser(const long long _id, const QVariantHash &_userData,
const QString &_token);
/**
* @brief edit user permissions
@ -191,10 +184,9 @@ public:
* user auth token
* @return true on successful user permission edition
*/
QueuedResult<bool>
editUserPermission(const long long _id,
const QueuedEnums::Permission &_permission,
const bool _add, const QString &_token);
QueuedResult<bool> editUserPermission(const long long _id,
const QueuedEnums::Permission &_permission,
const bool _add, const QString &_token);
/**
* @brief hash password
* @param _password
@ -222,8 +214,7 @@ public:
* @return performance table
*/
QueuedResult<QList<QVariantHash>>
performanceReport(const QDateTime &_from, const QDateTime &_to,
const QString &_token) const;
performanceReport(const QDateTime &_from, const QDateTime &_to, const QString &_token) const;
/**
* @brief get plugin description
* @param _plugin
@ -232,8 +223,8 @@ public:
* user auth token
* @return dictionary of PluginSpecification representation
*/
QueuedResult<QueuedPluginSpecification::Plugin>
plugin(const QString &_plugin, const QString &_token);
QueuedResult<QueuedPluginSpecification::Plugin> plugin(const QString &_plugin,
const QString &_token);
/**
* @brief get plugin settings
* @param _plugin
@ -242,8 +233,7 @@ public:
* user auth token
* @return hash of plugin settings
*/
QueuedResult<QVariantHash> pluginSettings(const QString &_plugin,
const QString &_token);
QueuedResult<QVariantHash> pluginSettings(const QString &_plugin, const QString &_token);
/**
* @brief remove plugin from autoload and unload it now
* @param _plugin
@ -252,8 +242,7 @@ public:
* user auth token
* @return true on successful plugin removal
*/
QueuedResult<bool> removePlugin(const QString &_plugin,
const QString &_token);
QueuedResult<bool> removePlugin(const QString &_plugin, const QString &_token);
/**
* @brief force start task
* @param _id
@ -293,10 +282,8 @@ public:
* user auth token
* @return list of tasks in database format
*/
QueuedResult<QList<QVariantHash>> taskReport(const long long _user,
const QDateTime &_from,
const QDateTime &_to,
const QString &_token) const;
QueuedResult<QList<QVariantHash>> taskReport(const long long _user, const QDateTime &_from,
const QDateTime &_to, const QString &_token) const;
/**
* @brief get user by ID
* @param _id
@ -325,10 +312,9 @@ public:
* user auth token
* @return list of users in database format
*/
QueuedResult<QList<QVariantHash>>
userReport(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission,
const QString &_token) const;
QueuedResult<QList<QVariantHash>> userReport(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission,
const QString &_token) const;
// control methods
/**
* @brief deinit subclasses

72
sources/queued/include/queued/QueuedCoreAdaptor.h
View File

@ -95,8 +95,7 @@ QueuedResult<bool> sendPluginAdd(const QString &_plugin, const QString &_token);
* auth user token
* @return true on successful plugin removal
*/
QueuedResult<bool> sendPluginRemove(const QString &_plugin,
const QString &_token);
QueuedResult<bool> sendPluginRemove(const QString &_plugin, const QString &_token);
/**
* @brief send TaskAdd
* @param _definitions
@ -105,9 +104,8 @@ QueuedResult<bool> sendPluginRemove(const QString &_plugin,
* auth user token
* @return task ID or {0, -1} if no task added
*/
QueuedResult<long long>
sendTaskAdd(const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token);
QueuedResult<long long> sendTaskAdd(const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token);
/**
* @brief send TaskEdit
* @param _id
@ -118,10 +116,9 @@ sendTaskAdd(const QueuedProcess::QueuedProcessDefinitions &_definitions,
* auth user token
* @return true on successful task edition
*/
QueuedResult<bool>
sendTaskEdit(const long long _id,
const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token);
QueuedResult<bool> sendTaskEdit(const long long _id,
const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token);
/**
* @brief send TaskStart
* @param _id
@ -148,9 +145,8 @@ QueuedResult<bool> sendTaskStop(const long long _id, const QString &_token);
* auth user token
* @return user ID or -1 if no user added
*/
QueuedResult<long long>
sendUserAdd(const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token);
QueuedResult<long long> sendUserAdd(const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token);
/**
* @brief send UserEdit
* @param _id
@ -161,10 +157,9 @@ sendUserAdd(const QueuedUser::QueuedUserDefinitions &_definitions,
* auth user token
* @return true on successful user edition
*/
QueuedResult<bool>
sendUserEdit(const long long _id,
const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token);
QueuedResult<bool> sendUserEdit(const long long _id,
const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token);
/**
* @brief send UserPermissionsAdd
* @param _id
@ -175,10 +170,9 @@ sendUserEdit(const long long _id,
* auth user token
* @return true on successful permission addition
*/
QueuedResult<bool>
sendUserPermissionAdd(const long long _id,
const QueuedEnums::Permission _permission,
const QString &_token);
QueuedResult<bool> sendUserPermissionAdd(const long long _id,
const QueuedEnums::Permission _permission,
const QString &_token);
/**
* @brief send sendUserPermissionRemove
* @param _id
@ -189,10 +183,9 @@ sendUserPermissionAdd(const long long _id,
* auth user token
* @return true on successful permission removal
*/
QueuedResult<bool>
sendUserPermissionRemove(const long long _id,
const QueuedEnums::Permission _permission,
const QString &_token);
QueuedResult<bool> sendUserPermissionRemove(const long long _id,
const QueuedEnums::Permission _permission,
const QString &_token);
// specific methods for properties
/**
* @brief get plugin
@ -202,8 +195,8 @@ sendUserPermissionRemove(const long long _id,
* user auth token
* @return plugin specification body
*/
QueuedResult<QueuedPluginSpecification::Plugin>
getPlugin(const QString &_plugin, const QString &_token);
QueuedResult<QueuedPluginSpecification::Plugin> getPlugin(const QString &_plugin,
const QString &_token);
/**
* @brief get plugin options
* @param _plugin
@ -212,8 +205,7 @@ getPlugin(const QString &_plugin, const QString &_token);
* user auth token
* @return plugin options dictionary
*/
QueuedResult<QVariantHash> getPluginOptions(const QString &_plugin,
const QString &_token);
QueuedResult<QVariantHash> getPluginOptions(const QString &_plugin, const QString &_token);
/**
* @brief get option
* @param _property
@ -222,8 +214,7 @@ QueuedResult<QVariantHash> getPluginOptions(const QString &_plugin,
* user auth token
* @return option value
*/
QueuedResult<QVariant> getOption(const QString &_property,
const QString &_token);
QueuedResult<QVariant> getOption(const QString &_property, const QString &_token);
/**
* @brief get option
* @param _property
@ -244,8 +235,7 @@ QueuedResult<QVariant> getOption(const QueuedConfig::QueuedSettings _property,
* user auth token
* @return list of user with used resources
*/
QueuedResult<QList<QVariantHash>> getPerformance(const QDateTime &_from,
const QDateTime &_to,
QueuedResult<QList<QVariantHash>> getPerformance(const QDateTime &_from, const QDateTime &_to,
const QString &_token);
/**
* @brief server status
@ -285,10 +275,8 @@ QueuedResult<QVariant> getTask(const long long _id, const QString &_property,
* user auth token
* @return list of task in database representation
*/
QueuedResult<QList<QVariantHash>> getTasks(const long long _user,
const QDateTime &_from,
const QDateTime &_to,
const QString &_token);
QueuedResult<QList<QVariantHash>> getTasks(const long long _user, const QDateTime &_from,
const QDateTime &_to, const QString &_token);
/**
* @brief get user properties
* @param _id
@ -330,9 +318,9 @@ QueuedResult<long long> getUserId(const QString &_name, const QString &_token);
* user auth token
* @return list of users in database representation
*/
QueuedResult<QList<QVariantHash>>
getUsers(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission, const QString &_token);
QueuedResult<QList<QVariantHash>> getUsers(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission,
const QString &_token);
// common methods
/**
* @brief additional method to avoid conversion from QueuedResult to
@ -380,13 +368,11 @@ QueuedResult<T> sendRequest(const QString &_service, const QString &_path,
const QVariantList &_args)
{
QDBusConnection bus = QDBusConnection::systemBus();
QDBusMessage request
= QDBusMessage::createMethodCall(_service, _path, _interface, _cmd);
QDBusMessage request = QDBusMessage::createMethodCall(_service, _path, _interface, _cmd);
if (!_args.isEmpty())
request.setArguments(_args);
QDBusReply<QDBusVariant> dbusResponse
= bus.call(request, QDBus::BlockWithGui);
QDBusReply<QDBusVariant> dbusResponse = bus.call(request, QDBus::BlockWithGui);
if (dbusResponse.isValid()) {
auto response = dbusResponse.value();

37
sources/queued/include/queued/QueuedCoreInterface.h
View File

@ -72,8 +72,7 @@ public slots:
* auth user token
* @return true on successful option edition
*/
QDBusVariant OptionEdit(const QString &key, const QDBusVariant &value,
const QString &token);
QDBusVariant OptionEdit(const QString &key, const QDBusVariant &value, const QString &token);
/**
* @brief get password hash
* @param password
@ -126,11 +125,9 @@ public slots:
* @return task ID or -1 if no task added
*/
QDBusVariant TaskAdd(const QString &command, const QStringList &arguments,
const QString &workingDirectory, const qlonglong user,
const uint nice, const qlonglong cpu,
const qlonglong gpu, const qlonglong memory,
const qlonglong gpumemory, const qlonglong storage,
const QString &token);
const QString &workingDirectory, const qlonglong user, const uint nice,
const qlonglong cpu, const qlonglong gpu, const qlonglong memory,
const qlonglong gpumemory, const qlonglong storage, const QString &token);
/**
* @brief edit task
* @param id
@ -163,11 +160,9 @@ public slots:
* auth user token
* @return true on successful task edition
*/
QDBusVariant TaskEdit(const qlonglong id, const QString &command,
const QStringList &arguments,
const QString &directory, const uint nice,
const uint uid, const uint gid, const qlonglong user,
const qlonglong cpu, const qlonglong gpu,
QDBusVariant TaskEdit(const qlonglong id, const QString &command, const QStringList &arguments,
const QString &directory, const uint nice, const uint uid, const uint gid,
const qlonglong user, const qlonglong cpu, const qlonglong gpu,
const qlonglong memory, const qlonglong gpumemory,
const qlonglong storage, const QString &token);
/**
@ -221,12 +216,10 @@ public slots:
* auth user token
* @return user ID or -1 if no user found
*/
QDBusVariant UserAdd(const QString &name, const QString &email,
const QString &password, const uint permissions,
const uint priority, const qlonglong cpu,
const qlonglong gpu, const qlonglong memory,
const qlonglong gpumemory, const qlonglong storage,
const QString &token);
QDBusVariant UserAdd(const QString &name, const QString &email, const QString &password,
const uint permissions, const uint priority, const qlonglong cpu,
const qlonglong gpu, const qlonglong memory, const qlonglong gpumemory,
const qlonglong storage, const QString &token);
/**
* @brief edit user
* @param id
@ -251,9 +244,8 @@ public slots:
* auth user token
* @return true on successful user edition
*/
QDBusVariant UserEdit(const qlonglong id, const QString &name,
const QString &password, const QString &email,
const qlonglong cpu, const qlonglong gpu,
QDBusVariant UserEdit(const qlonglong id, const QString &name, const QString &password,
const QString &email, const qlonglong cpu, const qlonglong gpu,
const qlonglong memory, const qlonglong gpumemory,
const qlonglong storage, const QString &token);
/**
@ -266,8 +258,7 @@ public slots:
* auth user token
* @return true on successful permission addition
*/
QDBusVariant UserPermissionAdd(const qlonglong id, const uint permission,
const QString &token);
QDBusVariant UserPermissionAdd(const qlonglong id, const uint permission, const QString &token);
/**
* @brief remove permission from user
* @param id

13
sources/queued/include/queued/QueuedDatabase.h
View File

@ -47,8 +47,7 @@ public:
* @param driver
* database driver
*/
explicit QueuedDatabase(QObject *parent, const QString path,
const QString driver);
explicit QueuedDatabase(QObject *parent, const QString path, const QString driver);
/**
* @brief QueuedDatabase class destructor
*/
@ -89,8 +88,7 @@ public:
* optional condition string
* @return list of records from table
*/
QList<QVariantHash> get(const QString &_table,
const QString &_condition = "");
QList<QVariantHash> get(const QString &_table, const QString &_condition = "");
/**
* @brief get record from table with given id
* @param _table
@ -112,8 +110,8 @@ public:
* password to connect, will be ignored if _username is empty
* @return true on successful opening
*/
bool open(const QString &_hostname, const int _port,
const QString &_username, const QString &_password);
bool open(const QString &_hostname, const int _port, const QString &_username,
const QString &_password);
/**
* @brief path to database
* @return path to used database
@ -140,8 +138,7 @@ public slots:
* value to update
* @return true on successfully modification
*/
bool modify(const QString &_table, const long long _id,
const QVariantHash &_value);
bool modify(const QString &_table, const long long _id, const QVariantHash &_value);
/**
* @brief remove record in table by ID
* @param _table

72
sources/queued/include/queued/QueuedDatabaseSchema.h
View File

@ -76,47 +76,37 @@ typedef QHash<QString, QHash<QString, QueuedDBField>> QueuedDBSchema;
/**
* @brief database schema
*/
static const QueuedDBSchema DBSchema = {
{SETTINGS_TABLE,
{{"_id",
{"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong,
true}},
{"key", {"key", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}},
{"value", {"value", "TEXT", QVariant::String, true}}}},
{TASKS_TABLE,
{{"_id",
{"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong,
true}},
{"user", {"user", "INT NOT NULL DEFAULT 0", QVariant::LongLong, true}},
{"command", {"command", "TEXT", QVariant::String, false}},
{"commandArguments",
{"commandArguments", "TEXT", QVariant::String, false}},
{"workDirectory", {"workDirectory", "TEXT", QVariant::String, false}},
{"nice", {"nice", "INT NOT NULL DEFAULT 0", QVariant::UInt, true}},
{"uid", {"uid", "INT", QVariant::UInt, true}},
{"gid", {"gid", "INT", QVariant::UInt, true}},
{"limits", {"limits", "TEXT", QVariant::String, false}},
{"startTime", {"startTime", "INT", QVariant::LongLong, true}},
{"endTime", {"endTime", "INT", QVariant::LongLong, true}}}},
{TOKENS_TABLE,
{{"_id",
{"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong,
true}},
{"token", {"token", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}},
{"user", {"user", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}},
{"validUntil",
{"validUntil", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}}}},
{USERS_TABLE,
{{"_id",
{"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong,
true}},
{"name", {"name", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}},
{"password", {"password", "TEXT", QVariant::String, false}},
{"email", {"email", "TEXT", QVariant::String, false}},
{"lastLogin", {"lastLogin", "TEXT", QVariant::String, true}},
{"limits", {"limits", "TEXT", QVariant::String, true}},
{"permissions", {"permissions", "INT", QVariant::UInt, true}},
{"priotiry", {"priority", "INT", QVariant::UInt, true}}}}};
static const QueuedDBSchema DBSchema
= {{SETTINGS_TABLE,
{{"_id", {"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong, true}},
{"key", {"key", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}},
{"value", {"value", "TEXT", QVariant::String, true}}}},
{TASKS_TABLE,
{{"_id", {"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong, true}},
{"user", {"user", "INT NOT NULL DEFAULT 0", QVariant::LongLong, true}},
{"command", {"command", "TEXT", QVariant::String, false}},
{"commandArguments", {"commandArguments", "TEXT", QVariant::String, false}},
{"workDirectory", {"workDirectory", "TEXT", QVariant::String, false}},
{"nice", {"nice", "INT NOT NULL DEFAULT 0", QVariant::UInt, true}},
{"uid", {"uid", "INT", QVariant::UInt, true}},
{"gid", {"gid", "INT", QVariant::UInt, true}},
{"limits", {"limits", "TEXT", QVariant::String, false}},
{"startTime", {"startTime", "INT", QVariant::LongLong, true}},
{"endTime", {"endTime", "INT", QVariant::LongLong, true}}}},
{TOKENS_TABLE,
{{"_id", {"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong, true}},
{"token", {"token", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}},
{"user", {"user", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}},
{"validUntil", {"validUntil", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}}}},
{USERS_TABLE,
{{"_id", {"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong, true}},
{"name", {"name", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}},
{"password", {"password", "TEXT", QVariant::String, false}},
{"email", {"email", "TEXT", QVariant::String, false}},
{"lastLogin", {"lastLogin", "TEXT", QVariant::String, true}},
{"limits", {"limits", "TEXT", QVariant::String, true}},
{"permissions", {"permissions", "INT", QVariant::UInt, true}},
{"priotiry", {"priority", "INT", QVariant::UInt, true}}}}};
};
#endif /* QUEUEDDATABASESCHEMA_H */

11
sources/queued/include/queued/QueuedDebug.h
View File

@ -62,12 +62,11 @@ namespace QueuedDebug
/**
* @brief default log format
*/
static const char LOG_FORMAT[]
= "[%{time "
"process}][%{if-debug}DD%{endif}%{if-info}II%{endif}%"
"{if-warning}WW%{endif}%{if-critical}CC%{endif}%{if-"
"fatal}FF%{endif}][%{category}][%{function}] "
"%{message}";
static const char LOG_FORMAT[] = "[%{time "
"process}][%{if-debug}DD%{endif}%{if-info}II%{endif}%"
"{if-warning}WW%{endif}%{if-critical}CC%{endif}%{if-"
"fatal}FF%{endif}][%{category}][%{function}] "
"%{message}";
/**
* @brief method to apply log format
*/

5
sources/queued/include/queued/QueuedExceptions.h
View File

@ -46,10 +46,7 @@ public:
/**
* @brief clone QueuedException
*/
QueuedException *clone() const override
{
return new QueuedException(*this);
};
QueuedException *clone() const override { return new QueuedException(*this); };
/**
* @brief message of this exception
* @return message for logging, etc

3
sources/queued/include/queued/QueuedLimits.h
View File

@ -163,8 +163,7 @@ bool limitCompare(const long long _first, const long long _second);
* default limits if anu
* @return minimal limits from given
*/
Limits minimalLimits(const Limits &_task, const Limits &_user,
const Limits &_default);
Limits minimalLimits(const Limits &_task, const Limits &_user, const Limits &_default);
};

3
sources/queued/include/queued/QueuedPluginInterface.h
View File

@ -69,8 +69,7 @@ public:
* @param _value
* option value
*/
virtual void updateSettings(const QString &_key, const QVariant &_value)
= 0;
virtual void updateSettings(const QString &_key, const QVariant &_value) = 0;
};
Q_DECLARE_INTERFACE(QueuedPluginInterface, PLUGIN_INTERFACE_NAME)

12
sources/queued/include/queued/QueuedPluginSpecification.h
View File

@ -60,12 +60,10 @@ struct PluginOption {
* input variant object
* @return appended argument body
*/
inline QDBusArgument &operator<<(QDBusArgument &_argument,
const PluginOption &_arg)
inline QDBusArgument &operator<<(QDBusArgument &_argument, const PluginOption &_arg)
{
_argument.beginStructure();
_argument << QDBusVariant(_arg.defaultValue.isValid() ? _arg.defaultValue
: "");
_argument << QDBusVariant(_arg.defaultValue.isValid() ? _arg.defaultValue : "");
_argument << _arg.description;
_argument << _arg.name;
_argument << _arg.type;
@ -81,8 +79,7 @@ inline QDBusArgument &operator<<(QDBusArgument &_argument,
* output variant object
* @return source DBus argument
*/
inline const QDBusArgument &operator>>(const QDBusArgument &_argument,
PluginOption &_arg)
inline const QDBusArgument &operator>>(const QDBusArgument &_argument, PluginOption &_arg)
{
QDBusVariant variant;
@ -145,8 +142,7 @@ inline QDBusArgument &operator<<(QDBusArgument &_argument, const Plugin &_arg)
* output variant object
* @return source DBus argument
*/
inline const QDBusArgument &operator>>(const QDBusArgument &_argument,
Plugin &_arg)
inline const QDBusArgument &operator>>(const QDBusArgument &_argument, Plugin &_arg)
{
_argument.beginStructure();
_argument >> _arg.author;

3
sources/queued/include/queued/QueuedProcess.h
View File

@ -102,8 +102,7 @@ public:
* @param index
* index of process
*/
explicit QueuedProcess(QObject *_parent,
const QueuedProcessDefinitions &definitions,
explicit QueuedProcess(QObject *_parent, const QueuedProcessDefinitions &definitions,
const long long index);
/**
* @brief QueuedProcess class destructor

11
sources/queued/include/queued/QueuedProcessManager.h
View File

@ -55,8 +55,7 @@ public:
* @typedef QueuedProcessConnectionMap
* map of indices to related QMetaObject::Connection
*/
typedef QHash<long long, QMetaObject::Connection>
QueuedProcessConnectionMap;
typedef QHash<long long, QMetaObject::Connection> QueuedProcessConnectionMap;
/**
* @brief QueuedProcessManager class constructor
@ -93,9 +92,8 @@ public:
* task index
* @return pointer to created task
*/
QueuedProcess *
add(const QueuedProcess::QueuedProcessDefinitions &_definitions,
const long long _index);
QueuedProcess *add(const QueuedProcess::QueuedProcessDefinitions &_definitions,
const long long _index);
/**
* @brief add tasks from database
* @param _processes
@ -182,8 +180,7 @@ private slots:
* @param _index
* index of finished task
*/
void taskFinished(const int _exitCode,
const QProcess::ExitStatus _exitStatus,
void taskFinished(const int _exitCode, const QProcess::ExitStatus _exitStatus,
const long long _index);
private:

6
sources/queued/include/queued/QueuedPropertyInterface.h
View File

@ -91,8 +91,7 @@ public slots:
* @remark if property is empty it return map of all properties
* @return property value or empty if task or property not found
*/
QDBusVariant Task(const long long id, const QString &property,
const QString &token);
QDBusVariant Task(const long long id, const QString &property, const QString &token);
/**
* @brief get user property
* @param id
@ -104,8 +103,7 @@ public slots:
* @remark if property is empty it return map of all properties
* @return property value or empty if user or property not found
*/
QDBusVariant User(const long long id, const QString &property,
const QString &token);
QDBusVariant User(const long long id, const QString &property, const QString &token);
/**
* @brief get user ID by name
* @param name

10
sources/queued/include/queued/QueuedReportInterface.h
View File

@ -63,8 +63,7 @@ public slots:
* user auth token
* @return
*/
QDBusVariant Performance(const QString &from, const QString &to,
const QString &token);
QDBusVariant Performance(const QString &from, const QString &to, const QString &token);
/**
* @brief server status
* @return server status
@ -82,8 +81,8 @@ public slots:
* user auth token
* @return list of tasks match to query
*/
QDBusVariant Tasks(const qlonglong user, const QString &from,
const QString &to, const QString &token);
QDBusVariant Tasks(const qlonglong user, const QString &from, const QString &to,
const QString &token);
/**
* @brief users list
* @param lastLogged
@ -94,8 +93,7 @@ public slots:
* user auth token
* @return list of users match to query
*/
QDBusVariant Users(const QString &lastLogged, const uint permission,
const QString &token);
QDBusVariant Users(const QString &lastLogged, const uint permission, const QString &token);
private:
/**

6
sources/queued/include/queued/QueuedReportManager.h
View File

@ -66,8 +66,7 @@ public:
* pointer to core object
* @return performance table
*/
QList<QVariantHash> performance(const QueuedCore *_core,
const QDateTime &_from = QDateTime(),
QList<QVariantHash> performance(const QueuedCore *_core, const QDateTime &_from = QDateTime(),
const QDateTime &_to = QDateTime()) const;
/**
* list of tasks which match criteria
@ -79,8 +78,7 @@ public:
* maximal end time
* @return list of tasks in database format
*/
QList<QVariantHash> tasks(const long long _user = -1,
const QDateTime &_from = QDateTime(),
QList<QVariantHash> tasks(const long long _user = -1, const QDateTime &_from = QDateTime(),
const QDateTime &_to = QDateTime()) const;
/**
* list of users which match criteria

21
sources/queued/include/queued/QueuedResult.h
View File

@ -50,8 +50,7 @@ typedef Result::Error<QueuedEnums::ReturnStatus> QueuedError;
* input error class
* @return appended argument body
*/
inline QDBusArgument &operator<<(QDBusArgument &_argument,
const QueuedError &_arg)
inline QDBusArgument &operator<<(QDBusArgument &_argument, const QueuedError &_arg)
{
_argument.beginStructure();
_argument << QString(_arg.message().c_str());
@ -68,8 +67,7 @@ inline QDBusArgument &operator<<(QDBusArgument &_argument,
* output object
* @return source DBus argument
*/
inline const QDBusArgument &operator>>(const QDBusArgument &_argument,
QueuedError &_arg)
inline const QDBusArgument &operator>>(const QDBusArgument &_argument, QueuedError &_arg)
{
QString message;
long long code;
@ -79,8 +77,7 @@ inline const QDBusArgument &operator>>(const QDBusArgument &_argument,
_argument >> code;
_argument.endStructure();
_arg = QueuedError(message.toStdString(),
static_cast<QueuedEnums::ReturnStatus>(code));
_arg = QueuedError(message.toStdString(), static_cast<QueuedEnums::ReturnStatus>(code));
return _argument;
};
/**
@ -94,8 +91,7 @@ typedef QHash<QString, QHash<QString, QString>> QueuedStatusMap;
* result value payload class
* custom Result<T, E> implementation
*/
template <class T>
using QueuedResult = Result::Result<T, QueuedEnums::ReturnStatus>;
template <class T> using QueuedResult = Result::Result<T, QueuedEnums::ReturnStatus>;
Q_DECLARE_METATYPE(QueuedResult<bool>)
Q_DECLARE_METATYPE(QueuedResult<long long>)
Q_DECLARE_METATYPE(QueuedResult<QString>)
@ -128,8 +124,7 @@ inline QDBusArgument &operator<<(QDBusArgument &_argument, const QVariant &_arg)
* output variant object
* @return source DBus argument
*/
inline const QDBusArgument &operator>>(const QDBusArgument &_argument,
QVariant &_arg)
inline const QDBusArgument &operator>>(const QDBusArgument &_argument, QVariant &_arg)
{
QDBusVariant variant;
@ -149,8 +144,7 @@ inline const QDBusArgument &operator>>(const QDBusArgument &_argument,
* @return appended argument body
*/
template <class T>
inline QDBusArgument &operator<<(QDBusArgument &_argument,
const QueuedResult<T> &_arg)
inline QDBusArgument &operator<<(QDBusArgument &_argument, const QueuedResult<T> &_arg)
{
// HACK we are using explicit cast to QString here to make sure of valid
// marshalling
@ -187,8 +181,7 @@ inline QDBusArgument &operator<<(QDBusArgument &_argument,
* @return source DBus argument
*/
template <class T>
inline const QDBusArgument &operator>>(const QDBusArgument &_argument,
QueuedResult<T> &_arg)
inline const QDBusArgument &operator>>(const QDBusArgument &_argument, QueuedResult<T> &_arg)
{
QString type;
T value;

3
sources/queued/include/queued/QueuedStaticConfig.h
View File

@ -145,8 +145,7 @@ typedef QHash<QString, QueuedSettingsField> QueuedSettingsDefaultMap;
static const QueuedSettingsDefaultMap QueuedSettingsDefaults = {
{"", {QueuedSettings::Invalid, QVariant(), false}},
{"DatabaseInterval", {QueuedSettings::DatabaseInterval, 86400000, true}},
{"DatabaseVersion",
{QueuedSettings::DatabaseVersion, QueuedConfig::DATABASE_VERSION, true}},
{"DatabaseVersion", {QueuedSettings::DatabaseVersion, QueuedConfig::DATABASE_VERSION, true}},
{"DefaultLimits", {QueuedSettings::DefaultLimits, "0\n0\n0\n0\n0", false}},
{"KeepTasks", {QueuedSettings::KeepTasks, 0, false}},
{"KeepUsers", {QueuedSettings::KeepUsers, 0, false}},

3
sources/queued/include/queued/QueuedTokenManager.h
View File

@ -74,8 +74,7 @@ public:
* @param _definitions
* token definitions
*/
void
loadToken(const QueuedTokenManager::QueuedTokenDefinitions &_definitions);
void loadToken(const QueuedTokenManager::QueuedTokenDefinitions &_definitions);
/**
* @brief upload tokens from database
* @param _values

12
sources/queued/include/queued/QueuedUser.h
View File

@ -84,8 +84,7 @@ public:
* @param index
* index of process
*/
explicit QueuedUser(QObject *_parent,
const QueuedUserDefinitions &definitions,
explicit QueuedUser(QObject *_parent, const QueuedUserDefinitions &definitions,
const long long index);
/**
* @brief QueuedUser class destructor
@ -98,8 +97,7 @@ public:
* new user permission
* @return current user permissions
*/
QueuedEnums::Permissions
addPermission(const QueuedEnums::Permission _permission);
QueuedEnums::Permissions addPermission(const QueuedEnums::Permission _permission);
/**
* @brief generates SHA512 hash from given password
* @param _password
@ -108,8 +106,7 @@ public:
* password salt if any
* @return SHA512 of password
*/
static QString hashFromPassword(const QString &_password,
const QString &_salt);
static QString hashFromPassword(const QString &_password, const QString &_salt);
/**
* @brief test user permissions
* @param _permission
@ -137,8 +134,7 @@ public:
* permission to remove
* @return current user permissions
*/
QueuedEnums::Permissions
removePermission(const QueuedEnums::Permission _permission);
QueuedEnums::Permissions removePermission(const QueuedEnums::Permission _permission);
// main properties
/**
* @brief user email

16
sources/queued/include/queued/QueuedUserManager.h
View File

@ -39,8 +39,7 @@ class QueuedUserManager : public QObject
{
Q_OBJECT
Q_PROPERTY(QString salt READ salt WRITE setSalt)
Q_PROPERTY(
long long tokenExpiration READ tokenExpiration WRITE setTokenExpiration)
Q_PROPERTY(long long tokenExpiration READ tokenExpiration WRITE setTokenExpiration)
public:
/**
@ -53,6 +52,13 @@ public:
* @brief QueuedUserManager class destructor
*/
virtual ~QueuedUserManager();
/**
* @brief parse user definitions from table data
* @param _properties
* map of usr properties
* @return data mapped to internal format
*/
static QueuedUser::QueuedUserDefinitions parseDefinitions(const QVariantHash &_properties);
/**
* @brief add user
* @param _properties
@ -70,8 +76,7 @@ public:
* user ID
* @return pointer to created user
*/
QueuedUser *add(const QueuedUser::QueuedUserDefinitions &_definitions,
const long long _id);
QueuedUser *add(const QueuedUser::QueuedUserDefinitions &_definitions, const long long _id);
/**
* @brief authorize user manually
* @remark it ignores password input and creates unlimited token
@ -97,8 +102,7 @@ public:
* service to authorize
* @return true if user allowed to do it otherwise return false
*/
bool authorize(const QString &_token,
const QueuedEnums::Permission _service);
bool authorize(const QString &_token, const QueuedEnums::Permission _service);
/**
* @brief check token expiration
* @param _token

60
sources/queued/include/queued/private/QueuedCorePrivate.h
View File

@ -89,11 +89,9 @@ public:
* user auth token
* @return task ID or -1 if no task added
*/
QueuedResult<long long> addTask(const QString &_command,
const QStringList &_arguments,
const QString &_workingDirectory,
const long long _userId, const uint _nice,
const QueuedLimits::Limits &_limits,
QueuedResult<long long> addTask(const QString &_command, const QStringList &_arguments,
const QString &_workingDirectory, const long long _userId,
const uint _nice, const QueuedLimits::Limits &_limits,
const QString &_token);
/**
* @brief add new user
@ -114,10 +112,8 @@ public:
* @return user ID or -1 if no user created
*/
QueuedResult<long long> addUser(const QString &_name, const QString &_email,
const QString &_password,
const uint _permissions,
const uint _priority,
const QueuedLimits::Limits &_limits,
const QString &_password, const uint _permissions,
const uint _priority, const QueuedLimits::Limits &_limits,
const QString &_token);
/**
* @brief try to authorize by given token
@ -134,8 +130,7 @@ public:
* user password
* @return token. It will be empty if authorization error occurs
*/
QueuedResult<QString> authorization(const QString &_name,
const QString &_password);
QueuedResult<QString> authorization(const QString &_name, const QString &_password);
/**
* @brief edit advanced settings
* @param _key
@ -160,8 +155,7 @@ public:
* fields will be ignored. No need to pass all properties here
* @return true on successful task edition
*/
QueuedResult<bool> editTask(const long long _id,
const QVariantHash &_taskData,
QueuedResult<bool> editTask(const long long _id, const QVariantHash &_taskData,
const QString &_token);
/**
* @brief edit user
@ -175,8 +169,7 @@ public:
* fields will be ignored. No need to pass all properties here
* @return true on successful user edition
*/
QueuedResult<bool> editUser(const long long _id,
const QVariantHash &_userData,
QueuedResult<bool> editUser(const long long _id, const QVariantHash &_userData,
const QString &_token);
/**
* @brief edit user permissions
@ -190,10 +183,9 @@ public:
* user auth token
* @return true on successful user permission edition
*/
QueuedResult<bool>
editUserPermission(const long long _id,
const QueuedEnums::Permission &_permission,
const bool _add, const QString &_token);
QueuedResult<bool> editUserPermission(const long long _id,
const QueuedEnums::Permission &_permission,
const bool _add, const QString &_token);
/**
* @brief hash password
* @param _password
@ -221,8 +213,7 @@ public:
* @return performance table
*/
QueuedResult<QList<QVariantHash>>
performanceReport(const QDateTime &_from, const QDateTime &_to,
const QString &_token) const;
performanceReport(const QDateTime &_from, const QDateTime &_to, const QString &_token) const;
/**
* @brief get plugin description
* @param _plugin
@ -231,8 +222,8 @@ public:
* user auth token
* @return dictionary of PluginSpecification representation
*/
QueuedResult<QueuedPluginSpecification::Plugin>
plugin(const QString &_plugin, const QString &_token);
QueuedResult<QueuedPluginSpecification::Plugin> plugin(const QString &_plugin,
const QString &_token);
/**
* @brief get plugin settings
* @param _plugin
@ -241,8 +232,7 @@ public:
* user auth token
* @return hash of plugin settings
*/
QueuedResult<QVariantHash> pluginSettings(const QString &_plugin,
const QString &_token);
QueuedResult<QVariantHash> pluginSettings(const QString &_plugin, const QString &_token);
/**
* @brief remove plugin from autoload and unload it now
* @param _plugin
@ -251,8 +241,7 @@ public:
* user auth token
* @return true on successful plugin removal
*/
QueuedResult<bool> removePlugin(const QString &_plugin,
const QString &_token);
QueuedResult<bool> removePlugin(const QString &_plugin, const QString &_token);
/**
* @brief force start task
* @param _id
@ -292,10 +281,8 @@ public:
* user auth token
* @return list of tasks in database format
*/
QueuedResult<QList<QVariantHash>> taskReport(const long long _user,
const QDateTime &_from,
const QDateTime &_to,
const QString &_token) const;
QueuedResult<QList<QVariantHash>> taskReport(const long long _user, const QDateTime &_from,
const QDateTime &_to, const QString &_token) const;
/**
* @brief get user by ID
* @param _id
@ -324,10 +311,9 @@ public:
* user auth token
* @return list of users in database format
*/
QueuedResult<QList<QVariantHash>>
userReport(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission,
const QString &_token) const;
QueuedResult<QList<QVariantHash>> userReport(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission,
const QString &_token) const;
// control methods
/**
* @brief deinit subclasses
@ -352,8 +338,8 @@ private slots:
* @param _value
* new value
*/
void updateSettings(const QueuedConfig::QueuedSettings _id,
const QString &_key, const QVariant &_value);
void updateSettings(const QueuedConfig::QueuedSettings _id, const QString &_key,
const QVariant &_value);
/**
* @brief update process time
* @param _id

53
sources/queued/include/queued/private/QueuedCorePrivateHelper.h
View File

@ -37,6 +37,7 @@ class QueuedDatabase;
class QueuedPluginManager;
class QueuedProcess;
class QueuedProcessManager;
class QueuedUser;
class QueuedUserManager;
/**
@ -96,8 +97,7 @@ private:
* initial database payload
* @return payload with dropped keys
*/
QVariantHash dropAdminFields(const QString &_table,
const QVariantHash &_payload);
QVariantHash dropAdminFields(const QString &_table, const QVariantHash &_payload);
/**
* @brief method allows to init class if it was not created
* @tparam T
@ -132,10 +132,10 @@ private:
* task defined limits
* @return task ID or -1 if no task added
*/
QueuedResult<long long>
addTaskPrivate(const QString &_command, const QStringList &_arguments,
const QString &_workingDirectory, const long long _userId,
const uint _nice, const QueuedLimits::Limits &_limits);
QueuedResult<long long> addTaskPrivate(const QString &_command, const QStringList &_arguments,
const QString &_workingDirectory,
const long long _userId, const uint _nice,
const QueuedLimits::Limits &_limits);
/**
* @brief add new user
* @param _name
@ -152,10 +152,10 @@ private:
* user limits
* @return user ID or -1 if no user found
*/
QueuedResult<long long>
addUserPrivate(const QString &_name, const QString &_email,
const QString &_password, const uint _permissions,
const uint _priority, const QueuedLimits::Limits &_limits);
QueuedResult<long long> addUserPrivate(const QString &_name, const QString &_email,
const QString &_password, const uint _permissions,
const uint _priority,
const QueuedLimits::Limits &_limits);
/**
* @brief edit advanced settings
* @param _key
@ -164,8 +164,7 @@ private:
* advanced settings value
* @return true on successful option edition
*/
QueuedResult<bool> editOptionPrivate(const QString &_key,
const QVariant &_value);
QueuedResult<bool> editOptionPrivate(const QString &_key, const QVariant &_value);
/**
* @brief edit plugin list
* @param _plugin
@ -174,8 +173,7 @@ private:
* true if it requires add plugin
* @return true on successful action
*/
QueuedResult<bool> editPluginPrivate(const QString &_plugin,
const bool _add);
QueuedResult<bool> editPluginPrivate(const QString &_plugin, const bool _add);
/**
* @brief edit task
* @param _process
@ -186,8 +184,7 @@ private:
* fields will be ignored. No need to pass all properties here
* @return true on successful task edition
*/
QueuedResult<bool> editTaskPrivate(QueuedProcess *_process,
const QVariantHash &_taskData);
QueuedResult<bool> editTaskPrivate(QueuedProcess *_process, const QVariantHash &_taskData);
/**
* @brief edit user
* @param _id
@ -198,8 +195,7 @@ private:
* fields will be ignored. No need to pass all properties here
* @return true on successful user edition
*/
QueuedResult<bool> editUserPrivate(const long long _id,
const QVariantHash &_userData);
QueuedResult<bool> editUserPrivate(QueuedUser *_user, const QVariantHash &_userData);
/**
* @brief edit user permissions
* @param _id
@ -210,10 +206,23 @@ private:
* indicates whether it should be added or removed
* @return true on successful user permission edition
*/
QueuedResult<bool>
editUserPermissionPrivate(const long long _id,
const QueuedEnums::Permission &_permission,
const bool _add);
QueuedResult<bool> editUserPermissionPrivate(const long long _id,
const QueuedEnums::Permission &_permission,
const bool _add);
/**
* @brief try get task from storages
* @param _id
* task ID to search
* @return pointer to found task if any
*/
QueuedProcess *tryGetTask(const long long _id);
/**
* @brief try get user from storages
* @param _id
* user ID to search
* @return pointer to found user if any
*/
QueuedUser *tryGetUser(const long long _id);
};

15
sources/queued/src/QueuedAdvancedSettings.cpp
View File

@ -54,8 +54,7 @@ bool QueuedAdvancedSettings::checkDatabaseVersion() const
{
QString key = internalId(QueuedConfig::QueuedSettings::DatabaseVersion);
return m_values.contains(key.toLower())
&& (get(key).toInt() == QueuedConfig::DATABASE_VERSION);
return m_values.contains(key.toLower()) && (get(key).toInt() == QueuedConfig::DATABASE_VERSION);
}
@ -70,16 +69,14 @@ QVariant QueuedAdvancedSettings::get(const QString &_key) const
if (m_values.contains(key))
return m_values.value(key);
else
return QueuedConfig::QueuedSettingsDefaults[internalId(_key)]
.defaultValue;
return QueuedConfig::QueuedSettingsDefaults[internalId(_key)].defaultValue;
}
/**
* @fn get
*/
QVariant
QueuedAdvancedSettings::get(const QueuedConfig::QueuedSettings _key) const
QVariant QueuedAdvancedSettings::get(const QueuedConfig::QueuedSettings _key) const
{
qCDebug(LOG_LIB) << "Looking for key" << static_cast<int>(_key);
@ -125,8 +122,7 @@ QString QueuedAdvancedSettings::internalId(const QString &_key)
/**
* @fn internalId
*/
QString
QueuedAdvancedSettings::internalId(const QueuedConfig::QueuedSettings _key)
QString QueuedAdvancedSettings::internalId(const QueuedConfig::QueuedSettings _key)
{
qCDebug(LOG_LIB) << "Looking for key" << static_cast<int>(_key);
@ -157,8 +153,7 @@ bool QueuedAdvancedSettings::isAdmin(const QString &_key) const
/**
* @fn isAdmin
*/
bool QueuedAdvancedSettings::isAdmin(
const QueuedConfig::QueuedSettings &_key) const
bool QueuedAdvancedSettings::isAdmin(const QueuedConfig::QueuedSettings &_key) const
{
qCDebug(LOG_LIB) << "Check if admin option" << static_cast<int>(_key);

76
sources/queued/src/QueuedControlGroupsAdaptor.cpp
View File

@ -32,8 +32,7 @@
/**
* @fn QueuedControlGroupsAdaptor
*/
QueuedControlGroupsAdaptor::QueuedControlGroupsAdaptor(QObject *_parent,
QString _name)
QueuedControlGroupsAdaptor::QueuedControlGroupsAdaptor(QObject *_parent, QString _name)
: QObject(_parent)
{
qCDebug(LOG_LIB) << __PRETTY_FUNCTION__;
@ -157,8 +156,7 @@ void QueuedControlGroupsAdaptor::setCpuLimit(const long long _value)
stream << _value;
stream.flush();
} else {
qCCritical(LOG_LIB)
<< "Could not set CPU limit" << name() << "to" << _value;
qCCritical(LOG_LIB) << "Could not set CPU limit" << name() << "to" << _value;
return;
}
file.close();
@ -179,8 +177,7 @@ void QueuedControlGroupsAdaptor::setMemoryLimit(const long long _value)
stream << _value;
stream.flush();
} else {
qCCritical(LOG_LIB)
<< "Could not set memory limit" << name() << "to" << _value;
qCCritical(LOG_LIB) << "Could not set memory limit" << name() << "to" << _value;
return;
}
file.close();
@ -204,8 +201,7 @@ bool QueuedControlGroupsAdaptor::addProcess(const uint _pid)
QTextStream stream(&file);
stream << _pid;
} else {
qCCritical(LOG_LIB)
<< "Cound not assign pid" << _pid << "to" << proc;
qCCritical(LOG_LIB) << "Cound not assign pid" << _pid << "to" << proc;
return false;
}
@ -226,40 +222,33 @@ bool QueuedControlGroupsAdaptor::createGroup()
auto paths = controlPaths();
// create cgroups
bool status = std::all_of(
paths.cbegin(), paths.cend(),
[this](const QString &path) { return QDir(path).mkpath(name()); });
bool status = std::all_of(paths.cbegin(), paths.cend(),
[this](const QString &path) { return QDir(path).mkpath(name()); });
// apply settings
status &= std::all_of(
paths.cbegin(), paths.cend(), [this](const QString &path) {
auto notify
= QDir(groupPath(path)).filePath(CG_NOTIFY_ON_RELEASE_FILE);
QFile file(notify);
if (file.open(QIODevice::WriteOnly)) {
QTextStream stream(&file);
stream << 1;
} else {
qCCritical(LOG_LIB)
<< "Could not apply rules to" << CG_NOTIFY_ON_RELEASE_FILE;
return false;
}
return true;
});
status &= std::all_of(
paths.cbegin(), paths.cend(), [this](const QString &path) {
auto agent = QDir(groupPath(path)).filePath(CG_RELEASE_FILE);
QFile file(agent);
if (file.open(QIODevice::WriteOnly)) {
QTextStream stream(&file);
stream
<< QString("rmdir \"%1\"").arg(QDir(path).filePath(name()));
} else {
qCCritical(LOG_LIB)
<< "Could not apply rules to" << CG_RELEASE_FILE;
return false;
}
return true;
});
status &= std::all_of(paths.cbegin(), paths.cend(), [this](const QString &path) {
auto notify = QDir(groupPath(path)).filePath(CG_NOTIFY_ON_RELEASE_FILE);
QFile file(notify);
if (file.open(QIODevice::WriteOnly)) {
QTextStream stream(&file);
stream << 1;
} else {
qCCritical(LOG_LIB) << "Could not apply rules to" << CG_NOTIFY_ON_RELEASE_FILE;
return false;
}
return true;
});
status &= std::all_of(paths.cbegin(), paths.cend(), [this](const QString &path) {
auto agent = QDir(groupPath(path)).filePath(CG_RELEASE_FILE);
QFile file(agent);
if (file.open(QIODevice::WriteOnly)) {
QTextStream stream(&file);
stream << QString("rmdir \"%1\"").arg(QDir(path).filePath(name()));
} else {
qCCritical(LOG_LIB) << "Could not apply rules to" << CG_RELEASE_FILE;
return false;
}
return true;
});
return status;
@ -275,7 +264,6 @@ bool QueuedControlGroupsAdaptor::removeGroup()
auto paths = controlPaths();
return std::all_of(
paths.cbegin(), paths.cend(),
[this](const QString &path) { return QDir(path).rmdir(name()); });
return std::all_of(paths.cbegin(), paths.cend(),
[this](const QString &path) { return QDir(path).rmdir(name()); });
}

145
sources/queued/src/QueuedCore.cpp
View File

@ -56,8 +56,7 @@ QueuedCore::~QueuedCore()
/**
* @fn addPlugin
*/
QueuedResult<bool> QueuedCore::addPlugin(const QString &_plugin,
const QString &_token)
QueuedResult<bool> QueuedCore::addPlugin(const QString &_plugin, const QString &_token)
{
qCDebug(LOG_LIB) << "Add plugin" << _plugin;
@ -68,34 +67,33 @@ QueuedResult<bool> QueuedCore::addPlugin(const QString &_plugin,
/**
* @addTask
*/
QueuedResult<long long>
QueuedCore::addTask(const QString &_command, const QStringList &_arguments,
const QString &_workingDirectory, const long long _userId,
const uint _nice, const QueuedLimits::Limits &_limits,
const QString &_token)
QueuedResult<long long> QueuedCore::addTask(const QString &_command, const QStringList &_arguments,
const QString &_workingDirectory,
const long long _userId, const uint _nice,
const QueuedLimits::Limits &_limits,
const QString &_token)
{
qCDebug(LOG_LIB) << "Add task" << _command << "with arguments" << _arguments
<< "from user" << _userId;
qCDebug(LOG_LIB) << "Add task" << _command << "with arguments" << _arguments << "from user"
<< _userId;
return m_impl->addTask(_command, _arguments, _workingDirectory, _userId,
_nice, _limits, _token);
return m_impl->addTask(_command, _arguments, _workingDirectory, _userId, _nice, _limits,
_token);
}
/**
* @fn addUser
*/
QueuedResult<long long>
QueuedCore::addUser(const QString &_name, const QString &_email,
const QString &_password, const uint _permissions,
const uint _priority, const QueuedLimits::Limits &_limits,
const QString &_token)
QueuedResult<long long> QueuedCore::addUser(const QString &_name, const QString &_email,
const QString &_password, const uint _permissions,
const uint _priority,
const QueuedLimits::Limits &_limits,
const QString &_token)
{
qCDebug(LOG_LIB) << "Add user" << _name << "with email" << _email
<< "and permissions" << _permissions;
qCDebug(LOG_LIB) << "Add user" << _name << "with email" << _email << "and permissions"
<< _permissions;
return m_impl->addUser(_name, _email, _password, _permissions, _priority,
_limits, _token);
return m_impl->addUser(_name, _email, _password, _permissions, _priority, _limits, _token);
}
@ -111,8 +109,7 @@ QueuedResult<bool> QueuedCore::authorization(const QString &_token)
/**
* @fn authorization
*/
QueuedResult<QString> QueuedCore::authorization(const QString &_name,
const QString &_password)
QueuedResult<QString> QueuedCore::authorization(const QString &_name, const QString &_password)
{
qCDebug(LOG_LIB) << "Authorize user" << _name;
@ -123,8 +120,7 @@ QueuedResult<QString> QueuedCore::authorization(const QString &_name,
/**
* @fn editOption
*/
QueuedResult<bool> QueuedCore::editOption(const QString &_key,
const QVariant &_value,
QueuedResult<bool> QueuedCore::editOption(const QString &_key, const QVariant &_value,
const QString &_token)
{
qCDebug(LOG_LIB) << "Set key" << _key << "to" << _value;
@ -136,8 +132,7 @@ QueuedResult<bool> QueuedCore::editOption(const QString &_key,
/**
* @fn editTask
*/
QueuedResult<bool> QueuedCore::editTask(const long long _id,
const QVariantHash &_taskData,
QueuedResult<bool> QueuedCore::editTask(const long long _id, const QVariantHash &_taskData,
const QString &_token)
{
qCDebug(LOG_LIB) << "Edit task with ID" << _id;
@ -149,8 +144,7 @@ QueuedResult<bool> QueuedCore::editTask(const long long _id,
/**
* @fn editUser
*/
QueuedResult<bool> QueuedCore::editUser(const long long _id,
const QVariantHash &_userData,
QueuedResult<bool> QueuedCore::editUser(const long long _id, const QVariantHash &_userData,
const QString &_token)
{
qCDebug(LOG_LIB) << "Edit user with ID" << _id;
@ -162,13 +156,12 @@ QueuedResult<bool> QueuedCore::editUser(const long long _id,
/**
* @fn editUserPermission
*/
QueuedResult<bool>
QueuedCore::editUserPermission(const long long _id,
const QueuedEnums::Permission &_permission,
const bool _add, const QString &_token)
QueuedResult<bool> QueuedCore::editUserPermission(const long long _id,
const QueuedEnums::Permission &_permission,
const bool _add, const QString &_token)
{
qCDebug(LOG_LIB) << "Edit permissions" << static_cast<int>(_permission)
<< "for user" << _id << "add" << _add;
qCDebug(LOG_LIB) << "Edit permissions" << static_cast<int>(_permission) << "for user" << _id
<< "add" << _add;
return m_impl->editUserPermission(_id, _permission, _add, _token);
}
@ -186,8 +179,7 @@ QueuedResult<QString> QueuedCore::hashFromPassword(const QString &_password)
/**
* @fn option
*/
QueuedResult<QVariant> QueuedCore::option(const QString &_key,
const QString &_token)
QueuedResult<QVariant> QueuedCore::option(const QString &_key, const QString &_token)
{
qCDebug(LOG_LIB) << "Look for option" << _key;
@ -198,9 +190,9 @@ QueuedResult<QVariant> QueuedCore::option(const QString &_key,
/**
* @fn performanceReport
*/
QueuedResult<QList<QVariantHash>>
QueuedCore::performanceReport(const QDateTime &_from, const QDateTime &_to,
const QString &_token) const
QueuedResult<QList<QVariantHash>> QueuedCore::performanceReport(const QDateTime &_from,
const QDateTime &_to,
const QString &_token) const
{
qCDebug(LOG_LIB) << "Get performance report for" << _from << _to;
@ -211,8 +203,8 @@ QueuedCore::performanceReport(const QDateTime &_from, const QDateTime &_to,
/**
* @fn plugin
*/
QueuedResult<QueuedPluginSpecification::Plugin>
QueuedCore::plugin(const QString &_plugin, const QString &_token)
QueuedResult<QueuedPluginSpecification::Plugin> QueuedCore::plugin(const QString &_plugin,
const QString &_token)
{
qCDebug(LOG_LIB) << "Get data for plugin" << _plugin;
@ -223,8 +215,7 @@ QueuedCore::plugin(const QString &_plugin, const QString &_token)
/**
* @fn pluginSettings
*/
QueuedResult<QVariantHash> QueuedCore::pluginSettings(const QString &_plugin,
const QString &_token)
QueuedResult<QVariantHash> QueuedCore::pluginSettings(const QString &_plugin, const QString &_token)
{
qCDebug(LOG_LIB) << "Get plugin settings for" << _plugin;
@ -235,8 +226,7 @@ QueuedResult<QVariantHash> QueuedCore::pluginSettings(const QString &_plugin,
/**
* @fn removePlugin
*/
QueuedResult<bool> QueuedCore::removePlugin(const QString &_plugin,
const QString &_token)
QueuedResult<bool> QueuedCore::removePlugin(const QString &_plugin, const QString &_token)
{
qCDebug(LOG_LIB) << "Remove plugin" << _plugin;
@ -247,8 +237,7 @@ QueuedResult<bool> QueuedCore::removePlugin(const QString &_plugin,
/**
* @fn startTask
*/
QueuedResult<bool> QueuedCore::startTask(const long long _id,
const QString &_token)
QueuedResult<bool> QueuedCore::startTask(const long long _id, const QString &_token)
{
qCDebug(LOG_LIB) << "Force start task with ID" << _id;
@ -259,8 +248,7 @@ QueuedResult<bool> QueuedCore::startTask(const long long _id,
/**
* @fn stopTask
*/
QueuedResult<bool> QueuedCore::stopTask(const long long _id,
const QString &_token)
QueuedResult<bool> QueuedCore::stopTask(const long long _id, const QString &_token)
{
qCDebug(LOG_LIB) << "Force stop task with ID" << _id;
@ -271,8 +259,7 @@ QueuedResult<bool> QueuedCore::stopTask(const long long _id,
/**
* @fn task
*/
const QueuedProcess *QueuedCore::task(const long long _id,
const QString &_token) const
const QueuedProcess *QueuedCore::task(const long long _id, const QString &_token) const
{
qCDebug(LOG_LIB) << "Get task by ID" << _id;
@ -283,9 +270,10 @@ const QueuedProcess *QueuedCore::task(const long long _id,
/**
* @fn taskReport
*/
QueuedResult<QList<QVariantHash>>
QueuedCore::taskReport(const long long _user, const QDateTime &_from,
const QDateTime &_to, const QString &_token) const
QueuedResult<QList<QVariantHash>> QueuedCore::taskReport(const long long _user,
const QDateTime &_from,
const QDateTime &_to,
const QString &_token) const
{
qCDebug(LOG_LIB) << "Get tasks table by" << _user << _from << _to;
@ -296,8 +284,7 @@ QueuedCore::taskReport(const long long _user, const QDateTime &_from,
/**
* @fn user
*/
const QueuedUser *QueuedCore::user(const long long _id,
const QString &_token) const
const QueuedUser *QueuedCore::user(const long long _id, const QString &_token) const
{
qCDebug(LOG_LIB) << "Get user by ID" << _id;
@ -308,8 +295,7 @@ const QueuedUser *QueuedCore::user(const long long _id,
/**
* @fn user
*/
const QueuedUser *QueuedCore::user(const QString &_name,
const QString &_token) const
const QueuedUser *QueuedCore::user(const QString &_name, const QString &_token) const
{
qCDebug(LOG_LIB) << "Get user by name" << _name;
@ -320,13 +306,11 @@ const QueuedUser *QueuedCore::user(const QString &_name,
/**
* @fn userReport
*/
QueuedResult<QList<QVariantHash>>
QueuedCore::userReport(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission,
const QString &_token) const
QueuedResult<QList<QVariantHash>> QueuedCore::userReport(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission,
const QString &_token) const
{
qCDebug(LOG_LIB) << "Get users table by" << _lastLogged
<< static_cast<int>(_permission);
qCDebug(LOG_LIB) << "Get users table by" << _lastLogged << static_cast<int>(_permission);
return m_impl->userReport(_lastLogged, _permission, _token);
}
@ -340,12 +324,9 @@ void QueuedCore::deinit()
m_impl->deinit();
// dbus cleanup
QDBusConnection::systemBus().unregisterObject(
QueuedConfig::DBUS_OBJECT_PATH);
QDBusConnection::systemBus().unregisterObject(
QueuedConfig::DBUS_PROPERTY_PATH);
QDBusConnection::systemBus().unregisterObject(
QueuedConfig::DBUS_REPORTS_PATH);
QDBusConnection::systemBus().unregisterObject(QueuedConfig::DBUS_OBJECT_PATH);
QDBusConnection::systemBus().unregisterObject(QueuedConfig::DBUS_PROPERTY_PATH);
QDBusConnection::systemBus().unregisterObject(QueuedConfig::DBUS_REPORTS_PATH);
QDBusConnection::systemBus().unregisterService(QueuedConfig::DBUS_SERVICE);
}
@ -372,33 +353,29 @@ void QueuedCore::initDBus()
QDBusConnection bus = QDBusConnection::systemBus();
if (!bus.registerService(QueuedConfig::DBUS_SERVICE)) {
QString message = QString("Could not register service %1")
.arg(bus.lastError().message());
QString message = QString("Could not register service %1").arg(bus.lastError().message());
qCCritical(LOG_DBUS) << message;
throw QueuedDBusException(message);
}
if (!bus.registerObject(QueuedConfig::DBUS_OBJECT_PATH,
new QueuedCoreInterface(this),
if (!bus.registerObject(QueuedConfig::DBUS_OBJECT_PATH, new QueuedCoreInterface(this),
QDBusConnection::ExportAllContents)) {
QString message = QString("Could not register core object %1")
.arg(bus.lastError().message());
QString message
= QString("Could not register core object %1").arg(bus.lastError().message());
qCCritical(LOG_DBUS) << message;
throw QueuedDBusException(message);
}
if (!bus.registerObject(QueuedConfig::DBUS_PROPERTY_PATH,
new QueuedPropertyInterface(this),
if (!bus.registerObject(QueuedConfig::DBUS_PROPERTY_PATH, new QueuedPropertyInterface(this),
QDBusConnection::ExportAllContents)) {
QString message = QString("Could not register properties object %1")
.arg(bus.lastError().message());
QString message
= QString("Could not register properties object %1").arg(bus.lastError().message());
qCCritical(LOG_DBUS) << message;
throw QueuedDBusException(message);
}
if (!bus.registerObject(QueuedConfig::DBUS_REPORTS_PATH,
new QueuedReportInterface(this),
if (!bus.registerObject(QueuedConfig::DBUS_REPORTS_PATH, new QueuedReportInterface(this),
QDBusConnection::ExportAllContents)) {
QString message = QString("Could not register reports object %1")
.arg(bus.lastError().message());
QString message
= QString("Could not register reports object %1").arg(bus.lastError().message());
qCCritical(LOG_DBUS) << message;
throw QueuedDBusException(message);
}

244
sources/queued/src/QueuedCoreAdaptor.cpp
View File

@ -31,8 +31,7 @@
QueuedResult<bool> QueuedCoreAdaptor::auth(const QString &_token)
{
QVariantList args = {_token};
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "TryAuth", args);
}
@ -40,14 +39,12 @@ QueuedResult<bool> QueuedCoreAdaptor::auth(const QString &_token)
/**
* @fn auth
*/
QueuedResult<QString> QueuedCoreAdaptor::auth(const QString &_name,
const QString &_password)
QueuedResult<QString> QueuedCoreAdaptor::auth(const QString &_name, const QString &_password)
{
qCDebug(LOG_DBUS) << "Auth user" << _name;
QVariantList args = {_name, _password};
return sendRequest<QString>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
return sendRequest<QString>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "Auth", args);
}
@ -55,16 +52,13 @@ QueuedResult<QString> QueuedCoreAdaptor::auth(const QString &_name,
/**
* @fn sendOptionEdit
*/
QueuedResult<bool> QueuedCoreAdaptor::sendOptionEdit(const QString &_key,
const QVariant &_value,
QueuedResult<bool> QueuedCoreAdaptor::sendOptionEdit(const QString &_key, const QVariant &_value,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Edit option" << _key << "to" << _value;
QVariantList args
= {_key, QVariant::fromValue(QDBusVariant(_value)), _token};
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
QVariantList args = {_key, QVariant::fromValue(QDBusVariant(_value)), _token};
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "OptionEdit", args);
}
@ -72,27 +66,23 @@ QueuedResult<bool> QueuedCoreAdaptor::sendOptionEdit(const QString &_key,
/**
* @fn sendPasswordHash
*/
QueuedResult<QString>
QueuedCoreAdaptor::sendPasswordHash(const QString &_password)
QueuedResult<QString> QueuedCoreAdaptor::sendPasswordHash(const QString &_password)
{
QVariantList args = {_password};
return sendRequest<QString>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "PasswordHash", args);
return sendRequest<QString>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "PasswordHash", args);
}
/**
* @fn sendPluginAdd
*/
QueuedResult<bool> QueuedCoreAdaptor::sendPluginAdd(const QString &_plugin,
const QString &_token)
QueuedResult<bool> QueuedCoreAdaptor::sendPluginAdd(const QString &_plugin, const QString &_token)
{
qCDebug(LOG_DBUS) << "Add plugin" << _plugin;
QVariantList args = {_plugin, _token};
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "PluginAdd", args);
}
@ -106,8 +96,7 @@ QueuedResult<bool> QueuedCoreAdaptor::sendPluginRemove(const QString &_plugin,
qCDebug(LOG_DBUS) << "Remove plugin" << _plugin;
QVariantList args = {_plugin, _token};
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "PluginRemove", args);
}
@ -115,9 +104,9 @@ QueuedResult<bool> QueuedCoreAdaptor::sendPluginRemove(const QString &_plugin,
/**
* @fn sendTaskAdd
*/
QueuedResult<long long> QueuedCoreAdaptor::sendTaskAdd(
const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token)
QueuedResult<long long>
QueuedCoreAdaptor::sendTaskAdd(const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Add task" << _definitions.command;
@ -133,8 +122,7 @@ QueuedResult<long long> QueuedCoreAdaptor::sendTaskAdd(
limits.gpumemory,
limits.storage,
_token};
return sendRequest<long long>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
return sendRequest<long long>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "TaskAdd", args);
}
@ -142,10 +130,10 @@ QueuedResult<long long> QueuedCoreAdaptor::sendTaskAdd(
/**
* @fn sendTaskEdit
*/
QueuedResult<bool> QueuedCoreAdaptor::sendTaskEdit(
const long long _id,
const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token)
QueuedResult<bool>
QueuedCoreAdaptor::sendTaskEdit(const long long _id,
const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Edit task" << _id;
@ -164,8 +152,7 @@ QueuedResult<bool> QueuedCoreAdaptor::sendTaskEdit(
limits.gpumemory,
limits.storage,
_token};
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "TaskEdit", args);
}
@ -173,14 +160,12 @@ QueuedResult<bool> QueuedCoreAdaptor::sendTaskEdit(
/**
* @fn sendTaskStart
*/
QueuedResult<bool> QueuedCoreAdaptor::sendTaskStart(const long long _id,
const QString &_token)
QueuedResult<bool> QueuedCoreAdaptor::sendTaskStart(const long long _id, const QString &_token)
{
qCDebug(LOG_DBUS) << "Start task" << _id;
QVariantList args = {_id, _token};
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "TaskStart", args);
}
@ -188,14 +173,12 @@ QueuedResult<bool> QueuedCoreAdaptor::sendTaskStart(const long long _id,
/**
* @fn sendTaskStop
*/
QueuedResult<bool> QueuedCoreAdaptor::sendTaskStop(const long long _id,
const QString &_token)
QueuedResult<bool> QueuedCoreAdaptor::sendTaskStop(const long long _id, const QString &_token)
{
qCDebug(LOG_DBUS) << "Stop task" << _id;
QVariantList args = {_id, _token};
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "TaskStop", args);
}
@ -203,9 +186,9 @@ QueuedResult<bool> QueuedCoreAdaptor::sendTaskStop(const long long _id,
/**
* @fn sendUserAdd
*/
QueuedResult<long long> QueuedCoreAdaptor::sendUserAdd(
const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token)
QueuedResult<long long>
QueuedCoreAdaptor::sendUserAdd(const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Add user" << _definitions.name;
@ -221,8 +204,7 @@ QueuedResult<long long> QueuedCoreAdaptor::sendUserAdd(
limits.gpumemory,
limits.storage,
_token};
return sendRequest<long long>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
return sendRequest<long long>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "UserAdd", args);
}
@ -230,25 +212,18 @@ QueuedResult<long long> QueuedCoreAdaptor::sendUserAdd(
/**
* @fn sendUserEdit
*/
QueuedResult<bool> QueuedCoreAdaptor::sendUserEdit(
const long long _id, const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token)
QueuedResult<bool>
QueuedCoreAdaptor::sendUserEdit(const long long _id,
const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Edit user" << _id;
auto limits = QueuedLimits::Limits(_definitions.limits);
QVariantList args = {_id,
_definitions.name,
_definitions.password,
_definitions.email,
limits.cpu,
limits.gpu,
limits.memory,
limits.gpumemory,
limits.storage,
_token};
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_OBJECT_PATH,
QVariantList args
= {_id, _definitions.name, _definitions.password, _definitions.email, limits.cpu,
limits.gpu, limits.memory, limits.gpumemory, limits.storage, _token};
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "UserEdit", args);
}
@ -257,16 +232,13 @@ QueuedResult<bool> QueuedCoreAdaptor::sendUserEdit(
* @fn sendUserPermissionAdd
*/
QueuedResult<bool> QueuedCoreAdaptor::sendUserPermissionAdd(
const long long _id, const QueuedEnums::Permission _permission,
const QString &_token)
const long long _id, const QueuedEnums::Permission _permission, const QString &_token)
{
qCDebug(LOG_DBUS) << "Add permission" << static_cast<int>(_permission)
<< "to" << _id;
qCDebug(LOG_DBUS) << "Add permission" << static_cast<int>(_permission) << "to" << _id;
QVariantList args = {_id, static_cast<uint>(_permission), _token};
return sendRequest<bool>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "UserPermissionAdd", args);
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "UserPermissionAdd", args);
}
@ -274,63 +246,56 @@ QueuedResult<bool> QueuedCoreAdaptor::sendUserPermissionAdd(
* @fn sendUserPermissionRemove
*/
QueuedResult<bool> QueuedCoreAdaptor::sendUserPermissionRemove(
const long long _id, const QueuedEnums::Permission _permission,
const QString &_token)
const long long _id, const QueuedEnums::Permission _permission, const QString &_token)
{
qCDebug(LOG_DBUS) << "Remove permission" << static_cast<int>(_permission)
<< "from" << _id;
qCDebug(LOG_DBUS) << "Remove permission" << static_cast<int>(_permission) << "from" << _id;
QVariantList args = {_id, static_cast<uint>(_permission), _token};
return sendRequest<bool>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "UserPermissionRemove", args);
return sendRequest<bool>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_OBJECT_PATH,
QueuedConfig::DBUS_SERVICE, "UserPermissionRemove", args);
}
/**
* @fn getPlugin
*/
QueuedResult<QueuedPluginSpecification::Plugin>
QueuedCoreAdaptor::getPlugin(const QString &_plugin, const QString &_token)
QueuedResult<QueuedPluginSpecification::Plugin> QueuedCoreAdaptor::getPlugin(const QString &_plugin,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Get information for plugin" << _plugin;
QVariantList args = {_plugin, _token};
return sendRequest<QueuedPluginSpecification::Plugin>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_PROPERTY_PATH,
QueuedConfig::DBUS_SERVICE, "Plugin", args);
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_PROPERTY_PATH, QueuedConfig::DBUS_SERVICE,
"Plugin", args);
}
/**
* @fn getPluginOptions
*/
QueuedResult<QVariantHash>
QueuedCoreAdaptor::getPluginOptions(const QString &_plugin,
const QString &_token)
QueuedResult<QVariantHash> QueuedCoreAdaptor::getPluginOptions(const QString &_plugin,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Get options for plugin" << _plugin;
QVariantList args = {_plugin, _token};
return sendRequest<QVariantHash>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_PROPERTY_PATH,
QueuedConfig::DBUS_SERVICE, "PluginOptions", args);
return sendRequest<QVariantHash>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_PROPERTY_PATH,
QueuedConfig::DBUS_SERVICE, "PluginOptions", args);
}
/**
* @fn getOption
*/
QueuedResult<QVariant> QueuedCoreAdaptor::getOption(const QString &_property,
const QString &_token)
QueuedResult<QVariant> QueuedCoreAdaptor::getOption(const QString &_property, const QString &_token)
{
qCDebug(LOG_DBUS) << "Get option" << _property;
QVariantList args = {_property, _token};
return sendRequest<QVariant>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_PROPERTY_PATH,
return sendRequest<QVariant>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_PROPERTY_PATH,
QueuedConfig::DBUS_SERVICE, "Option", args);
}
@ -338,9 +303,8 @@ QueuedResult<QVariant> QueuedCoreAdaptor::getOption(const QString &_property,
/**
* @fn getOption
*/
QueuedResult<QVariant>
QueuedCoreAdaptor::getOption(const QueuedConfig::QueuedSettings _property,
const QString &_token)
QueuedResult<QVariant> QueuedCoreAdaptor::getOption(const QueuedConfig::QueuedSettings _property,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Get option" << static_cast<int>(_property);
@ -351,17 +315,17 @@ QueuedCoreAdaptor::getOption(const QueuedConfig::QueuedSettings _property,
/**
* @fn getPerformance
*/
QueuedResult<QList<QVariantHash>>
QueuedCoreAdaptor::getPerformance(const QDateTime &_from, const QDateTime &_to,
const QString &_token)
QueuedResult<QList<QVariantHash>> QueuedCoreAdaptor::getPerformance(const QDateTime &_from,
const QDateTime &_to,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Get performance report for" << _from << _to;
QVariantList args = {_from.toString(Qt::ISODateWithMs),
_to.toString(Qt::ISODateWithMs), _token};
return sendRequest<QList<QVariantHash>>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_REPORTS_PATH,
QueuedConfig::DBUS_SERVICE, "Performance", args);
QVariantList args
= {_from.toString(Qt::ISODateWithMs), _to.toString(Qt::ISODateWithMs), _token};
return sendRequest<QList<QVariantHash>>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_REPORTS_PATH,
QueuedConfig::DBUS_SERVICE, "Performance", args);
}
@ -370,28 +334,23 @@ QueuedCoreAdaptor::getPerformance(const QDateTime &_from, const QDateTime &_to,
*/
QueuedResult<QueuedStatusMap> QueuedCoreAdaptor::getStatus()
{
return sendRequest<QueuedStatusMap>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_REPORTS_PATH,
QueuedConfig::DBUS_SERVICE, "Status", {});
return sendRequest<QueuedStatusMap>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_REPORTS_PATH,
QueuedConfig::DBUS_SERVICE, "Status", {});
}
/**
* @fn getTask
*/
QueuedResult<QVariantHash> QueuedCoreAdaptor::getTask(const long long _id,
const QString &_token)
QueuedResult<QVariantHash> QueuedCoreAdaptor::getTask(const long long _id, const QString &_token)
{
qCDebug(LOG_DBUS) << "Get task properties" << _id;
auto res = getTask(_id, "", _token);
QueuedResult<QVariantHash> output;
res.match(
[&output](const QVariant &val) {
output = toResult<QVariantHash>(val);
},
[&output](const QueuedError &err) { output = err; });
res.match([&output](const QVariant &val) { output = toResult<QVariantHash>(val); },
[&output](const QueuedError &err) { output = err; });
return output;
}
@ -400,15 +359,13 @@ QueuedResult<QVariantHash> QueuedCoreAdaptor::getTask(const long long _id,
/**
* @fn getTask
*/
QueuedResult<QVariant> QueuedCoreAdaptor::getTask(const long long _id,
const QString &_property,
QueuedResult<QVariant> QueuedCoreAdaptor::getTask(const long long _id, const QString &_property,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Get task property" << _id << _property;
QVariantList args = {_id, _property, _token};
return sendRequest<QVariant>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_PROPERTY_PATH,
return sendRequest<QVariant>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_PROPERTY_PATH,
QueuedConfig::DBUS_SERVICE, "Task", args);
}
@ -416,36 +373,33 @@ QueuedResult<QVariant> QueuedCoreAdaptor::getTask(const long long _id,
/**
* @fn getTasks
*/
QueuedResult<QList<QVariantHash>>
QueuedCoreAdaptor::getTasks(const long long _user, const QDateTime &_from,
const QDateTime &_to, const QString &_token)
QueuedResult<QList<QVariantHash>> QueuedCoreAdaptor::getTasks(const long long _user,
const QDateTime &_from,
const QDateTime &_to,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Get tasks list for" << _user << _from << _to;
QVariantList args = {_user, _from.toString(Qt::ISODateWithMs),
_to.toString(Qt::ISODateWithMs), _token};
return sendRequest<QList<QVariantHash>>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_REPORTS_PATH,
QueuedConfig::DBUS_SERVICE, "Tasks", args);
QVariantList args
= {_user, _from.toString(Qt::ISODateWithMs), _to.toString(Qt::ISODateWithMs), _token};
return sendRequest<QList<QVariantHash>>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_REPORTS_PATH,
QueuedConfig::DBUS_SERVICE, "Tasks", args);
}
/**
* @fn getUser
*/
QueuedResult<QVariantHash> QueuedCoreAdaptor::getUser(const long long _id,
const QString &_token)
QueuedResult<QVariantHash> QueuedCoreAdaptor::getUser(const long long _id, const QString &_token)
{
qCDebug(LOG_DBUS) << "Get user property" << _id;
auto res = getUser(_id, "", _token);
QueuedResult<QVariantHash> output;
res.match(
[&output](const QVariant &val) {
output = toResult<QVariantHash>(val);
},
[&output](const QueuedError &err) { output = err; });
res.match([&output](const QVariant &val) { output = toResult<QVariantHash>(val); },
[&output](const QueuedError &err) { output = err; });
return output;
}
@ -454,15 +408,13 @@ QueuedResult<QVariantHash> QueuedCoreAdaptor::getUser(const long long _id,
/**
* @fn getUser
*/
QueuedResult<QVariant> QueuedCoreAdaptor::getUser(const long long _id,
const QString &_property,
QueuedResult<QVariant> QueuedCoreAdaptor::getUser(const long long _id, const QString &_property,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Get user property" << _id << _property;
QVariantList args = {_id, _property, _token};
return sendRequest<QVariant>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_PROPERTY_PATH,
return sendRequest<QVariant>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_PROPERTY_PATH,
QueuedConfig::DBUS_SERVICE, "User", args);
}
@ -470,8 +422,7 @@ QueuedResult<QVariant> QueuedCoreAdaptor::getUser(const long long _id,
/**
* @fn getUserId
*/
QueuedResult<long long> QueuedCoreAdaptor::getUserId(const QString &_name,
const QString &_token)
QueuedResult<long long> QueuedCoreAdaptor::getUserId(const QString &_name, const QString &_token)
{
qCDebug(LOG_DBUS) << "Get user ID for" << _name;
@ -481,9 +432,8 @@ QueuedResult<long long> QueuedCoreAdaptor::getUserId(const QString &_name,
return stringToLong;
QVariantList args = {_name, _token};
return sendRequest<long long>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_PROPERTY_PATH,
QueuedConfig::DBUS_SERVICE, "UserIdByName", args);
return sendRequest<long long>(QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_PROPERTY_PATH,
QueuedConfig::DBUS_SERVICE, "UserIdByName", args);
}
@ -491,16 +441,14 @@ QueuedResult<long long> QueuedCoreAdaptor::getUserId(const QString &_name,
* @fn getUsers
*/
QueuedResult<QList<QVariantHash>>
QueuedCoreAdaptor::getUsers(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission,
QueuedCoreAdaptor::getUsers(const QDateTime &_lastLogged, const QueuedEnums::Permission _permission,
const QString &_token)
{
qCDebug(LOG_DBUS) << "Get users list for" << _lastLogged
<< static_cast<int>(_permission);
qCDebug(LOG_DBUS) << "Get users list for" << _lastLogged << static_cast<int>(_permission);
QVariantList args = {_lastLogged.toString(Qt::ISODateWithMs),
static_cast<uint>(_permission), _token};
return sendRequest<QList<QVariantHash>>(
QueuedConfig::DBUS_SERVICE, QueuedConfig::DBUS_REPORTS_PATH,
QueuedConfig::DBUS_SERVICE, "Users", args);
QVariantList args
= {_lastLogged.toString(Qt::ISODateWithMs), static_cast<uint>(_permission), _token};
return sendRequest<QList<QVariantHash>>(QueuedConfig::DBUS_SERVICE,
QueuedConfig::DBUS_REPORTS_PATH,
QueuedConfig::DBUS_SERVICE, "Users", args);
}

112
sources/queued/src/QueuedCoreInterface.cpp
View File

@ -61,27 +61,23 @@ QueuedCoreInterface::~QueuedCoreInterface()
/**
* @fn Auth
*/
QDBusVariant QueuedCoreInterface::Auth(const QString &name,
const QString &password)
QDBusVariant QueuedCoreInterface::Auth(const QString &name, const QString &password)
{
qCDebug(LOG_DBUS) << "Authorize user" << name;
return QueuedCoreAdaptor::toDBusVariant(
m_core->authorization(name, password));
return QueuedCoreAdaptor::toDBusVariant(m_core->authorization(name, password));
}
/**
* @fn OptionEdit
*/
QDBusVariant QueuedCoreInterface::OptionEdit(const QString &key,
const QDBusVariant &value,
QDBusVariant QueuedCoreInterface::OptionEdit(const QString &key, const QDBusVariant &value,
const QString &token)
{
qCDebug(LOG_DBUS) << "Edit option" << key << value.variant();
return QueuedCoreAdaptor::toDBusVariant(
m_core->editOption(key, value.variant(), token));
return QueuedCoreAdaptor::toDBusVariant(m_core->editOption(key, value.variant(), token));
}
@ -97,8 +93,7 @@ QDBusVariant QueuedCoreInterface::PasswordHash(const QString &password)
/**
* @fn PluginAdd
*/
QDBusVariant QueuedCoreInterface::PluginAdd(const QString &plugin,
const QString &token)
QDBusVariant QueuedCoreInterface::PluginAdd(const QString &plugin, const QString &token)
{
qCDebug(LOG_DBUS) << "Add plugin" << plugin;
@ -109,54 +104,51 @@ QDBusVariant QueuedCoreInterface::PluginAdd(const QString &plugin,
/**
* @fn PluginRemove
*/
QDBusVariant QueuedCoreInterface::PluginRemove(const QString &plugin,
const QString &token)
QDBusVariant QueuedCoreInterface::PluginRemove(const QString &plugin, const QString &token)
{
qCDebug(LOG_DBUS) << "Remove plugin" << plugin;
return QueuedCoreAdaptor::toDBusVariant(
m_core->removePlugin(plugin, token));
return QueuedCoreAdaptor::toDBusVariant(m_core->removePlugin(plugin, token));
}
/**
* @fn TaskAdd
*/
QDBusVariant QueuedCoreInterface::TaskAdd(
const QString &command, const QStringList &arguments,
const QString &workingDirectory, const qlonglong user, const uint nice,
const qlonglong cpu, const qlonglong gpu, const qlonglong memory,
const qlonglong gpumemory, const qlonglong storage, const QString &token)
QDBusVariant QueuedCoreInterface::TaskAdd(const QString &command, const QStringList &arguments,
const QString &workingDirectory, const qlonglong user,
const uint nice, const qlonglong cpu, const qlonglong gpu,
const qlonglong memory, const qlonglong gpumemory,
const qlonglong storage, const QString &token)
{
qCDebug(LOG_DBUS) << "Add new task with parameters" << command << arguments
<< workingDirectory << "from user" << user;
qCDebug(LOG_DBUS) << "Add new task with parameters" << command << arguments << workingDirectory
<< "from user" << user;
return QueuedCoreAdaptor::toDBusVariant(m_core->addTask(
command, arguments, workingDirectory, user, nice,
QueuedLimits::Limits(cpu, gpu, memory, gpumemory, storage), token));
return QueuedCoreAdaptor::toDBusVariant(
m_core->addTask(command, arguments, workingDirectory, user, nice,
QueuedLimits::Limits(cpu, gpu, memory, gpumemory, storage), token));
}
/**
* @fn TaskEdit
*/
QDBusVariant QueuedCoreInterface::TaskEdit(
const qlonglong id, const QString &command, const QStringList &arguments,
const QString &directory, const uint nice, const uint uid, const uint gid,
const qlonglong user, const qlonglong cpu, const qlonglong gpu,
const qlonglong memory, const qlonglong gpumemory, const qlonglong storage,
const QString &token)
QDBusVariant QueuedCoreInterface::TaskEdit(const qlonglong id, const QString &command,
const QStringList &arguments, const QString &directory,
const uint nice, const uint uid, const uint gid,
const qlonglong user, const qlonglong cpu,
const qlonglong gpu, const qlonglong memory,
const qlonglong gpumemory, const qlonglong storage,
const QString &token)
{
qCDebug(LOG_DBUS) << "Edit task" << id << command << arguments << directory
<< nice << uid << gid << cpu << gpu << memory << gpumemory
<< storage;
qCDebug(LOG_DBUS) << "Edit task" << id << command << arguments << directory << nice << uid
<< gid << cpu << gpu << memory << gpumemory << storage;
auto task = m_core->task(id, token);
if (!task) {
qCWarning(LOG_DBUS) << "Could not find task" << id;
return QueuedCoreAdaptor::toDBusVariant(QueuedResult<bool>(
QueuedError("Task does not exist",
QueuedEnums::ReturnStatus::InvalidArgument)));
QueuedError("Task does not exist", QueuedEnums::ReturnStatus::InvalidArgument)));
}
// build payload
@ -196,8 +188,7 @@ QDBusVariant QueuedCoreInterface::TaskEdit(
/**
* @fn TaskStart
*/
QDBusVariant QueuedCoreInterface::TaskStart(const qlonglong id,
const QString &token)
QDBusVariant QueuedCoreInterface::TaskStart(const qlonglong id, const QString &token)
{
qCDebug(LOG_DBUS) << "Force start task" << id;
@ -208,8 +199,7 @@ QDBusVariant QueuedCoreInterface::TaskStart(const qlonglong id,
/**
* @fn TaskStop
*/
QDBusVariant QueuedCoreInterface::TaskStop(const qlonglong id,
const QString &token)
QDBusVariant QueuedCoreInterface::TaskStop(const qlonglong id, const QString &token)
{
qCDebug(LOG_DBUS) << "Force stop task" << id;
@ -229,41 +219,39 @@ QDBusVariant QueuedCoreInterface::TryAuth(const QString &token)
/**
* @fn UserAdd
*/
QDBusVariant QueuedCoreInterface::UserAdd(
const QString &name, const QString &email, const QString &password,
const uint permissions, const uint priority, const qlonglong cpu,
const qlonglong gpu, const qlonglong memory, const qlonglong gpumemory,
const qlonglong storage, const QString &token)
QDBusVariant QueuedCoreInterface::UserAdd(const QString &name, const QString &email,
const QString &password, const uint permissions,
const uint priority, const qlonglong cpu,
const qlonglong gpu, const qlonglong memory,
const qlonglong gpumemory, const qlonglong storage,
const QString &token)
{
qCDebug(LOG_DBUS) << "Add new user with paramaters" << name << email
<< permissions;
qCDebug(LOG_DBUS) << "Add new user with paramaters" << name << email << permissions;
return QueuedCoreAdaptor::toDBusVariant(m_core->addUser(
name, email, password, permissions, priority,
QueuedLimits::Limits(cpu, gpu, memory, gpumemory, storage), token));
return QueuedCoreAdaptor::toDBusVariant(
m_core->addUser(name, email, password, permissions, priority,
QueuedLimits::Limits(cpu, gpu, memory, gpumemory, storage), token));
}
/**
* @fn UserEdit
*/
QDBusVariant
QueuedCoreInterface::UserEdit(const qlonglong id, const QString &name,
const QString &password, const QString &email,
const qlonglong cpu, const qlonglong gpu,
const qlonglong memory, const qlonglong gpumemory,
const qlonglong storage, const QString &token)
QDBusVariant QueuedCoreInterface::UserEdit(const qlonglong id, const QString &name,
const QString &password, const QString &email,
const qlonglong cpu, const qlonglong gpu,
const qlonglong memory, const qlonglong gpumemory,
const qlonglong storage, const QString &token)
{
qCDebug(LOG_DBUS) << "Edit user" << id << name << email << cpu << gpu
<< memory << gpumemory << storage;
qCDebug(LOG_DBUS) << "Edit user" << id << name << email << cpu << gpu << memory << gpumemory
<< storage;
// get user object first to match limits
auto user = m_core->user(id, token);
if (!user) {
qCWarning(LOG_DBUS) << "Could not find user" << id;
return QueuedCoreAdaptor::toDBusVariant(QueuedResult<bool>(
QueuedError("User does not exist",
QueuedEnums::ReturnStatus::InvalidArgument)));
QueuedError("User does not exist", QueuedEnums::ReturnStatus::InvalidArgument)));
}
// build payload
@ -295,8 +283,7 @@ QueuedCoreInterface::UserEdit(const qlonglong id, const QString &name,
/**
* @fn UserPermissionAdd
*/
QDBusVariant QueuedCoreInterface::UserPermissionAdd(const qlonglong id,
const uint permission,
QDBusVariant QueuedCoreInterface::UserPermissionAdd(const qlonglong id, const uint permission,
const QString &token)
{
qCDebug(LOG_DBUS) << "Add permission" << permission << "to user" << id;
@ -309,8 +296,7 @@ QDBusVariant QueuedCoreInterface::UserPermissionAdd(const qlonglong id,
/**
* @fn UserPermissionRemove
*/
QDBusVariant QueuedCoreInterface::UserPermissionRemove(const qlonglong id,
const uint permission,
QDBusVariant QueuedCoreInterface::UserPermissionRemove(const qlonglong id, const uint permission,
const QString &token)
{
qCDebug(LOG_DBUS) << "Remove permission" << permission << "from user" << id;

276
sources/queued/src/QueuedCorePrivate.cpp
View File

@ -35,16 +35,14 @@
/**
* @fn addPlugin
*/
QueuedResult<bool> QueuedCorePrivate::addPlugin(const QString &_plugin,
const QString &_token)
QueuedResult<bool> QueuedCorePrivate::addPlugin(const QString &_plugin, const QString &_token)
{
qCDebug(LOG_LIB) << "Add plugin" << _plugin;
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to add plugin";
return QueuedError("Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
return m_helper->editPluginPrivate(_plugin, true);
@ -54,19 +52,20 @@ QueuedResult<bool> QueuedCorePrivate::addPlugin(const QString &_plugin,
/**
* @addTask
*/
QueuedResult<long long> QueuedCorePrivate::addTask(
const QString &_command, const QStringList &_arguments,
const QString &_workingDirectory, const long long _userId, const uint _nice,
const QueuedLimits::Limits &_limits, const QString &_token)
QueuedResult<long long> QueuedCorePrivate::addTask(const QString &_command,
const QStringList &_arguments,
const QString &_workingDirectory,
const long long _userId, const uint _nice,
const QueuedLimits::Limits &_limits,
const QString &_token)
{
qCDebug(LOG_LIB) << "Add task" << _command << "with arguments" << _arguments
<< "from user" << _userId;
qCDebug(LOG_LIB) << "Add task" << _command << "with arguments" << _arguments << "from user"
<< _userId;
auto authUser = m_users->user(_token, true);
if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return QueuedError("Invalid token",
QueuedEnums::ReturnStatus::InvalidToken);
return QueuedError("Invalid token", QueuedEnums::ReturnStatus::InvalidToken);
}
long long userAuthId = authUser->index();
long long actualUserId = (_userId == -1) ? userAuthId : _userId;
@ -78,54 +77,48 @@ QueuedResult<long long> QueuedCorePrivate::addTask(
// it means that user places task as own one
if (!isUser) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to add task";
return QueuedError(
"Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
} else {
// user tries to place task as another one
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to add task";
return QueuedError(
"Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
}
return m_helper->addTaskPrivate(_command, _arguments, _workingDirectory,
_userId, _nice, _limits);
return m_helper->addTaskPrivate(_command, _arguments, _workingDirectory, _userId, _nice,
_limits);
}
/**
* @fn addUser
*/
QueuedResult<long long> QueuedCorePrivate::addUser(
const QString &_name, const QString &_email, const QString &_password,
const uint _permissions, const uint _priority,
const QueuedLimits::Limits &_limits, const QString &_token)
QueuedResult<long long> QueuedCorePrivate::addUser(const QString &_name, const QString &_email,
const QString &_password,
const uint _permissions, const uint _priority,
const QueuedLimits::Limits &_limits,
const QString &_token)
{
qCDebug(LOG_LIB) << "Add user" << _name << "with email" << _email
<< "and permissions" << _permissions;
qCDebug(LOG_LIB) << "Add user" << _name << "with email" << _email << "and permissions"
<< _permissions;
// check permissions
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to add user";
return QueuedError("Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
// check if already exists
auto userObj = user(_name, _token);
if (userObj) {
qCWarning(LOG_LIB) << "User" << _name << "already exists";
return QueuedError("User already exists",
QueuedEnums::ReturnStatus::InvalidArgument);
return QueuedError("User already exists", QueuedEnums::ReturnStatus::InvalidArgument);
}
return m_helper->addUserPrivate(_name, _email, _password, _permissions,
_priority, _limits);
return m_helper->addUserPrivate(_name, _email, _password, _permissions, _priority, _limits);
}
@ -157,8 +150,7 @@ QueuedResult<QString> QueuedCorePrivate::authorization(const QString &_name,
QVariantHash payload
= {{"token", token},
{"user", _name},
{"validUntil",
m_users->checkToken(token).toString(Qt::ISODateWithMs)}};
{"validUntil", m_users->checkToken(token).toString(Qt::ISODateWithMs)}};
m_database->add(QueuedDB::TOKENS_TABLE, payload);
return token;
}
@ -168,8 +160,7 @@ QueuedResult<QString> QueuedCorePrivate::authorization(const QString &_name,
/**
* @fn editOption
*/
QueuedResult<bool> QueuedCorePrivate::editOption(const QString &_key,
const QVariant &_value,
QueuedResult<bool> QueuedCorePrivate::editOption(const QString &_key, const QVariant &_value,
const QString &_token)
{
qCDebug(LOG_LIB) << "Set key" << _key << "to" << _value;
@ -178,8 +169,7 @@ QueuedResult<bool> QueuedCorePrivate::editOption(const QString &_key,
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to edit options";
return QueuedError("Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
return m_helper->editOptionPrivate(_key, _value);
@ -189,33 +179,20 @@ QueuedResult<bool> QueuedCorePrivate::editOption(const QString &_key,
/**
* @fn editTask
*/
QueuedResult<bool> QueuedCorePrivate::editTask(const long long _id,
const QVariantHash &_taskData,
QueuedResult<bool> QueuedCorePrivate::editTask(const long long _id, const QVariantHash &_taskData,
const QString &_token)
{
qCDebug(LOG_LIB) << "Edit task with ID" << _id;
auto task = m_processes->process(_id);
if (!task) {
qCInfo(LOG_LIB) << "Try to get information about task" << _id
<< "from database";
auto data = m_database->get(QueuedDB::TASKS_TABLE, _id);
if (data.isEmpty()) {
qCWarning(LOG_LIB) << "Could not find task with ID" << _id;
return QueuedError("Task does not exist",
QueuedEnums::ReturnStatus::InvalidArgument);
}
auto defs = QueuedProcessManager::parseDefinitions(data);
task = new QueuedProcess(this, defs, _id);
}
auto task = m_helper->tryGetTask(_id);
if (!task)
return QueuedError("Task does not exist", QueuedEnums::ReturnStatus::InvalidArgument);
// check permissions
auto authUser = m_users->user(_token, true);
if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return QueuedError("Invalid token",
QueuedEnums::ReturnStatus::InvalidToken);
return QueuedError("Invalid token", QueuedEnums::ReturnStatus::InvalidToken);
}
long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
@ -224,37 +201,28 @@ QueuedResult<bool> QueuedCorePrivate::editTask(const long long _id,
// it means that user edits own task
if (!isUser) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to edit task";
return QueuedError(
"Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
} else {
// user tries to edit random task
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to edit task";
return QueuedError(
"Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
}
// only admin can edit run/stopped task
if (!task->startTime().isNull()) {
if (!isAdmin) {
qCInfo(LOG_LIB)
<< "User" << _token << "not allowed to edit run/exited task";
return QueuedError(
"Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
qCInfo(LOG_LIB) << "User" << _token << "not allowed to edit run/exited task";
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
}
// drop admin fields
QVariantHash payload
= isAdmin ? _taskData
: m_helper->dropAdminFields(QueuedDB::TASKS_TABLE, _taskData);
= isAdmin ? _taskData : m_helper->dropAdminFields(QueuedDB::TASKS_TABLE, _taskData);
if (payload.contains("nice"))
payload["nice"]
= std::min(payload["nice"].toUInt(), authUser->priority());
payload["nice"] = std::min(payload["nice"].toUInt(), authUser->priority());
return m_helper->editTaskPrivate(task, payload);
}
@ -263,63 +231,53 @@ QueuedResult<bool> QueuedCorePrivate::editTask(const long long _id,
/**
* @fn editUser
*/
QueuedResult<bool> QueuedCorePrivate::editUser(const long long _id,
const QVariantHash &_userData,
QueuedResult<bool> QueuedCorePrivate::editUser(const long long _id, const QVariantHash &_userData,
const QString &_token)
{
qCDebug(LOG_LIB) << "Edit user with ID" << _id;
auto userObj = user(_id, _token);
if (!userObj) {
qCWarning(LOG_LIB) << "Could not find user with ID" << _id;
return QueuedError("User does not exist",
QueuedEnums::ReturnStatus::InvalidArgument);
}
auto userObj = m_helper->tryGetUser(_id);
if (!userObj)
return QueuedError("User does not exist", QueuedEnums::ReturnStatus::InvalidArgument);
// check permissions
auto authUser = m_users->user(_token, true);
if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return QueuedError("Invalid token",
QueuedEnums::ReturnStatus::InvalidToken);
return QueuedError("Invalid token", QueuedEnums::ReturnStatus::InvalidToken);
}
long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (userAuthId != _id) {
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to edit user";
return QueuedError(
"Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
}
// drop admin fields
QVariantHash payload
= isAdmin ? _userData
: m_helper->dropAdminFields(QueuedDB::USERS_TABLE, _userData);
= isAdmin ? _userData : m_helper->dropAdminFields(QueuedDB::USERS_TABLE, _userData);
return m_helper->editUserPrivate(_id, payload);
return m_helper->editUserPrivate(userObj, payload);
}
/**
* @fn editUserPermission
*/
QueuedResult<bool> QueuedCorePrivate::editUserPermission(
const long long _id, const QueuedEnums::Permission &_permission,
const bool _add, const QString &_token)
QueuedResult<bool> QueuedCorePrivate::editUserPermission(const long long _id,
const QueuedEnums::Permission &_permission,
const bool _add, const QString &_token)
{
qCDebug(LOG_LIB) << "Edit permissions" << static_cast<int>(_permission)
<< "for user" << _id << "add" << _add;
qCDebug(LOG_LIB) << "Edit permissions" << static_cast<int>(_permission) << "for user" << _id
<< "add" << _add;
// check permissions
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token
<< "not allowed to edit permissions";
return QueuedError("Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
qCInfo(LOG_LIB) << "User" << _token << "not allowed to edit permissions";
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
return m_helper->editUserPermissionPrivate(_id, _permission, _add);
@ -329,20 +287,17 @@ QueuedResult<bool> QueuedCorePrivate::editUserPermission(
/**
* @fn hashFromPassword
*/
QueuedResult<QString>
QueuedCorePrivate::hashFromPassword(const QString &_password)
QueuedResult<QString> QueuedCorePrivate::hashFromPassword(const QString &_password)
{
return _password.isEmpty() ? ""
: QueuedUser::hashFromPassword(
_password, m_settings->admin().salt);
: QueuedUser::hashFromPassword(_password, m_settings->admin().salt);
}
/**
* @fn option
*/
QueuedResult<QVariant> QueuedCorePrivate::option(const QString &_key,
const QString &_token)
QueuedResult<QVariant> QueuedCorePrivate::option(const QString &_key, const QString &_token)
{
qCDebug(LOG_LIB) << "Look for option" << _key;
@ -351,16 +306,16 @@ QueuedResult<QVariant> QueuedCorePrivate::option(const QString &_key,
if ((isAdmin) || (!m_advancedSettings->isAdmin(_key)))
return m_advancedSettings->get(_key);
else
return QueuedError("Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
/**
* @fn performanceReport
*/
QueuedResult<QList<QVariantHash>> QueuedCorePrivate::performanceReport(
const QDateTime &_from, const QDateTime &_to, const QString &_token) const
QueuedResult<QList<QVariantHash>> QueuedCorePrivate::performanceReport(const QDateTime &_from,
const QDateTime &_to,
const QString &_token) const
{
qCDebug(LOG_LIB) << "Get performance report for" << _from << _to;
@ -368,18 +323,15 @@ QueuedResult<QList<QVariantHash>> QueuedCorePrivate::performanceReport(
auto authUser = m_users->user(_token, true);
if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return QueuedError("Invalid token",
QueuedEnums::ReturnStatus::InvalidToken);
return QueuedError("Invalid token", QueuedEnums::ReturnStatus::InvalidToken);
}
long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Reports);
if (isAdmin) {
return m_reports->performance(static_cast<QueuedCore *>(parent()),
_from, _to);
return m_reports->performance(static_cast<QueuedCore *>(parent()), _from, _to);
} else {
auto data = m_reports->performance(static_cast<QueuedCore *>(parent()),
_from, _to);
auto data = m_reports->performance(static_cast<QueuedCore *>(parent()), _from, _to);
QList<QVariantHash> output;
for (auto &userData : data) {
if (userData["_id"].toLongLong() != userAuthId)
@ -394,13 +346,12 @@ QueuedResult<QList<QVariantHash>> QueuedCorePrivate::performanceReport(
/**
* @fn plugin
*/
QueuedResult<QueuedPluginSpecification::Plugin>
QueuedCorePrivate::plugin(const QString &_plugin, const QString &_token)
QueuedResult<QueuedPluginSpecification::Plugin> QueuedCorePrivate::plugin(const QString &_plugin,
const QString &_token)
{
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin)
return QueuedError("Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
return m_plugins->loadSpecification(_plugin);
}
@ -409,19 +360,17 @@ QueuedCorePrivate::plugin(const QString &_plugin, const QString &_token)
/**
* @fn pluginSettings
*/
QueuedResult<QVariantHash>
QueuedCorePrivate::pluginSettings(const QString &_plugin, const QString &_token)
QueuedResult<QVariantHash> QueuedCorePrivate::pluginSettings(const QString &_plugin,
const QString &_token)
{
qCDebug(LOG_LIB) << "Get plugin settings for" << _plugin;
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin)
return QueuedError("Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
auto dbSettings
= m_database->get(QueuedDB::SETTINGS_TABLE,
QString("WHERE key LIKE 'Plugin.%1.%'").arg(_plugin));
auto dbSettings = m_database->get(QueuedDB::SETTINGS_TABLE,
QString("WHERE key LIKE 'Plugin.%1.%'").arg(_plugin));
QVariantHash settings;
std::for_each(dbSettings.cbegin(), dbSettings.cend(),
[&settings, &_plugin](const QVariantHash &value) {
@ -446,16 +395,14 @@ QueuedCorePrivate::pluginSettings(const QString &_plugin, const QString &_token)
/**
* @fn removePlugin
*/
QueuedResult<bool> QueuedCorePrivate::removePlugin(const QString &_plugin,
const QString &_token)
QueuedResult<bool> QueuedCorePrivate::removePlugin(const QString &_plugin, const QString &_token)
{
qCDebug(LOG_LIB) << "Remove plugin" << _plugin;
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to remove plugin";
return QueuedError("Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
return m_helper->editPluginPrivate(_plugin, false);
@ -465,8 +412,7 @@ QueuedResult<bool> QueuedCorePrivate::removePlugin(const QString &_plugin,
/**
* @fn startTask
*/
QueuedResult<bool> QueuedCorePrivate::startTask(const long long _id,
const QString &_token)
QueuedResult<bool> QueuedCorePrivate::startTask(const long long _id, const QString &_token)
{
qCDebug(LOG_LIB) << "Force start task with ID" << _id;
@ -474,17 +420,14 @@ QueuedResult<bool> QueuedCorePrivate::startTask(const long long _id,
auto authUser = m_users->user(_token, true);
if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return QueuedError("Invalid token",
QueuedEnums::ReturnStatus::InvalidToken);
return QueuedError("Invalid token", QueuedEnums::ReturnStatus::InvalidToken);
}
long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (userAuthId != _id) {
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to start tasks";
return QueuedError(
"Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
}
@ -497,24 +440,21 @@ QueuedResult<bool> QueuedCorePrivate::startTask(const long long _id,
/**
* @fn stopTask
*/
QueuedResult<bool> QueuedCorePrivate::stopTask(const long long _id,
const QString &_token)
QueuedResult<bool> QueuedCorePrivate::stopTask(const long long _id, const QString &_token)
{
qCDebug(LOG_LIB) << "Force stop task with ID" << _id;
auto task = m_processes->process(_id);
if (!task) {
qCWarning(LOG_LIB) << "Could not find task with ID" << _id;
return QueuedError("Task does not exist",
QueuedEnums::ReturnStatus::InvalidArgument);
return QueuedError("Task does not exist", QueuedEnums::ReturnStatus::InvalidArgument);
}
// check permissions
auto authUser = m_users->user(_token, true);
if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return QueuedError("Invalid token",
QueuedEnums::ReturnStatus::InvalidToken);
return QueuedError("Invalid token", QueuedEnums::ReturnStatus::InvalidToken);
}
long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
@ -523,17 +463,13 @@ QueuedResult<bool> QueuedCorePrivate::stopTask(const long long _id,
// it means that user edits own task
if (!isUser) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to stop task";
return QueuedError(
"Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
} else {
// user tries to edit random task
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to stop task";
return QueuedError(
"Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
}
@ -546,16 +482,13 @@ QueuedResult<bool> QueuedCorePrivate::stopTask(const long long _id,
/**
* @fn task
*/
const QueuedProcess *QueuedCorePrivate::task(const long long _id,
const QString &_token) const
const QueuedProcess *QueuedCorePrivate::task(const long long _id, const QString &_token) const
{
qCDebug(LOG_LIB) << "Get task by ID" << _id;
auto task = m_processes->process(_id);
if (!task) {
qCWarning(LOG_LIB) << "Could not find task with ID" << _id;
return task;
}
auto task = m_helper->tryGetTask(_id);
if (!task)
return nullptr;
// check permissions
auto authUser = m_users->user(_token, true);
@ -580,9 +513,10 @@ const QueuedProcess *QueuedCorePrivate::task(const long long _id,
/**
* @fn taskReport
*/
QueuedResult<QList<QVariantHash>>
QueuedCorePrivate::taskReport(const long long _user, const QDateTime &_from,
const QDateTime &_to, const QString &_token) const
QueuedResult<QList<QVariantHash>> QueuedCorePrivate::taskReport(const long long _user,
const QDateTime &_from,
const QDateTime &_to,
const QString &_token) const
{
qCDebug(LOG_LIB) << "Get tasks table by" << _user << _from << _to;
@ -590,8 +524,7 @@ QueuedCorePrivate::taskReport(const long long _user, const QDateTime &_from,
auto authUser = m_users->user(_token, true);
if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return QueuedError("Invalid token",
QueuedEnums::ReturnStatus::InvalidToken);
return QueuedError("Invalid token", QueuedEnums::ReturnStatus::InvalidToken);
}
long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Reports);
@ -600,11 +533,8 @@ QueuedCorePrivate::taskReport(const long long _user, const QDateTime &_from,
effectiveUserId = userAuthId;
} else if (userAuthId != _user) {
if (!isAdmin) {
qCInfo(LOG_LIB)
<< "User" << _token << "not allowed to get task report";
return QueuedError(
"Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
qCInfo(LOG_LIB) << "User" << _token << "not allowed to get task report";
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
}
@ -615,16 +545,13 @@ QueuedCorePrivate::taskReport(const long long _user, const QDateTime &_from,
/**
* @fn user
*/
const QueuedUser *QueuedCorePrivate::user(const long long _id,
const QString &_token) const
const QueuedUser *QueuedCorePrivate::user(const long long _id, const QString &_token) const
{
qCDebug(LOG_LIB) << "Get user by ID" << _id;
auto user = m_users->user(_id);
if (!user) {
qCWarning(LOG_LIB) << "Could not find user with ID" << _id;
return user;
}
auto user = m_helper->tryGetUser(_id);
if (!user)
return nullptr;
// check permissions
auto authUser = m_users->user(_token, true);
@ -649,8 +576,7 @@ const QueuedUser *QueuedCorePrivate::user(const long long _id,
/**
* @fn user
*/
const QueuedUser *QueuedCorePrivate::user(const QString &_name,
const QString &_token) const
const QueuedUser *QueuedCorePrivate::user(const QString &_name, const QString &_token) const
{
qCDebug(LOG_LIB) << "Get user by name" << _name;
@ -668,15 +594,13 @@ QueuedCorePrivate::userReport(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission,
const QString &_token) const
{
qCDebug(LOG_LIB) << "Get users table by" << _lastLogged
<< static_cast<int>(_permission);
qCDebug(LOG_LIB) << "Get users table by" << _lastLogged << static_cast<int>(_permission);
// check permissions
bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Reports);
if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _token << "not allowed to get user report";
return QueuedError("Not allowed",
QueuedEnums::ReturnStatus::InsufficientPermissions);
return QueuedError("Not allowed", QueuedEnums::ReturnStatus::InsufficientPermissions);
}
return m_reports->users(_lastLogged, _permission);

164
sources/queued/src/QueuedCorePrivateHelper.cpp
View File

@ -102,12 +102,10 @@ QueuedUserManager *QueuedCorePrivateHelper::users()
/**
* @fn dropAdminFields
*/
QVariantHash
QueuedCorePrivateHelper::dropAdminFields(const QString &_table,
const QVariantHash &_payload)
QVariantHash QueuedCorePrivateHelper::dropAdminFields(const QString &_table,
const QVariantHash &_payload)
{
qCDebug(LOG_LIB) << "Drop admin fields from" << _payload << "in table"
<< _table;
qCDebug(LOG_LIB) << "Drop admin fields from" << _payload << "in table" << _table;
QVariantHash payload;
for (auto &key : _payload.keys()) {
@ -123,28 +121,25 @@ QueuedCorePrivateHelper::dropAdminFields(const QString &_table,
/**
* @addTaskPrivate
*/
QueuedResult<long long> QueuedCorePrivateHelper::addTaskPrivate(
const QString &_command, const QStringList &_arguments,
const QString &_workingDirectory, const long long _userId, const uint _nice,
const QueuedLimits::Limits &_limits)
QueuedResult<long long>
QueuedCorePrivateHelper::addTaskPrivate(const QString &_command, const QStringList &_arguments,
const QString &_workingDirectory, const long long _userId,
const uint _nice, const QueuedLimits::Limits &_limits)
{
qCDebug(LOG_LIB) << "Add task" << _command << "with arguments" << _arguments
<< "from user" << _userId;
qCDebug(LOG_LIB) << "Add task" << _command << "with arguments" << _arguments << "from user"
<< _userId;
// add to database
auto ids = users()->ids(_userId);
auto userObj = m_core->user(_userId, m_core->m_adminToken);
if (!userObj) {
qCWarning(LOG_LIB) << "Could not find task user" << _userId;
return QueuedError("Invalid token",
QueuedEnums::ReturnStatus::InvalidToken);
return QueuedError("Invalid token", QueuedEnums::ReturnStatus::InvalidToken);
}
auto taskLimits = QueuedLimits::minimalLimits(
_limits, userObj->nativeLimits(),
QueuedLimits::Limits(
advancedSettings()
->get(QueuedConfig::QueuedSettings::DefaultLimits)
.toString()));
advancedSettings()->get(QueuedConfig::QueuedSettings::DefaultLimits).toString()));
QVariantHash properties = {{"user", _userId},
{"command", _command},
{"commandArguments", _arguments},
@ -172,18 +167,17 @@ QueuedResult<long long> QueuedCorePrivateHelper::addTaskPrivate(
/**
* @fn addUserPrivate
*/
QueuedResult<long long> QueuedCorePrivateHelper::addUserPrivate(
const QString &_name, const QString &_email, const QString &_password,
const uint _permissions, const uint _priority,
const QueuedLimits::Limits &_limits)
QueuedResult<long long>
QueuedCorePrivateHelper::addUserPrivate(const QString &_name, const QString &_email,
const QString &_password, const uint _permissions,
const uint _priority, const QueuedLimits::Limits &_limits)
{
qCDebug(LOG_LIB) << "Add user" << _name << "with email" << _email
<< "and permissions" << _permissions;
qCDebug(LOG_LIB) << "Add user" << _name << "with email" << _email << "and permissions"
<< _permissions;
// add to database
QVariantHash properties
= {{"name", _name}, {"password", _password},
{"email", _email}, {"permissions", _permissions},
{"priority", _priority}, {"limits", _limits.toString()}};
QVariantHash properties = {{"name", _name}, {"password", _password},
{"email", _email}, {"permissions", _permissions},
{"priority", _priority}, {"limits", _limits.toString()}};
auto id = database()->add(QueuedDB::USERS_TABLE, properties);
if (id == -1) {
qCWarning(LOG_LIB) << "Could not add user" << _name;
@ -203,9 +197,8 @@ QueuedResult<long long> QueuedCorePrivateHelper::addUserPrivate(
/**
* @fn editOptionPrivate
*/
QueuedResult<bool>
QueuedCorePrivateHelper::editOptionPrivate(const QString &_key,
const QVariant &_value)
QueuedResult<bool> QueuedCorePrivateHelper::editOptionPrivate(const QString &_key,
const QVariant &_value)
{
qCDebug(LOG_LIB) << "Set key" << _key << "to" << _value;
@ -220,8 +213,7 @@ QueuedCorePrivateHelper::editOptionPrivate(const QString &_key,
status = (id != -1);
} else {
status = database()->modify(QueuedDB::SETTINGS_TABLE, id, payload);
qCInfo(LOG_LIB) << "Value for" << _key
<< "has been modified with status" << status;
qCInfo(LOG_LIB) << "Value for" << _key << "has been modified with status" << status;
}
// add to child object
@ -230,8 +222,7 @@ QueuedCorePrivateHelper::editOptionPrivate(const QString &_key,
// notify plugins if required
if (plugins()) {
auto tryPluginOption = plugins()->convertOptionName(_key);
if ((!tryPluginOption.first.isEmpty())
&& (!tryPluginOption.second.isEmpty()))
if ((!tryPluginOption.first.isEmpty()) && (!tryPluginOption.second.isEmpty()))
plugins()->optionChanged(_key, _value);
// notify plugins
emit(plugins()->interface()->onEditOption(_key, _value));
@ -245,16 +236,13 @@ QueuedCorePrivateHelper::editOptionPrivate(const QString &_key,
/**
* @fn editPluginPrivate
*/
QueuedResult<bool>
QueuedCorePrivateHelper::editPluginPrivate(const QString &_plugin,
const bool _add)
QueuedResult<bool> QueuedCorePrivateHelper::editPluginPrivate(const QString &_plugin,
const bool _add)
{
qCDebug(LOG_LIB) << "Edit plugin" << _plugin << "add" << _add;
QStringList pluginList = advancedSettings()
->get(QueuedConfig::QueuedSettings::Plugins)
.toString()
.split('\n');
QStringList pluginList
= advancedSettings()->get(QueuedConfig::QueuedSettings::Plugins).toString().split('\n');
QueuedResult<bool> r;
if (_add && !pluginList.contains(_plugin)) {
@ -270,15 +258,12 @@ QueuedCorePrivateHelper::editPluginPrivate(const QString &_plugin,
r = true;
}
} else {
qCDebug(LOG_LIB) << "Plugin" << _plugin
<< "not loaded or already loaded";
r = QueuedError("Plugin is not loaded or already loaded",
QueuedEnums::ReturnStatus::Error);
qCDebug(LOG_LIB) << "Plugin" << _plugin << "not loaded or already loaded";
r = QueuedError("Plugin is not loaded or already loaded", QueuedEnums::ReturnStatus::Error);
}
if (r.type() == Result::Content::Value) {
editOptionPrivate(advancedSettings()->internalId(
QueuedConfig::QueuedSettings::Plugins),
editOptionPrivate(advancedSettings()->internalId(QueuedConfig::QueuedSettings::Plugins),
pluginList.join('\n'));
// notify plugins
if (plugins()) {
@ -296,9 +281,8 @@ QueuedCorePrivateHelper::editPluginPrivate(const QString &_plugin,
/**
* @fn editTaskPrivate
*/
QueuedResult<bool>
QueuedCorePrivateHelper::editTaskPrivate(QueuedProcess *_process,
const QVariantHash &_taskData)
QueuedResult<bool> QueuedCorePrivateHelper::editTaskPrivate(QueuedProcess *_process,
const QVariantHash &_taskData)
{
qCDebug(LOG_LIB) << "Edit task with ID" << _process->index();
@ -324,33 +308,25 @@ QueuedCorePrivateHelper::editTaskPrivate(QueuedProcess *_process,
/**
* @fn editUserPrivate
*/
QueuedResult<bool>
QueuedCorePrivateHelper::editUserPrivate(const long long _id,
const QVariantHash &_userData)
QueuedResult<bool> QueuedCorePrivateHelper::editUserPrivate(QueuedUser *_user,
const QVariantHash &_userData)
{
qCDebug(LOG_LIB) << "Edit user with ID" << _id;
auto userObj = users()->user(_id);
if (!userObj) {
qCWarning(LOG_LIB) << "Could not find user with ID" << _id;
return QueuedError("User does not exist",
QueuedEnums::ReturnStatus::InvalidArgument);
};
qCDebug(LOG_LIB) << "Edit user with ID" << _user->index();
// modify record in database first
bool status = database()->modify(QueuedDB::USERS_TABLE, _id, _userData);
bool status = database()->modify(QueuedDB::USERS_TABLE, _user->index(), _userData);
if (!status) {
qCWarning(LOG_LIB) << "Could not modify user record" << _id
qCWarning(LOG_LIB) << "Could not modify user record" << _user->index()
<< "in database, do not edit it in memory";
return QueuedError("", QueuedEnums::ReturnStatus::Error);
}
// modify values stored in memory
for (auto &property : _userData.keys())
userObj->setProperty(qPrintable(property), _userData[property]);
_user->setProperty(qPrintable(property), _userData[property]);
// notify plugins
if (plugins())
emit(plugins()->interface()->onEditUser(_id, _userData));
emit(plugins()->interface()->onEditUser(_user->index(), _userData));
return true;
}
@ -360,22 +336,20 @@ QueuedCorePrivateHelper::editUserPrivate(const long long _id,
* @fn editUserPermissionPrivate
*/
QueuedResult<bool> QueuedCorePrivateHelper::editUserPermissionPrivate(
const long long _id, const QueuedEnums::Permission &_permission,
const bool _add)
const long long _id, const QueuedEnums::Permission &_permission, const bool _add)
{
qCDebug(LOG_LIB) << "Edit permissions" << static_cast<int>(_permission)
<< "for user" << _id << "add" << _add;
qCDebug(LOG_LIB) << "Edit permissions" << static_cast<int>(_permission) << "for user" << _id
<< "add" << _add;
auto userObj = users()->user(_id);
if (!userObj) {
qCWarning(LOG_LIB) << "Could not find user with ID" << _id;
return QueuedError("User does not exist",
QueuedEnums::ReturnStatus::InvalidArgument);
return QueuedError("User does not exist", QueuedEnums::ReturnStatus::InvalidArgument);
}
// edit runtime permissions to get value
auto perms = _add ? userObj->addPermission(_permission)
: userObj->removePermission(_permission);
auto perms
= _add ? userObj->addPermission(_permission) : userObj->removePermission(_permission);
auto permissions = static_cast<uint>(perms);
qCInfo(LOG_LIB) << "New user permissions" << perms;
@ -395,3 +369,49 @@ QueuedResult<bool> QueuedCorePrivateHelper::editUserPermissionPrivate(
return true;
}
/**
* @fn tryGetTask
*/
QueuedProcess *QueuedCorePrivateHelper::tryGetTask(const long long _id)
{
qCDebug(LOG_LIB) << "Search for task" << _id;
auto task = processes()->process(_id);
if (!task) {
qCInfo(LOG_LIB) << "Try to get information about task" << _id << "from database";
auto data = database()->get(QueuedDB::TASKS_TABLE, _id);
if (data.isEmpty()) {
qCWarning(LOG_LIB) << "Could not find task with ID" << _id;
return nullptr;
}
auto defs = QueuedProcessManager::parseDefinitions(data);
task = new QueuedProcess(this, defs, _id);
}
return task;
}
/**
* @fn tryGetUser
*/
QueuedUser *QueuedCorePrivateHelper::tryGetUser(const long long _id)
{
auto user = users()->user(_id);
if (!user) {
qCInfo(LOG_LIB) << "Try to get information about user" << _id << "from database";
auto data = database()->get(QueuedDB::USERS_TABLE, _id);
if (data.isEmpty()) {
qCWarning(LOG_LIB) << "Could not find user with ID" << _id;
return nullptr;
}
auto defs = QueuedUserManager::parseDefinitions(data);
user = new QueuedUser(this, defs, _id);
}
return user;
}

66
sources/queued/src/QueuedCorePrivateInitializator.cpp
View File

@ -88,13 +88,12 @@ void QueuedCorePrivate::init(const QString &_configuration)
initReports();
// settings update notifier
m_connections
+= connect(m_advancedSettings,
SIGNAL(valueUpdated(const QueuedConfig::QueuedSettings,
const QString &, const QVariant &)),
this,
SLOT(updateSettings(const QueuedConfig::QueuedSettings,
const QString &, const QVariant &)));
m_connections += connect(
m_advancedSettings,
SIGNAL(valueUpdated(const QueuedConfig::QueuedSettings, const QString &, const QVariant &)),
this,
SLOT(
updateSettings(const QueuedConfig::QueuedSettings, const QString &, const QVariant &)));
// run!
m_processes->start();
@ -107,17 +106,13 @@ void QueuedCorePrivate::init(const QString &_configuration)
void QueuedCorePrivate::initPlugins()
{
QStringList pluginList
= m_advancedSettings->get(QueuedConfig::QueuedSettings::Plugins)
.toString()
.split('\n');
= m_advancedSettings->get(QueuedConfig::QueuedSettings::Plugins).toString().split('\n');
m_plugins = m_helper->initObject(m_plugins, m_adminToken);
for (auto &plugin : pluginList) {
auto settings = pluginSettings(plugin, m_adminToken);
settings.match(
[this, &plugin](const QVariantHash &opts) {
m_plugins->loadPlugin(plugin, opts);
},
[this, &plugin](const QVariantHash &opts) { m_plugins->loadPlugin(plugin, opts); },
[&plugin](const QueuedError &) {
qCWarning(LOG_LIB) << "Could not load settings for" << plugin;
});
@ -132,25 +127,21 @@ void QueuedCorePrivate::initProcesses()
{
// init processes
auto onExitAction = static_cast<QueuedEnums::ExitAction>(
m_advancedSettings->get(QueuedConfig::QueuedSettings::OnExitAction)
.toInt());
m_advancedSettings->get(QueuedConfig::QueuedSettings::OnExitAction).toInt());
m_processes = m_helper->initObject(m_processes);
m_processes->setExitAction(onExitAction);
auto dbProcesses
= m_database->get(QueuedDB::TASKS_TABLE, "WHERE endTime IS NULL");
auto dbProcesses = m_database->get(QueuedDB::TASKS_TABLE, "WHERE endTime IS NULL");
m_processes->loadProcesses(dbProcesses);
m_connections
+= connect(m_processes, &QueuedProcessManager::taskStartTimeReceived,
[this](const long long _index, const QDateTime &_time) {
return updateTaskTime(_index, _time, QDateTime());
});
m_connections
+= connect(m_processes, &QueuedProcessManager::taskStopTimeReceived,
[this](const long long _index, const QDateTime &_time) {
return updateTaskTime(_index, QDateTime(), _time);
});
m_connections += connect(m_processes, &QueuedProcessManager::taskStartTimeReceived,
[this](const long long _index, const QDateTime &_time) {
return updateTaskTime(_index, _time, QDateTime());
});
m_connections += connect(m_processes, &QueuedProcessManager::taskStopTimeReceived,
[this](const long long _index, const QDateTime &_time) {
return updateTaskTime(_index, QDateTime(), _time);
});
}
@ -176,8 +167,8 @@ void QueuedCorePrivate::initSettings(const QString &_configuration)
auto dbSetup = m_settings->db();
m_database = m_helper->initObject(m_database, dbSetup.path, dbSetup.driver);
m_database->close();
bool status = m_database->open(dbSetup.hostname, dbSetup.port,
dbSetup.username, dbSetup.password);
bool status
= m_database->open(dbSetup.hostname, dbSetup.port, dbSetup.username, dbSetup.password);
if (!status) {
QString message = "Could not open database";
qCCritical(LOG_LIB) << message;
@ -192,11 +183,9 @@ void QueuedCorePrivate::initSettings(const QString &_configuration)
m_advancedSettings = m_helper->initObject(m_advancedSettings);
m_advancedSettings->set(m_database->get(QueuedDB::SETTINGS_TABLE));
if (!m_advancedSettings->checkDatabaseVersion()) {
qCInfo(LOG_LIB) << "Bump database version to"
<< QueuedConfig::DATABASE_VERSION;
qCInfo(LOG_LIB) << "Bump database version to" << QueuedConfig::DATABASE_VERSION;
m_helper->editOptionPrivate(
m_advancedSettings->internalId(
QueuedConfig::QueuedSettings::DatabaseVersion),
m_advancedSettings->internalId(QueuedConfig::QueuedSettings::DatabaseVersion),
QueuedConfig::DATABASE_VERSION);
}
@ -212,21 +201,18 @@ void QueuedCorePrivate::initUsers()
{
// load users and tokens
auto expiry
= m_advancedSettings->get(QueuedConfig::QueuedSettings::TokenExpiration)
.toLongLong();
= m_advancedSettings->get(QueuedConfig::QueuedSettings::TokenExpiration).toLongLong();
m_users = m_helper->initObject(m_users);
m_users->setSalt(m_settings->admin().salt);
m_users->setTokenExpiration(expiry);
QString now = QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs);
auto dbTokens = m_database->get(
QueuedDB::TOKENS_TABLE,
QString("WHERE datetime(validUntil) > datetime('%1')").arg(now));
QueuedDB::TOKENS_TABLE, QString("WHERE datetime(validUntil) > datetime('%1')").arg(now));
m_users->loadTokens(dbTokens);
auto dbUsers = m_database->get(QueuedDB::USERS_TABLE);
m_users->loadUsers(dbUsers);
m_connections += connect(
m_users, SIGNAL(userLoggedIn(const long long, const QDateTime &)), this,
SLOT(updateUserLoginTime(const long long, const QDateTime &)));
m_connections += connect(m_users, SIGNAL(userLoggedIn(const long long, const QDateTime &)),
this, SLOT(updateUserLoginTime(const long long, const QDateTime &)));
}

19
sources/queued/src/QueuedCorePrivateSlots.cpp
View File

@ -35,12 +35,11 @@
/**
* @fn updateSettings
*/
void QueuedCorePrivate::updateSettings(const QueuedConfig::QueuedSettings _id,
const QString &_key,
void QueuedCorePrivate::updateSettings(const QueuedConfig::QueuedSettings _id, const QString &_key,
const QVariant &_value)
{
qCDebug(LOG_LIB) << "Received update for" << static_cast<int>(_id) << _key
<< "with value" << _value;
qCDebug(LOG_LIB) << "Received update for" << static_cast<int>(_id) << _key << "with value"
<< _value;
// FIXME probably there is a better way to change settings
switch (_id) {
@ -64,8 +63,7 @@ void QueuedCorePrivate::updateSettings(const QueuedConfig::QueuedSettings _id,
m_databaseManager->setKeepUsers(_value.toLongLong());
break;
case QueuedConfig::QueuedSettings::OnExitAction:
m_processes->setExitAction(
static_cast<QueuedEnums::ExitAction>(_value.toInt()));
m_processes->setExitAction(static_cast<QueuedEnums::ExitAction>(_value.toInt()));
break;
case QueuedConfig::QueuedSettings::Plugins:
// do nothing here
@ -86,12 +84,10 @@ void QueuedCorePrivate::updateSettings(const QueuedConfig::QueuedSettings _id,
/**
* @fn updateTaskTime
*/
void QueuedCorePrivate::updateTaskTime(const long long _id,
const QDateTime &_startTime,
void QueuedCorePrivate::updateTaskTime(const long long _id, const QDateTime &_startTime,
const QDateTime &_endTime)
{
qCDebug(LOG_LIB) << "Update task" << _id << "time to" << _startTime
<< _endTime;
qCDebug(LOG_LIB) << "Update task" << _id << "time to" << _startTime << _endTime;
QVariantHash record;
if (_startTime.isValid()) {
@ -114,8 +110,7 @@ void QueuedCorePrivate::updateTaskTime(const long long _id,
/**
* @fn updateUserLoginTime
*/
void QueuedCorePrivate::updateUserLoginTime(const long long _id,
const QDateTime &_time)
void QueuedCorePrivate::updateUserLoginTime(const long long _id, const QDateTime &_time)
{
qCDebug(LOG_LIB) << "Update user" << _id << "with login time" << _time;

134
sources/queued/src/QueuedDatabase.cpp
View File

@ -33,8 +33,7 @@
/**
* @fn QueuedDatabase
*/
QueuedDatabase::QueuedDatabase(QObject *parent, const QString path,
const QString driver)
QueuedDatabase::QueuedDatabase(QObject *parent, const QString path, const QString driver)
: QObject(parent)
, m_path(path)
{
@ -85,28 +84,23 @@ void QueuedDatabase::close()
/**
* @fn createAdministrator
*/
void QueuedDatabase::createAdministrator(const QString &_user,
const QString &_password)
void QueuedDatabase::createAdministrator(const QString &_user, const QString &_password)
{
qCDebug(LOG_LIB) << "Check for user" << _user;
QSqlQuery query
= m_database.exec(QString("SELECT * FROM '%1' WHERE name='%2'")
.arg(QueuedDB::USERS_TABLE)
.arg(_user));
QSqlQuery query = m_database.exec(
QString("SELECT * FROM '%1' WHERE name='%2'").arg(QueuedDB::USERS_TABLE).arg(_user));
QSqlError error = query.lastError();
if (error.isValid())
qCWarning(LOG_LIB) << "Could not get record" << _user << "from"
<< QueuedDB::USERS_TABLE << "message"
<< error.text();
qCWarning(LOG_LIB) << "Could not get record" << _user << "from" << QueuedDB::USERS_TABLE
<< "message" << error.text();
else if (query.next())
return;
qCInfo(LOG_LIB) << "Create administrator user" << _user;
QVariantHash payload = {
{"name", _user},
{"password", _password},
{"permissions", static_cast<int>(QueuedEnums::Permission::SuperAdmin)}};
QVariantHash payload = {{"name", _user},
{"password", _password},
{"permissions", static_cast<int>(QueuedEnums::Permission::SuperAdmin)}};
if (!add(QueuedDB::USERS_TABLE, payload))
qCCritical(LOG_LIB) << "Could not create administrator";
@ -132,16 +126,14 @@ void QueuedDatabase::createSchema(const QString &_table)
if (columns.contains(column))
continue;
QueuedDB::QueuedDBField field = QueuedDB::DBSchema[_table][column];
QSqlQuery query
= m_database.exec(QString("ALTER TABLE '%1' ADD `%2` %3")
.arg(_table)
.arg(column)
.arg(field.sqlDescription));
QSqlQuery query = m_database.exec(QString("ALTER TABLE '%1' ADD `%2` %3")
.arg(_table)
.arg(column)
.arg(field.sqlDescription));
QSqlError error = query.lastError();
if (error.isValid())
qCCritical(LOG_LIB)
<< "Could not insert column" << column << "to table" << _table
<< "error:" << error.text();
qCCritical(LOG_LIB) << "Could not insert column" << column << "to table" << _table
<< "error:" << error.text();
}
}
@ -154,34 +146,27 @@ void QueuedDatabase::createTable(const QString &_table)
qCDebug(LOG_LIB) << "Create table" << _table;
QSqlQuery query = m_database.exec(
QString("CREATE TABLE '%1' (`_id` INTEGER PRIMARY KEY AUTOINCREMENT)")
.arg(_table));
QString("CREATE TABLE '%1' (`_id` INTEGER PRIMARY KEY AUTOINCREMENT)").arg(_table));
QSqlError error = query.lastError();
if (error.isValid())
qCCritical(LOG_LIB)
<< "Could not create table" << _table << "error:" << error.text();
qCCritical(LOG_LIB) << "Could not create table" << _table << "error:" << error.text();
}
/**
* @fn get
*/
QList<QVariantHash> QueuedDatabase::get(const QString &_table,
const QString &_condition)
QList<QVariantHash> QueuedDatabase::get(const QString &_table, const QString &_condition)
{
qCDebug(LOG_LIB) << "Get records in table" << _table << "with condition"
<< _condition;
qCDebug(LOG_LIB) << "Get records in table" << _table << "with condition" << _condition;
QList<QVariantHash> output;
QSqlQuery query
= m_database.exec(QString("SELECT * FROM '%1' %2 ORDER BY _id ASC")
.arg(_table)
.arg(_condition));
QSqlQuery query = m_database.exec(
QString("SELECT * FROM '%1' %2 ORDER BY _id ASC").arg(_table).arg(_condition));
QSqlError error = query.lastError();
if (error.isValid()) {
qCWarning(LOG_LIB) << "Could not get records from" << _table
<< "message" << error.text();
qCWarning(LOG_LIB) << "Could not get records from" << _table << "message" << error.text();
return output;
}
QSqlRecord record = query.record();
@ -221,18 +206,16 @@ QVariantHash QueuedDatabase::get(const QString &_table, const long long _id)
/**
* @fn open
*/
bool QueuedDatabase::open(const QString &_hostname, const int _port,
const QString &_username, const QString &_password)
bool QueuedDatabase::open(const QString &_hostname, const int _port, const QString &_username,
const QString &_password)
{
qCDebug(LOG_LIB) << "Open database at" << _hostname << _port << "as user"
<< _username;
qCDebug(LOG_LIB) << "Open database at" << _hostname << _port << "as user" << _username;
if (!_hostname.isEmpty())
m_database.setHostName(_hostname);
if (_port > 0)
m_database.setPort(_port);
bool status = _username.isEmpty() ? m_database.open()
: m_database.open(_username, _password);
bool status = _username.isEmpty() ? m_database.open() : m_database.open(_username, _password);
qCDebug(LOG_LIB) << "Open database status" << status;
if (status)
@ -265,8 +248,8 @@ long long QueuedDatabase::add(const QString &_table, const QVariantHash &_value)
.arg(payload.values().join(',')));
QSqlError error = query.lastError();
if (error.isValid()) {
qCCritical(LOG_LIB) << "Could not add record" << _value << "to table"
<< _table << "message" << error.text();
qCCritical(LOG_LIB) << "Could not add record" << _value << "to table" << _table << "message"
<< error.text();
return -1;
}
@ -277,25 +260,21 @@ long long QueuedDatabase::add(const QString &_table, const QVariantHash &_value)
/**
* @fn modify
*/
bool QueuedDatabase::modify(const QString &_table, const long long _id,
const QVariantHash &_value)
bool QueuedDatabase::modify(const QString &_table, const long long _id, const QVariantHash &_value)
{
qCDebug(LOG_LIB) << "Modify record" << _id << "in table" << _table
<< "with value" << _value;
qCDebug(LOG_LIB) << "Modify record" << _id << "in table" << _table << "with value" << _value;
auto payload = getQueryPayload(_table, _value);
QStringList stringPayload;
for (auto &key : payload.keys())
stringPayload.append(QString("%1=%2").arg(key).arg(payload[key]));
// build query
QSqlQuery query = m_database.exec(QString("UPDATE %1 SET %2 WHERE _id=%3")
.arg(_table)
.arg(stringPayload.join(','))
.arg(_id));
QSqlQuery query = m_database.exec(
QString("UPDATE %1 SET %2 WHERE _id=%3").arg(_table).arg(stringPayload.join(',')).arg(_id));
QSqlError error = query.lastError();
if (error.isValid()) {
qCCritical(LOG_LIB) << "Could not modify record" << _value << "in table"
<< _table << "message" << error.text();
qCCritical(LOG_LIB) << "Could not modify record" << _value << "in table" << _table
<< "message" << error.text();
return false;
}
@ -310,12 +289,11 @@ bool QueuedDatabase::remove(const QString &_table, const long long _id)
{
qCDebug(LOG_LIB) << "Remove row" << _id << "from" << _table;
QSqlQuery query = m_database.exec(
QString("DELETE FROM %1 WHERE _id=%2").arg(_table).arg(_id));
QSqlQuery query = m_database.exec(QString("DELETE FROM %1 WHERE _id=%2").arg(_table).arg(_id));
QSqlError error = query.lastError();
if (error.isValid()) {
qCCritical(LOG_LIB) << "Could not remove record" << _id << "in table"
<< _table << "message" << error.text();
qCCritical(LOG_LIB) << "Could not remove record" << _id << "in table" << _table << "message"
<< error.text();
return false;
}
@ -330,10 +308,10 @@ void QueuedDatabase::removeTasks(const QDateTime &_endTime)
{
qCDebug(LOG_LIB) << "Remove all tasks which are older than" << _endTime;
QSqlQuery query = m_database.exec(
QString("DELETE FROM %1 WHERE datetime(endTime) < datetime('%2')")
.arg(QueuedDB::TASKS_TABLE)
.arg(_endTime.toString(Qt::ISODateWithMs)));
QSqlQuery query
= m_database.exec(QString("DELETE FROM %1 WHERE datetime(endTime) < datetime('%2')")
.arg(QueuedDB::TASKS_TABLE)
.arg(_endTime.toString(Qt::ISODateWithMs)));
QSqlError error = query.lastError();
if (error.isValid())
@ -348,10 +326,10 @@ void QueuedDatabase::removeTasks(const QDateTime &_endTime)
void QueuedDatabase::removeTokens()
{
QString now = QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs);
QSqlQuery query = m_database.exec(
QString("DELETE FROM %1 WHERE datetime(validUntil) > datetime('%2')")
.arg(QueuedDB::TOKENS_TABLE)
.arg(now));
QSqlQuery query
= m_database.exec(QString("DELETE FROM %1 WHERE datetime(validUntil) > datetime('%2')")
.arg(QueuedDB::TOKENS_TABLE)
.arg(now));
QSqlError error = query.lastError();
if (error.isValid())
@ -365,13 +343,12 @@ void QueuedDatabase::removeTokens()
*/
void QueuedDatabase::removeUsers(const QDateTime &_lastLogin)
{
qCDebug(LOG_LIB) << "Remove all users which logged older than"
<< _lastLogin;
qCDebug(LOG_LIB) << "Remove all users which logged older than" << _lastLogin;
QSqlQuery query = m_database.exec(
QString("DELETE FROM %1 WHERE datetime(lastLogin) < datetime('%2')")
.arg(QueuedDB::USERS_TABLE)
.arg(_lastLogin.toString(Qt::ISODateWithMs)));
QSqlQuery query
= m_database.exec(QString("DELETE FROM %1 WHERE datetime(lastLogin) < datetime('%2')")
.arg(QueuedDB::USERS_TABLE)
.arg(_lastLogin.toString(Qt::ISODateWithMs)));
QSqlError error = query.lastError();
if (error.isValid())
@ -402,8 +379,7 @@ long long QueuedDatabase::lastInsertionId(const QString &_table) const
{
qCDebug(LOG_LIB) << "Get last row ID from" << _table;
QSqlQuery query
= m_database.exec(QString("SELECT max(_id) FROM '%1'").arg(_table));
QSqlQuery query = m_database.exec(QString("SELECT max(_id) FROM '%1'").arg(_table));
QSqlError error = query.lastError();
if (error.isValid()) {
qCCritical(LOG_LIB) << "Could not get last insertion ID";
@ -421,9 +397,8 @@ long long QueuedDatabase::lastInsertionId(const QString &_table) const
/**
* @fn getQueryPayload
*/
QHash<QString, QString>
QueuedDatabase::getQueryPayload(const QString &_table,
const QVariantHash &_value) const
QHash<QString, QString> QueuedDatabase::getQueryPayload(const QString &_table,
const QVariantHash &_value) const
{
qCDebug(LOG_LIB) << "Add record" << _value << "to table" << _table;
@ -432,8 +407,7 @@ QueuedDatabase::getQueryPayload(const QString &_table,
for (auto &key : _value.keys()) {
// we would check it only if there is data about this table
if (!schemaColumns.isEmpty() && !schemaColumns.contains(key)) {
qCWarning(LOG_LIB)
<< "No key" << key << "found in schema of" << _table;
qCWarning(LOG_LIB) << "No key" << key << "found in schema of" << _table;
continue;
}
if (key == "_id") {

3
sources/queued/src/QueuedDatabaseManager.cpp
View File

@ -30,8 +30,7 @@
/**
* @fn QueuedDatabaseManager
*/
QueuedDatabaseManager::QueuedDatabaseManager(QObject *_parent,
QueuedDatabase *_database)
QueuedDatabaseManager::QueuedDatabaseManager(QObject *_parent, QueuedDatabase *_database)
: QObject(_parent)
, m_database(_database)
{

16
sources/queued/src/QueuedDebug.cpp
View File

@ -90,18 +90,16 @@ QHash<QString, QHash<QString, QString>> QueuedDebug::getBuildMetaData()
// api
{"API",
{
{"DATABASE_VERSION",
QString::number(QueuedConfig::DATABASE_VERSION)},
{"DATABASE_VERSION", QString::number(QueuedConfig::DATABASE_VERSION)},
{"PLUGIN_INTERFACE", QueuedConfig::PLUGIN_INTERFACE},
{"WEBAPI_TOKEN_HEADER", QueuedConfig::WEBAPI_TOKEN_HEADER},
{"WEBAPI_VERSIONS",
std::accumulate(
std::next(std::begin(QueuedConfig::WEBAPI_VERSIONS)),
std::end(QueuedConfig::WEBAPI_VERSIONS),
QString::number(QueuedConfig::WEBAPI_VERSIONS[0]),
[](const QString str, const int version) {
return QString("%1,%2").arg(str).arg(version);
})},
std::accumulate(std::next(std::begin(QueuedConfig::WEBAPI_VERSIONS)),
std::end(QueuedConfig::WEBAPI_VERSIONS),
QString::number(QueuedConfig::WEBAPI_VERSIONS[0]),
[](const QString str, const int version) {
return QString("%1,%2").arg(str).arg(version);
})},
}},
// paths
{"Paths",

17
sources/queued/src/QueuedLimits.cpp
View File

@ -58,20 +58,17 @@ bool QueuedLimits::limitCompare(const long long _first, const long long _second)
/**
* @fn minimalLimits
*/
QueuedLimits::Limits
QueuedLimits::minimalLimits(const QueuedLimits::Limits &_task,
const QueuedLimits::Limits &_user,
const QueuedLimits::Limits &_default)
QueuedLimits::Limits QueuedLimits::minimalLimits(const QueuedLimits::Limits &_task,
const QueuedLimits::Limits &_user,
const QueuedLimits::Limits &_default)
{
QueuedLimits::Limits limits;
limits.cpu = std::min({_task.cpu, _user.cpu, _default.cpu}, &limitCompare);
limits.gpu = std::min({_task.gpu, _user.gpu, _default.gpu}, &limitCompare);
limits.memory = std::min({_task.memory, _user.memory, _default.memory},
&limitCompare);
limits.gpumemory = std::min(
{_task.gpumemory, _user.gpumemory, _default.gpumemory}, &limitCompare);
limits.storage = std::min({_task.storage, _user.storage, _default.storage},
&limitCompare);
limits.memory = std::min({_task.memory, _user.memory, _default.memory}, &limitCompare);
limits.gpumemory
= std::min({_task.gpumemory, _user.gpumemory, _default.gpumemory}, &limitCompare);
limits.storage = std::min({_task.storage, _user.storage, _default.storage}, &limitCompare);
return limits;
}

22
sources/queued/src/QueuedPluginManager.cpp
View File

@ -62,8 +62,7 @@ QueuedPluginManager::~QueuedPluginManager()
/**
* @fn convertOptionName
*/
QPair<QString, QString>
QueuedPluginManager::convertOptionName(const QString &_key)
QPair<QString, QString> QueuedPluginManager::convertOptionName(const QString &_key)
{
qCDebug(LOG_PL) << "Convert option name" << _key;
@ -94,8 +93,7 @@ QueuedPluginManagerInterface *QueuedPluginManager::interface()
/**
* @fn loadPlugin
*/
bool QueuedPluginManager::loadPlugin(const QString &_name,
const QVariantHash &_settings)
bool QueuedPluginManager::loadPlugin(const QString &_name, const QVariantHash &_settings)
{
qCDebug(LOG_PL) << "Load plugin" << _name << "with settings" << _settings;
@ -125,8 +123,8 @@ bool QueuedPluginManager::loadPlugin(const QString &_name,
if (loader.isLoaded())
item = qobject_cast<QueuedPluginInterface *>(plugin);
else
qCCritical(LOG_PL) << "Could not load the library for" << _name
<< "error" << loader.errorString();
qCCritical(LOG_PL) << "Could not load the library for" << _name << "error"
<< loader.errorString();
if (item) {
m_plugins[_name] = item;
item->init(pluginSettings);
@ -143,8 +141,7 @@ bool QueuedPluginManager::loadPlugin(const QString &_name,
}
QueuedPluginSpecification::Plugin
QueuedPluginManager::loadSpecification(const QString &_name)
QueuedPluginSpecification::Plugin QueuedPluginManager::loadSpecification(const QString &_name)
{
qCDebug(LOG_PL) << "Load specification for" << _name;
@ -171,8 +168,7 @@ QueuedPluginManager::loadSpecification(const QString &_name)
*/
QStringList QueuedPluginManager::pluginLocations()
{
QStringList locations = QStandardPaths::standardLocations(
QStandardPaths::GenericDataLocation);
QStringList locations = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation);
for (auto &loc : locations)
loc = QString("%1/%2/%3")
.arg(loc)
@ -205,15 +201,13 @@ bool QueuedPluginManager::unloadPlugin(const QString &_name)
/**
* @fn optionChanged
*/
void QueuedPluginManager::optionChanged(const QString &_key,
const QVariant &_value)
void QueuedPluginManager::optionChanged(const QString &_key, const QVariant &_value)
{
qCDebug(LOG_PL) << "Option" << _key << "changed to" << _value;
auto option = convertOptionName(_key);
if (!m_plugins.contains(option.first)) {
qCWarning(LOG_PL) << "Plugin" << option.first << "not found for"
<< _key;
qCWarning(LOG_PL) << "Plugin" << option.first << "not found for" << _key;
return;
}

8
sources/queued/src/QueuedPluginSpecification.cpp
View File

@ -39,9 +39,8 @@ QVariantHash QueuedPluginSpecification::dumpSpecification(const Plugin &_plugin)
QVariantHash options;
for (auto opt : _plugin.options)
options[opt.name] = QVariantHash({{"default", opt.defaultValue},
{"description", opt.description},
{"type", opt.type}});
options[opt.name] = QVariantHash(
{{"default", opt.defaultValue}, {"description", opt.description}, {"type", opt.type}});
output["options"] = options;
return output;
@ -51,8 +50,7 @@ QVariantHash QueuedPluginSpecification::dumpSpecification(const Plugin &_plugin)
/**
* @fn readSpecification
*/
QueuedPluginSpecification::Plugin
QueuedPluginSpecification::readSpecification(const QString &_path)
QueuedPluginSpecification::Plugin QueuedPluginSpecification::readSpecification(const QString &_path)
{
qCDebug(LOG_PL) << "Read specification from" << _path;

44
sources/queued/src/QueuedProcess.cpp
View File

@ -41,8 +41,7 @@ extern "C" {
/**
* @fn QueuedProcess
*/
QueuedProcess::QueuedProcess(QObject *_parent,
const QueuedProcessDefinitions &definitions,
QueuedProcess::QueuedProcess(QObject *_parent, const QueuedProcessDefinitions &definitions,
const long long index)
: QProcess(_parent)
, m_definitions(definitions)
@ -98,11 +97,9 @@ void QueuedProcess::updateLimits()
{
auto nl = nativeLimits();
m_cgroup->setCpuLimit(
std::llround(QueuedSystemInfo::cpuWeight(nl.cpu) * 100.0));
m_cgroup->setCpuLimit(std::llround(QueuedSystemInfo::cpuWeight(nl.cpu) * 100.0));
m_cgroup->setMemoryLimit(
std::llround(QueuedSystemInfo::memoryWeight(nl.memory)
* QueuedSystemInfo::memoryCount()));
std::llround(QueuedSystemInfo::memoryWeight(nl.memory) * QueuedSystemInfo::memoryCount()));
}
@ -111,27 +108,27 @@ void QueuedProcess::updateLimits()
*/
QList<Q_PID> QueuedProcess::childrenPids() const
{
QStringList allDirectories = QDir("/proc").entryList(
QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);
QStringList allDirectories
= QDir("/proc").entryList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);
QStringList directories = allDirectories.filter(QRegExp("(\\d+)"));
QList<Q_PID> pids = std::accumulate(
directories.cbegin(), directories.cend(), QList<Q_PID>(),
[this](QList<Q_PID> &list, const QString &dir) {
QFile statFile(QString("/proc/%1/stat").arg(dir));
if (!statFile.open(QIODevice::ReadOnly | QIODevice::Text))
return list;
QList<Q_PID> pids
= std::accumulate(directories.cbegin(), directories.cend(), QList<Q_PID>(),
[this](QList<Q_PID> &list, const QString &dir) {
QFile statFile(QString("/proc/%1/stat").arg(dir));
if (!statFile.open(QIODevice::ReadOnly | QIODevice::Text))
return list;
QString output = statFile.readAll();
output.remove(QRegExp("\\d+ \\(.*\\) . "));
Q_PID ppid = output.split(' ').first().toLongLong();
if (ppid == pid())
list.append(dir.toLongLong());
QString output = statFile.readAll();
output.remove(QRegExp("\\d+ \\(.*\\) . "));
Q_PID ppid = output.split(' ').first().toLongLong();
if (ppid == pid())
list.append(dir.toLongLong());
statFile.close();
statFile.close();
return list;
});
return list;
});
return pids;
}
@ -359,8 +356,7 @@ void QueuedProcess::setWorkDirectory(const QString &_workDirectory)
m_definitions.workingDirectory
= _workDirectory.isEmpty()
? QStandardPaths::writableLocation(
QStandardPaths::StandardLocation::TempLocation)
? QStandardPaths::writableLocation(QStandardPaths::StandardLocation::TempLocation)
: _workDirectory;
setLogError("");
setLogOutput("");

73
sources/queued/src/QueuedProcessManager.cpp
View File

@ -78,10 +78,8 @@ QueuedProcessManager::parseDefinitions(const QVariantHash &_properties)
defs.gid = _properties["gid"].toUInt();
defs.user = _properties["user"].toLongLong();
// metadata
defs.startTime = QDateTime::fromString(_properties["startTime"].toString(),
Qt::ISODateWithMs);
defs.endTime = QDateTime::fromString(_properties["endTime"].toString(),
Qt::ISODateWithMs);
defs.startTime = QDateTime::fromString(_properties["startTime"].toString(), Qt::ISODateWithMs);
defs.endTime = QDateTime::fromString(_properties["endTime"].toString(), Qt::ISODateWithMs);
return defs;
}
@ -90,11 +88,9 @@ QueuedProcessManager::parseDefinitions(const QVariantHash &_properties)
/**
* @fn add
*/
QueuedProcess *QueuedProcessManager::add(const QVariantHash &_properties,
const long long _index)
QueuedProcess *QueuedProcessManager::add(const QVariantHash &_properties, const long long _index)
{
qCDebug(LOG_LIB) << "Add new process" << _properties << "with index"
<< _index;
qCDebug(LOG_LIB) << "Add new process" << _properties << "with index" << _index;
return add(parseDefinitions(_properties), _index);
}
@ -103,12 +99,11 @@ QueuedProcess *QueuedProcessManager::add(const QVariantHash &_properties,
/**
* @fn add
*/
QueuedProcess *QueuedProcessManager::add(
const QueuedProcess::QueuedProcessDefinitions &_definitions,
const long long _index)
QueuedProcess *
QueuedProcessManager::add(const QueuedProcess::QueuedProcessDefinitions &_definitions,
const long long _index)
{
qCDebug(LOG_LIB) << "Add new process" << _definitions.command
<< "with index" << _index;
qCDebug(LOG_LIB) << "Add new process" << _definitions.command << "with index" << _index;
if (processes().contains(_index))
return process(_index);
@ -117,9 +112,7 @@ QueuedProcess *QueuedProcessManager::add(
m_processes[_index] = process;
// connect to signal
m_connections[_index] = connect(
process,
static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(
&QProcess::finished),
process, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
[=](const int exitCode, const QProcess::ExitStatus exitStatus) {
return taskFinished(exitCode, exitStatus, _index);
});
@ -199,11 +192,9 @@ void QueuedProcessManager::start()
long long index = -1;
// gather used resources
QueuedLimits::Limits limits = usedLimits();
double weightedCpu
= limits.cpu == 0 ? 0.0 : QueuedSystemInfo::cpuWeight(limits.cpu);
double weightedMemory = limits.memory == 0
? 0.0
: QueuedSystemInfo::memoryWeight(limits.memory);
double weightedCpu = limits.cpu == 0 ? 0.0 : QueuedSystemInfo::cpuWeight(limits.cpu);
double weightedMemory
= limits.memory == 0 ? 0.0 : QueuedSystemInfo::memoryWeight(limits.memory);
auto tasks = processes().values();
for (auto pr : tasks) {
@ -211,10 +202,8 @@ void QueuedProcessManager::start()
if (pr->state() != QProcess::ProcessState::NotRunning)
continue;
// check limits first
if (((1.0 - weightedCpu)
< QueuedSystemInfo::cpuWeight(pr->nativeLimits().cpu))
&& ((1.0 - weightedMemory)
< QueuedSystemInfo::memoryWeight(pr->nativeLimits().memory)))
if (((1.0 - weightedCpu) < QueuedSystemInfo::cpuWeight(pr->nativeLimits().cpu))
&& ((1.0 - weightedMemory) < QueuedSystemInfo::memoryWeight(pr->nativeLimits().memory)))
continue;
// now check nice level
if ((index > -1) && (pr->nice() < process(index)->nice()))
@ -314,28 +303,19 @@ QueuedLimits::Limits QueuedProcessManager::usedLimits()
{
auto tasks = processes().values();
long long cpu = std::accumulate(
tasks.cbegin(), tasks.cend(), 0,
[](long long value, QueuedProcess *process) {
auto limit = process->nativeLimits().cpu == 0
? QueuedSystemInfo::cpuCount()
: process->nativeLimits().cpu;
return process->state() == QProcess::ProcessState::Running
? value + limit
: value;
tasks.cbegin(), tasks.cend(), 0, [](long long value, QueuedProcess *process) {
auto limit = process->nativeLimits().cpu == 0 ? QueuedSystemInfo::cpuCount()
: process->nativeLimits().cpu;
return process->state() == QProcess::ProcessState::Running ? value + limit : value;
});
long long memory = std::accumulate(
tasks.cbegin(), tasks.cend(), 0,
[](long long value, QueuedProcess *process) {
auto limit = process->nativeLimits().memory == 0
? QueuedSystemInfo::memoryCount()
: process->nativeLimits().memory;
return process->state() == QProcess::ProcessState::Running
? value + limit
: value;
tasks.cbegin(), tasks.cend(), 0, [](long long value, QueuedProcess *process) {
auto limit = process->nativeLimits().memory == 0 ? QueuedSystemInfo::memoryCount()
: process->nativeLimits().memory;
return process->state() == QProcess::ProcessState::Running ? value + limit : value;
});
long long storage = std::accumulate(
tasks.cbegin(), tasks.cend(), 0,
[](long long value, QueuedProcess *process) {
tasks.cbegin(), tasks.cend(), 0, [](long long value, QueuedProcess *process) {
return process->state() == QProcess::ProcessState::Running
? value + process->nativeLimits().storage
: value;
@ -348,12 +328,11 @@ QueuedLimits::Limits QueuedProcessManager::usedLimits()
/**
* @fn taskFinished
*/
void QueuedProcessManager::taskFinished(const int _exitCode,
const QProcess::ExitStatus _exitStatus,
void QueuedProcessManager::taskFinished(const int _exitCode, const QProcess::ExitStatus _exitStatus,
const long long _index)
{
qCDebug(LOG_LIB) << "Process" << _index << "finished with code" << _exitCode
<< "and status" << _exitStatus;
qCDebug(LOG_LIB) << "Process" << _index << "finished with code" << _exitCode << "and status"
<< _exitStatus;
auto pr = process(_index);
if (pr) {

55
sources/queued/src/QueuedPropertyInterface.cpp
View File

@ -39,6 +39,10 @@ QueuedPropertyInterface::QueuedPropertyInterface(QueuedCore *parent)
{
qCDebug(LOG_DBUS) << __PRETTY_FUNCTION__;
qRegisterMetaType<QList<Q_PID>>("QList<Q_PID>");
qDBusRegisterMetaType<QList<Q_PID>>();
qRegisterMetaType<QueuedResult<QVariant>>("QueuedResult<QVariant>");
qDBusRegisterMetaType<QueuedResult<QVariant>>();
@ -49,8 +53,7 @@ QueuedPropertyInterface::QueuedPropertyInterface(QueuedCore *parent)
"QueuedPluginSpecification::PluginOption");
qDBusRegisterMetaType<QueuedPluginSpecification::PluginOption>();
qRegisterMetaType<QueuedPluginSpecification::Plugin>(
"QueuedPluginSpecification::Plugin");
qRegisterMetaType<QueuedPluginSpecification::Plugin>("QueuedPluginSpecification::Plugin");
qDBusRegisterMetaType<QueuedPluginSpecification::Plugin>();
qRegisterMetaType<QueuedResult<QueuedPluginSpecification::Plugin>>(
@ -71,8 +74,7 @@ QueuedPropertyInterface::~QueuedPropertyInterface()
/**
* @fn Plugin
*/
QDBusVariant QueuedPropertyInterface::Plugin(const QString &plugin,
const QString &token)
QDBusVariant QueuedPropertyInterface::Plugin(const QString &plugin, const QString &token)
{
qCDebug(LOG_DBUS) << "Get plugin" << plugin;
@ -83,21 +85,18 @@ QDBusVariant QueuedPropertyInterface::Plugin(const QString &plugin,
/**
* @fn PluginOptions
*/
QDBusVariant QueuedPropertyInterface::PluginOptions(const QString &plugin,
const QString &token)
QDBusVariant QueuedPropertyInterface::PluginOptions(const QString &plugin, const QString &token)
{
qCDebug(LOG_DBUS) << "Get plugin options" << plugin;
return QueuedCoreAdaptor::toDBusVariant(
m_core->pluginSettings(plugin, token));
return QueuedCoreAdaptor::toDBusVariant(m_core->pluginSettings(plugin, token));
}
/**
* @fn Option
*/
QDBusVariant QueuedPropertyInterface::Option(const QString &property,
const QString &token)
QDBusVariant QueuedPropertyInterface::Option(const QString &property, const QString &token)
{
qCDebug(LOG_DBUS) << "Get property" << property;
@ -108,8 +107,7 @@ QDBusVariant QueuedPropertyInterface::Option(const QString &property,
/**
* @fn Task
*/
QDBusVariant QueuedPropertyInterface::Task(const long long id,
const QString &property,
QDBusVariant QueuedPropertyInterface::Task(const long long id, const QString &property,
const QString &token)
{
qCDebug(LOG_DBUS) << "Get property" << property << "from task" << id;
@ -118,20 +116,17 @@ QDBusVariant QueuedPropertyInterface::Task(const long long id,
if (!task) {
qCWarning(LOG_DBUS) << "Could not find task" << id;
return QueuedCoreAdaptor::toDBusVariant(QueuedResult<QVariant>(
QueuedError("Task does not exist",
QueuedEnums::ReturnStatus::InvalidArgument)));
QueuedError("Task does not exist", QueuedEnums::ReturnStatus::InvalidArgument)));
}
if (property.isEmpty()) {
auto response = QVariant::fromValue<QVariantHash>(getProperties(task));
return QueuedCoreAdaptor::toDBusVariant(
QueuedResult<QVariant>(response));
return QueuedCoreAdaptor::toDBusVariant(QueuedResult<QVariant>(response));
} else {
auto response = task->property(qPrintable(property));
if (response.type() == QVariant::DateTime)
response = response.toDateTime().toString(Qt::ISODateWithMs);
return QueuedCoreAdaptor::toDBusVariant(
QueuedResult<QVariant>(response));
return QueuedCoreAdaptor::toDBusVariant(QueuedResult<QVariant>(response));
}
}
@ -139,8 +134,7 @@ QDBusVariant QueuedPropertyInterface::Task(const long long id,
/**
* @fn User
*/
QDBusVariant QueuedPropertyInterface::User(const long long id,
const QString &property,
QDBusVariant QueuedPropertyInterface::User(const long long id, const QString &property,
const QString &token)
{
qCDebug(LOG_DBUS) << "Get property" << property << "from user" << id;
@ -149,20 +143,17 @@ QDBusVariant QueuedPropertyInterface::User(const long long id,
if (!user) {
qCWarning(LOG_DBUS) << "Could not find user" << id;
return QueuedCoreAdaptor::toDBusVariant(QueuedResult<QVariant>(
QueuedError("User does not exist",
QueuedEnums::ReturnStatus::InvalidArgument)));
QueuedError("User does not exist", QueuedEnums::ReturnStatus::InvalidArgument)));
}
if (property.isEmpty()) {
auto response = QVariant::fromValue<QVariantHash>(getProperties(user));
return QueuedCoreAdaptor::toDBusVariant(
QueuedResult<QVariant>(response));
return QueuedCoreAdaptor::toDBusVariant(QueuedResult<QVariant>(response));
} else {
auto response = user->property(qPrintable(property));
if (response.type() == QVariant::DateTime)
response = response.toDateTime().toString(Qt::ISODateWithMs);
return QueuedCoreAdaptor::toDBusVariant(
QueuedResult<QVariant>(response));
return QueuedCoreAdaptor::toDBusVariant(QueuedResult<QVariant>(response));
}
}
@ -170,8 +161,7 @@ QDBusVariant QueuedPropertyInterface::User(const long long id,
/**
* @fn UserIdByName
*/
QDBusVariant QueuedPropertyInterface::UserIdByName(const QString &name,
const QString &token)
QDBusVariant QueuedPropertyInterface::UserIdByName(const QString &name, const QString &token)
{
qCDebug(LOG_DBUS) << "Look for user ID" << name;
@ -179,12 +169,10 @@ QDBusVariant QueuedPropertyInterface::UserIdByName(const QString &name,
if (!user) {
qCWarning(LOG_DBUS) << "Could not find user" << name;
return QueuedCoreAdaptor::toDBusVariant(QueuedResult<long long>(
QueuedError("User does not exist",
QueuedEnums::ReturnStatus::InvalidArgument)));
QueuedError("User does not exist", QueuedEnums::ReturnStatus::InvalidArgument)));
}
return QueuedCoreAdaptor::toDBusVariant(
QueuedResult<long long>(user->index()));
return QueuedCoreAdaptor::toDBusVariant(QueuedResult<long long>(user->index()));
}
@ -206,8 +194,7 @@ QVariantHash QueuedPropertyInterface::getProperties(const QObject *_object)
continue;
result[name] = _object->property(name);
if (result[name].type() == QVariant::DateTime)
result[name]
= result[name].toDateTime().toString(Qt::ISODateWithMs);
result[name] = result[name].toDateTime().toString(Qt::ISODateWithMs);
}
return result;

42
sources/queued/src/QueuedReportInterface.cpp
View File

@ -41,12 +41,10 @@ QueuedReportInterface::QueuedReportInterface(QueuedCore *parent)
qRegisterMetaType<QHash<QString, QString>>("QHash<QString, QString>");
qDBusRegisterMetaType<QHash<QString, QString>>();
qRegisterMetaType<QueuedResult<QList<QVariantHash>>>(
"QueuedResult<QList<QVariantHash>>");
qRegisterMetaType<QueuedResult<QList<QVariantHash>>>("QueuedResult<QList<QVariantHash>>");
qDBusRegisterMetaType<QueuedResult<QList<QVariantHash>>>();
qRegisterMetaType<QueuedResult<QueuedStatusMap>>(
"QueuedResult<QueuedStatusMap>");
qRegisterMetaType<QueuedResult<QueuedStatusMap>>("QueuedResult<QueuedStatusMap>");
qDBusRegisterMetaType<QueuedResult<QueuedStatusMap>>();
}
@ -63,15 +61,14 @@ QueuedReportInterface::~QueuedReportInterface()
/**
* @fn Performance
*/
QDBusVariant QueuedReportInterface::Performance(const QString &from,
const QString &to,
QDBusVariant QueuedReportInterface::Performance(const QString &from, const QString &to,
const QString &token)
{
qCDebug(LOG_DBUS) << "Performance report for" << from << to;
return QueuedCoreAdaptor::toDBusVariant(m_core->performanceReport(
QDateTime::fromString(from, Qt::ISODateWithMs),
QDateTime::fromString(to, Qt::ISODateWithMs), token));
return QueuedCoreAdaptor::toDBusVariant(
m_core->performanceReport(QDateTime::fromString(from, Qt::ISODateWithMs),
QDateTime::fromString(to, Qt::ISODateWithMs), token));
}
@ -83,39 +80,34 @@ QDBusVariant QueuedReportInterface::Status()
QueuedResult<QueuedStatusMap> metadata = QueuedDebug::getBuildMetaData();
// append metadata here
return QDBusVariant(
QVariant::fromValue<QueuedResult<QueuedStatusMap>>(metadata));
return QDBusVariant(QVariant::fromValue<QueuedResult<QueuedStatusMap>>(metadata));
}
/**
* @fn Tasks
*/
QDBusVariant QueuedReportInterface::Tasks(const qlonglong user,
const QString &from,
const QString &to,
const QString &token)
QDBusVariant QueuedReportInterface::Tasks(const qlonglong user, const QString &from,
const QString &to, const QString &token)
{
qCDebug(LOG_DBUS) << "Search for tasks" << user << from << to;
return QueuedCoreAdaptor::toDBusVariant(m_core->taskReport(
user, QDateTime::fromString(from, Qt::ISODateWithMs),
QDateTime::fromString(to, Qt::ISODateWithMs), token));
return QueuedCoreAdaptor::toDBusVariant(
m_core->taskReport(user, QDateTime::fromString(from, Qt::ISODateWithMs),
QDateTime::fromString(to, Qt::ISODateWithMs), token));
}
/**
* @fn Users
*/
QDBusVariant QueuedReportInterface::Users(const QString &lastLogged,
const uint permission,
QDBusVariant QueuedReportInterface::Users(const QString &lastLogged, const uint permission,
const QString &token)
{
qCDebug(LOG_DBUS) << "Search for users" << lastLogged << permission;
return QueuedCoreAdaptor::toDBusVariant(
m_core->userReport(QDateTime::fromString(lastLogged, Qt::ISODateWithMs),
permission < 1 ? QueuedEnums::Permission::Invalid
: QueuedEnums::Permission(permission),
token));
return QueuedCoreAdaptor::toDBusVariant(m_core->userReport(
QDateTime::fromString(lastLogged, Qt::ISODateWithMs),
permission < 1 ? QueuedEnums::Permission::Invalid : QueuedEnums::Permission(permission),
token));
}

55
sources/queued/src/QueuedReportManager.cpp
View File

@ -32,8 +32,7 @@
/**
* @fn QueuedReportManager
*/
QueuedReportManager::QueuedReportManager(QObject *_parent,
QueuedDatabase *_database,
QueuedReportManager::QueuedReportManager(QObject *_parent, QueuedDatabase *_database,
const QString &_token)
: QObject(_parent)
, m_database(_database)
@ -72,17 +71,14 @@ QList<QVariantHash> QueuedReportManager::performance(const QueuedCore *_core,
.arg(_to.toString(Qt::ISODateWithMs));
QString condition
= conditions.isEmpty()
? ""
: QString("WHERE (%1)").arg(conditions.join(" AND "));
= conditions.isEmpty() ? "" : QString("WHERE (%1)").arg(conditions.join(" AND "));
qCInfo(LOG_LIB) << "Task condition select" << condition;
auto tasks = m_database->get(QueuedDB::TASKS_TABLE, condition);
// build hash first
QHash<long long, QVariantHash> hashOutput;
for (auto &task : tasks) {
QueuedLimits::Limits limits
= QueuedLimits::Limits(task["limits"].toString());
QueuedLimits::Limits limits = QueuedLimits::Limits(task["limits"].toString());
// update values to system ones if empty
if (limits.cpu == 0)
limits.cpu = QueuedSystemInfo::cpuCount();
@ -90,11 +86,9 @@ QList<QVariantHash> QueuedReportManager::performance(const QueuedCore *_core,
limits.memory = QueuedSystemInfo::memoryCount();
// calculate usage stats
long long taskTime
= QDateTime::fromString(task["endTime"].toString(),
Qt::ISODateWithMs)
= QDateTime::fromString(task["endTime"].toString(), Qt::ISODateWithMs)
.toMSecsSinceEpoch()
- QDateTime::fromString(task["startTime"].toString(),
Qt::ISODateWithMs)
- QDateTime::fromString(task["startTime"].toString(), Qt::ISODateWithMs)
.toMSecsSinceEpoch();
limits *= taskTime / 1000;
@ -102,16 +96,12 @@ QList<QVariantHash> QueuedReportManager::performance(const QueuedCore *_core,
long long userId = task.value("user").toLongLong();
auto userObj = _core->user(userId, m_token);
QVariantHash currentData = hashOutput[userId];
currentData["cpu"]
= currentData.value("cpu", 0).toLongLong() + limits.cpu;
currentData["memory"]
= currentData.value("memory", 0).toLongLong() + limits.memory;
currentData["gpu"]
= currentData.value("gpu", 0).toLongLong() + limits.gpu;
currentData["cpu"] = currentData.value("cpu", 0).toLongLong() + limits.cpu;
currentData["memory"] = currentData.value("memory", 0).toLongLong() + limits.memory;
currentData["gpu"] = currentData.value("gpu", 0).toLongLong() + limits.gpu;
currentData["gpumemory"]
= currentData.value("gpumemory", 0).toLongLong() + limits.gpumemory;
currentData["storage"]
= currentData.value("storage", 0).toLongLong() + limits.storage;
currentData["storage"] = currentData.value("storage", 0).toLongLong() + limits.storage;
currentData["count"] = currentData.value("count", 0).toLongLong() + 1;
// internal fields
currentData["user"] = userObj ? userObj->name() : "";
@ -124,9 +114,7 @@ QList<QVariantHash> QueuedReportManager::performance(const QueuedCore *_core,
// append output data
auto userList = hashOutput.keys();
std::sort(userList.begin(), userList.end(),
[](const long long first, const long long second) {
return first < second;
});
[](const long long first, const long long second) { return first < second; });
QList<QVariantHash> output;
for (auto userId : userList)
output.append(hashOutput[userId]);
@ -138,8 +126,7 @@ QList<QVariantHash> QueuedReportManager::performance(const QueuedCore *_core,
/**
* @fn tasks
*/
QList<QVariantHash> QueuedReportManager::tasks(const long long _user,
const QDateTime &_from,
QList<QVariantHash> QueuedReportManager::tasks(const long long _user, const QDateTime &_from,
const QDateTime &_to) const
{
qCDebug(LOG_LIB) << "Search for tasks in" << _user << _from << _to;
@ -157,9 +144,7 @@ QList<QVariantHash> QueuedReportManager::tasks(const long long _user,
.arg(_to.toString(Qt::ISODateWithMs));
QString condition
= conditions.isEmpty()
? ""
: QString("WHERE (%1)").arg(conditions.join(" AND "));
= conditions.isEmpty() ? "" : QString("WHERE (%1)").arg(conditions.join(" AND "));
qCInfo(LOG_LIB) << "Task condition select" << condition;
return m_database->get(QueuedDB::TASKS_TABLE, condition);
@ -169,12 +154,10 @@ QList<QVariantHash> QueuedReportManager::tasks(const long long _user,
/**
* @fn users
*/
QList<QVariantHash>
QueuedReportManager::users(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission) const
QList<QVariantHash> QueuedReportManager::users(const QDateTime &_lastLogged,
const QueuedEnums::Permission _permission) const
{
qCDebug(LOG_LIB) << "Search for users in" << _lastLogged
<< static_cast<uint>(_permission);
qCDebug(LOG_LIB) << "Search for users in" << _lastLogged << static_cast<uint>(_permission);
QStringList conditions;
if (_lastLogged.isValid())
@ -182,13 +165,11 @@ QueuedReportManager::users(const QDateTime &_lastLogged,
"(lastLogin NOT NULL))")
.arg(_lastLogged.toString(Qt::ISODateWithMs));
if (_permission != QueuedEnums::Permission::Invalid)
conditions += QString("((permissions & ~%1) != permissions)")
.arg(static_cast<uint>(_permission));
conditions
+= QString("((permissions & ~%1) != permissions)").arg(static_cast<uint>(_permission));
QString condition
= conditions.isEmpty()
? ""
: QString("WHERE (%1)").arg(conditions.join(" AND "));
= conditions.isEmpty() ? "" : QString("WHERE (%1)").arg(conditions.join(" AND "));
qCInfo(LOG_LIB) << "User condition select" << condition;
return m_database->get(QueuedDB::USERS_TABLE, condition);

18
sources/queued/src/QueuedSettings.cpp
View File

@ -40,10 +40,8 @@ QueuedSettings::QueuedSettings(QObject *_parent, const QString _path)
{
qCDebug(LOG_LIB) << __PRETTY_FUNCTION__;
qRegisterMetaType<QueuedConfig::QueuedAdminSetup>(
"QueuedConfig::QueuedAdminSetup");
qRegisterMetaType<QueuedConfig::QueuedDBSetup>(
"QueuedConfig::QueuedDBSetup");
qRegisterMetaType<QueuedConfig::QueuedAdminSetup>("QueuedConfig::QueuedAdminSetup");
qRegisterMetaType<QueuedConfig::QueuedDBSetup>("QueuedConfig::QueuedDBSetup");
}
@ -79,8 +77,7 @@ QueuedConfig::QueuedDBSetup QueuedSettings::db() const
*/
QString QueuedSettings::defaultPath()
{
QString fileName
= QStandardPaths::locate(QStandardPaths::ConfigLocation, "queued.ini");
QString fileName = QStandardPaths::locate(QStandardPaths::ConfigLocation, "queued.ini");
qCInfo(LOG_LIB) << "Found configuration file" << fileName;
return fileName;
@ -92,9 +89,9 @@ QString QueuedSettings::defaultPath()
*/
QString QueuedSettings::defaultTokenPath()
{
QString fileName = QString("%1/queued")
.arg(QStandardPaths::writableLocation(
QStandardPaths::GenericCacheLocation));
QString fileName
= QString("%1/queued")
.arg(QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation));
qCInfo(LOG_LIB) << "Cache file location" << fileName;
return fileName;
@ -132,8 +129,7 @@ void QueuedSettings::readConfiguration()
m_cfgDB.password = settings.value("Password").toString();
// get standard path for temporary files
QString defaultDB = QString("%1/queued.db")
.arg(QStandardPaths::writableLocation(
QStandardPaths::TempLocation));
.arg(QStandardPaths::writableLocation(QStandardPaths::TempLocation));
m_cfgDB.path = settings.value("Path", defaultDB).toString();
m_cfgDB.port = settings.value("Port").toInt();
m_cfgDB.username = settings.value("Username").toString();

3
sources/queued/src/QueuedSystemInfo.cpp
View File

@ -74,8 +74,7 @@ double QueuedSystemInfo::memoryWeight(const long long _memory)
qCDebug(LOG_LIB) << "Get memory weight for" << _memory;
if ((_memory > 0) && (_memory < memoryCount()))
return static_cast<double>(_memory)
/ static_cast<double>(memoryCount());
return static_cast<double>(_memory) / static_cast<double>(memoryCount());
else
return 1.0;
}

28
sources/queued/src/QueuedTokenManager.cpp
View File

@ -55,8 +55,7 @@ QString QueuedTokenManager::isTokenValid(const QString &_token) const
{
qCDebug(LOG_LIB) << "Check token on validity" << _token;
if (m_tokens.contains(_token)
&& (tokenExpiration(_token) > QDateTime::currentDateTimeUtc()))
if (m_tokens.contains(_token) && (tokenExpiration(_token) > QDateTime::currentDateTimeUtc()))
return m_tokens[_token].user;
else
return "";
@ -66,18 +65,16 @@ QString QueuedTokenManager::isTokenValid(const QString &_token) const
/**
* @brief loadToken
*/
void QueuedTokenManager::loadToken(
const QueuedTokenManager::QueuedTokenDefinitions &_definitions)
void QueuedTokenManager::loadToken(const QueuedTokenManager::QueuedTokenDefinitions &_definitions)
{
qCDebug(LOG_LIB) << "Add token for user" << _definitions.user
<< "valid until" << _definitions.validUntil;
qCDebug(LOG_LIB) << "Add token for user" << _definitions.user << "valid until"
<< _definitions.validUntil;
m_tokens[_definitions.token] = _definitions;
// register expiry timer
std::chrono::milliseconds duration(
_definitions.validUntil.toMSecsSinceEpoch()
- QDateTime::currentDateTimeUtc().toMSecsSinceEpoch());
std::chrono::milliseconds duration(_definitions.validUntil.toMSecsSinceEpoch()
- QDateTime::currentDateTimeUtc().toMSecsSinceEpoch());
QTimer timer;
timer.setSingleShot(true);
timer.setInterval(duration);
@ -94,10 +91,9 @@ void QueuedTokenManager::loadTokens(const QList<QVariantHash> &_values)
qCDebug(LOG_LIB) << "Set values from" << _values;
for (auto &token : _values) {
QDateTime validUntil = QDateTime::fromString(
token["validUntil"].toString(), Qt::ISODateWithMs);
loadToken(
{token["token"].toString(), token["user"].toString(), validUntil});
QDateTime validUntil
= QDateTime::fromString(token["validUntil"].toString(), Qt::ISODateWithMs);
loadToken({token["token"].toString(), token["user"].toString(), validUntil});
}
}
@ -105,13 +101,11 @@ void QueuedTokenManager::loadTokens(const QList<QVariantHash> &_values)
/**
* @fn registerToken
*/
QString QueuedTokenManager::registerToken(const QString &_user,
const QDateTime &_validUntil)
QString QueuedTokenManager::registerToken(const QString &_user, const QDateTime &_validUntil)
{
// generate from uuid
QString token = QUuid::createUuid().toString().remove('{').remove('}');
qCInfo(LOG_LIB) << "Registered token" << token << "valid until"
<< _validUntil;
qCInfo(LOG_LIB) << "Registered token" << token << "valid until" << _validUntil;
// append to internal storage
loadToken({token, _user, _validUntil});

33
sources/queued/src/QueuedUser.cpp
View File

@ -36,8 +36,7 @@ extern "C" {
/**
* @fn QueuedUser
*/
QueuedUser::QueuedUser(QObject *_parent,
const QueuedUserDefinitions &definitions,
QueuedUser::QueuedUser(QObject *_parent, const QueuedUserDefinitions &definitions,
const long long index)
: QObject(_parent)
, m_definitions(definitions)
@ -61,14 +60,11 @@ QueuedUser::~QueuedUser()
/**
* @fn addPermissions
*/
QueuedEnums::Permissions
QueuedUser::addPermission(const QueuedEnums::Permission _permission)
QueuedEnums::Permissions QueuedUser::addPermission(const QueuedEnums::Permission _permission)
{
qCDebug(LOG_LIB) << "Add user permission" << static_cast<uint>(_permission);
setPermissions(
static_cast<QueuedEnums::Permissions>(m_definitions.permissions)
| _permission);
setPermissions(static_cast<QueuedEnums::Permissions>(m_definitions.permissions) | _permission);
return static_cast<QueuedEnums::Permissions>(m_definitions.permissions);
}
@ -77,11 +73,9 @@ QueuedUser::addPermission(const QueuedEnums::Permission _permission)
/**
* @fn hashFromPassword
*/
QString QueuedUser::hashFromPassword(const QString &_password,
const QString &_salt)
QString QueuedUser::hashFromPassword(const QString &_password, const QString &_salt)
{
return QCryptographicHash::hash(_salt.toUtf8() + _password.toUtf8(),
QCryptographicHash::Sha512)
return QCryptographicHash::hash(_salt.toUtf8() + _password.toUtf8(), QCryptographicHash::Sha512)
.toHex();
}
@ -121,24 +115,19 @@ QPair<uint, uint> QueuedUser::ids()
/**
* @fn isPasswordValid
*/
bool QueuedUser::isPasswordValid(const QString &_password,
const QString &_salt) const
bool QueuedUser::isPasswordValid(const QString &_password, const QString &_salt) const
{
return (m_definitions.password.toUtf8()
== hashFromPassword(_password, _salt));
return (m_definitions.password.toUtf8() == hashFromPassword(_password, _salt));
}
QueuedEnums::Permissions
QueuedUser::removePermission(const QueuedEnums::Permission _permission)
QueuedEnums::Permissions QueuedUser::removePermission(const QueuedEnums::Permission _permission)
{
qCDebug(LOG_LIB) << "Remove user permission"
<< static_cast<uint>(_permission);
qCDebug(LOG_LIB) << "Remove user permission" << static_cast<uint>(_permission);
if (hasPermission(_permission))
setPermissions(
static_cast<QueuedEnums::Permissions>(m_definitions.permissions)
^ _permission);
setPermissions(static_cast<QueuedEnums::Permissions>(m_definitions.permissions)
^ _permission);
return static_cast<QueuedEnums::Permissions>(m_definitions.permissions);
}

35
sources/queued/src/QueuedUserManager.cpp
View File

@ -53,12 +53,12 @@ QueuedUserManager::~QueuedUserManager()
/**
* @fn add
* @fn parseDefinitions
*/
QueuedUser *QueuedUserManager::add(const QVariantHash &_properties,
const long long _id)
QueuedUser::QueuedUserDefinitions
QueuedUserManager::parseDefinitions(const QVariantHash &_properties)
{
qCDebug(LOG_LIB) << "Add user" << _properties << "with ID" << _id;
qCDebug(LOG_LIB) << "Parse definitions from" << _properties;
QueuedUser::QueuedUserDefinitions defs;
defs.name = _properties["name"].toString();
@ -68,16 +68,26 @@ QueuedUser *QueuedUserManager::add(const QVariantHash &_properties,
defs.priority = _properties["priority"].toUInt();
defs.limits = _properties["limits"].toString();
return add(defs, _id);
return defs;
}
/**
* @fn add
*/
QueuedUser *
QueuedUserManager::add(const QueuedUser::QueuedUserDefinitions &_definitions,
const long long _id)
QueuedUser *QueuedUserManager::add(const QVariantHash &_properties, const long long _id)
{
qCDebug(LOG_LIB) << "Add user" << _properties << "with ID" << _id;
return add(parseDefinitions(_properties), _id);
}
/**
* @fn add
*/
QueuedUser *QueuedUserManager::add(const QueuedUser::QueuedUserDefinitions &_definitions,
const long long _id)
{
qCDebug(LOG_LIB) << "Add user" << _definitions.name << "with ID" << _id;
@ -110,8 +120,7 @@ QString QueuedUserManager::authorize(const QString &_user)
/**
* @fn authorize
*/
QString QueuedUserManager::authorize(const QString &_user,
const QString &_password)
QString QueuedUserManager::authorize(const QString &_user, const QString &_password)
{
qCDebug(LOG_LIB) << "Authorize user" << _user;
@ -137,8 +146,7 @@ QString QueuedUserManager::authorize(const QString &_user,
/**
* @fn authorize
*/
bool QueuedUserManager::authorize(const QString &_token,
const QueuedEnums::Permission _service)
bool QueuedUserManager::authorize(const QString &_token, const QueuedEnums::Permission _service)
{
qCDebug(LOG_LIB) << "Authorize user for" << static_cast<int>(_service);
@ -161,8 +169,7 @@ bool QueuedUserManager::authorize(const QString &_token,
/**
* @fn checkToken
*/
QDateTime QueuedUserManager::checkToken(const QString &_token,
bool *_valid) const
QDateTime QueuedUserManager::checkToken(const QString &_token, bool *_valid) const
{
if (_valid) {
QString user = m_tokens->isTokenValid(_token);

9
sources/queuedctl/src/QueuedctlAuth.cpp
View File

@ -23,8 +23,7 @@
#include "QueuedctlUser.h"
QueuedctlCommon::QueuedctlResult QueuedctlAuth::auth(const QString &_user,
const QString &_cache)
QueuedctlCommon::QueuedctlResult QueuedctlAuth::auth(const QString &_user, const QString &_cache)
{
qCDebug(LOG_APP) << "Auth as user" << _user;
@ -47,8 +46,7 @@ QueuedctlCommon::QueuedctlResult QueuedctlAuth::auth(const QString &_user,
QString QueuedctlAuth::getToken(const QString &_cache, const QString &_user)
{
qCDebug(LOG_APP) << "Get token using cache" << _cache << "and user"
<< _user;
qCDebug(LOG_APP) << "Get token using cache" << _cache << "and user" << _user;
QString tokenId = token(_user, _cache);
if (tryAuth(tokenId)) {
@ -63,8 +61,7 @@ QString QueuedctlAuth::getToken(const QString &_cache, const QString &_user)
void QueuedctlAuth::parser(QCommandLineParser &_parser) {}
void QueuedctlAuth::setToken(const QString &_token, const QString &_user,
const QString &_cache)
void QueuedctlAuth::setToken(const QString &_token, const QString &_user, const QString &_cache)
{
qCDebug(LOG_APP) << "Save token to" << _cache << "from user" << _user;

6
sources/queuedctl/src/QueuedctlAuth.h
View File

@ -24,12 +24,10 @@
namespace QueuedctlAuth
{
QueuedctlCommon::QueuedctlResult auth(const QString &_user,
const QString &_cache);
QueuedctlCommon::QueuedctlResult auth(const QString &_user, const QString &_cache);
QString getToken(const QString &_cache, const QString &_user);
void parser(QCommandLineParser &_parser);
void setToken(const QString &_token, const QString &_user,
const QString &_cache);
void setToken(const QString &_token, const QString &_user, const QString &_cache);
QString token(const QString &_user, const QString &_cache);
bool tryAuth(const QString &_token);
};

80
sources/queuedctl/src/QueuedctlCommon.cpp
View File

@ -48,15 +48,13 @@ QString QueuedctlCommon::commandsHelp()
commands.sort();
for (auto &cmd : commands)
// align like default help message
cmdList += QString(" %1%2").arg(cmd, -21).arg(
QueuedctlArguments[cmd].description);
cmdList += QString(" %1%2").arg(cmd, -21).arg(QueuedctlArguments[cmd].description);
return cmdList.join('\n');
}
QString QueuedctlCommon::hashHashToString(
const QHash<QString, QHash<QString, QString>> &_hash)
QString QueuedctlCommon::hashHashToString(const QHash<QString, QHash<QString, QString>> &_hash)
{
qCDebug(LOG_APP) << "Convert hash to string" << _hash;
@ -84,8 +82,7 @@ QString QueuedctlCommon::hashToString(const QVariantHash &_hash)
QStringList keys = _hash.keys();
keys.sort();
for (auto &key : keys)
output += QString("%1: %2").arg(key).arg(
_hash[key].toString().replace('\n', ' '));
output += QString("%1: %2").arg(key).arg(_hash[key].toString().replace('\n', ' '));
return output.join('\n');
}
@ -106,10 +103,9 @@ QString QueuedctlCommon::hashListToString(const QList<QVariantHash> &_list)
// append rows
for (auto &hash : _list) {
QStringList row;
std::for_each(header.cbegin(), header.cend(),
[&hash, &row](const QString &column) {
row += hash[column].toString().replace('\n', ' ');
});
std::for_each(header.cbegin(), header.cend(), [&hash, &row](const QString &column) {
row += hash[column].toString().replace('\n', ' ');
});
output += row.join(',');
}
@ -117,18 +113,15 @@ QString QueuedctlCommon::hashListToString(const QList<QVariantHash> &_list)
}
void QueuedctlCommon::preprocess(const QStringList &_args,
QCommandLineParser &_parser)
void QueuedctlCommon::preprocess(const QStringList &_args, QCommandLineParser &_parser)
{
qCDebug(LOG_APP) << "Preprocess command" << _args;
QString command = _args.isEmpty() ? "" : _args.first();
// HACK: workaround to show valid help message
auto id = QueuedctlArguments.contains(command)
? QueuedctlArguments[command].id
: QueuedctlArgument::Invalid;
_parser.addPositionalArgument(id == QueuedctlArgument::Invalid ? "command"
: command,
auto id = QueuedctlArguments.contains(command) ? QueuedctlArguments[command].id
: QueuedctlArgument::Invalid;
_parser.addPositionalArgument(id == QueuedctlArgument::Invalid ? "command" : command,
"Command to execute.");
if (command.isEmpty())
@ -206,8 +199,7 @@ void QueuedctlCommon::print(const QueuedctlResult &_result)
QueuedctlCommon::QueuedctlResult
QueuedctlCommon::process(QCommandLineParser &_parser, const QString &_cache,
const QString &_user)
QueuedctlCommon::process(QCommandLineParser &_parser, const QString &_cache, const QString &_user)
{
qCDebug(LOG_APP) << "Process command with args"
<< "using auth" << _cache << _user;
@ -216,14 +208,11 @@ QueuedctlCommon::process(QCommandLineParser &_parser, const QString &_cache,
QStringList args = _parser.positionalArguments();
QString command = args.isEmpty() ? "" : args.first();
auto id = QueuedctlArguments.contains(command)
? QueuedctlArguments[command].id
: QueuedctlArgument::Invalid;
auto id = QueuedctlArguments.contains(command) ? QueuedctlArguments[command].id
: QueuedctlArgument::Invalid;
checkArgs(args, QueuedctlArguments[command].positionalArgsCount, _parser);
QString token = (id == QueuedctlArgument::Auth)
? ""
: QueuedctlAuth::getToken(_cache, _user);
QString token = (id == QueuedctlArgument::Auth) ? "" : QueuedctlAuth::getToken(_cache, _user);
switch (id) {
case QueuedctlArgument::Auth: {
@ -241,10 +230,9 @@ QueuedctlCommon::process(QCommandLineParser &_parser, const QString &_cache,
case QueuedctlArgument::PermissionAdd: {
auto userIdRes = QueuedCoreAdaptor::getUserId(args.at(1), token);
long long userId = -1;
userIdRes.match([&userId](const long long val) { userId = val; },
[&result](const QueuedError &err) {
result.output = err.message().c_str();
});
userIdRes.match(
[&userId](const long long val) { userId = val; },
[&result](const QueuedError &err) { result.output = err.message().c_str(); });
if (userId == -1)
break;
result = QueuedctlPermissions::addPermission(userId, args.at(2), token);
@ -253,14 +241,12 @@ QueuedctlCommon::process(QCommandLineParser &_parser, const QString &_cache,
case QueuedctlArgument::PermissionRemove: {
auto userIdRes = QueuedCoreAdaptor::getUserId(args.at(1), token);
long long userId = -1;
userIdRes.match([&userId](const long long val) { userId = val; },
[&result](const QueuedError &err) {
result.output = err.message().c_str();
});
userIdRes.match(
[&userId](const long long val) { userId = val; },
[&result](const QueuedError &err) { result.output = err.message().c_str(); });
if (userId == -1)
break;
result
= QueuedctlPermissions::removePermission(userId, args.at(2), token);
result = QueuedctlPermissions::removePermission(userId, args.at(2), token);
break;
}
case QueuedctlArgument::PluginAdd: {
@ -294,9 +280,7 @@ QueuedctlCommon::process(QCommandLineParser &_parser, const QString &_cache,
result.status = true;
result.output = hashHashToString(val);
},
[&result](const QueuedError &err) {
result.output = err.message().c_str();
});
[&result](const QueuedError &err) { result.output = err.message().c_str(); });
break;
}
case QueuedctlArgument::TaskAdd: {
@ -305,8 +289,7 @@ QueuedctlCommon::process(QCommandLineParser &_parser, const QString &_cache,
break;
}
case QueuedctlArgument::TaskGet: {
result = QueuedctlTask::getTask(args.at(1).toLongLong(), args.at(2),
token);
result = QueuedctlTask::getTask(args.at(1).toLongLong(), args.at(2), token);
break;
}
case QueuedctlArgument::TaskList: {
@ -315,8 +298,7 @@ QueuedctlCommon::process(QCommandLineParser &_parser, const QString &_cache,
}
case QueuedctlArgument::TaskSet: {
auto definitions = QueuedctlTask::getDefinitions(_parser, true, token);
result = QueuedctlTask::setTask(args.at(1).toLongLong(), definitions,
token);
result = QueuedctlTask::setTask(args.at(1).toLongLong(), definitions, token);
break;
}
case QueuedctlArgument::TaskStart: {
@ -335,10 +317,9 @@ QueuedctlCommon::process(QCommandLineParser &_parser, const QString &_cache,
case QueuedctlArgument::UserGet: {
auto userIdRes = QueuedCoreAdaptor::getUserId(args.at(1), token);
long long userId = -1;
userIdRes.match([&userId](const long long val) { userId = val; },
[&result](const QueuedError &err) {
result.output = err.message().c_str();
});
userIdRes.match(
[&userId](const long long val) { userId = val; },
[&result](const QueuedError &err) { result.output = err.message().c_str(); });
if (userId == -1)
break;
result = QueuedctlUser::getUser(userId, args.at(2), token);
@ -351,10 +332,9 @@ QueuedctlCommon::process(QCommandLineParser &_parser, const QString &_cache,
case QueuedctlArgument::UserSet: {
auto userIdRes = QueuedCoreAdaptor::getUserId(args.at(1), token);
long long userId = -1;
userIdRes.match([&userId](const long long val) { userId = val; },
[&result](const QueuedError &err) {
result.output = err.message().c_str();
});
userIdRes.match(
[&userId](const long long val) { userId = val; },
[&result](const QueuedError &err) { result.output = err.message().c_str(); });
if (userId == -1)
break;
auto definitions = QueuedctlUser::getDefinitions(_parser, true);

58
sources/queuedctl/src/QueuedctlCommon.h
View File

@ -57,46 +57,38 @@ typedef struct {
QString description;
int positionalArgsCount;
} QueuedctlArgumentInfo;
const QHash<QString, QueuedctlArgumentInfo> QueuedctlArguments = {
{"auth", {QueuedctlArgument::Auth, "Gets new auth token.", 1}},
{"option-get", {QueuedctlArgument::OptionGet, "Gets option value.", 2}},
{"option-set", {QueuedctlArgument::OptionSet, "Sets option value.", 3}},
{"perm-add",
{QueuedctlArgument::PermissionAdd, "Sets user permission.", 3}},
{"perm-remove",
{QueuedctlArgument::PermissionRemove, "Removes user permission.", 3}},
{"plugin",
{QueuedctlArgument::PluginSpecification, "Get plugin description.", 2}},
{"plugin-add", {QueuedctlArgument::PluginAdd, "Adds plugin to load.", 2}},
{"plugin-list",
{QueuedctlArgument::PluginList, "Shows enabled plugins.", 1}},
{"plugin-options",
{QueuedctlArgument::PluginOptions, "Get plugin options.", 2}},
{"plugin-remove",
{QueuedctlArgument::PluginRemove, "Removes plugin to load.", 2}},
{"report", {QueuedctlArgument::Report, "Shows usage report.", 1}},
{"status", {QueuedctlArgument::Status, "Server status.", 1}},
{"task-add", {QueuedctlArgument::TaskAdd, "Adds new task.", 2}},
{"task-get", {QueuedctlArgument::TaskGet, "Gets task properties.", 3}},
{"task-list", {QueuedctlArgument::TaskList, "Gets tasks list.", 1}},
{"task-set", {QueuedctlArgument::TaskSet, "Sets task properties.", 2}},
{"task-start", {QueuedctlArgument::TaskStart, "Starts task.", 2}},
{"task-stop", {QueuedctlArgument::TaskStop, "Stops task.", 2}},
{"user-add", {QueuedctlArgument::UserAdd, "Adds new user.", 2}},
{"user-get", {QueuedctlArgument::UserGet, "Gets user properties.", 3}},
{"user-list", {QueuedctlArgument::UserList, "Gets users list.", 1}},
{"user-set", {QueuedctlArgument::UserSet, "Sets user properties.", 2}}};
const QHash<QString, QueuedctlArgumentInfo> QueuedctlArguments
= {{"auth", {QueuedctlArgument::Auth, "Gets new auth token.", 1}},
{"option-get", {QueuedctlArgument::OptionGet, "Gets option value.", 2}},
{"option-set", {QueuedctlArgument::OptionSet, "Sets option value.", 3}},
{"perm-add", {QueuedctlArgument::PermissionAdd, "Sets user permission.", 3}},
{"perm-remove", {QueuedctlArgument::PermissionRemove, "Removes user permission.", 3}},
{"plugin", {QueuedctlArgument::PluginSpecification, "Get plugin description.", 2}},
{"plugin-add", {QueuedctlArgument::PluginAdd, "Adds plugin to load.", 2}},
{"plugin-list", {QueuedctlArgument::PluginList, "Shows enabled plugins.", 1}},
{"plugin-options", {QueuedctlArgument::PluginOptions, "Get plugin options.", 2}},
{"plugin-remove", {QueuedctlArgument::PluginRemove, "Removes plugin to load.", 2}},
{"report", {QueuedctlArgument::Report, "Shows usage report.", 1}},
{"status", {QueuedctlArgument::Status, "Server status.", 1}},
{"task-add", {QueuedctlArgument::TaskAdd, "Adds new task.", 2}},
{"task-get", {QueuedctlArgument::TaskGet, "Gets task properties.", 3}},
{"task-list", {QueuedctlArgument::TaskList, "Gets tasks list.", 1}},
{"task-set", {QueuedctlArgument::TaskSet, "Sets task properties.", 2}},
{"task-start", {QueuedctlArgument::TaskStart, "Starts task.", 2}},
{"task-stop", {QueuedctlArgument::TaskStop, "Stops task.", 2}},
{"user-add", {QueuedctlArgument::UserAdd, "Adds new user.", 2}},
{"user-get", {QueuedctlArgument::UserGet, "Gets user properties.", 3}},
{"user-list", {QueuedctlArgument::UserList, "Gets users list.", 1}},
{"user-set", {QueuedctlArgument::UserSet, "Sets user properties.", 2}}};
// methods
void checkArgs(const QStringList &_args, const int _count,
QCommandLineParser &_parser);
void checkArgs(const QStringList &_args, const int _count, QCommandLineParser &_parser);
QString commandsHelp();
QString hashHashToString(const QHash<QString, QHash<QString, QString>> &_hash);
QString hashToString(const QVariantHash &_hash);
QString hashListToString(const QList<QVariantHash> &_list);
void preprocess(const QStringList &_args, QCommandLineParser &_parser);
void print(const QueuedctlResult &_result);
QueuedctlResult process(QCommandLineParser &_parser, const QString &_cache,
const QString &_user);
QueuedctlResult process(QCommandLineParser &_parser, const QString &_cache, const QString &_user);
};

15
sources/queuedctl/src/QueuedctlOption.cpp
View File

@ -21,24 +21,21 @@
QueuedctlCommon::QueuedctlResult
QueuedctlOption::editOption(const QString &_option, const QVariant &_value,
const QString &_token)
QueuedctlOption::editOption(const QString &_option, const QVariant &_value, const QString &_token)
{
qCDebug(LOG_APP) << "Edit option" << _option << "to" << _value;
QueuedctlCommon::QueuedctlResult output;
auto res = QueuedCoreAdaptor::sendOptionEdit(_option, _value, _token);
res.match([&output](const bool val) { output.status = val; },
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
QueuedctlCommon::QueuedctlResult
QueuedctlOption::getOption(const QString &_option, const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlOption::getOption(const QString &_option,
const QString &_token)
{
qCDebug(LOG_APP) << "Get option" << _option;
@ -49,9 +46,7 @@ QueuedctlOption::getOption(const QString &_option, const QString &_token)
output.status = val.isValid();
output.output = QString("%1: %2").arg(_option, val.toString());
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}

6
sources/queuedctl/src/QueuedctlOption.h
View File

@ -24,11 +24,9 @@
namespace QueuedctlOption
{
QueuedctlCommon::QueuedctlResult editOption(const QString &_option,
const QVariant &_value,
QueuedctlCommon::QueuedctlResult editOption(const QString &_option, const QVariant &_value,
const QString &_token);
QueuedctlCommon::QueuedctlResult getOption(const QString &_option,
const QString &_token);
QueuedctlCommon::QueuedctlResult getOption(const QString &_option, const QString &_token);
void parserGet(QCommandLineParser &_parser);
void parserSet(QCommandLineParser &_parser);
};

27
sources/queuedctl/src/QueuedctlPermissions.cpp
View File

@ -20,8 +20,9 @@
#include <queued/Queued.h>
QueuedctlCommon::QueuedctlResult QueuedctlPermissions::addPermission(
const long long _id, const QString &_permission, const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlPermissions::addPermission(const long long _id,
const QString &_permission,
const QString &_token)
{
qCDebug(LOG_APP) << "Add permission" << _permission << "to" << _id;
@ -31,20 +32,18 @@ QueuedctlCommon::QueuedctlResult QueuedctlPermissions::addPermission(
if (permission == QueuedEnums::Permission::Invalid) {
output.output = "Invalid permission";
} else {
auto res
= QueuedCoreAdaptor::sendUserPermissionAdd(_id, permission, _token);
auto res = QueuedCoreAdaptor::sendUserPermissionAdd(_id, permission, _token);
res.match([&output](const bool val) { output.status = val; },
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
}
return output;
}
QueuedctlCommon::QueuedctlResult QueuedctlPermissions::removePermission(
const long long _id, const QString &_permission, const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlPermissions::removePermission(const long long _id,
const QString &_permission,
const QString &_token)
{
qCDebug(LOG_APP) << "Remove permission" << _permission << "to" << _id;
@ -54,12 +53,9 @@ QueuedctlCommon::QueuedctlResult QueuedctlPermissions::removePermission(
if (permission == QueuedEnums::Permission::Invalid) {
output.output = "Invalid permission";
} else {
auto res = QueuedCoreAdaptor::sendUserPermissionRemove(_id, permission,
_token);
auto res = QueuedCoreAdaptor::sendUserPermissionRemove(_id, permission, _token);
res.match([&output](const bool val) { output.status = val; },
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
}
return output;
@ -69,6 +65,5 @@ QueuedctlCommon::QueuedctlResult QueuedctlPermissions::removePermission(
void QueuedctlPermissions::parser(QCommandLineParser &_parser)
{
_parser.addPositionalArgument("user", "User ID.", "<user>");
_parser.addPositionalArgument("permission", "Permission name.",
"<permission>");
_parser.addPositionalArgument("permission", "Permission name.", "<permission>");
}

6
sources/queuedctl/src/QueuedctlPermissions.h
View File

@ -24,11 +24,9 @@
namespace QueuedctlPermissions
{
QueuedctlCommon::QueuedctlResult addPermission(const long long _id,
const QString &_permission,
QueuedctlCommon::QueuedctlResult addPermission(const long long _id, const QString &_permission,
const QString &_token);
QueuedctlCommon::QueuedctlResult removePermission(const long long _id,
const QString &_permission,
QueuedctlCommon::QueuedctlResult removePermission(const long long _id, const QString &_permission,
const QString &_token);
void parser(QCommandLineParser &_parser);
};

43
sources/queuedctl/src/QueuedctlPlugins.cpp
View File

@ -20,8 +20,8 @@
#include <queued/Queued.h>
QueuedctlCommon::QueuedctlResult
QueuedctlPlugins::addPlugin(const QString &_plugin, const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlPlugins::addPlugin(const QString &_plugin,
const QString &_token)
{
qCDebug(LOG_APP) << "Add plugin" << _plugin;
@ -29,16 +29,14 @@ QueuedctlPlugins::addPlugin(const QString &_plugin, const QString &_token)
QueuedctlCommon::QueuedctlResult output;
res.match([&output](const bool val) { output.status = val; },
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
QueuedctlCommon::QueuedctlResult
QueuedctlPlugins::getPlugin(const QString &_plugin, const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlPlugins::getPlugin(const QString &_plugin,
const QString &_token)
{
qCDebug(LOG_APP) << "Get plugin" << _plugin;
@ -57,24 +55,20 @@ QueuedctlPlugins::getPlugin(const QString &_plugin, const QString &_token)
text += QString(" %1").arg(opt.name);
text += QString(" description: %1").arg(opt.description);
text += QString(" type: %1").arg(opt.type);
text += QString(" default: %1")
.arg(opt.defaultValue.toString());
text += QString(" default: %1").arg(opt.defaultValue.toString());
}
output.status = true;
output.output = text.join('\n');
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
QueuedctlCommon::QueuedctlResult
QueuedctlPlugins::getPluginOptions(const QString &_plugin,
const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlPlugins::getPluginOptions(const QString &_plugin,
const QString &_token)
{
qCDebug(LOG_APP) << "Get plugin options" << _plugin;
@ -86,9 +80,7 @@ QueuedctlPlugins::getPluginOptions(const QString &_plugin,
output.status = true;
output.output = QueuedctlCommon::hashToString(val);
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
@ -96,8 +88,7 @@ QueuedctlPlugins::getPluginOptions(const QString &_plugin,
QueuedctlCommon::QueuedctlResult QueuedctlPlugins::listPlugins()
{
auto res = QueuedCoreAdaptor::getOption(
QueuedConfig::QueuedSettings::Plugins, "");
auto res = QueuedCoreAdaptor::getOption(QueuedConfig::QueuedSettings::Plugins, "");
QueuedctlCommon::QueuedctlResult output;
res.match(
@ -105,16 +96,14 @@ QueuedctlCommon::QueuedctlResult QueuedctlPlugins::listPlugins()
output.status = val.isValid();
output.output = val.toString();
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
QueuedctlCommon::QueuedctlResult
QueuedctlPlugins::removePlugin(const QString &_plugin, const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlPlugins::removePlugin(const QString &_plugin,
const QString &_token)
{
qCDebug(LOG_APP) << "Remove plugin" << _plugin;
@ -122,9 +111,7 @@ QueuedctlPlugins::removePlugin(const QString &_plugin, const QString &_token)
QueuedctlCommon::QueuedctlResult output;
res.match([&output](const bool val) { output.status = val; },
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}

12
sources/queuedctl/src/QueuedctlPlugins.h
View File

@ -24,15 +24,11 @@
namespace QueuedctlPlugins
{
QueuedctlCommon::QueuedctlResult addPlugin(const QString &_plugin,
const QString &_token);
QueuedctlCommon::QueuedctlResult getPlugin(const QString &_plugin,
const QString &_token);
QueuedctlCommon::QueuedctlResult getPluginOptions(const QString &_plugin,
const QString &_token);
QueuedctlCommon::QueuedctlResult addPlugin(const QString &_plugin, const QString &_token);
QueuedctlCommon::QueuedctlResult getPlugin(const QString &_plugin, const QString &_token);
QueuedctlCommon::QueuedctlResult getPluginOptions(const QString &_plugin, const QString &_token);
QueuedctlCommon::QueuedctlResult listPlugins();
QueuedctlCommon::QueuedctlResult removePlugin(const QString &_plugin,
const QString &_token);
QueuedctlCommon::QueuedctlResult removePlugin(const QString &_plugin, const QString &_token);
void parser(QCommandLineParser &_parser);
};

161
sources/queuedctl/src/QueuedctlTask.cpp
View File

@ -26,9 +26,9 @@ extern "C" {
}
QueuedctlCommon::QueuedctlResult QueuedctlTask::addTask(
const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token)
QueuedctlCommon::QueuedctlResult
QueuedctlTask::addTask(const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token)
{
qCDebug(LOG_APP) << "Add task" << _definitions.command;
@ -40,25 +40,21 @@ QueuedctlCommon::QueuedctlResult QueuedctlTask::addTask(
output.status = (val > 0);
output.output = QString::number(val);
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
QueuedProcess::QueuedProcessDefinitions
QueuedctlTask::getDefinitions(const QCommandLineParser &_parser,
const bool _expandAll, const QString &_token)
QueuedctlTask::getDefinitions(const QCommandLineParser &_parser, const bool _expandAll,
const QString &_token)
{
qCDebug(LOG_APP) << "Parse task definitions from parser, expand all"
<< _expandAll;
qCDebug(LOG_APP) << "Parse task definitions from parser, expand all" << _expandAll;
QueuedProcess::QueuedProcessDefinitions definitions;
std::for_each(_parser.values("argument").cbegin(),
_parser.values("argument").cend(),
std::for_each(_parser.values("argument").cbegin(), _parser.values("argument").cend(),
[&definitions](const QString &arg) {
if (!arg.isEmpty())
definitions.arguments += arg;
@ -68,37 +64,29 @@ QueuedctlTask::getDefinitions(const QCommandLineParser &_parser,
if (_parser.value("task-user").isEmpty()) {
definitions.user = 0;
} else {
auto res
= QueuedCoreAdaptor::getUserId(_parser.value("task-user"), _token);
res.match(
[&definitions](const long long val) { definitions.user = val; },
[&definitions](const QueuedError &) { definitions.user = 0; });
auto res = QueuedCoreAdaptor::getUserId(_parser.value("task-user"), _token);
res.match([&definitions](const long long val) { definitions.user = val; },
[&definitions](const QueuedError &) { definitions.user = 0; });
}
definitions.workingDirectory
= QFileInfo(_parser.value("directory")).absoluteFilePath();
definitions.workingDirectory = QFileInfo(_parser.value("directory")).absoluteFilePath();
// limits now
QueuedLimits::Limits limits(
_parser.value("limit-cpu").toLongLong(),
_parser.value("limit-gpu").toLongLong(),
QueuedLimits::convertMemory(_parser.value("limit-memory")),
QueuedLimits::convertMemory(_parser.value("limit-gpumemory")),
QueuedLimits::convertMemory(_parser.value("limit-storage")));
QueuedLimits::Limits limits(_parser.value("limit-cpu").toLongLong(),
_parser.value("limit-gpu").toLongLong(),
QueuedLimits::convertMemory(_parser.value("limit-memory")),
QueuedLimits::convertMemory(_parser.value("limit-gpumemory")),
QueuedLimits::convertMemory(_parser.value("limit-storage")));
definitions.limits = limits.toString();
// all options
if (_expandAll) {
definitions.command
= QFileInfo(_parser.value("program")).absoluteFilePath();
definitions.endTime
= QDateTime::fromString(_parser.value("stop"), Qt::ISODateWithMs);
definitions.command = QFileInfo(_parser.value("program")).absoluteFilePath();
definitions.endTime = QDateTime::fromString(_parser.value("stop"), Qt::ISODateWithMs);
definitions.gid = _parser.value("gid").toUInt();
definitions.startTime
= QDateTime::fromString(_parser.value("start"), Qt::ISODateWithMs);
definitions.startTime = QDateTime::fromString(_parser.value("start"), Qt::ISODateWithMs);
definitions.uid = _parser.value("uid").toUInt();
} else {
// queuedctl -- task-add /path/to/application
definitions.command
= QFileInfo(_parser.positionalArguments().at(1)).absoluteFilePath();
definitions.command = QFileInfo(_parser.positionalArguments().at(1)).absoluteFilePath();
}
return definitions;
@ -106,8 +94,7 @@ QueuedctlTask::getDefinitions(const QCommandLineParser &_parser,
QueuedctlCommon::QueuedctlResult
QueuedctlTask::getTask(const long long _id, const QString &_property,
const QString &_token)
QueuedctlTask::getTask(const long long _id, const QString &_property, const QString &_token)
{
qCDebug(LOG_APP) << "Get property" << _property << "from task" << _id;
@ -120,9 +107,7 @@ QueuedctlTask::getTask(const long long _id, const QString &_property,
output.status = true;
output.output = QueuedctlCommon::hashToString(val);
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
} else {
auto res = QueuedCoreAdaptor::getTask(_id, _property);
res.match(
@ -130,30 +115,24 @@ QueuedctlTask::getTask(const long long _id, const QString &_property,
output.status = val.isValid();
output.output = val.toString();
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
}
return output;
}
QueuedctlCommon::QueuedctlResult
QueuedctlTask::getTasks(const QCommandLineParser &_parser,
const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlTask::getTasks(const QCommandLineParser &_parser,
const QString &_token)
{
long long userId = -1;
if (!_parser.value("task-user").isEmpty()) {
auto res
= QueuedCoreAdaptor::getUserId(_parser.value("task-user"), _token);
auto res = QueuedCoreAdaptor::getUserId(_parser.value("task-user"), _token);
res.match([&userId](const long long val) { userId = val; },
[&userId](const QueuedError &) {});
}
QDateTime stop
= QDateTime::fromString(_parser.value("stop"), Qt::ISODateWithMs);
QDateTime start
= QDateTime::fromString(_parser.value("start"), Qt::ISODateWithMs);
QDateTime stop = QDateTime::fromString(_parser.value("stop"), Qt::ISODateWithMs);
QDateTime start = QDateTime::fromString(_parser.value("start"), Qt::ISODateWithMs);
QueuedctlCommon::QueuedctlResult output;
@ -163,9 +142,7 @@ QueuedctlTask::getTasks(const QCommandLineParser &_parser,
output.status = true;
output.output = QueuedctlCommon::hashListToString(val);
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
@ -176,40 +153,33 @@ void QueuedctlTask::parserAdd(QCommandLineParser &_parser)
_parser.addPositionalArgument("program", "Command line.", "<program>");
// command line arguments
QCommandLineOption argumentOption({"a", "argument"},
"Command line argument.", "argument", "");
QCommandLineOption argumentOption({"a", "argument"}, "Command line argument.", "argument", "");
_parser.addOption(argumentOption);
// working directory
QCommandLineOption directoryOption("directory",
"Command working directory.",
"directory", QDir::currentPath());
QCommandLineOption directoryOption("directory", "Command working directory.", "directory",
QDir::currentPath());
_parser.addOption(directoryOption);
// user
QCommandLineOption userOption("task-user", "Task user.", "task-user",
::getlogin());
QCommandLineOption userOption("task-user", "Task user.", "task-user", ::getlogin());
_parser.addOption(userOption);
// nice
QCommandLineOption niceOption("nice", "Task nice level.", "nice", "0");
_parser.addOption(niceOption);
// cpu limit
QCommandLineOption cpuOption("limit-cpu", "Task CPU limit.", "limit-cpu",
"0");
QCommandLineOption cpuOption("limit-cpu", "Task CPU limit.", "limit-cpu", "0");
_parser.addOption(cpuOption);
// gpu limit
QCommandLineOption gpuOption("limit-gpu", "Task GPU limit.", "limit-gpu",
"0");
QCommandLineOption gpuOption("limit-gpu", "Task GPU limit.", "limit-gpu", "0");
_parser.addOption(gpuOption);
// memory limit
QCommandLineOption memoryOption("limit-memory", "Task memory limit.",
"limit-memory", "0");
QCommandLineOption memoryOption("limit-memory", "Task memory limit.", "limit-memory", "0");
_parser.addOption(memoryOption);
// gpu memory limit
QCommandLineOption gpumemoryOption(
"limit-gpumemory", "Task GPU memory limit.", "limit-gpumemory", "0");
QCommandLineOption gpumemoryOption("limit-gpumemory", "Task GPU memory limit.",
"limit-gpumemory", "0");
_parser.addOption(gpumemoryOption);
// storage limit
QCommandLineOption storageOption("limit-storage", "Task storage limit.",
"limit-storage", "0");
QCommandLineOption storageOption("limit-storage", "Task storage limit.", "limit-storage", "0");
_parser.addOption(storageOption);
}
@ -217,8 +187,7 @@ void QueuedctlTask::parserAdd(QCommandLineParser &_parser)
void QueuedctlTask::parserGet(QCommandLineParser &_parser)
{
_parser.addPositionalArgument("id", "Task ID.", "<id>");
_parser.addPositionalArgument("property", "Task property name.",
"<property>");
_parser.addPositionalArgument("property", "Task property name.", "<property>");
}
@ -241,16 +210,13 @@ void QueuedctlTask::parserSet(QCommandLineParser &_parser)
_parser.addPositionalArgument("id", "Task ID.", "<id>");
// command line
QCommandLineOption commandOption({"p", "program"}, "Command line.",
"program", "");
QCommandLineOption commandOption({"p", "program"}, "Command line.", "program", "");
_parser.addOption(commandOption);
// command line arguments
QCommandLineOption argumentOption({"a", "argument"},
"Command line argument.", "argument", "");
QCommandLineOption argumentOption({"a", "argument"}, "Command line argument.", "argument", "");
_parser.addOption(argumentOption);
// working directory
QCommandLineOption directoryOption(
"directory", "Command working directory.", "directory", "");
QCommandLineOption directoryOption("directory", "Command working directory.", "directory", "");
_parser.addOption(directoryOption);
// user
QCommandLineOption userOption("task-user", "Task user.", "task-user", "");
@ -271,24 +237,20 @@ void QueuedctlTask::parserSet(QCommandLineParser &_parser)
QCommandLineOption stopOption("stop", "Task stop time.", "stop", "");
_parser.addOption(stopOption);
// cpu limit
QCommandLineOption cpuOption("limit-cpu", "Task CPU limit.", "limit-cpu",
"-1");
QCommandLineOption cpuOption("limit-cpu", "Task CPU limit.", "limit-cpu", "-1");
_parser.addOption(cpuOption);
// gpu limit
QCommandLineOption gpuOption("limit-gpu", "Task GPU limit.", "limit-gpu",
"-1");
QCommandLineOption gpuOption("limit-gpu", "Task GPU limit.", "limit-gpu", "-1");
_parser.addOption(gpuOption);
// memory limit
QCommandLineOption memoryOption("limit-memory", "Task memory limit.",
"limit-memory", "-1");
QCommandLineOption memoryOption("limit-memory", "Task memory limit.", "limit-memory", "-1");
_parser.addOption(memoryOption);
// gpu memory limit
QCommandLineOption gpumemoryOption(
"limit-gpumemory", "Task GPU memory limit.", "limit-gpumemory", "-1");
QCommandLineOption gpumemoryOption("limit-gpumemory", "Task GPU memory limit.",
"limit-gpumemory", "-1");
_parser.addOption(gpumemoryOption);
// storage limit
QCommandLineOption storageOption("limit-storage", "Task storage limit.",
"limit-storage", "-1");
QCommandLineOption storageOption("limit-storage", "Task storage limit.", "limit-storage", "-1");
_parser.addOption(storageOption);
}
@ -299,10 +261,10 @@ void QueuedctlTask::parserStart(QCommandLineParser &_parser)
}
QueuedctlCommon::QueuedctlResult QueuedctlTask::setTask(
const long long _id,
const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token)
QueuedctlCommon::QueuedctlResult
QueuedctlTask::setTask(const long long _id,
const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token)
{
qCDebug(LOG_APP) << "Edit task" << _id;
@ -310,9 +272,7 @@ QueuedctlCommon::QueuedctlResult QueuedctlTask::setTask(
QueuedctlCommon::QueuedctlResult output;
res.match([&output](const bool val) { output.status = val; },
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
@ -327,16 +287,13 @@ QueuedctlCommon::QueuedctlResult QueuedctlTask::startTask(const long long _id,
QueuedctlCommon::QueuedctlResult output;
res.match([&output](const bool val) { output.status = val; },
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
QueuedctlCommon::QueuedctlResult QueuedctlTask::stopTask(const long long _id,
const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlTask::stopTask(const long long _id, const QString &_token)
{
qCDebug(LOG_APP) << "Stop task" << _id;
@ -344,9 +301,7 @@ QueuedctlCommon::QueuedctlResult QueuedctlTask::stopTask(const long long _id,
QueuedctlCommon::QueuedctlResult output;
res.match([&output](const bool val) { output.status = val; },
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}

22
sources/queuedctl/src/QueuedctlTask.h
View File

@ -27,28 +27,22 @@
namespace QueuedctlTask
{
QueuedctlCommon::QueuedctlResult
addTask(const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token);
addTask(const QueuedProcess::QueuedProcessDefinitions &_definitions, const QString &_token);
QueuedProcess::QueuedProcessDefinitions
getDefinitions(const QCommandLineParser &_parser, const bool _expandAll,
const QString &_token);
QueuedctlCommon::QueuedctlResult
getTask(const long long _id, const QString &_property, const QString &_token);
QueuedctlCommon::QueuedctlResult getTasks(const QCommandLineParser &_parser,
const QString &_token);
getDefinitions(const QCommandLineParser &_parser, const bool _expandAll, const QString &_token);
QueuedctlCommon::QueuedctlResult getTask(const long long _id, const QString &_property,
const QString &_token);
QueuedctlCommon::QueuedctlResult getTasks(const QCommandLineParser &_parser, const QString &_token);
void parserAdd(QCommandLineParser &_parser);
void parserGet(QCommandLineParser &_parser);
void parserList(QCommandLineParser &_parser);
void parserSet(QCommandLineParser &_parser);
void parserStart(QCommandLineParser &_parser);
QueuedctlCommon::QueuedctlResult
setTask(const long long _id,
const QueuedProcess::QueuedProcessDefinitions &_definitions,
setTask(const long long _id, const QueuedProcess::QueuedProcessDefinitions &_definitions,
const QString &_token);
QueuedctlCommon::QueuedctlResult startTask(const long long _id,
const QString &_token);
QueuedctlCommon::QueuedctlResult stopTask(const long long _id,
const QString &_token);
QueuedctlCommon::QueuedctlResult startTask(const long long _id, const QString &_token);
QueuedctlCommon::QueuedctlResult stopTask(const long long _id, const QString &_token);
};

147
sources/queuedctl/src/QueuedctlUser.cpp
View File

@ -29,8 +29,7 @@ extern "C" {
QueuedctlCommon::QueuedctlResult
QueuedctlUser::addUser(const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token)
QueuedctlUser::addUser(const QueuedUser::QueuedUserDefinitions &_definitions, const QString &_token)
{
qCDebug(LOG_APP) << "Add user" << _definitions.name;
@ -42,24 +41,19 @@ QueuedctlUser::addUser(const QueuedUser::QueuedUserDefinitions &_definitions,
output.status = (val > 0);
output.output = QString::number(val);
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
QueuedctlCommon::QueuedctlResult
QueuedctlUser::getReport(const QCommandLineParser &_parser,
const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlUser::getReport(const QCommandLineParser &_parser,
const QString &_token)
{
qCDebug(LOG_APP) << "Get usage report";
QDateTime stop
= QDateTime::fromString(_parser.value("stop"), Qt::ISODateWithMs);
QDateTime start
= QDateTime::fromString(_parser.value("start"), Qt::ISODateWithMs);
QDateTime stop = QDateTime::fromString(_parser.value("stop"), Qt::ISODateWithMs);
QDateTime start = QDateTime::fromString(_parser.value("start"), Qt::ISODateWithMs);
auto res = QueuedCoreAdaptor::getPerformance(start, stop, _token);
@ -69,41 +63,34 @@ QueuedctlUser::getReport(const QCommandLineParser &_parser,
output.status = true;
output.output = QueuedctlCommon::hashListToString(val);
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
QueuedUser::QueuedUserDefinitions
QueuedctlUser::getDefinitions(const QCommandLineParser &_parser,
const bool _expandAll)
QueuedUser::QueuedUserDefinitions QueuedctlUser::getDefinitions(const QCommandLineParser &_parser,
const bool _expandAll)
{
qCDebug(LOG_APP) << "Parse user definitions from parser, expand all"
<< _expandAll;
qCDebug(LOG_APP) << "Parse user definitions from parser, expand all" << _expandAll;
QueuedUser::QueuedUserDefinitions definitions;
// define password first
definitions.password = _parser.isSet("stdin-password")
? getPassword()
: _parser.value("password");
definitions.password
= _parser.isSet("stdin-password") ? getPassword() : _parser.value("password");
auto res = QueuedCoreAdaptor::sendPasswordHash(definitions.password);
res.match(
[&definitions](const QString &val) { definitions.password = val; },
[&definitions](const QueuedError &) { definitions.password = ""; });
res.match([&definitions](const QString &val) { definitions.password = val; },
[&definitions](const QueuedError &) { definitions.password = ""; });
definitions.email = _parser.value("email");
definitions.priority = _parser.value("priority").toUInt();
// limits now
QueuedLimits::Limits limits(
_parser.value("limit-cpu").toLongLong(),
_parser.value("limit-gpu").toLongLong(),
QueuedLimits::convertMemory(_parser.value("limit-memory")),
QueuedLimits::convertMemory(_parser.value("limit-gpumemory")),
QueuedLimits::convertMemory(_parser.value("limit-storage")));
QueuedLimits::Limits limits(_parser.value("limit-cpu").toLongLong(),
_parser.value("limit-gpu").toLongLong(),
QueuedLimits::convertMemory(_parser.value("limit-memory")),
QueuedLimits::convertMemory(_parser.value("limit-gpumemory")),
QueuedLimits::convertMemory(_parser.value("limit-storage")));
definitions.limits = limits.toString();
// all options
@ -137,8 +124,7 @@ QString QueuedctlUser::getPassword()
QueuedctlCommon::QueuedctlResult
QueuedctlUser::getUser(const long long _id, const QString &_property,
const QString &_token)
QueuedctlUser::getUser(const long long _id, const QString &_property, const QString &_token)
{
qCDebug(LOG_APP) << "Get property" << _property << "from user" << _id;
@ -151,9 +137,7 @@ QueuedctlUser::getUser(const long long _id, const QString &_property,
output.status = true;
output.output = QueuedctlCommon::hashToString(val);
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
} else {
auto res = QueuedCoreAdaptor::getUser(_id, _property);
res.match(
@ -161,25 +145,20 @@ QueuedctlUser::getUser(const long long _id, const QString &_property,
output.status = val.isValid();
output.output = val.toString();
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
}
return output;
}
QueuedctlCommon::QueuedctlResult
QueuedctlUser::getUsers(const QCommandLineParser &_parser,
const QString &_token)
QueuedctlCommon::QueuedctlResult QueuedctlUser::getUsers(const QCommandLineParser &_parser,
const QString &_token)
{
QDateTime lastLogin = QDateTime::fromString(_parser.value("last-logged"),
Qt::ISODateWithMs);
auto permission
= _parser.value("access").isEmpty()
? QueuedEnums::Permission::Invalid
: QueuedEnums::Permission(_parser.value("access").toInt());
QDateTime lastLogin = QDateTime::fromString(_parser.value("last-logged"), Qt::ISODateWithMs);
auto permission = _parser.value("access").isEmpty()
? QueuedEnums::Permission::Invalid
: QueuedEnums::Permission(_parser.value("access").toInt());
auto res = QueuedCoreAdaptor::getUsers(lastLogin, permission, _token);
@ -189,9 +168,7 @@ QueuedctlUser::getUsers(const QCommandLineParser &_parser,
output.status = true;
output.output = QueuedctlCommon::hashListToString(val);
},
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}
@ -202,43 +179,35 @@ void QueuedctlUser::parserAdd(QCommandLineParser &_parser)
_parser.addPositionalArgument("name", "User name.", "<name>");
// permissions
QCommandLineOption accessOption({"a", "access"}, "User permission.",
"access", "0");
QCommandLineOption accessOption({"a", "access"}, "User permission.", "access", "0");
_parser.addOption(accessOption);
// email
QCommandLineOption emailOption({"e", "email"}, "User email.", "email", "");
_parser.addOption(emailOption);
// priority
QCommandLineOption priorityOption({"p", "priority"}, "User priority.",
"priority", "0");
QCommandLineOption priorityOption({"p", "priority"}, "User priority.", "priority", "0");
_parser.addOption(priorityOption);
// password
QCommandLineOption passwordOption("password", "User password.", "password",
"");
QCommandLineOption passwordOption("password", "User password.", "password", "");
_parser.addOption(passwordOption);
// password
QCommandLineOption stdinPasswordOption("stdin-password",
"User password from stdin.");
QCommandLineOption stdinPasswordOption("stdin-password", "User password from stdin.");
_parser.addOption(stdinPasswordOption);
// cpu limit
QCommandLineOption cpuOption("limit-cpu", "User CPU limit.", "limit-cpu",
"0");
QCommandLineOption cpuOption("limit-cpu", "User CPU limit.", "limit-cpu", "0");
_parser.addOption(cpuOption);
// gpu limit
QCommandLineOption gpuOption("limit-gpu", "User GPU limit.", "limit-gpu",
"0");
QCommandLineOption gpuOption("limit-gpu", "User GPU limit.", "limit-gpu", "0");
_parser.addOption(gpuOption);
// memory limit
QCommandLineOption memoryOption("limit-memory", "User memory limit.",
"limit-memory", "0");
QCommandLineOption memoryOption("limit-memory", "User memory limit.", "limit-memory", "0");
_parser.addOption(memoryOption);
// gpu memory limit
QCommandLineOption gpumemoryOption(
"limit-gpumemory", "User GPU memory limit.", "limit-gpumemory", "0");
QCommandLineOption gpumemoryOption("limit-gpumemory", "User GPU memory limit.",
"limit-gpumemory", "0");
_parser.addOption(gpumemoryOption);
// storage limit
QCommandLineOption storageOption("limit-storage", "User storage limit.",
"limit-storage", "0");
QCommandLineOption storageOption("limit-storage", "User storage limit.", "limit-storage", "0");
_parser.addOption(storageOption);
}
@ -246,16 +215,14 @@ void QueuedctlUser::parserAdd(QCommandLineParser &_parser)
void QueuedctlUser::parserGet(QCommandLineParser &_parser)
{
_parser.addPositionalArgument("id", "User ID.", "<id>");
_parser.addPositionalArgument("property", "User property name.",
"<property>");
_parser.addPositionalArgument("property", "User property name.", "<property>");
}
void QueuedctlUser::parserList(QCommandLineParser &_parser)
{
// last logged in
QCommandLineOption loggedOption("last-logged", "User last logged time.",
"last-logged", "");
QCommandLineOption loggedOption("last-logged", "User last logged time.", "last-logged", "");
_parser.addOption(loggedOption);
// permissions
QCommandLineOption accessOption("access", "User permission.", "access", "");
@ -285,43 +252,35 @@ void QueuedctlUser::parserSet(QCommandLineParser &_parser)
QCommandLineOption nameOption({"n", "name"}, "User name.", "name", "");
_parser.addOption(nameOption);
// priority
QCommandLineOption priorityOption({"p", "priority"}, "User priority.",
"priority", "0");
QCommandLineOption priorityOption({"p", "priority"}, "User priority.", "priority", "0");
_parser.addOption(priorityOption);
// password
QCommandLineOption passwordOption("password", "User password.", "password",
"");
QCommandLineOption passwordOption("password", "User password.", "password", "");
_parser.addOption(passwordOption);
// password
QCommandLineOption stdinPasswordOption("stdin-password",
"User password from stdin.");
QCommandLineOption stdinPasswordOption("stdin-password", "User password from stdin.");
_parser.addOption(stdinPasswordOption);
// cpu limit
QCommandLineOption cpuOption("limit-cpu", "User CPU limit.", "limit-cpu",
"0");
QCommandLineOption cpuOption("limit-cpu", "User CPU limit.", "limit-cpu", "0");
_parser.addOption(cpuOption);
// gpu limit
QCommandLineOption gpuOption("limit-gpu", "User GPU limit.", "limit-gpu",
"0");
QCommandLineOption gpuOption("limit-gpu", "User GPU limit.", "limit-gpu", "0");
_parser.addOption(gpuOption);
// memory limit
QCommandLineOption memoryOption("limit-memory", "User memory limit.",
"limit-memory", "0");
QCommandLineOption memoryOption("limit-memory", "User memory limit.", "limit-memory", "0");
_parser.addOption(memoryOption);
// gpu memory limit
QCommandLineOption gpumemoryOption(
"limit-gpumemory", "User GPU memory limit.", "limit-gpumemory", "0");
QCommandLineOption gpumemoryOption("limit-gpumemory", "User GPU memory limit.",
"limit-gpumemory", "0");
_parser.addOption(gpumemoryOption);
// storage limit
QCommandLineOption storageOption("limit-storage", "User storage limit.",
"limit-storage", "0");
QCommandLineOption storageOption("limit-storage", "User storage limit.", "limit-storage", "0");
_parser.addOption(storageOption);
}
QueuedctlCommon::QueuedctlResult
QueuedctlUser::setUser(const long long _id,
const QueuedUser::QueuedUserDefinitions &_definitions,
QueuedctlUser::setUser(const long long _id, const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token)
{
qCDebug(LOG_APP) << "Edit user" << _id;
@ -330,9 +289,7 @@ QueuedctlUser::setUser(const long long _id,
QueuedctlCommon::QueuedctlResult output;
res.match([&output](const bool val) { output.status = val; },
[&output](const QueuedError &err) {
output.output = err.message().c_str();
});
[&output](const QueuedError &err) { output.output = err.message().c_str(); });
return output;
}

23
sources/queuedctl/src/QueuedctlUser.h
View File

@ -26,27 +26,24 @@
namespace QueuedctlUser
{
QueuedctlCommon::QueuedctlResult
addUser(const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token);
QueuedctlCommon::QueuedctlResult addUser(const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token);
QueuedctlCommon::QueuedctlResult getReport(const QCommandLineParser &_parser,
const QString &_token);
QueuedUser::QueuedUserDefinitions
getDefinitions(const QCommandLineParser &_parser, const bool _expandAll);
QueuedUser::QueuedUserDefinitions getDefinitions(const QCommandLineParser &_parser,
const bool _expandAll);
QString getPassword();
QueuedctlCommon::QueuedctlResult
getUser(const long long _id, const QString &_property, const QString &_token);
QueuedctlCommon::QueuedctlResult getUsers(const QCommandLineParser &_parser,
const QString &_token);
QueuedctlCommon::QueuedctlResult getUser(const long long _id, const QString &_property,
const QString &_token);
QueuedctlCommon::QueuedctlResult getUsers(const QCommandLineParser &_parser, const QString &_token);
void parserAdd(QCommandLineParser &_parser);
void parserGet(QCommandLineParser &_parser);
void parserList(QCommandLineParser &_parser);
void parserReport(QCommandLineParser &_parser);
void parserSet(QCommandLineParser &_parser);
QueuedctlCommon::QueuedctlResult
setUser(const long long _id,
const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token);
QueuedctlCommon::QueuedctlResult setUser(const long long _id,
const QueuedUser::QueuedUserDefinitions &_definitions,
const QString &_token);
};

16
sources/queuedctl/src/main.cpp
View File

@ -38,8 +38,7 @@ int main(int argc, char *argv[])
// parser
QCommandLineParser parser;
parser.setApplicationDescription(
"Daemon for starting jobs to queue of calculations");
parser.setApplicationDescription("Daemon for starting jobs to queue of calculations");
parser.addHelpOption();
parser.addVersionOption();
// info
@ -51,12 +50,11 @@ int main(int argc, char *argv[])
parser.addOption(debugOption);
// configuration option
QCommandLineOption tokenOption({"t", "token"}, "Path to cached token.",
"token", QueuedSettings::defaultTokenPath());
QCommandLineOption tokenOption({"t", "token"}, "Path to cached token.", "token",
QueuedSettings::defaultTokenPath());
parser.addOption(tokenOption);
QCommandLineOption userOption({"u", "user"},
"User to login instead of current one.",
"user", ::getlogin());
QCommandLineOption userOption({"u", "user"}, "User to login instead of current one.", "user",
::getlogin());
parser.addOption(userOption);
// additional help option
@ -91,8 +89,8 @@ int main(int argc, char *argv[])
QueuedDebug::enableDebug();
// process
auto result = QueuedctlCommon::process(parser, parser.value(tokenOption),
parser.value(userOption));
auto result
= QueuedctlCommon::process(parser, parser.value(tokenOption), parser.value(userOption));
QueuedctlCommon::print(result);
return result.status ? 0 : 1;

12
sources/version.h.in
View File

@ -22,13 +22,10 @@ static const char SPECIAL_THANKS[] = "";
// links
static const char HOMEPAGE[] = "https://arcanis.me/projects/queued";
static const char REPOSITORY[] = "https://github.com/arcan1s/queued";
static const char RELEASES[]
= "https://github.com/arcan1s/queued/releases/tag/V.";
static const char VERSION_API[]
= "https://api.github.com/repos/arcan1s/queued/releases";
static const char RELEASES[] = "https://github.com/arcan1s/queued/releases/tag/V.";
static const char VERSION_API[] = "https://api.github.com/repos/arcan1s/queued/releases";
static const char BUGTRACKER[] = "https://github.com/arcan1s/queued/issues";
static const char BUGTRACKER_API[]
= "https://arcanis.me/repos/arcan1s/queued/issues";
static const char BUGTRACKER_API[] = "https://arcanis.me/repos/arcan1s/queued/issues";
// build information
static const char BUILD_DATE[] = "@CURRENT_DATE@";
@ -39,8 +36,7 @@ static const char CMAKE_CXX_COMPILER[] = "@CMAKE_CXX_COMPILER@";
static const char CMAKE_CXX_FLAGS[] = "@CMAKE_CXX_FLAGS@";
static const char CMAKE_CXX_FLAGS_DEBUG[] = "@CMAKE_CXX_FLAGS_DEBUG@";
static const char CMAKE_CXX_FLAGS_RELEASE[] = "@CMAKE_CXX_FLAGS_RELEASE@";
static const char CMAKE_CXX_FLAGS_OPTIMIZATION[]
= "@CMAKE_CXX_FLAGS_OPTIMIZATION@";
static const char CMAKE_CXX_FLAGS_OPTIMIZATION[] = "@CMAKE_CXX_FLAGS_OPTIMIZATION@";
static const char CMAKE_DEFINITIONS[] = "@CMAKE_DEFINITIONS@";
static const char CMAKE_INSTALL_PREFIX[] = "@CMAKE_INSTALL_PREFIX@";
static const char CMAKE_MODULE_LINKER_FLAGS[] = "@CMAKE_MODULE_LINKER_FLAGS@";