arcanis/queued
1
0
Fork 0
mirror of https://github.com/arcan1s/queued.git synced 2025-04-25 07:57:18 +00:00
Code Issues Projects Releases Wiki Activity

core and processanager improvements

Browse Source
This commit is contained in:
Evgenii Alekseev 2017-02-27 00:40:37 +03:00
parent c2b92cd212
commit 8ab4eb155c
16 changed files with 698 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -51,6 +51,12 @@ public:
* @return value by key if found * @return value by key if found
*/ */
QVariant get(const QString &_key) const; QVariant get(const QString &_key) const;
/**
* @brief get database value ID
* @param _key key to search in
* @return database id or -1 if not found
*/
long long id(const QString &_key) const;
/** /**
* @brief set value * @brief set value
* @param _key key to change * @param _key key to change
@ -71,6 +77,10 @@ private:
* @brief stored values * @brief stored values
*/ */
QVariantHash m_values; QVariantHash m_values;
/**
* @brief ids of values
*/
QHash<QString, long long> m_ids;
}; };

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

@ -26,6 +26,7 @@
#include <QObject> #include <QObject>
#include "QueuedEnums.h"
#include "QueuedLimits.h" #include "QueuedLimits.h"
@ -83,14 +84,41 @@ public:
* @brief deinit subclasses * @brief deinit subclasses
*/ */
void deinit(); void deinit();
/**
* @brief edit advanced settings
* @param _key advanced settings key
* @param _value advanced settings value
* @return true on successful option edition
*/
bool editOption(const QString &_key, const QVariant &_value);
/**
* @brief edit task
* @param _id task ID to edit
* @param _taskData task data to edit
* @remark _taskData should contain only fields defined in schema, any other
* fields will be ignored. No need to pass all properties here
* @return true on successful task edition
*/
bool editTask(const long long _id, const QVariantHash &_taskData);
/** /**
* @brief edit user * @brief edit user
* @param _id user ID to edit * @param _id user ID to edit
* @param _userData user data to edit * @param _userData user data to edit
* @remark ref * @remark _userData should contain only fields defined in schema, any other
* @return * fields will be ignored. No need to pass all properties here
* @return true on successful user edition
*/ */
bool editUser(const long long _id, const QVariantHash &_userData); bool editUser(const long long _id, const QVariantHash &_userData);
/**
* @brief edit user permissions
* @param _id user ID to edit
* @param _permission permission to add or remove
* @param _add indicates whether it should be added or removed
* @return true on successful user permission edition
*/
bool editUserPermission(const long long _id,
const QueuedEnums::Permission &_permission,
const bool _add);
/** /**
* @brief init subclasses * @brief init subclasses
* @param _configuration path to configuration file * @param _configuration path to configuration file
@ -98,6 +126,12 @@ public:
void init(const QString &_configuration); void init(const QString &_configuration);
private slots: private slots:
/**
* @brief notify clients about settings update
* @param _key updated key
* @param _value new value
*/
void updateSettings(const QString &_key, const QVariant &_value);
/** /**
* @brief update process time * @brief update process time
* @param _id task id * @param _id task id

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

@ -89,13 +89,14 @@ const QueuedDBSchema DBSchema = {
{TASKS_TABLE, {TASKS_TABLE,
{{"_id", {{"_id",
{"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong}}, {"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong}},
{"userId", {"userId", "INT NOT NULL DEFAULT 0", QVariant::LongLong}}, {"user", {"user", "INT NOT NULL DEFAULT 0", QVariant::LongLong}},
{"command", {"command", "TEXT", QVariant::String}}, {"command", {"command", "TEXT", QVariant::String}},
{"arguments", {"arguments", "TEXT", QVariant::String}}, {"commandArguments", {"commandArguments", "TEXT", QVariant::String}},
{"workDirectory", {"workDirectory", "TEXT", QVariant::String}}, {"workDirectory", {"workDirectory", "TEXT", QVariant::String}},
{"nice", {"nice", "INT", QVariant::UInt}}, {"nice", {"nice", "INT", QVariant::UInt}},
{"uid", {"uid", "INT", QVariant::UInt}}, {"uid", {"uid", "INT", QVariant::UInt}},
{"gid", {"gid", "INT", QVariant::UInt}}, {"gid", {"gid", "INT", QVariant::UInt}},
{"state", {"state", "INT", QVariant::UInt}},
{"limits", {"limits", "TEXT", QVariant::String}}, {"limits", {"limits", "TEXT", QVariant::String}},
{"startTime", {"startTime", "INT", QVariant::LongLong}}, {"startTime", {"startTime", "INT", QVariant::LongLong}},
{"endTime", {"endTime", "INT", QVariant::LongLong}}}}, {"endTime", {"endTime", "INT", QVariant::LongLong}}}},
@ -110,7 +111,7 @@ const QueuedDBSchema DBSchema = {
{{"_id", {{"_id",
{"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong}}, {"_id", "INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE", QVariant::LongLong}},
{"name", {"name", "TEXT NOT NULL UNIQUE DEFAULT '0'", QVariant::String}}, {"name", {"name", "TEXT NOT NULL UNIQUE DEFAULT '0'", QVariant::String}},
{"passwordSHA512", {"passwordSHA512", "TEXT", QVariant::String}}, {"password", {"password", "TEXT", QVariant::String}},
{"email", {"email", "TEXT", QVariant::String}}, {"email", {"email", "TEXT", QVariant::String}},
{"lastLogin", {"lastLogin", "TEXT", QVariant::String}}, {"lastLogin", {"lastLogin", "TEXT", QVariant::String}},
{"limits", {"limits", "TEXT", QVariant::String}}, {"limits", {"limits", "TEXT", QVariant::String}},

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

@ -83,6 +83,22 @@ 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 << 0,
Running = 1 << 1,
Exited = 1 << 2
};
}; };

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

@ -27,6 +27,7 @@
#include <QDateTime> #include <QDateTime>
#include <QProcess> #include <QProcess>
#include "QueuedEnums.h"
#include "QueuedLimits.h" #include "QueuedLimits.h"
@ -38,6 +39,19 @@ class QueuedProcess : public QProcess
Q_OBJECT Q_OBJECT
Q_PROPERTY(long long index READ index) Q_PROPERTY(long long index READ index)
Q_PROPERTY(QString name READ name) Q_PROPERTY(QString name READ name)
// mutable properties
Q_PROPERTY(QString command READ command WRITE setCommand)
Q_PROPERTY(QStringList commandArguments READ commandArguments WRITE
setCommandArguments)
Q_PROPERTY(QDateTime endTime READ endTime WRITE setEndTime)
Q_PROPERTY(unsigned int gid READ uid WRITE setGid)
Q_PROPERTY(QueuedLimits::Limits limits READ limits WRITE setLimits)
Q_PROPERTY(unsigned int nice READ nice WRITE setNice)
Q_PROPERTY(QueuedEnums::ProcessState pstate READ pstate WRITE setPState)
Q_PROPERTY(QDateTime startTime READ startTime WRITE setStartTime)
Q_PROPERTY(unsigned int uid READ uid WRITE setUid)
Q_PROPERTY(long long user READ user WRITE setUser)
Q_PROPERTY(QString workDirectory READ workDirectory WRITE setWorkDirectory)
public: public:
/** /**
@ -63,6 +77,8 @@ 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;
@ -75,6 +91,7 @@ public:
QDateTime endTime; QDateTime endTime;
long long user; long long user;
QueuedLimits::Limits limits; QueuedLimits::Limits limits;
QueuedEnums::ProcessState state;
} QueuedProcessDefinitions; } QueuedProcessDefinitions;
/** /**
@ -100,6 +117,117 @@ public:
* @return generated name of process * @return generated name of process
*/ */
QString name() const; QString name() const;
// mutable properties
/**
* @brief command line
* @return process command line
*/
QString command() const;
/**
* @brief command line arguments
* @return process command line arguments
*/
QStringList commandArguments() const;
/**
* @brief process end time
* @return process end time
*/
QDateTime endTime() const;
/**
* @brief process GID
* @return process GID
*/
unsigned int gid() const;
/**
* @brief process limits
* @return process defined limits
*/
QueuedLimits::Limits limits() const;
/**
* @brief process nice
* @return process nice
*/
unsigned int nice() const;
/**
* @brief process state
* @return process defined state
*/
QueuedEnums::ProcessState pstate() const;
/**
* @brief process start time
* @return process start time
*/
QDateTime startTime() const;
/**
* @brief process UID
* @return process UID
*/
unsigned int uid() const;
/**
* @brief user
* @return process owner ID
*/
long long user() const;
/**
* @brief working directory
* @return process working directory
*/
QString workDirectory() const;
/**
* @brief set command line
* @param _command new command line
*/
void setCommand(const QString &_command);
/**
* @brief set command line arguments
* @param _commandArguments new command line arguments
*/
void setCommandArguments(const QStringList &_commandArguments);
/**
* @brief set end time
* @param _time process end time
*/
void setEndTime(const QDateTime &_time);
/**
* @brief set process GID
* @param _gid new process GID
*/
void setGid(const unsigned int _gid);
/**
* @brief set process limits
* @param _limits new process limits
*/
void setLimits(const QueuedLimits::Limits &_limits);
/**
* @brief set process nice
* @param _nice new process nice
*/
void setNice(const unsigned int _nice);
/**
* @brief set process state
* @param _limits new process state
*/
void setPState(const QueuedEnums::ProcessState _state);
/**
* @brief set start time
* @param _time process start time
*/
void setStartTime(const QDateTime &_time);
/**
* @brief set process UID
* @param _uid new process UID
*/
void setUid(const unsigned int _uid);
/**
* @brief set user ID
* @param _user new user ID
*/
void setUser(const long long _user);
/**
* @brief set working directory
* @param _workDirectory new process working directory
*/
void setWorkDirectory(const QString &_workDirectory);
/** /**
* @brief equal operator implementation * @brief equal operator implementation
* @param _other other object * @param _other other object
@ -113,17 +241,6 @@ protected:
*/ */
void setupChildProcess(); void setupChildProcess();
public slots:
/**
* @brief run process
*/
void run();
/**
* @brief set end time
* @param _time process end time
*/
void setEndTime(const QDateTime &_time);
private: private:
/** /**
* @brief process definitions * @brief process definitions

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

@ -37,7 +37,7 @@
class QueuedProcessManager : public QObject class QueuedProcessManager : public QObject
{ {
Q_OBJECT Q_OBJECT
Q_PROPERTY(OnExitAction onExit READ onExit) Q_PROPERTY(OnExitAction onExit READ onExit WRITE setOnExitAction)
public: public:
/** /**
@ -109,16 +109,27 @@ public:
* @param _index task index * @param _index task index
*/ */
void remove(const long long _index); void remove(const long long _index);
/**
* @brief force start task
* @param _index task index
*/
void start(const long long _index);
/** /**
* @brief force stop task * @brief force stop task
* @param _index task index * @param _index task index
*/ */
void stop(const long long _index); void stop(const long long _index);
// properties
/** /**
* @brief default action on exit * @brief default action on exit
* @return default action from possible ones * @return default action from possible ones
*/ */
OnExitAction onExit() const; OnExitAction onExit() const;
/**
* @brief set on exit action
* @param _action new on exit action
*/
void setOnExitAction(const OnExitAction _action);
signals: signals:
/** /**

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

@ -51,17 +51,17 @@ public:
* @return true if token is valid otherwise return false * @return true if token is valid otherwise return false
*/ */
bool isTokenValid(const QString &_token); bool isTokenValid(const QString &_token);
/**
* @brief upload tokens from database
* @param _value tokens from database
*/
void loadTokens(const QList<QVariantHash> &_values);
/** /**
* @brief register new token * @brief register new token
* @param _validUntil token valid until * @param _validUntil token valid until
* @return new generated token * @return new generated token
*/ */
QString registerToken(const QDateTime _validUntil); QString registerToken(const QDateTime _validUntil);
/**
* @brief upload tokens from database
* @param _value tokens from database
*/
void set(const QList<QVariantHash> &_values);
public slots: public slots:
/** /**

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

@ -39,15 +39,12 @@ class QueuedUser : public QObject
Q_OBJECT Q_OBJECT
Q_PROPERTY(long long index READ index) Q_PROPERTY(long long index READ index)
// generic properties // generic properties
Q_PROPERTY(QString email READ email WRITE setEmail NOTIFY userUpdated) Q_PROPERTY(QString email READ email WRITE setEmail)
Q_PROPERTY(QString name READ name WRITE setName NOTIFY userUpdated) Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY( Q_PROPERTY(QString password READ password WRITE setPassword)
QString password READ password WRITE setPassword NOTIFY userUpdated) Q_PROPERTY(unsigned int permissions READ permissions WRITE setPermissions)
Q_PROPERTY(unsigned int permissions READ permissions WRITE setPermissions
NOTIFY userUpdated)
// limits // limits
Q_PROPERTY(QueuedLimits::Limits limits READ limits WRITE setLimits NOTIFY Q_PROPERTY(QueuedLimits::Limits limits READ limits WRITE setLimits)
userUpdated)
public: public:
/** /**
@ -57,7 +54,7 @@ public:
* user name * user name
* @var email * @var email
* user email * user email
* @var passwordSHA512 * @var password
* password hash, may be empty * password hash, may be empty
* @var permissions * @var permissions
* user permissions * user permissions
@ -67,7 +64,7 @@ public:
typedef struct { typedef struct {
QString name; QString name;
QString email; QString email;
QString passwordSHA512; QString password;
unsigned int permissions; unsigned int permissions;
QueuedLimits::Limits limits; QueuedLimits::Limits limits;
} QueuedUserDefinitions; } QueuedUserDefinitions;
@ -189,12 +186,6 @@ public:
*/ */
bool operator==(const QueuedUser &_other); bool operator==(const QueuedUser &_other);
signals:
/**
* @brief signal which emits on any property set action
*/
void userUpdated();
private: private:
/** /**
* @brief process definitions * @brief process definitions

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

@ -53,7 +53,18 @@ QVariant QueuedAdvancedSettings::get(const QString &_key) const
{ {
qCDebug(LOG_LIB) << "Looking for key" << _key; qCDebug(LOG_LIB) << "Looking for key" << _key;
return m_values[_key]; return m_values.value(_key.toLower(), QVariant());
}
/**
* @fn id
*/
long long QueuedAdvancedSettings::id(const QString &_key) const
{
qCDebug(LOG_LIB) << "Looking for ID for key" << _key;
return m_ids.value(_key.toLower(), -1);
} }
@ -64,7 +75,7 @@ void QueuedAdvancedSettings::set(const QString &_key, const QVariant &_value)
{ {
qCDebug(LOG_LIB) << "Set value" << _value << "for key" << _key; qCDebug(LOG_LIB) << "Set value" << _value << "for key" << _key;
m_values[_key] = _value; m_values[_key.toLower()] = _value;
emit(valueUpdated(_key, _value)); emit(valueUpdated(_key, _value));
} }
@ -76,6 +87,9 @@ void QueuedAdvancedSettings::set(const QList<QVariantHash> &_values)
{ {
qCDebug(LOG_LIB) << "Set values from" << _values; qCDebug(LOG_LIB) << "Set values from" << _values;
for (auto &pair : _values) for (auto &pair : _values) {
set(pair[QString("key")].toString(), pair[QString("value")]); QString key = pair[QString("key")].toString().toLower();
m_ids[key] = pair[QString("_id")].toLongLong();
set(key, pair[QString("value")]);
}
} }

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

@ -66,11 +66,14 @@ bool QueuedCore::addTask(const QString &_command, const QStringList &_arguments,
_limits, m_users->user(_userId)->limits(), _limits, m_users->user(_userId)->limits(),
QueuedLimits::Limits( QueuedLimits::Limits(
m_advancedSettings->get(QString("DefaultLimits")).toString())); m_advancedSettings->get(QString("DefaultLimits")).toString()));
QVariantHash properties QVariantHash properties = {{"user", _userId},
= {{"userId", _userId}, {"command", _command}, {"command", _command},
{"arguments", _arguments}, {"workDirectory", _workingDirectory}, {"commandArguments", _arguments},
{"nice", _nice}, {"uid", ids.first}, {"workDirectory", _workingDirectory},
{"gid", ids.second}, {"limits", taskLimits.toString()}}; {"nice", _nice},
{"uid", ids.first},
{"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;
@ -95,7 +98,7 @@ bool QueuedCore::addUser(const QString &_name, const QString &_email,
QVariantHash properties QVariantHash properties
= {{"name", _name}, = {{"name", _name},
{"passwordSHA512", QueuedUser::hashFromPassword(_password)}, {"password", QueuedUser::hashFromPassword(_password)},
{"email", _email}, {"email", _email},
{"permissions", _permissions}, {"permissions", _permissions},
{"limits", _limits.toString()}}; {"limits", _limits.toString()}};
@ -136,6 +139,136 @@ void QueuedCore::deinit()
} }
/**
* @fn editOption
*/
bool QueuedCore::editOption(const QString &_key, const QVariant &_value)
{
qCDebug(LOG_LIB) << "Set key" << _key << "to" << _value;
long long id = m_advancedSettings->id(_key);
QVariantHash payload = {
{"key", _key}, {"value", _value},
};
bool status = false;
if (id == -1) {
id = m_database->add(QueuedDB::SETTINGS_TABLE, payload);
qCInfo(LOG_LIB) << "Added new key with ID" << id;
status = (id != -1);
} else {
status = m_database->modify(QueuedDB::SETTINGS_TABLE, id, payload);
qCInfo(LOG_LIB) << "Value for" << _key
<< "has been modified with status" << status;
}
if (status)
m_advancedSettings->set(_key, _value);
return status;
}
/**
* @fn editTask
*/
bool QueuedCore::editTask(const long long _id, const QVariantHash &_taskData)
{
qCDebug(LOG_LIB) << "Edit task with ID" << _id;
auto task = m_processes->process(_id);
if (!task) {
qCWarning(LOG_LIB) << "Could not find task with ID" << _id;
return false;
}
// modify record in database first
bool status = m_database->modify(QueuedDB::TASKS_TABLE, _id, _taskData);
if (!status) {
qCWarning(LOG_LIB) << "Could not modify task record" << _id
<< "in database, do not edit it in memory";
return false;
}
// modify values stored in memory
for (auto &property : _taskData.keys())
task->setProperty(property.toLocal8Bit().constData(),
_taskData[property]);
return true;
}
/**
* @fn editUser
*/
bool QueuedCore::editUser(const long long _id, const QVariantHash &_userData)
{
qCDebug(LOG_LIB) << "Edit user with ID" << _id;
auto user = m_users->user(_id);
if (!user) {
qCWarning(LOG_LIB) << "Could not find user with ID" << _id;
return false;
}
// modify record in database first
bool status = m_database->modify(QueuedDB::USERS_TABLE, _id, _userData);
if (!status) {
qCWarning(LOG_LIB) << "Could not modify user record" << _id
<< "in database, do not edit it in memory";
return false;
}
// modify values stored in memory
for (auto &property : _userData.keys())
user->setProperty(property.toLocal8Bit().constData(),
_userData[property]);
return true;
}
/**
* @fn editUserPermission
*/
bool QueuedCore::editUserPermission(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;
auto user = m_users->user(_id);
if (!user) {
qCWarning(LOG_LIB) << "Could not find user with ID" << _id;
return false;
}
if (_add)
user->addPermissions(_permission);
else
user->removePermissions(_permission);
unsigned int permissions = user->permissions();
qCInfo(LOG_LIB) << "New user permissions";
// modify in database now
QVariantHash payload = {{"permissions", permissions}};
bool status = m_database->modify(QueuedDB::USERS_TABLE, _id, payload);
if (!status) {
qCWarning(LOG_LIB) << "Could not modify user record" << _id
<< "in database, do not edit it in memory";
// rollback in-memory values
if (_add)
user->removePermissions(_permission);
else
user->addPermissions(_permission);
return false;
}
return true;
}
/** /**
* @fn init * @fn init
*/ */
@ -189,6 +322,33 @@ void QueuedCore::init(const QString &_configuration)
[this](const long long _index, const QDateTime &_time) { [this](const long long _index, const QDateTime &_time) {
return updateTaskTime(_index, QDateTime(), _time); return updateTaskTime(_index, QDateTime(), _time);
}); });
// settings update notifier
m_connections += connect(
m_advancedSettings,
SIGNAL(valueUpdated(const QString &, const QVariant &)), this,
SLOT(updateSettings(const QString &, const QVariant &)));
}
/**
* @fn updateSettings
*/
void QueuedCore::updateSettings(const QString &_key, const QVariant &_value)
{
qCDebug(LOG_LIB) << "Received update for" << _key << "with value" << _value;
// FIXME propbably there is a better way to change settings
QString key = _key.toLower();
if (key == QString("defaultlimits"))
;
else if (key == QString("tokenexpiration"))
m_users->setTokenExpiration(_value.toLongLong());
else if (key == QString("onexitaction"))
m_processes->setOnExitAction(
static_cast<QueuedProcessManager::OnExitAction>(_value.toInt()));
else
qCInfo(LOG_LIB) << "Unused key" << _key;
} }

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

@ -354,6 +354,10 @@ QueuedDatabase::getQueryPayload(const QString &_table,
<< _table; << _table;
continue; continue;
} }
if (key == QString("_id")) {
qCWarning(LOG_LIB) << "Modifying record ID is not allowed";
continue;
}
keys.append(key); keys.append(key);
values.append(QString("'%1'").arg(_value[key].toString())); values.append(QString("'%1'").arg(_value[key].toString()));
} }

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

@ -45,9 +45,10 @@ QueuedProcess::QueuedProcess(QObject *parent,
{ {
qCDebug(LOG_LIB) << __PRETTY_FUNCTION__; qCDebug(LOG_LIB) << __PRETTY_FUNCTION__;
setArguments(m_definitions.arguments); // update QProcess related values as well
setProgram(m_definitions.command); setCommand(m_definitions.command);
setWorkingDirectory(m_definitions.workingDirectory); setCommandArguments(m_definitions.arguments);
setWorkDirectory(m_definitions.workingDirectory);
} }
@ -78,6 +79,229 @@ QString QueuedProcess::name() const
} }
/**
* @fn command
*/
QString QueuedProcess::command() const
{
return m_definitions.command;
}
/**
* @fn commandArguments
*/
QStringList QueuedProcess::commandArguments() const
{
return m_definitions.arguments;
}
/**
* @fn endTime
*/
QDateTime QueuedProcess::endTime() const
{
return m_definitions.endTime;
}
/**
* @fn gid
*/
unsigned int QueuedProcess::gid() const
{
return m_definitions.gid;
}
/**
* @fn limits
*/
QueuedLimits::Limits QueuedProcess::limits() const
{
return m_definitions.limits;
}
/**
* @fn nice
*/
unsigned int QueuedProcess::nice() const
{
return m_definitions.nice;
}
/**
* @fn pstate
*/
QueuedEnums::ProcessState QueuedProcess::pstate() const
{
return m_definitions.state;
}
/**
* @fn startTime
*/
QDateTime QueuedProcess::startTime() const
{
return m_definitions.startTime;
}
/**
* @fn uid
*/
unsigned int QueuedProcess::uid() const
{
return m_definitions.uid;
}
/**
* @fn user
*/
long long QueuedProcess::user() const
{
return m_definitions.user;
}
/**
* @fn workDirectory
*/
QString QueuedProcess::workDirectory() const
{
return m_definitions.workingDirectory;
}
/**
* @fn setCommand
*/
void QueuedProcess::setCommand(const QString &_command)
{
qCDebug(LOG_LIB) << "Set command to" << _command;
m_definitions.command = _command;
setProgram(_command);
}
/**
* @fn setCommandArguments
*/
void QueuedProcess::setCommandArguments(const QStringList &_commandArguments)
{
qCDebug(LOG_LIB) << "Set command line arguments to" << _commandArguments;
m_definitions.arguments = _commandArguments;
setArguments(_commandArguments);
}
/**
* @fn setEndTime
*/
void QueuedProcess::setEndTime(const QDateTime &_time)
{
qCDebug(LOG_LIB) << "Set end time to" << _time;
m_definitions.endTime = _time;
}
/**
* @fn setGid
*/
void QueuedProcess::setGid(const unsigned int _gid)
{
qCDebug(LOG_LIB) << "Set process GID to" << _gid;
m_definitions.gid = _gid;
}
/**
* setLimits
*/
void QueuedProcess::setLimits(const QueuedLimits::Limits &_limits)
{
qCDebug(LOG_LIB) << "Set process limits" << _limits.toString();
m_definitions.limits = _limits;
}
/**
* @fn setNice
*/
void QueuedProcess::setNice(const unsigned int _nice)
{
qCDebug(LOG_LIB) << "Set nice level to" << _nice;
m_definitions.nice = _nice;
}
/**
* @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
*/
void QueuedProcess::setStartTime(const QDateTime &_time)
{
qCDebug(LOG_LIB) << "Set start time to" << _time;
m_definitions.startTime = _time;
}
/**
* @fn setUid
*/
void QueuedProcess::setUid(const unsigned int _uid)
{
qCDebug(LOG_LIB) << "Set process UID to" << _uid;
m_definitions.uid = _uid;
}
/**
* @fn setUser
*/
void QueuedProcess::setUser(const long long _user)
{
qCDebug(LOG_LIB) << "Set user to" << _user;
m_definitions.user = _user;
}
/**
* @fn setWorkDirectory
*/
void QueuedProcess::setWorkDirectory(const QString &_workDirectory)
{
qCDebug(LOG_LIB) << "Set working directory to" << _workDirectory;
m_definitions.workingDirectory = _workDirectory;
setWorkingDirectory(_workDirectory);
}
/** /**
* @fn operator== * @fn operator==
*/ */
@ -95,24 +319,3 @@ void QueuedProcess::setupChildProcess()
::setgid(m_definitions.gid); ::setgid(m_definitions.gid);
::setuid(m_definitions.uid); ::setuid(m_definitions.uid);
} }
/**
* @fn run
*/
void QueuedProcess::run()
{
m_definitions.startTime = QDateTime::currentDateTimeUtc();
return start();
}
/**
* @fn setEndTime
*/
void QueuedProcess::setEndTime(const QDateTime &_time)
{
qCDebug(LOG_LIB) << "Set end time to" << _time;
m_definitions.endTime = _time;
}

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

@ -31,9 +31,10 @@
QueuedProcessManager::QueuedProcessManager(QObject *parent, QueuedProcessManager::QueuedProcessManager(QObject *parent,
const OnExitAction onExit) const OnExitAction onExit)
: QObject(parent) : QObject(parent)
, m_onExit(onExit)
{ {
qCDebug(LOG_LIB) << __PRETTY_FUNCTION__; qCDebug(LOG_LIB) << __PRETTY_FUNCTION__;
setOnExitAction(onExit);
} }
@ -62,8 +63,8 @@ QueuedProcess *QueuedProcessManager::add(const QVariantHash &_properties,
QueuedProcess::QueuedProcessDefinitions defs; QueuedProcess::QueuedProcessDefinitions defs;
// parameters // parameters
defs.command = _properties[QString("command")].toString(); defs.command = _properties[QString("command")].toString();
defs.arguments defs.arguments = _properties[QString("commandArguments")].toString().split(
= _properties[QString("arguments")].toString().split(QChar('\x01')); QChar('\x01'));
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 defs.limits
@ -116,8 +117,13 @@ void QueuedProcessManager::loadProcesses(const QList<QVariantHash> &_processes)
{ {
qCDebug(LOG_LIB) << "Add tasks from" << _processes; qCDebug(LOG_LIB) << "Add tasks from" << _processes;
for (auto &processData : _processes) for (auto &processData : _processes) {
if (static_cast<QueuedEnums::ProcessState>(
processData[QString("state")].toUInt())
== QueuedEnums::ProcessState::Exited)
continue;
add(processData, processData[QString("_id")].toLongLong()); add(processData, processData[QString("_id")].toLongLong());
}
} }
@ -169,6 +175,23 @@ void QueuedProcessManager::remove(const long long _index)
} }
/**
* @fn start
*/
void QueuedProcessManager::start(const long long _index)
{
qCDebug(LOG_LIB) << "Start task" << _index;
auto pr = process(_index);
if (!pr) {
qCWarning(LOG_LIB) << "No task" << _index << "found";
return;
}
pr->start();
}
/** /**
* @fn stop * @fn stop
*/ */
@ -203,6 +226,17 @@ QueuedProcessManager::OnExitAction QueuedProcessManager::onExit() const
} }
/**
* @fn setOnExitAction
*/
void QueuedProcessManager::setOnExitAction(const OnExitAction _action)
{
qCDebug(LOG_LIB) << "New action on exit" << static_cast<int>(_action);
m_onExit = _action;
}
/** /**
* @fn taskFinished * @fn taskFinished
*/ */

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

@ -61,29 +61,9 @@ bool QueuedTokenManager::isTokenValid(const QString &_token)
/** /**
* @fn registerToken * @fn loadTokens
*/ */
QString QueuedTokenManager::registerToken(const QDateTime _validUntil) void QueuedTokenManager::loadTokens(const QList<QVariantHash> &_values)
{
// generate from uuid
QString token
= QUuid::createUuid().toString().remove(QChar('{')).remove(QChar('}'));
qCInfo(LOG_LIB) << "Registered token" << token << "valid until"
<< _validUntil;
// append to internal storage
m_tokens[token] = _validUntil;
emit(tokenRegistered(token, _validUntil));
// and return requester
return token;
}
/**
* @fn set
*/
void QueuedTokenManager::set(const QList<QVariantHash> &_values)
{ {
qCDebug(LOG_LIB) << "Set values from" << _values; qCDebug(LOG_LIB) << "Set values from" << _values;
@ -103,6 +83,26 @@ void QueuedTokenManager::set(const QList<QVariantHash> &_values)
} }
/**
* @fn registerToken
*/
QString QueuedTokenManager::registerToken(const QDateTime _validUntil)
{
// generate from uuid
QString token
= QUuid::createUuid().toString().remove(QChar('{')).remove(QChar('}'));
qCInfo(LOG_LIB) << "Registered token" << token << "valid until"
<< _validUntil;
// append to internal storage
m_tokens[token] = _validUntil;
emit(tokenRegistered(token, _validUntil));
// and return requester
return token;
}
/** /**
* @fn expireToken * @fn expireToken
*/ */

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

@ -122,7 +122,7 @@ QPair<unsigned int, unsigned int> QueuedUser::ids()
*/ */
bool QueuedUser::isPasswordValid(const QString &_password) const bool QueuedUser::isPasswordValid(const QString &_password) const
{ {
return (m_definitions.passwordSHA512.toUtf8() return (m_definitions.password.toUtf8()
== QCryptographicHash::hash(_password.toUtf8(), == QCryptographicHash::hash(_password.toUtf8(),
QCryptographicHash::Sha512)); QCryptographicHash::Sha512));
} }
@ -173,7 +173,7 @@ QString QueuedUser::name() const
*/ */
QString QueuedUser::password() const QString QueuedUser::password() const
{ {
return m_definitions.passwordSHA512; return m_definitions.password;
} }
@ -224,7 +224,7 @@ void QueuedUser::setPassword(const QString _password)
{ {
qCDebug(LOG_LIB) << "New user passoword SHA" << _password; qCDebug(LOG_LIB) << "New user passoword SHA" << _password;
m_definitions.passwordSHA512 = _password; m_definitions.password = _password;
} }

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

@ -64,7 +64,7 @@ QueuedUser *QueuedUserManager::add(const QVariantHash &_properties,
QueuedUser::QueuedUserDefinitions defs; QueuedUser::QueuedUserDefinitions defs;
defs.name = _properties[QString("name")].toString(); defs.name = _properties[QString("name")].toString();
defs.email = _properties[QString("email")].toString(); defs.email = _properties[QString("email")].toString();
defs.passwordSHA512 = _properties[QString("passwordSHA512")].toString(); defs.password = _properties[QString("password")].toString();
defs.permissions = _properties[QString("permissions")].toUInt(); defs.permissions = _properties[QString("permissions")].toUInt();
defs.limits defs.limits
= QueuedLimits::Limits(_properties[QString("limits")].toString()); = QueuedLimits::Limits(_properties[QString("limits")].toString());
@ -169,7 +169,7 @@ void QueuedUserManager::loadTokens(const QList<QVariantHash> &_tokens)
{ {
qCDebug(LOG_LIB) << "Set tokens from" << _tokens; qCDebug(LOG_LIB) << "Set tokens from" << _tokens;
m_tokens->set(_tokens); m_tokens->loadTokens(_tokens);
} }