arcanis/queued
1
0
Fork 0
mirror of https://github.com/arcan1s/queued.git synced 2025-07-23 10:19:55 +00:00
Code Issues Projects Releases Wiki Activity

massive fixes in logic

Browse Source
This commit is contained in:
Evgenii Alekseev
2017-03-11 05:27:46 +03:00
parent 9000bf08a4
commit 57281bbb88
17 changed files with 316 additions and 407 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
sources/queued/include/queued/QueuedConfiguration.h
View File

@ -137,22 +137,21 @@ typedef QHash<QString, QueuedSettingsField> QueuedSettingsDefaultMap;
* @ingroup QueuedCfg * @ingroup QueuedCfg
* @brief default settings map * @brief default settings map
*/ */
const QueuedSettingsDefaultMap QueuedSettingsDefaults = { const QueuedSettingsDefaultMap QueuedSettingsDefaults
{"", {QueuedSettings::Invalid, QVariant()}}, = {{"", {QueuedSettings::Invalid, QVariant()}},
{"DatabaseInterval", {QueuedSettings::DatabaseInterval, 86400000}}, {"DatabaseInterval", {QueuedSettings::DatabaseInterval, 86400000}},
{"DefaultLimits", {QueuedSettings::DefaultLimits, "0\x010\x010\x010\x010"}}, {"DefaultLimits", {QueuedSettings::DefaultLimits, "0\n0\n0\n0\n0"}},
{"KeepTasks", {QueuedSettings::KeepTasks, 0}}, {"KeepTasks", {QueuedSettings::KeepTasks, 0}},
{"KeepUsers", {QueuedSettings::KeepUsers, 0}}, {"KeepUsers", {QueuedSettings::KeepUsers, 0}},
{"OnExitAction", {QueuedSettings::OnExitAction, 2}}, {"OnExitAction", {QueuedSettings::OnExitAction, 2}},
{"TokenExpiration", {QueuedSettings::TokenExpiration, 30}}, {"TokenExpiration", {QueuedSettings::TokenExpiration, 30}},
{"DatabaseVersion", {"DatabaseVersion",
{QueuedSettings::DatabaseVersion, QueuedConfig::DATABASE_VERSION}}, {QueuedSettings::DatabaseVersion, QueuedConfig::DATABASE_VERSION}},
{"ProcessCommandLine", {"ProcessCommandLine",
{QueuedSettings::ProcessCommandLine, {QueuedSettings::ProcessCommandLine,
"systemd-run\x01--scope\x01--unit={name}\x01--uid={uid}\x01--gid={gid}" "systemd-run\n--scope\n--unit={name}\n--uid={uid}\n--gid={gid}"
"\x01-p\x01CPUQuota={cpu}%\x01-p\x01MemoryHigh={memory}\x01{" "\n-p\nCPUQuota={cpu}%\n-p\nMemoryHigh={memory}\n{application}"}},
"application}"}}, {"Plugins", {QueuedSettings::Plugins, ""}}};
{"Plugins", {QueuedSettings::Plugins, ""}}};
}; };
#endif /* QUEUEDCONFIGURATION_H */ #endif /* QUEUEDCONFIGURATION_H */

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

@ -29,7 +29,6 @@
#include "QueuedConfiguration.h" #include "QueuedConfiguration.h"
#include "QueuedEnums.h" #include "QueuedEnums.h"
#include "QueuedLimits.h" #include "QueuedLimits.h"
#include "QueuedUserManager.h"
class QueuedAdvancedSettings; class QueuedAdvancedSettings;
@ -41,6 +40,8 @@ class QueuedProcessManager;
class QueuedReportManager; class QueuedReportManager;
class QueuedSettings; class QueuedSettings;
class QueuedTokenManager; class QueuedTokenManager;
class QueuedUser;
class QueuedUserManager;
/** /**
* @brief aggregator of queued classes * @brief aggregator of queued classes
@ -63,12 +64,11 @@ public:
* @brief add plugin to autoload and load it now * @brief add plugin to autoload and load it now
* @param _plugin * @param _plugin
* plugin name * plugin name
* @param _auth * @param _token
* user auth structure * user auth token
* @return true on successfully addition * @return true on successfully addition
*/ */
bool addPlugin(const QString &_plugin, bool addPlugin(const QString &_plugin, const QString &_token);
const QueuedUserManager::QueuedUserAuthorization &_auth);
/** /**
* @brief add new task * @brief add new task
* @param _command * @param _command
@ -83,14 +83,14 @@ public:
* task owner user ID * task owner user ID
* @param _limits * @param _limits
* task defined limits * task defined limits
* @param _auth * @param _token
* user auth structure * user auth token
* @return true on successfully addition * @return true on successfully addition
*/ */
bool addTask(const QString &_command, const QStringList &_arguments, bool addTask(const QString &_command, const QStringList &_arguments,
const QString &_workingDirectory, const uint _nice, const QString &_workingDirectory, const uint _nice,
const long long _userId, const QueuedLimits::Limits &_limits, const long long _userId, const QueuedLimits::Limits &_limits,
const QueuedUserManager::QueuedUserAuthorization &_auth); const QString &_token);
/** /**
* @brief add new user * @brief add new user
* @param _name * @param _name
@ -103,65 +103,62 @@ public:
* user permissions * user permissions
* @param _limits * @param _limits
* user limits * user limits
* @param _auth * @param _token
* user auth structure * user auth token
* @return true on successfully addition * @return true on successfully addition
*/ */
bool addUser(const QString &_name, const QString &_email, bool addUser(const QString &_name, const QString &_email,
const QString &_password, const uint _permissions, const QString &_password, const uint _permissions,
const QueuedLimits::Limits &_limits, const QueuedLimits::Limits &_limits, const QString &_token);
const QueuedUserManager::QueuedUserAuthorization &_auth);
/** /**
* @brief authorize and create new token for user * @brief authorize and create new token for user
* @param _name * @param _name
* user name * user name
* @param _password * @param _password
* user password * user password
* @return authorization structure. Token field will be empty in case if no * @return token. It will be empty if authorization error occurs
* authorization occurs
*/ */
QueuedUserManager::QueuedUserAuthorization QString authorization(const QString &_name, const QString &_password);
authorization(const QString &_name, const QString &_password);
/** /**
* @brief edit advanced settings * @brief edit advanced settings
* @param _key * @param _key
* advanced settings key * advanced settings key
* @param _value * @param _value
* advanced settings value * advanced settings value
* @param _auth * @param _token
* user auth structure * user auth token
* @return true on successful option edition * @return true on successful option edition
*/ */
bool editOption(const QString &_key, const QVariant &_value, bool editOption(const QString &_key, const QVariant &_value,
const QueuedUserManager::QueuedUserAuthorization &_auth); const QString &_token);
/** /**
* @brief edit task * @brief edit task
* @param _id * @param _id
* task ID to edit * task ID to edit
* @param _taskData * @param _taskData
* task data to edit * task data to edit
* @param _auth * @param _token
* user auth structure * user auth token
* @remark _taskData should contain only fields defined in schema, any other * @remark _taskData should contain only fields defined in schema, any other
* fields will be ignored. No need to pass all properties here * fields will be ignored. No need to pass all properties here
* @return true on successful task edition * @return true on successful task edition
*/ */
bool editTask(const long long _id, const QVariantHash &_taskData, bool editTask(const long long _id, const QVariantHash &_taskData,
const QueuedUserManager::QueuedUserAuthorization &_auth); const QString &_token);
/** /**
* @brief edit user * @brief edit user
* @param _id * @param _id
* user ID to edit * user ID to edit
* @param _userData * @param _userData
* user data to edit * user data to edit
* @param _auth * @param _token
* user auth structure * user auth token
* @remark _userData should contain only fields defined in schema, any other * @remark _userData should contain only fields defined in schema, any other
* fields will be ignored. No need to pass all properties here * fields will be ignored. No need to pass all properties here
* @return true on successful user edition * @return true on successful user edition
*/ */
bool editUser(const long long _id, const QVariantHash &_userData, bool editUser(const long long _id, const QVariantHash &_userData,
const QueuedUserManager::QueuedUserAuthorization &_auth); const QString &_token);
/** /**
* @brief edit user permissions * @brief edit user permissions
* @param _id * @param _id
@ -170,15 +167,13 @@ public:
* permission to add or remove * permission to add or remove
* @param _add * @param _add
* indicates whether it should be added or removed * indicates whether it should be added or removed
* @param _auth * @param _token
* user auth structure * user auth token
* @return true on successful user permission edition * @return true on successful user permission edition
*/ */
bool bool editUserPermission(const long long _id,
editUserPermission(const long long _id, const QueuedEnums::Permission &_permission,
const QueuedEnums::Permission &_permission, const bool _add, const QString &_token);
const bool _add,
const QueuedUserManager::QueuedUserAuthorization &_auth);
/** /**
* @brief get value from advanced settings * @brief get value from advanced settings
* @param _key * @param _key
@ -197,32 +192,29 @@ public:
* @brief remove plugin from autoload and unload it now * @brief remove plugin from autoload and unload it now
* @param _plugin * @param _plugin
* plugin name * plugin name
* @param _auth * @param _token
* user auth structure * user auth token
* @return true on successful plugin removal * @return true on successful plugin removal
*/ */
bool removePlugin(const QString &_plugin, bool removePlugin(const QString &_plugin, const QString &_token);
const QueuedUserManager::QueuedUserAuthorization &_auth);
/** /**
* @brief force start task * @brief force start task
* @param _id * @param _id
* task ID * task ID
* @param _auth * @param _token
* user auth structure * user auth token
* @return true on successful task start * @return true on successful task start
*/ */
bool startTask(const long long _id, bool startTask(const long long _id, const QString &_token);
const QueuedUserManager::QueuedUserAuthorization &_auth);
/** /**
* @brief force stop task * @brief force stop task
* @param _id * @param _id
* task ID * task ID
* @param _auth * @param _token
* user auth structure * user auth token
* @return true on successful task stop * @return true on successful task stop
*/ */
bool stopTask(const long long _id, bool stopTask(const long long _id, const QString &_token);
const QueuedUserManager::QueuedUserAuthorization &_auth);
/** /**
* @brief get task by ID * @brief get task by ID
* @param _id * @param _id

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

@ -68,26 +68,21 @@ public slots:
* option key to edit * option key to edit
* @param value * @param value
* option value to edit * option value to edit
* @param whoAmI
* auth user name
* @param token * @param token
* auth user token * auth user token
* @return true on successful option edition * @return true on successful option edition
*/ */
bool OptionEdit(const QString &key, const QDBusVariant &value, bool OptionEdit(const QString &key, const QDBusVariant &value,
const QString &whoAmI, const QString &token); const QString &token);
/** /**
* @brief add plugin * @brief add plugin
* @param plugin * @param plugin
* plugin name * plugin name
* @param whoAmI
* auth user name
* @param token * @param token
* auth user token * auth user token
* @return true on successful plugin addition * @return true on successful plugin addition
*/ */
bool PluginAdd(const QString &plugin, const QString &whoAmI, bool PluginAdd(const QString &plugin, const QString &token);
const QString &token);
/** /**
* @brief remove plugin * @brief remove plugin
* @param plugin * @param plugin
@ -98,8 +93,7 @@ public slots:
* auth user token * auth user token
* @return true on successful plugin removal * @return true on successful plugin removal
*/ */
bool PluginRemove(const QString &plugin, const QString &whoAmI, bool PluginRemove(const QString &plugin, const QString &token);
const QString &token);
/** /**
* @brief add new task * @brief add new task
* @param command * @param command
@ -132,8 +126,7 @@ public slots:
const QString &workingDirectory, const uint nice, const QString &workingDirectory, const uint nice,
const long long user, const long long cpu, const long long gpu, const long long user, const long long cpu, const long long gpu,
const QString &memory, const QString &gpumemory, const QString &memory, const QString &gpumemory,
const QString &storage, const QString &whoAmI, const QString &storage, const QString &token);
const QString &token);
/** /**
* @brief edit task * @brief edit task
* @param id * @param id
@ -175,8 +168,7 @@ public slots:
const uint nice, const uint uid, const uint gid, const uint nice, const uint uid, const uint gid,
const uint state, const long long cpu, const long long gpu, const uint state, const long long cpu, const long long gpu,
const QString &memory, const QString &gpumemory, const QString &memory, const QString &gpumemory,
const QString &storage, const QString &whoAmI, const QString &storage, const QString &token);
const QString &token);
/** /**
* @brief force start task * @brief force start task
* @param id * @param id
@ -187,8 +179,7 @@ public slots:
* auth user token * auth user token
* @return true on successful task start * @return true on successful task start
*/ */
bool TaskStart(const qlonglong id, const QString &whoAmI, bool TaskStart(const qlonglong id, const QString &token);
const QString &token);
/** /**
* @brief force stop task * @brief force stop task
* @param id * @param id
@ -199,8 +190,7 @@ public slots:
* auth user token * auth user token
* @return true on successful task stop * @return true on successful task stop
*/ */
bool TaskStop(const qlonglong id, const QString &whoAmI, bool TaskStop(const qlonglong id, const QString &token);
const QString &token);
/** /**
* @brief add new user * @brief add new user
* @param name * @param name
@ -231,8 +221,7 @@ public slots:
const QString &password, const uint permissions, const QString &password, const uint permissions,
const long long cpu, const long long gpu, const long long cpu, const long long gpu,
const QString &memory, const QString &gpumemory, const QString &memory, const QString &gpumemory,
const QString &storage, const QString &whoAmI, const QString &storage, const QString &token);
const QString &token);
/** /**
* @brief edit user * @brief edit user
* @param id * @param id
@ -263,8 +252,7 @@ public slots:
const QString &password, const QString &email, const QString &password, const QString &email,
const long long cpu, const long long gpu, const long long cpu, const long long gpu,
const QString &memory, const QString &gpumemory, const QString &memory, const QString &gpumemory,
const QString &storage, const QString &whoAmI, const QString &storage, const QString &token);
const QString &token);
/** /**
* @brief add permission to user * @brief add permission to user
* @param id * @param id
@ -278,7 +266,7 @@ public slots:
* @return true on successful permission addition * @return true on successful permission addition
*/ */
bool UserPermissionAdd(const qlonglong id, const uint permission, bool UserPermissionAdd(const qlonglong id, const uint permission,
const QString &whoAmI, const QString &token); const QString &token);
/** /**
* @brief remove permission from user * @brief remove permission from user
* @param id * @param id
@ -292,7 +280,7 @@ public slots:
* @return true on successful permission removal * @return true on successful permission removal
*/ */
bool UserPermissionRemove(const qlonglong id, const uint permission, bool UserPermissionRemove(const qlonglong id, const uint permission,
const QString &whoAmI, const QString &token); const QString &token);
private: private:
/** /**

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

@ -102,7 +102,6 @@ const QueuedDBSchema DBSchema = {
{"nice", {"nice", "INT", QVariant::UInt, false}}, {"nice", {"nice", "INT", QVariant::UInt, false}},
{"uid", {"uid", "INT", QVariant::UInt, false}}, {"uid", {"uid", "INT", QVariant::UInt, false}},
{"gid", {"gid", "INT", QVariant::UInt, false}}, {"gid", {"gid", "INT", QVariant::UInt, false}},
{"state", {"state", "INT", QVariant::UInt, true}},
{"limits", {"limits", "TEXT", QVariant::String, false}}, {"limits", {"limits", "TEXT", QVariant::String, false}},
{"startTime", {"startTime", "INT", QVariant::LongLong, true}}, {"startTime", {"startTime", "INT", QVariant::LongLong, true}},
{"endTime", {"endTime", "INT", QVariant::LongLong, true}}}}, {"endTime", {"endTime", "INT", QVariant::LongLong, true}}}},
@ -111,6 +110,7 @@ const QueuedDBSchema DBSchema = {
{"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong, {"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong,
true}}, true}},
{"token", {"token", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}}, {"token", {"token", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}},
{"user", {"user", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}},
{"validUntil", {"validUntil",
{"validUntil", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}}}}, {"validUntil", "TEXT NOT NULL DEFAULT '0'", QVariant::String, true}}}},
{USERS_TABLE, {USERS_TABLE,

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

@ -55,22 +55,6 @@ enum class Permission {
}; };
Q_DECLARE_FLAGS(Permissions, Permission) Q_DECLARE_FLAGS(Permissions, Permission)
Q_DECLARE_OPERATORS_FOR_FLAGS(Permissions) Q_DECLARE_OPERATORS_FOR_FLAGS(Permissions)
/**
* @ingroup QueuedEnums
* @enum ProcessState
* @brief process state description
* @var ProcessState::NotRunning
* process is not running yet
* @var ProcessState::Running
* process running at the moment
* @var ProcessState::Exited
* process exit
*/
enum class ProcessState {
NotRunning = 1 << 1,
Running = 1 << 2,
Exited = 1 << 3
};
}; };

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

@ -63,7 +63,7 @@ struct Limits {
*/ */
QString toString() const QString toString() const
{ {
return QString("%1\x01%2\x01%3\x01%4\x01%5") return QString("%1\n%2\n%3\n%4\n%5")
.arg(cpu) .arg(cpu)
.arg(gpu) .arg(gpu)
.arg(memory) .arg(memory)
@ -87,7 +87,7 @@ struct Limits {
*/ */
Limits(const QString &_stringLimits) Limits(const QString &_stringLimits)
{ {
QStringList limits = _stringLimits.split(QChar('\x01')); QStringList limits = _stringLimits.split(QChar('\n'));
while (limits.count() < 5) while (limits.count() < 5)
limits.append(QString("0")); limits.append(QString("0"));

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

@ -27,7 +27,6 @@
#include <QDateTime> #include <QDateTime>
#include <QProcess> #include <QProcess>
#include "QueuedEnums.h"
#include "QueuedLimits.h" #include "QueuedLimits.h"
@ -49,7 +48,6 @@ class QueuedProcess : public QProcess
Q_PROPERTY(QueuedLimits::Limits nativeLimtis READ nativeLimits) Q_PROPERTY(QueuedLimits::Limits nativeLimtis READ nativeLimits)
Q_PROPERTY(uint nice READ nice WRITE setNice) Q_PROPERTY(uint nice READ nice WRITE setNice)
Q_PROPERTY(QString processLine READ processLine WRITE setProcessLine) Q_PROPERTY(QString processLine READ processLine WRITE setProcessLine)
Q_PROPERTY(QueuedEnums::ProcessState pstate READ pstate WRITE setPState)
Q_PROPERTY(QDateTime startTime READ startTime WRITE setStartTime) Q_PROPERTY(QDateTime startTime READ startTime WRITE setStartTime)
Q_PROPERTY(uint uid READ uid WRITE setUid) Q_PROPERTY(uint uid READ uid WRITE setUid)
Q_PROPERTY(long long user READ user WRITE setUser) Q_PROPERTY(long long user READ user WRITE setUser)
@ -79,8 +77,6 @@ public:
* task owner ID * task owner ID
* @var limits * @var limits
* task limits * task limits
* @var state
* current task state
*/ */
typedef struct { typedef struct {
QString command; QString command;
@ -93,7 +89,6 @@ public:
QDateTime endTime; QDateTime endTime;
long long user; long long user;
QString limits; QString limits;
QueuedEnums::ProcessState state;
} QueuedProcessDefinitions; } QueuedProcessDefinitions;
/** /**
@ -168,11 +163,6 @@ public:
* @return process line as is in configuration * @return process line as is in configuration
*/ */
QString processLine() const; QString processLine() const;
/**
* @brief process state
* @return process defined state
*/
QueuedEnums::ProcessState pstate() const;
/** /**
* @brief process start time * @brief process start time
* @return process start time * @return process start time
@ -239,12 +229,6 @@ public:
* 4. {application} will be replaced to application line and arguments * 4. {application} will be replaced to application line and arguments
*/ */
void setProcessLine(const QString &_processLine); void setProcessLine(const QString &_processLine);
/**
* @brief set process state
* @param _limits
* new process state
*/
void setPState(const QueuedEnums::ProcessState _state);
/** /**
* @brief set start time * @brief set start time
* @param _time * @param _time

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

@ -36,6 +36,22 @@ class QueuedTokenManager : public QObject
Q_OBJECT Q_OBJECT
public: public:
/**
* @struct QueuedTokenDefinitions
* @brief structure to define token
* @var token
* token ID
* @var user
* token owner user
* @var validUntil
* valid until
*/
typedef struct {
QString token;
QString user;
QDateTime validUntil;
} QueuedTokenDefinitions;
/** /**
* @brief QueuedTokenManager class constructor * @brief QueuedTokenManager class constructor
* @param parent * @param parent
@ -50,22 +66,31 @@ public:
* @brief check if token is valid * @brief check if token is valid
* @param _token * @param _token
* token ID * token ID
* @return true if token is valid otherwise return false * @return token user if token is valid otherwise return false
*/ */
bool isTokenValid(const QString &_token) const; QString isTokenValid(const QString &_token) const;
/** /**
* @brief upload tokens from database * @brief load token
* @param _value * @param _definitions
* token definitions
*/
void
loadToken(const QueuedTokenManager::QueuedTokenDefinitions &_definitions);
/**
* @brief upload tokens from database
* @param _value
* tokens from database * tokens from database
*/ */
void loadTokens(const QList<QVariantHash> &_values); void loadTokens(const QList<QVariantHash> &_values);
/** /**
* @brief register new token * @brief register new token
* @param _user
* token user
* @param _validUntil * @param _validUntil
* token valid until * token valid until
* @return new generated token * @return new generated token
*/ */
QString registerToken(const QDateTime _validUntil); QString registerToken(const QString &_user, const QDateTime &_validUntil);
/** /**
* @brief token expiration * @brief token expiration
* @param _token * @param _token
@ -90,20 +115,12 @@ signals:
* token ID * token ID
*/ */
void tokenExpired(const QString &_token); void tokenExpired(const QString &_token);
/**
* @brief signal which will be emitted on newly created token
* @param _token
* token ID
* @param _validUntil
* token valid until
*/
void tokenRegistered(const QString &_token, const QDateTime &_validUntil);
private: private:
/** /**
* @brief token storage * @brief token storage
*/ */
QHash<QString, QDateTime> m_tokens; QHash<QString, QueuedTokenDefinitions> m_tokens;
}; };

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

@ -43,20 +43,6 @@ class QueuedUserManager : public QObject
long long tokenExpiration READ tokenExpiration WRITE setTokenExpiration) long long tokenExpiration READ tokenExpiration WRITE setTokenExpiration)
public: public:
/**
* @struct UserAuthorization
* user authorization structure
* @remark only
* @var token
* authorization token
* @var user
* username, token owner
*/
typedef struct {
QString token;
QString user;
} QueuedUserAuthorization;
/** /**
* @brief QueuedUserManager class constructor * @brief QueuedUserManager class constructor
* @param parent * @param parent
@ -86,16 +72,6 @@ public:
*/ */
QueuedUser *add(const QueuedUser::QueuedUserDefinitions &_definitions, QueuedUser *add(const QueuedUser::QueuedUserDefinitions &_definitions,
const long long _id); const long long _id);
/**
* @brief build user auth structure
* @param _user
* user name
* @param _token
* user token
* @return generated structure
*/
static QueuedUserAuthorization auth(const QString &_user,
const QString &_token);
/** /**
* @brief authorize user * @brief authorize user
* @param _user * @param _user
@ -107,13 +83,13 @@ public:
QString authorize(const QString &_user, const QString &_password); QString authorize(const QString &_user, const QString &_password);
/** /**
* @brief authorize user for service * @brief authorize user for service
* @param _auth * @param _token
* user authorization structure * user token
* @param _service * @param _service
* service to authorize * service to authorize
* @return true if user allowed to do it otherwise return false * @return true if user allowed to do it otherwise return false
*/ */
bool authorize(const QueuedUserAuthorization &_auth, bool authorize(const QString &_token,
const QueuedEnums::Permission _service); const QueuedEnums::Permission _service);
/** /**
* @brief check token expiration * @brief check token expiration
@ -154,9 +130,11 @@ public:
* @brief user by name * @brief user by name
* @param _name * @param _name
* user name for search * user name for search
* @param _isToken
* is passed name token or not
* @return user by name or nullptr if no user found * @return user by name or nullptr if no user found
*/ */
QueuedUser *user(const QString &_name); QueuedUser *user(const QString &_name, const bool _isToken);
// properties // properties
/** /**
* @brief token expiration * @brief token expiration

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

@ -56,15 +56,13 @@ QueuedCore::~QueuedCore()
/** /**
* @fn addPlugin * @fn addPlugin
*/ */
bool QueuedCore::addPlugin( bool QueuedCore::addPlugin(const QString &_plugin, const QString &_token)
const QString &_plugin,
const QueuedUserManager::QueuedUserAuthorization &_auth)
{ {
qCDebug(LOG_LIB) << "Add plugin" << _plugin; qCDebug(LOG_LIB) << "Add plugin" << _plugin;
bool isAdmin = m_users->authorize(_auth, QueuedEnums::Permission::Admin); bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user << "not allowed to add plugin"; qCInfo(LOG_LIB) << "User" << _token << "not allowed to add plugin";
return false; return false;
} }
@ -75,38 +73,36 @@ bool QueuedCore::addPlugin(
/** /**
* @addTask * @addTask
*/ */
bool QueuedCore::addTask( bool QueuedCore::addTask(const QString &_command, const QStringList &_arguments,
const QString &_command, const QStringList &_arguments, const QString &_workingDirectory, const uint _nice,
const QString &_workingDirectory, const uint _nice, const long long _userId, const long long _userId,
const QueuedLimits::Limits &_limits, const QueuedLimits::Limits &_limits,
const QueuedUserManager::QueuedUserAuthorization &_auth) const QString &_token)
{ {
qCDebug(LOG_LIB) << "Add task" << _command << "with arguments" << _arguments qCDebug(LOG_LIB) << "Add task" << _command << "with arguments" << _arguments
<< "from user" << _userId; << "from user" << _userId;
auto authUser = m_users->user(_auth.user); auto authUser = m_users->user(_token, true);
if (!authUser) { if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _auth.user; qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return false; return false;
} }
long long userAuthId = authUser->index(); long long userAuthId = authUser->index();
long long actualUserId = (_userId == -1) ? userAuthId : _userId; long long actualUserId = (_userId == -1) ? userAuthId : _userId;
// check permissions // check permissions
bool isAdmin = m_users->authorize(_auth, QueuedEnums::Permission::Admin); bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
bool isUser = m_users->authorize(_auth, QueuedEnums::Permission::JobOwner); bool isUser = m_users->authorize(_token, QueuedEnums::Permission::JobOwner);
if (userAuthId == actualUserId) { if (userAuthId == actualUserId) {
// it means that user places task as own one // it means that user places task as own one
if (!isUser) { if (!isUser) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token << "not allowed to add task";
<< "not allowed to add task";
return false; return false;
} }
} else { } else {
// user tries to place task as another one // user tries to place task as another one
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token << "not allowed to add task";
<< "not allowed to add task";
return false; return false;
} }
} }
@ -119,23 +115,23 @@ bool QueuedCore::addTask(
/** /**
* @fn addUser * @fn addUser
*/ */
bool QueuedCore::addUser( bool QueuedCore::addUser(const QString &_name, const QString &_email,
const QString &_name, const QString &_email, const QString &_password, const QString &_password, const uint _permissions,
const uint _permissions, const QueuedLimits::Limits &_limits, const QueuedLimits::Limits &_limits,
const QueuedUserManager::QueuedUserAuthorization &_auth) const QString &_token)
{ {
qCDebug(LOG_LIB) << "Add user" << _name << "with email" << _email qCDebug(LOG_LIB) << "Add user" << _name << "with email" << _email
<< "and permissions" << _permissions; << "and permissions" << _permissions;
// check permissions // check permissions
bool isAdmin = m_users->authorize(_auth, QueuedEnums::Permission::Admin); bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user << "not allowed to add user"; qCInfo(LOG_LIB) << "User" << _token << "not allowed to add user";
return false; return false;
} }
// check if already exists // check if already exists
auto user = m_users->user(_name); auto user = m_users->user(_name, false);
if (user) { if (user) {
qCWarning(LOG_LIB) << "User" << _name << "already exists"; qCWarning(LOG_LIB) << "User" << _name << "already exists";
return false; return false;
@ -148,41 +144,36 @@ bool QueuedCore::addUser(
/** /**
* @fn authorization * @fn authorization
*/ */
QueuedUserManager::QueuedUserAuthorization QString QueuedCore::authorization(const QString &_name,
QueuedCore::authorization(const QString &_name, const QString &_password) const QString &_password)
{ {
qCDebug(LOG_LIB) << "Authorize user" << _name; qCDebug(LOG_LIB) << "Authorize user" << _name;
QString token = m_users->authorize(_name, _password); QString token = m_users->authorize(_name, _password);
QueuedUserManager::QueuedUserAuthorization auth;
auth.user = _name;
auth.token = token;
if (!token.isEmpty()) { if (!token.isEmpty()) {
QVariantHash payload = { QVariantHash payload = {
{"token", token}, {"token", token},
{"user", _name},
{"validUntil", m_users->checkToken(token).toString(Qt::ISODate)}}; {"validUntil", m_users->checkToken(token).toString(Qt::ISODate)}};
m_database->add(QueuedDB::TOKENS_TABLE, payload); m_database->add(QueuedDB::TOKENS_TABLE, payload);
} }
return auth; return token;
} }
/** /**
* @fn editOption * @fn editOption
*/ */
bool QueuedCore::editOption( bool QueuedCore::editOption(const QString &_key, const QVariant &_value,
const QString &_key, const QVariant &_value, const QString &_token)
const QueuedUserManager::QueuedUserAuthorization &_auth)
{ {
qCDebug(LOG_LIB) << "Set key" << _key << "to" << _value; qCDebug(LOG_LIB) << "Set key" << _key << "to" << _value;
// check permissions // check permissions
bool isAdmin = m_users->authorize(_auth, QueuedEnums::Permission::Admin); bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token << "not allowed to edit options";
<< "not allowed to edit options";
return false; return false;
} }
@ -193,9 +184,8 @@ bool QueuedCore::editOption(
/** /**
* @fn editTask * @fn editTask
*/ */
bool QueuedCore::editTask( bool QueuedCore::editTask(const long long _id, const QVariantHash &_taskData,
const long long _id, const QVariantHash &_taskData, const QString &_token)
const QueuedUserManager::QueuedUserAuthorization &_auth)
{ {
qCDebug(LOG_LIB) << "Edit task with ID" << _id; qCDebug(LOG_LIB) << "Edit task with ID" << _id;
@ -206,33 +196,31 @@ bool QueuedCore::editTask(
} }
// check permissions // check permissions
auto authUser = m_users->user(_auth.user); auto authUser = m_users->user(_token, true);
if (!authUser) { if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _auth.user; qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return false; return false;
} }
long long userAuthId = authUser->index(); long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_auth, QueuedEnums::Permission::Admin); bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
bool isUser = m_users->authorize(_auth, QueuedEnums::Permission::JobOwner); bool isUser = m_users->authorize(_token, QueuedEnums::Permission::JobOwner);
if (userAuthId == task->user()) { if (userAuthId == task->user()) {
// it means that user edits own task // it means that user edits own task
if (!isUser) { if (!isUser) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token << "not allowed to edit task";
<< "not allowed to edit task";
return false; return false;
} }
} else { } else {
// user tries to edit random task // user tries to edit random task
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token << "not allowed to edit task";
<< "not allowed to edit task";
return false; return false;
} }
} }
// only admin can edit run/stopped task // only admin can edit run/stopped task
if (task->pstate() != QueuedEnums::ProcessState::NotRunning) { if (!task->startTime().isNull()) {
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token
<< "not allowed to edit run/exited task"; << "not allowed to edit run/exited task";
return false; return false;
} }
@ -250,9 +238,8 @@ bool QueuedCore::editTask(
/** /**
* @fn editUser * @fn editUser
*/ */
bool QueuedCore::editUser( bool QueuedCore::editUser(const long long _id, const QVariantHash &_userData,
const long long _id, const QVariantHash &_userData, const QString &_token)
const QueuedUserManager::QueuedUserAuthorization &_auth)
{ {
qCDebug(LOG_LIB) << "Edit user with ID" << _id; qCDebug(LOG_LIB) << "Edit user with ID" << _id;
@ -263,17 +250,16 @@ bool QueuedCore::editUser(
} }
// check permissions // check permissions
auto authUser = m_users->user(_auth.user); auto authUser = m_users->user(_token, true);
if (!authUser) { if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _auth.user; qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return false; return false;
} }
long long userAuthId = authUser->index(); long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_auth, QueuedEnums::Permission::Admin); bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (userAuthId != _id) { if (userAuthId != _id) {
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token << "not allowed to edit user";
<< "not allowed to edit user";
return false; return false;
} }
} }
@ -290,24 +276,24 @@ bool QueuedCore::editUser(
/** /**
* @fn editUserPermission * @fn editUserPermission
*/ */
bool QueuedCore::editUserPermission( bool QueuedCore::editUserPermission(const long long _id,
const long long _id, const QueuedEnums::Permission &_permission, const QueuedEnums::Permission &_permission,
const bool _add, const QueuedUserManager::QueuedUserAuthorization &_auth) const bool _add, const QString &_token)
{ {
qCDebug(LOG_LIB) << "Edit permissions" << static_cast<int>(_permission) qCDebug(LOG_LIB) << "Edit permissions" << static_cast<int>(_permission)
<< "for user" << _id << "add" << _add; << "for user" << _id << "add" << _add;
// check permissions // check permissions
auto authUser = m_users->user(_auth.user); auto authUser = m_users->user(_token, true);
if (!authUser) { if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _auth.user; qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return false; return false;
} }
long long userAuthId = authUser->index(); long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_auth, QueuedEnums::Permission::Admin); bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (userAuthId != _id) { if (userAuthId != _id) {
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token
<< "not allowed to edit permissions"; << "not allowed to edit permissions";
return false; return false;
} }
@ -351,16 +337,13 @@ QVariantHash QueuedCore::pluginSettings(const QString &_plugin)
/** /**
* @fn removePlugin * @fn removePlugin
*/ */
bool QueuedCore::removePlugin( bool QueuedCore::removePlugin(const QString &_plugin, const QString &_token)
const QString &_plugin,
const QueuedUserManager::QueuedUserAuthorization &_auth)
{ {
qCDebug(LOG_LIB) << "Remove plugin" << _plugin; qCDebug(LOG_LIB) << "Remove plugin" << _plugin;
bool isAdmin = m_users->authorize(_auth, QueuedEnums::Permission::Admin); bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token << "not allowed to remove plugin";
<< "not allowed to remove plugin";
return false; return false;
} }
@ -371,24 +354,21 @@ bool QueuedCore::removePlugin(
/** /**
* @fn startTask * @fn startTask
*/ */
bool QueuedCore::startTask( bool QueuedCore::startTask(const long long _id, const QString &_token)
const long long _id,
const QueuedUserManager::QueuedUserAuthorization &_auth)
{ {
qCDebug(LOG_LIB) << "Force start task with ID" << _id; qCDebug(LOG_LIB) << "Force start task with ID" << _id;
// check permissions // check permissions
auto authUser = m_users->user(_auth.user); auto authUser = m_users->user(_token, true);
if (!authUser) { if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _auth.user; qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return false; return false;
} }
long long userAuthId = authUser->index(); long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_auth, QueuedEnums::Permission::Admin); bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
if (userAuthId != _id) { if (userAuthId != _id) {
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token << "not allowed to start tasks";
<< "not allowed to start tasks";
return false; return false;
} }
} }
@ -402,9 +382,7 @@ bool QueuedCore::startTask(
/** /**
* @fn stopTask * @fn stopTask
*/ */
bool QueuedCore::stopTask( bool QueuedCore::stopTask(const long long _id, const QString &_token)
const long long _id,
const QueuedUserManager::QueuedUserAuthorization &_auth)
{ {
qCDebug(LOG_LIB) << "Force stop task with ID" << _id; qCDebug(LOG_LIB) << "Force stop task with ID" << _id;
@ -415,26 +393,24 @@ bool QueuedCore::stopTask(
} }
// check permissions // check permissions
auto authUser = m_users->user(_auth.user); auto authUser = m_users->user(_token, true);
if (!authUser) { if (!authUser) {
qCWarning(LOG_LIB) << "Could not find auth user" << _auth.user; qCWarning(LOG_LIB) << "Could not find auth user" << _token;
return false; return false;
} }
long long userAuthId = authUser->index(); long long userAuthId = authUser->index();
bool isAdmin = m_users->authorize(_auth, QueuedEnums::Permission::Admin); bool isAdmin = m_users->authorize(_token, QueuedEnums::Permission::Admin);
bool isUser = m_users->authorize(_auth, QueuedEnums::Permission::JobOwner); bool isUser = m_users->authorize(_token, QueuedEnums::Permission::JobOwner);
if (userAuthId == task->user()) { if (userAuthId == task->user()) {
// it means that user edits own task // it means that user edits own task
if (!isUser) { if (!isUser) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token << "not allowed to stop task";
<< "not allowed to stop task";
return false; return false;
} }
} else { } else {
// user tries to edit random task // user tries to edit random task
if (!isAdmin) { if (!isAdmin) {
qCInfo(LOG_LIB) << "User" << _auth.user qCInfo(LOG_LIB) << "User" << _token << "not allowed to stop task";
<< "not allowed to stop task";
return false; return false;
} }
} }
@ -682,7 +658,7 @@ void QueuedCore::initPlugins()
QStringList pluginList QStringList pluginList
= m_advancedSettings->get(QueuedCfg::QueuedSettings::Plugins) = m_advancedSettings->get(QueuedCfg::QueuedSettings::Plugins)
.toString() .toString()
.split('\x01'); .split('\n');
m_plugins = new QueuedPluginManager(this); m_plugins = new QueuedPluginManager(this);
for (auto &plugin : pluginList) for (auto &plugin : pluginList)
@ -704,10 +680,8 @@ void QueuedCore::initProcesses()
.toString(); .toString();
m_processes = new QueuedProcessManager(this, processLine, onExitAction); m_processes = new QueuedProcessManager(this, processLine, onExitAction);
auto dbProcesses = m_database->get( auto dbProcesses = m_database->get(QueuedDB::TASKS_TABLE,
QueuedDB::TASKS_TABLE, QString("WHERE endTime IS NULL"));
QString("WHERE state != %1")
.arg(static_cast<int>(QueuedEnums::ProcessState::Exited)));
m_processes->loadProcesses(dbProcesses); m_processes->loadProcesses(dbProcesses);
m_connections m_connections
@ -813,14 +787,15 @@ bool QueuedCore::addTaskPrivate(const QString &_command,
QueuedLimits::Limits( QueuedLimits::Limits(
m_advancedSettings->get(QueuedCfg::QueuedSettings::DefaultLimits) m_advancedSettings->get(QueuedCfg::QueuedSettings::DefaultLimits)
.toString())); .toString()));
QVariantHash properties = {{"user", _userId}, QVariantHash properties
{"command", _command}, = {{"user", _userId},
{"commandArguments", _arguments}, {"command", _command},
{"workDirectory", _workingDirectory}, {"commandArguments", _arguments},
{"nice", _nice}, {"workDirectory", _workingDirectory},
{"uid", ids.first}, {"nice", _nice},
{"gid", ids.second}, {"uid", ids.first},
{"limits", taskLimits.toString()}}; {"gid", ids.second},
{"limits", taskLimits.toString()}};
auto id = m_database->add(QueuedDB::TASKS_TABLE, properties); auto id = m_database->add(QueuedDB::TASKS_TABLE, properties);
if (id == -1) { if (id == -1) {
qCWarning(LOG_LIB) << "Could not add task" << _command; qCWarning(LOG_LIB) << "Could not add task" << _command;
@ -903,7 +878,7 @@ bool QueuedCore::editPluginPrivate(const QString &_plugin, const bool _add)
QStringList pluginList QStringList pluginList
= m_advancedSettings->get(QueuedCfg::QueuedSettings::Plugins) = m_advancedSettings->get(QueuedCfg::QueuedSettings::Plugins)
.toString() .toString()
.split('\x01'); .split('\n');
bool status = false; bool status = false;
if (_add && !pluginList.contains(_plugin)) if (_add && !pluginList.contains(_plugin))

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

@ -54,7 +54,7 @@ QString QueuedCoreInterface::Auth(const QString &name, const QString &password)
{ {
qCDebug(LOG_DBUS) << "Authorize user" << name; qCDebug(LOG_DBUS) << "Authorize user" << name;
return m_core->authorization(name, password).token; return m_core->authorization(name, password);
} }
@ -63,26 +63,22 @@ QString QueuedCoreInterface::Auth(const QString &name, const QString &password)
*/ */
bool QueuedCoreInterface::OptionEdit(const QString &key, bool QueuedCoreInterface::OptionEdit(const QString &key,
const QDBusVariant &value, const QDBusVariant &value,
const QString &whoAmI,
const QString &token) const QString &token)
{ {
qCDebug(LOG_DBUS) << "Edit option" << key << value.variant() << "auth by" qCDebug(LOG_DBUS) << "Edit option" << key << value.variant();
<< whoAmI;
return m_core->editOption(key, value.variant(), return m_core->editOption(key, value.variant(), token);
QueuedUserManager::auth(whoAmI, token));
} }
/** /**
* @fn PluginAdd * @fn PluginAdd
*/ */
bool QueuedCoreInterface::PluginAdd(const QString &plugin, bool QueuedCoreInterface::PluginAdd(const QString &plugin, const QString &token)
const QString &whoAmI, const QString &token)
{ {
qCDebug(LOG_DBUS) << "Add plugin" << plugin << "auth by" << whoAmI; qCDebug(LOG_DBUS) << "Add plugin" << plugin;
return m_core->addPlugin(plugin, QueuedUserManager::auth(whoAmI, token)); return m_core->addPlugin(plugin, token);
} }
@ -90,12 +86,11 @@ bool QueuedCoreInterface::PluginAdd(const QString &plugin,
* @fn PluginRemove * @fn PluginRemove
*/ */
bool QueuedCoreInterface::PluginRemove(const QString &plugin, bool QueuedCoreInterface::PluginRemove(const QString &plugin,
const QString &whoAmI,
const QString &token) const QString &token)
{ {
qCDebug(LOG_DBUS) << "Remove plugin" << plugin << "auth by" << whoAmI; qCDebug(LOG_DBUS) << "Remove plugin" << plugin;
return m_core->removePlugin(plugin, QueuedUserManager::auth(whoAmI, token)); return m_core->removePlugin(plugin, token);
} }
@ -106,35 +101,35 @@ bool QueuedCoreInterface::TaskAdd(
const QString &command, const QStringList &arguments, const QString &command, const QStringList &arguments,
const QString &workingDirectory, const uint nice, const long long user, const QString &workingDirectory, const uint nice, const long long user,
const long long cpu, const long long gpu, const QString &memory, const long long cpu, const long long gpu, const QString &memory,
const QString &gpumemory, const QString &storage, const QString &whoAmI, const QString &gpumemory, const QString &storage, const QString &token)
const QString &token)
{ {
qCDebug(LOG_DBUS) << "Add new task with parameters" << command << arguments qCDebug(LOG_DBUS) << "Add new task with parameters" << command << arguments
<< workingDirectory << nice << "from user" << user << workingDirectory << nice << "from user" << user;
<< "auth by" << whoAmI;
return m_core->addTask( return m_core->addTask(
command, arguments, workingDirectory, nice, user, command, arguments, workingDirectory, nice, user,
QueuedLimits::Limits(cpu, gpu, QueuedLimits::convertMemory(memory), QueuedLimits::Limits(cpu, gpu, QueuedLimits::convertMemory(memory),
QueuedLimits::convertMemory(gpumemory), QueuedLimits::convertMemory(gpumemory),
QueuedLimits::convertMemory(storage)), QueuedLimits::convertMemory(storage)),
QueuedUserManager::auth(whoAmI, token)); token);
} }
/** /**
* @fn TaskEdit * @fn TaskEdit
*/ */
bool QueuedCoreInterface::TaskEdit( bool QueuedCoreInterface::TaskEdit(const qlonglong id, const QString &command,
const qlonglong id, const QString &command, const QStringList &arguments, const QStringList &arguments,
const QString &directory, const uint nice, const uint uid, const uint gid, const QString &directory, const uint nice,
const uint state, const long long cpu, const long long gpu, const uint uid, const uint gid,
const QString &memory, const QString &gpumemory, const QString &storage, const uint state, const long long cpu,
const QString &whoAmI, const QString &token) const long long gpu, const QString &memory,
const QString &gpumemory,
const QString &storage, const QString &token)
{ {
qCDebug(LOG_DBUS) << "Edit task" << id << command << arguments << directory qCDebug(LOG_DBUS) << "Edit task" << id << command << arguments << directory
<< nice << uid << gid << state << cpu << gpu << memory << nice << uid << gid << state << cpu << gpu << memory
<< gpumemory << storage << "auth by" << whoAmI; << gpumemory << storage;
auto task = m_core->task(id); auto task = m_core->task(id);
if (!task) { if (!task) {
@ -172,31 +167,29 @@ bool QueuedCoreInterface::TaskEdit(
limits.storage = QueuedLimits::convertMemory(storage); limits.storage = QueuedLimits::convertMemory(storage);
data[QString("limits")] = limits.toString(); data[QString("limits")] = limits.toString();
return m_core->editTask(id, data, QueuedUserManager::auth(whoAmI, token)); return m_core->editTask(id, data, token);
} }
/** /**
* @fn TaskStart * @fn TaskStart
*/ */
bool QueuedCoreInterface::TaskStart(const qlonglong id, const QString &whoAmI, bool QueuedCoreInterface::TaskStart(const qlonglong id, const QString &token)
const QString &token)
{ {
qCDebug(LOG_DBUS) << "Force start task" << id << "auth by" << whoAmI; qCDebug(LOG_DBUS) << "Force start task" << id;
return m_core->startTask(id, QueuedUserManager::auth(whoAmI, token)); return m_core->startTask(id, token);
} }
/** /**
* @fn TaskStop * @fn TaskStop
*/ */
bool QueuedCoreInterface::TaskStop(const qlonglong id, const QString &whoAmI, bool QueuedCoreInterface::TaskStop(const qlonglong id, const QString &token)
const QString &token)
{ {
qCDebug(LOG_DBUS) << "Force stop task" << id << "auth by" << whoAmI; qCDebug(LOG_DBUS) << "Force stop task" << id;
return m_core->stopTask(id, QueuedUserManager::auth(whoAmI, token)); return m_core->stopTask(id, token);
} }
@ -208,18 +201,17 @@ bool QueuedCoreInterface::UserAdd(const QString &name, const QString &email,
const uint permissions, const long long cpu, const uint permissions, const long long cpu,
const long long gpu, const QString &memory, const long long gpu, const QString &memory,
const QString &gpumemory, const QString &gpumemory,
const QString &storage, const QString &whoAmI, const QString &storage, const QString &token)
const QString &token)
{ {
qCDebug(LOG_DBUS) << "Add new user with paramaters" << name << email qCDebug(LOG_DBUS) << "Add new user with paramaters" << name << email
<< permissions << "auth by" << whoAmI; << permissions;
return m_core->addUser( return m_core->addUser(
name, email, password, permissions, name, email, password, permissions,
QueuedLimits::Limits(cpu, gpu, QueuedLimits::convertMemory(memory), QueuedLimits::Limits(cpu, gpu, QueuedLimits::convertMemory(memory),
QueuedLimits::convertMemory(gpumemory), QueuedLimits::convertMemory(gpumemory),
QueuedLimits::convertMemory(storage)), QueuedLimits::convertMemory(storage)),
QueuedUserManager::auth(whoAmI, token)); token);
} }
@ -231,11 +223,10 @@ bool QueuedCoreInterface::UserEdit(const qlonglong id, const QString &name,
const QString &email, const long long cpu, const QString &email, const long long cpu,
const long long gpu, const QString &memory, const long long gpu, const QString &memory,
const QString &gpumemory, const QString &gpumemory,
const QString &storage, const QString &storage, const QString &token)
const QString &whoAmI, const QString &token)
{ {
qCDebug(LOG_DBUS) << "Edit user" << id << name << email << cpu << gpu qCDebug(LOG_DBUS) << "Edit user" << id << name << email << cpu << gpu
<< memory << gpumemory << storage << "auth by" << whoAmI; << memory << gpumemory << storage;
// get user object first to match limits // get user object first to match limits
auto user = m_core->user(id); auto user = m_core->user(id);
@ -266,7 +257,7 @@ bool QueuedCoreInterface::UserEdit(const qlonglong id, const QString &name,
limits.storage = QueuedLimits::convertMemory(storage); limits.storage = QueuedLimits::convertMemory(storage);
data[QString("limits")] = limits.toString(); data[QString("limits")] = limits.toString();
return m_core->editUser(id, data, QueuedUserManager::auth(whoAmI, token)); return m_core->editUser(id, data, token);
} }
@ -275,15 +266,12 @@ bool QueuedCoreInterface::UserEdit(const qlonglong id, const QString &name,
*/ */
bool QueuedCoreInterface::UserPermissionAdd(const qlonglong id, bool QueuedCoreInterface::UserPermissionAdd(const qlonglong id,
const uint permission, const uint permission,
const QString &whoAmI,
const QString &token) const QString &token)
{ {
qCDebug(LOG_DBUS) << "Add permission" << permission << "to user" << id qCDebug(LOG_DBUS) << "Add permission" << permission << "to user" << id;
<< "auth by" << whoAmI;
return m_core->editUserPermission( return m_core->editUserPermission(
id, static_cast<QueuedEnums::Permission>(permission), true, id, static_cast<QueuedEnums::Permission>(permission), true, token);
QueuedUserManager::auth(whoAmI, token));
} }
@ -292,13 +280,10 @@ bool QueuedCoreInterface::UserPermissionAdd(const qlonglong id,
*/ */
bool QueuedCoreInterface::UserPermissionRemove(const qlonglong id, bool QueuedCoreInterface::UserPermissionRemove(const qlonglong id,
const uint permission, const uint permission,
const QString &whoAmI,
const QString &token) const QString &token)
{ {
qCDebug(LOG_DBUS) << "Remove permission" << permission << "from user" << id qCDebug(LOG_DBUS) << "Remove permission" << permission << "from user" << id;
<< "auth by" << whoAmI;
return m_core->editUserPermission( return m_core->editUserPermission(
id, static_cast<QueuedEnums::Permission>(permission), false, id, static_cast<QueuedEnums::Permission>(permission), false, token);
QueuedUserManager::auth(whoAmI, token));
} }

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

@ -41,14 +41,12 @@ QueuedProcess::QueuedProcess(QObject *parent,
{ {
qCDebug(LOG_LIB) << __PRETTY_FUNCTION__; qCDebug(LOG_LIB) << __PRETTY_FUNCTION__;
qRegisterMetaType<QueuedLimits::Limits>("QueuedLimits::Limits");
// update QProcess related values as well // update QProcess related values as well
// TODO configuration
setCommand(m_definitions.command); setCommand(m_definitions.command);
setCommandArguments(m_definitions.arguments); setCommandArguments(m_definitions.arguments);
setWorkDirectory(m_definitions.workingDirectory); setWorkDirectory(m_definitions.workingDirectory);
setStandardErrorFile(QString("%1-err.log").arg(name()), QIODevice::Append);
setStandardOutputFile(QString("%1-out.log").arg(name()), QIODevice::Append);
} }
@ -91,14 +89,14 @@ void QueuedProcess::updateArguments()
0, 'f', 0)); 0, 'f', 0));
// command line // command line
QString commandLine = command() + "\x01" + commandArguments().join('\x01'); QString commandLine = command() + "\n" + commandArguments().join('\n');
application.replace("{application}", commandLine); application.replace("{application}", commandLine);
QStringList arguments = application.split('\x01'); QStringList arguments = application.split('\n');
// set QProcess properties // set QProcess properties
setProgram(arguments.takeFirst()); setProgram(arguments.takeFirst());
setCommandArguments(arguments); setArguments(arguments);
} }
@ -192,15 +190,6 @@ QString QueuedProcess::processLine() const
} }
/**
* @fn pstate
*/
QueuedEnums::ProcessState QueuedProcess::pstate() const
{
return m_definitions.state;
}
/** /**
* @fn startTime * @fn startTime
*/ */
@ -319,17 +308,6 @@ void QueuedProcess::setProcessLine(const QString &_processLine)
} }
/**
* @fn setPState
*/
void QueuedProcess::setPState(const QueuedEnums::ProcessState _state)
{
qCDebug(LOG_LIB) << "Set process state to" << static_cast<int>(_state);
m_definitions.state = _state;
}
/** /**
* @fn setStartTime * @fn setStartTime
*/ */
@ -372,6 +350,12 @@ void QueuedProcess::setWorkDirectory(const QString &_workDirectory)
qCDebug(LOG_LIB) << "Set working directory to" << _workDirectory; qCDebug(LOG_LIB) << "Set working directory to" << _workDirectory;
m_definitions.workingDirectory = _workDirectory; m_definitions.workingDirectory = _workDirectory;
setStandardErrorFile(
QString("%1/%2-err.log").arg(_workDirectory).arg(name()),
QIODevice::Append);
setStandardOutputFile(
QString("%1/%2-out.log").arg(_workDirectory).arg(name()),
QIODevice::Append);
setWorkingDirectory(_workDirectory); setWorkingDirectory(_workDirectory);
} }

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

@ -35,6 +35,9 @@ QueuedProcessManager::QueuedProcessManager(QObject *parent,
{ {
qCDebug(LOG_LIB) << __PRETTY_FUNCTION__; qCDebug(LOG_LIB) << __PRETTY_FUNCTION__;
qRegisterMetaType<QueuedProcessManager::OnExitAction>(
"QueuedProcessManager::OnExitAction");
setOnExitAction(onExit); setOnExitAction(onExit);
setProcessLine(processLine); setProcessLine(processLine);
} }
@ -47,7 +50,7 @@ QueuedProcessManager::~QueuedProcessManager()
{ {
qCDebug(LOG_LIB) << __PRETTY_FUNCTION__; qCDebug(LOG_LIB) << __PRETTY_FUNCTION__;
QList<long long> indices = m_processes.keys(); QList<long long> indices = processes().keys();
for (auto index : indices) for (auto index : indices)
remove(index); remove(index);
} }
@ -66,7 +69,7 @@ QueuedProcess *QueuedProcessManager::add(const QVariantHash &_properties,
// parameters // parameters
defs.command = _properties[QString("command")].toString(); defs.command = _properties[QString("command")].toString();
defs.arguments = _properties[QString("commandArguments")].toString().split( defs.arguments = _properties[QString("commandArguments")].toString().split(
QChar('\x01')); QChar('\n'));
defs.workingDirectory = _properties[QString("workDirectory")].toString(); defs.workingDirectory = _properties[QString("workDirectory")].toString();
defs.nice = _properties[QString("nice")].toUInt(); defs.nice = _properties[QString("nice")].toUInt();
defs.limits = _properties[QString("limits")].toString(); defs.limits = _properties[QString("limits")].toString();
@ -94,10 +97,11 @@ QueuedProcess *QueuedProcessManager::add(
qCDebug(LOG_LIB) << "Add new process" << _definitions.command qCDebug(LOG_LIB) << "Add new process" << _definitions.command
<< "with index" << _index; << "with index" << _index;
if (m_processes.contains(_index)) if (processes().contains(_index))
return m_processes[_index]; return process(_index);
QueuedProcess *process = new QueuedProcess(this, _definitions, _index); QueuedProcess *process = new QueuedProcess(this, _definitions, _index);
process->setProcessLine(processLine());
m_processes[_index] = process; m_processes[_index] = process;
// connect to signal // connect to signal
m_connections[_index] = connect( m_connections[_index] = connect(
@ -107,6 +111,8 @@ QueuedProcess *QueuedProcessManager::add(
return taskFinished(exitCode, exitStatus, _index); return taskFinished(exitCode, exitStatus, _index);
}); });
// check if we can start new task
start();
return process; return process;
} }
@ -150,7 +156,7 @@ void QueuedProcessManager::remove(const long long _index)
{ {
qCDebug(LOG_LIB) << "Remove process by index" << _index; qCDebug(LOG_LIB) << "Remove process by index" << _index;
if (!m_processes.contains(_index)) if (!processes().contains(_index))
return; return;
QueuedProcess *pr = m_processes.take(_index); QueuedProcess *pr = m_processes.take(_index);
@ -188,6 +194,9 @@ void QueuedProcessManager::start()
auto tasks = processes().values(); auto tasks = processes().values();
for (auto pr : tasks) { for (auto pr : tasks) {
// check task state
if (pr->state() != QProcess::ProcessState::NotRunning)
continue;
// check limits first // check limits first
if (((1.0 - weightedCpu) if (((1.0 - weightedCpu)
< QueuedSystemInfo::cpuWeight(pr->nativeLimits().cpu)) < QueuedSystemInfo::cpuWeight(pr->nativeLimits().cpu))
@ -222,8 +231,10 @@ void QueuedProcessManager::start(const long long _index)
return; return;
} }
QDateTime start = QDateTime::currentDateTimeUtc();
pr->start(); pr->start();
emit(taskStartTimeReceived(_index, QDateTime::currentDateTimeUtc())); pr->setStartTime(start);
emit(taskStartTimeReceived(_index, start));
} }
@ -288,7 +299,7 @@ void QueuedProcessManager::setProcessLine(const QString _processLine)
qCDebug(LOG_LIB) << "Set process line to" << _processLine; qCDebug(LOG_LIB) << "Set process line to" << _processLine;
m_processLine = _processLine; m_processLine = _processLine;
for (auto process : m_processes.values()) for (auto process : processes().values())
process->setProcessLine(processLine()); process->setProcessLine(processLine());
} }
@ -302,35 +313,35 @@ QueuedLimits::Limits QueuedProcessManager::usedLimits()
long long cpu = std::accumulate( long long cpu = std::accumulate(
tasks.cbegin(), tasks.cend(), 0, tasks.cbegin(), tasks.cend(), 0,
[](long long value, QueuedProcess *process) { [](long long value, QueuedProcess *process) {
return process->pstate() == QueuedEnums::ProcessState::Running return process->state() == QProcess::ProcessState::Running
? value + process->nativeLimits().cpu ? value + process->nativeLimits().cpu
: value; : value;
}); });
long long gpu = std::accumulate( long long gpu = std::accumulate(
tasks.cbegin(), tasks.cend(), 0, tasks.cbegin(), tasks.cend(), 0,
[](long long value, QueuedProcess *process) { [](long long value, QueuedProcess *process) {
return process->pstate() == QueuedEnums::ProcessState::Running return process->state() == QProcess::ProcessState::Running
? value + process->nativeLimits().gpu ? value + process->nativeLimits().gpu
: value; : value;
}); });
long long memory = std::accumulate( long long memory = std::accumulate(
tasks.cbegin(), tasks.cend(), 0, tasks.cbegin(), tasks.cend(), 0,
[](long long value, QueuedProcess *process) { [](long long value, QueuedProcess *process) {
return process->pstate() == QueuedEnums::ProcessState::Running return process->state() == QProcess::ProcessState::Running
? value + process->nativeLimits().memory ? value + process->nativeLimits().memory
: value; : value;
}); });
long long gpumemory = std::accumulate( long long gpumemory = std::accumulate(
tasks.cbegin(), tasks.cend(), 0, tasks.cbegin(), tasks.cend(), 0,
[](long long value, QueuedProcess *process) { [](long long value, QueuedProcess *process) {
return process->pstate() == QueuedEnums::ProcessState::Running return process->state() == QProcess::ProcessState::Running
? value + process->nativeLimits().gpumemory ? value + process->nativeLimits().gpumemory
: value; : value;
}); });
long long storage = std::accumulate( long long storage = std::accumulate(
tasks.cbegin(), tasks.cend(), 0, tasks.cbegin(), tasks.cend(), 0,
[](long long value, QueuedProcess *process) { [](long long value, QueuedProcess *process) {
return process->pstate() == QueuedEnums::ProcessState::Running return process->state() == QProcess::ProcessState::Running
? value + process->nativeLimits().storage ? value + process->nativeLimits().storage
: value; : value;
}); });
@ -352,7 +363,7 @@ void QueuedProcessManager::taskFinished(const int _exitCode,
auto pr = process(_index); auto pr = process(_index);
if (pr) { if (pr) {
auto endTime = QDateTime::currentDateTimeUtc(); auto endTime = QDateTime::currentDateTimeUtc();
pr->setEndTime(endTime); remove(_index);
emit(taskStopTimeReceived(_index, endTime)); emit(taskStopTimeReceived(_index, endTime));
} }

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

@ -39,6 +39,10 @@ QueuedSettings::QueuedSettings(QObject *parent, const QString path)
{ {
qCDebug(LOG_LIB) << __PRETTY_FUNCTION__; qCDebug(LOG_LIB) << __PRETTY_FUNCTION__;
qRegisterMetaType<QueuedCfg::QueuedAdminSetup>(
"QueuedCfg::QueuedAdminSetup");
qRegisterMetaType<QueuedCfg::QueuedDBSetup>("QueuedCfg::QueuedDBSetup");
readConfiguration(); readConfiguration();
} }

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

@ -25,6 +25,7 @@
#include <QTimer> #include <QTimer>
#include <QUuid> #include <QUuid>
#include <queued/Queued.h>
/** /**
@ -52,12 +53,38 @@ QueuedTokenManager::~QueuedTokenManager()
/** /**
* @fn isTokenValid * @fn isTokenValid
*/ */
bool QueuedTokenManager::isTokenValid(const QString &_token) const QString QueuedTokenManager::isTokenValid(const QString &_token) const
{ {
qCDebug(LOG_LIB) << "Check token on validity" << _token; qCDebug(LOG_LIB) << "Check token on validity" << _token;
return m_tokens.contains(_token) if (m_tokens.contains(_token)
&& (tokenExpiration(_token) > QDateTime::currentDateTimeUtc()); && (tokenExpiration(_token) > QDateTime::currentDateTimeUtc()))
return m_tokens[_token].user;
else
return QString();
}
/**
* @brief loadToken
*/
void QueuedTokenManager::loadToken(
const QueuedTokenManager::QueuedTokenDefinitions &_definitions)
{
qCDebug(LOG_LIB) << "Add toen for user" << _definitions.user
<< "valud until" << _definitions.validUntil;
m_tokens[_definitions.token] = _definitions;
// register expiry timer
std::chrono::milliseconds duration(
_definitions.validUntil.toMSecsSinceEpoch()
- QDateTime::currentDateTimeUtc().toMSecsSinceEpoch());
QTimer timer;
timer.setSingleShot(true);
timer.setInterval(duration);
connect(&timer, &QTimer::timeout,
[this, _definitions]() { return expireToken(_definitions.token); });
} }
@ -71,17 +98,8 @@ void QueuedTokenManager::loadTokens(const QList<QVariantHash> &_values)
for (auto &token : _values) { for (auto &token : _values) {
QDateTime validUntil = QDateTime::fromString( QDateTime validUntil = QDateTime::fromString(
token[QString("validUntil")].toString(), Qt::ISODate); token[QString("validUntil")].toString(), Qt::ISODate);
QString tokenId = token[QString("token")].toString(); loadToken({token[QString("token")].toString(),
m_tokens[tokenId] = validUntil; token[QString("user")].toString(), validUntil});
// create timer
std::chrono::milliseconds duration(
validUntil.toMSecsSinceEpoch()
- QDateTime::currentDateTimeUtc().toMSecsSinceEpoch());
QTimer timer;
timer.setSingleShot(true);
timer.setInterval(duration);
connect(&timer, &QTimer::timeout,
[this, tokenId]() { return expireToken(tokenId); });
} }
} }
@ -89,7 +107,8 @@ void QueuedTokenManager::loadTokens(const QList<QVariantHash> &_values)
/** /**
* @fn registerToken * @fn registerToken
*/ */
QString QueuedTokenManager::registerToken(const QDateTime _validUntil) QString QueuedTokenManager::registerToken(const QString &_user,
const QDateTime &_validUntil)
{ {
// generate from uuid // generate from uuid
QString token QString token
@ -98,8 +117,7 @@ QString QueuedTokenManager::registerToken(const QDateTime _validUntil)
<< _validUntil; << _validUntil;
// append to internal storage // append to internal storage
m_tokens[token] = _validUntil; loadToken({token, _user, _validUntil});
emit(tokenRegistered(token, _validUntil));
// and return requester // and return requester
return token; return token;
@ -111,7 +129,7 @@ QString QueuedTokenManager::registerToken(const QDateTime _validUntil)
*/ */
QDateTime QueuedTokenManager::tokenExpiration(const QString &_token) const QDateTime QueuedTokenManager::tokenExpiration(const QString &_token) const
{ {
return m_tokens[_token]; return m_tokens[_token].validUntil;
} }

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

@ -44,6 +44,8 @@ QueuedUser::QueuedUser(QObject *parent,
, m_index(index) , m_index(index)
{ {
qCDebug(LOG_LIB) << __PRETTY_FUNCTION__; qCDebug(LOG_LIB) << __PRETTY_FUNCTION__;
qRegisterMetaType<QueuedLimits::Limits>("QueuedLimits::Limits");
} }

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

@ -93,22 +93,6 @@ QueuedUserManager::add(const QueuedUser::QueuedUserDefinitions &_definitions,
} }
/**
* @fn auth
*/
QueuedUserManager::QueuedUserAuthorization
QueuedUserManager::auth(const QString &_user, const QString &_token)
{
qCDebug(LOG_LIB) << "Generate auth structure for user" << _user;
QueuedUserAuthorization authObj;
authObj.user = _user;
authObj.token = _token;
return authObj;
}
/** /**
* @fn authorize * @fn authorize
*/ */
@ -117,7 +101,7 @@ QString QueuedUserManager::authorize(const QString &_user,
{ {
qCDebug(LOG_LIB) << "Authorize user" << _user; qCDebug(LOG_LIB) << "Authorize user" << _user;
auto userObj = user(_user); auto userObj = user(_user, false);
if (!userObj) { if (!userObj) {
qCInfo(LOG_LIB) << "No user found" << _user; qCInfo(LOG_LIB) << "No user found" << _user;
return QString(); return QString();
@ -132,28 +116,27 @@ QString QueuedUserManager::authorize(const QString &_user,
auto time = QDateTime::currentDateTimeUtc(); auto time = QDateTime::currentDateTimeUtc();
QDateTime expiry = time.addDays(tokenExpiration()); QDateTime expiry = time.addDays(tokenExpiration());
emit(userLoggedIn(userObj->index(), time)); emit(userLoggedIn(userObj->index(), time));
return m_tokens->registerToken(expiry); return m_tokens->registerToken(_user, expiry);
} }
/** /**
* @fn authorize * @fn authorize
*/ */
bool QueuedUserManager::authorize(const QueuedUserAuthorization &_auth, bool QueuedUserManager::authorize(const QString &_token,
const QueuedEnums::Permission _service) const QueuedEnums::Permission _service)
{ {
qCDebug(LOG_LIB) << "Authorize user" << _auth.user << "for" qCDebug(LOG_LIB) << "Authorize user for" << static_cast<int>(_service);
<< static_cast<int>(_service);
bool status = m_tokens->isTokenValid(_auth.token); QString username = m_tokens->isTokenValid(_token);
if (!status) { if (username.isEmpty()) {
qCInfo(LOG_LIB) << "Token invalid for user" << _auth.user; qCInfo(LOG_LIB) << "Token" << _token << "invalid";
return false; return false;
} }
auto userObj = user(_auth.user); auto userObj = user(username, false);
if (!userObj) { if (!userObj) {
qCInfo(LOG_LIB) << "No user found" << _auth.user; qCInfo(LOG_LIB) << "No user found" << username;
return false; return false;
} }
@ -167,8 +150,10 @@ bool QueuedUserManager::authorize(const QueuedUserAuthorization &_auth,
QDateTime QueuedUserManager::checkToken(const QString &_token, QDateTime QueuedUserManager::checkToken(const QString &_token,
bool *_valid) const bool *_valid) const
{ {
if (_valid) if (_valid) {
*_valid = m_tokens->isTokenValid(_token); QString user = m_tokens->isTokenValid(_token);
*_valid = !user.isEmpty();
}
return m_tokens->tokenExpiration(_token); return m_tokens->tokenExpiration(_token);
} }
@ -235,11 +220,14 @@ QueuedUser *QueuedUserManager::user(const long long _id)
/** /**
* @fn user * @fn user
*/ */
QueuedUser *QueuedUserManager::user(const QString &_name) QueuedUser *QueuedUserManager::user(const QString &_name, const bool _isToken)
{ {
qCDebug(LOG_LIB) << "Look for user" << _name; qCDebug(LOG_LIB) << "Look for user" << _name << "is token" << _isToken;
return m_users.value(_name, nullptr); if (_isToken)
return m_users.value(m_tokens->isTokenValid(_name), nullptr);
else
return m_users.value(_name, nullptr);
} }