mirrors/fort
1
0
Fork 0
mirror of https://github.com/tnodir/fort synced 2024-11-14 22:05:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

UI: Handle app group periods

Browse Source
This commit is contained in:
Nodir Temirkhodjaev 2024-10-14 12:23:46 +05:00
parent bf4247b73d
commit f818c182a1
17 changed files with 210 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/tests/UtilTest/tst_confutil.h
View File

@ -64,7 +64,7 @@ TEST_F(ConfUtilTest, confWriteRead)
conf.addAppGroup(appGroup1);
conf.addAppGroup(appGroup2);
conf.resetEdited(true);
conf.resetEdited(FirewallConf::AllEdited);
conf.prepareToSave();
ConfUtil confUtil;

10
src/ui/conf/appgroup.cpp
View File

@ -165,6 +165,16 @@ void AppGroup::setPeriodTo(const QString &periodTo)
}
}
bool AppGroup::isTimeInPeriod(QTime time) const
{
if (m_periodFrom.isNull()) {
m_periodFromTime = DateUtil::parseTime(m_periodFrom);
m_periodToTime = DateUtil::parseTime(m_periodTo);
}
return DateUtil::isTimeInPeriod(time, m_periodFromTime, m_periodToTime);
}
QString AppGroup::menuLabel() const
{
QString text = name();

6
src/ui/conf/appgroup.h
View File

@ -2,6 +2,7 @@
#define APPGROUP_H
#include <QObject>
#include <QTime>
#include <QVariant>
#define MAX_APP_GROUP_COUNT 16
@ -90,6 +91,8 @@ public:
QString periodTo() const { return m_periodTo; }
void setPeriodTo(const QString &periodTo);
bool isTimeInPeriod(QTime time) const;
QString menuLabel() const;
void copy(const AppGroup &o);
@ -132,6 +135,9 @@ private:
// In format "hh:mm"
QString m_periodFrom;
QString m_periodTo;
mutable QTime m_periodFromTime; // transient
mutable QTime m_periodToTime; // transient
};
#endif // APPGROUP_H

19
src/ui/conf/confappmanager.cpp
View File

@ -185,19 +185,18 @@ void ConfAppManager::setupAppEndTimer()
void ConfAppManager::updateAppEndTimer()
{
m_appEndTimer.stop();
const qint64 endTimeMsecs = DbQuery(sqliteDb()).sql(sqlSelectMinEndApp).execute().toLongLong();
if (endTimeMsecs == 0)
return;
if (endTimeMsecs != 0) {
const qint64 currentMsecs = QDateTime::currentMSecsSinceEpoch();
const qint64 deltaMsecs = endTimeMsecs - currentMsecs;
const int interval = qMax(
(deltaMsecs > 0 ? int(qMin(deltaMsecs, qint64(APP_END_TIMER_INTERVAL_MAX))) : 0),
APP_END_TIMER_INTERVAL_MIN);
const qint64 currentMsecs = QDateTime::currentMSecsSinceEpoch();
const qint64 deltaMsecs = endTimeMsecs - currentMsecs;
const int interval = qBound(
qint64(APP_END_TIMER_INTERVAL_MIN), deltaMsecs, qint64(APP_END_TIMER_INTERVAL_MAX));
m_appEndTimer.start(interval);
} else {
m_appEndTimer.stop();
}
m_appEndTimer.start(interval);
}
bool ConfAppManager::addAppPathBlocked(App &app)

33
src/ui/conf/confmanager.cpp
View File

@ -36,6 +36,8 @@ const QLoggingCategory LC("conf");
constexpr int DATABASE_USER_VERSION = 45;
constexpr int CONF_PERIODS_UPDATE_INTERVAL = 60 * 1000; // 1 minute
const char *const sqlSelectAddressGroups = "SELECT addr_group_id, include_all, exclude_all,"
" include_zones, exclude_zones,"
" include_text, exclude_text"
@ -457,6 +459,8 @@ bool importFile(const QString &filePath, const QString &path)
ConfManager::ConfManager(const QString &filePath, QObject *parent, quint32 openFlags) :
QObject(parent), m_sqliteDb(new SqliteDb(filePath, openFlags)), m_conf(createConf())
{
m_confTimer.setSingleShot(true);
connect(&m_confTimer, &QTimer::timeout, this, &ConfManager::updateConfPeriods);
}
IniUser &ConfManager::iniUser() const
@ -532,6 +536,25 @@ FirewallConf *ConfManager::createConf()
return conf;
}
bool ConfManager::applyConfPeriods(bool onlyFlags)
{
m_confTimer.stop();
if (!conf() || !conf()->updateGroupPeriods(onlyFlags))
return false;
m_confTimer.start(CONF_PERIODS_UPDATE_INTERVAL);
return true;
}
void ConfManager::updateConfPeriods()
{
if (applyConfPeriods(/*onlyFlags=*/false)) {
emit confChanged(/*onlyFlags=*/true, FirewallConf::FlagsEdited);
}
}
bool ConfManager::setupDb()
{
if (!sqliteDb()->open()) {
@ -623,7 +646,9 @@ void ConfManager::applySavedConf(FirewallConf *newConf)
}
}
emit confChanged(onlyFlags);
applyConfPeriods(onlyFlags);
emit confChanged(onlyFlags, conf()->editedFlags());
if (conf()->iniEdited()) {
emit iniChanged(conf()->ini());
@ -669,11 +694,11 @@ void ConfManager::saveIniUser(bool edited, bool onlyFlags)
}
}
QVariant ConfManager::toPatchVariant(bool onlyFlags) const
QVariant ConfManager::toPatchVariant(bool onlyFlags, uint editedFlags) const
{
return onlyFlags ? conf()->toVariant(/*onlyEdited=*/true) // send only flags to clients
: FirewallConf::editedFlagsToVariant(
FirewallConf::AllEdited); // clients have to reload all from storage
editedFlags); // clients have to reload all from storage
}
bool ConfManager::saveVariant(const QVariant &confVar)
@ -817,7 +842,7 @@ bool ConfManager::importMasterBackup(const QString &path)
if (ok) {
emit imported();
emit confChanged(/*onlyFlags=*/false);
load(); // Reload conf
} else {
qCWarning(LC) << "Import error:" << path;
}

11
src/ui/conf/confmanager.h
View File

@ -2,6 +2,7 @@
#define CONFMANAGER_H
#include <QObject>
#include <QTimer>
#include <sqlite/sqlite_types.h>
@ -49,7 +50,7 @@ public:
void saveIni();
void saveIniUser(bool edited = false, bool onlyFlags = false);
QVariant toPatchVariant(bool onlyFlags) const;
QVariant toPatchVariant(bool onlyFlags, uint editedFlags) const;
bool saveVariant(const QVariant &confVar);
bool loadTasks(const QList<TaskInfo *> &taskInfos);
@ -70,7 +71,7 @@ public:
signals:
void imported();
void confChanged(bool onlyFlags);
void confChanged(bool onlyFlags, uint editedFlags);
void iniChanged(const IniOptions &ini);
void iniUserChanged(const IniUser &ini, bool onlyFlags);
@ -78,7 +79,11 @@ protected:
void setConf(FirewallConf *newConf);
FirewallConf *createConf();
virtual bool applyConfPeriods(bool onlyFlags);
private:
void updateConfPeriods();
bool setupDb();
void setupDefault(FirewallConf &conf) const;
@ -103,6 +108,8 @@ private:
FirewallConf *m_confToEdit = nullptr;
IniUser *m_iniUserToEdit = nullptr;
QTimer m_confTimer;
};
#endif // CONFMANAGER_H

66
src/ui/conf/firewallconf.cpp
View File

@ -1,6 +1,7 @@
#include "firewallconf.h"
#include <manager/envmanager.h>
#include <util/dateutil.h>
#include <util/net/netutil.h>
#include "addressgroup.h"
@ -11,11 +12,6 @@ FirewallConf::FirewallConf(Settings *settings, QObject *parent) : QObject(parent
setupAddressGroups();
}
void FirewallConf::resetEdited(bool v)
{
m_editedFlags = v ? AllEdited : NoneEdited;
}
int FirewallConf::blockTrafficIndex() const
{
return m_blockInetTraffic ? 2 : (m_blockTraffic ? 1 : 0);
@ -90,29 +86,9 @@ QStringList FirewallConf::filterModeIconPaths()
":/icons/road_sign.png" };
}
void FirewallConf::setActivePeriodEnabled(bool activePeriodEnabled)
void FirewallConf::setupAppGroupBits(quint32 v)
{
m_activePeriodEnabled = activePeriodEnabled;
}
void FirewallConf::setActivePeriodFrom(const QString &activePeriodFrom)
{
m_activePeriodFrom = activePeriodFrom;
}
void FirewallConf::setActivePeriodTo(const QString &activePeriodTo)
{
m_activePeriodTo = activePeriodTo;
}
void FirewallConf::setAppGroupBits(quint32 groupBits)
{
m_appGroupBits = groupBits;
}
void FirewallConf::setupAppGroupBits(quint32 groupBits)
{
setAppGroupBits(groupBits);
setAppGroupBits(v);
applyAppGroupBits();
}
@ -214,6 +190,25 @@ void FirewallConf::clearRemovedAppGroupIdList() const
m_removedAppGroupIdList.clear();
}
void FirewallConf::loadGroupPeriodBits()
{
const QTime now = DateUtil::currentTime();
m_anyGroupPeriodEnabled = false;
m_groupActivePeriodBits = quint32(-1);
int groupIndex = 0;
for (AppGroup *appGroup : appGroups()) {
if (appGroup->periodEnabled()) {
m_anyGroupPeriodEnabled = true;
if (!appGroup->isTimeInPeriod(now)) {
m_groupActivePeriodBits ^= (1 << groupIndex);
}
}
++groupIndex;
}
}
void FirewallConf::loadAppGroupBits()
{
m_appGroupBits = 0;
@ -271,6 +266,15 @@ void FirewallConf::afterSaved()
ini().clear();
}
bool FirewallConf::updateGroupPeriods(bool onlyFlags)
{
if (!onlyFlags) {
loadGroupPeriodBits();
}
return m_anyGroupPeriodEnabled;
}
void FirewallConf::copyFlags(const FirewallConf &o)
{
m_editedFlags = o.editedFlags();
@ -476,11 +480,8 @@ void FirewallConf::fromVariant(const QVariant &v, bool onlyEdited)
{
const QVariantMap map = v.toMap();
if (onlyEdited) {
m_editedFlags = editedFlagsFromVariant(v);
} else {
resetEdited(true);
}
resetEdited(onlyEdited ? FirewallConf::EditedFlags(editedFlagsFromVariant(v))
: FirewallConf::AllEdited);
if (optEdited()) {
addressesFromVariant(map["addressGroups"]);
@ -510,5 +511,6 @@ QVariant FirewallConf::editedFlagsToVariant(uint editedFlags)
uint FirewallConf::editedFlagsFromVariant(const QVariant &v)
{
const QVariantMap map = v.toMap();
return map["editedFlags"].toUInt();
}

53
src/ui/conf/firewallconf.h
View File

@ -41,55 +41,52 @@ public:
void setTaskEdited() { m_editedFlags |= TaskEdited; }
bool anyEdited() const { return m_editedFlags != NoneEdited; }
void resetEdited(bool v = false);
void resetEdited(EditedFlags v = NoneEdited) { m_editedFlags = v; }
bool bootFilter() const { return m_bootFilter; }
void setBootFilter(bool bootFilter) { m_bootFilter = bootFilter; }
void setBootFilter(bool v) { m_bootFilter = v; }
bool filterEnabled() const { return m_filterEnabled; }
void setFilterEnabled(bool filterEnabled) { m_filterEnabled = filterEnabled; }
void setFilterEnabled(bool v) { m_filterEnabled = v; }
bool filterLocals() const { return m_filterLocals; }
void setFilterLocals(bool filterLocals) { m_filterLocals = filterLocals; }
void setFilterLocals(bool v) { m_filterLocals = v; }
bool filterLocalNet() const { return m_filterLocalNet; }
void setFilterLocalNet(bool filterLocalNet) { m_filterLocalNet = filterLocalNet; }
void setFilterLocalNet(bool v) { m_filterLocalNet = v; }
bool blockTraffic() const { return m_blockTraffic; }
void setBlockTraffic(bool blockTraffic) { m_blockTraffic = blockTraffic; }
void setBlockTraffic(bool v) { m_blockTraffic = v; }
bool blockInetTraffic() const { return m_blockInetTraffic; }
void setBlockInetTraffic(bool blockInetTraffic) { m_blockInetTraffic = blockInetTraffic; }
void setBlockInetTraffic(bool v) { m_blockInetTraffic = v; }
bool allowAllNew() const { return m_allowAllNew; }
void setAllowAllNew(bool allowAllNew) { m_allowAllNew = allowAllNew; }
void setAllowAllNew(bool v) { m_allowAllNew = v; }
bool askToConnect() const { return m_askToConnect; }
void setAskToConnect(bool askToConnect) { m_askToConnect = askToConnect; }
void setAskToConnect(bool v) { m_askToConnect = v; }
bool groupBlocked() const { return m_groupBlocked; }
void setGroupBlocked(bool groupBlocked) { m_groupBlocked = groupBlocked; }
void setGroupBlocked(bool v) { m_groupBlocked = v; }
bool logStat() const { return m_logStat; }
void setLogStat(bool logStat) { m_logStat = logStat; }
void setLogStat(bool v) { m_logStat = v; }
bool logStatNoFilter() const { return m_logStatNoFilter; }
void setLogStatNoFilter(bool logStatNoFilter) { m_logStatNoFilter = logStatNoFilter; }
void setLogStatNoFilter(bool v) { m_logStatNoFilter = v; }
bool logBlocked() const { return m_logBlocked; }
void setLogBlocked(bool logBlocked) { m_logBlocked = logBlocked; }
void setLogBlocked(bool v) { m_logBlocked = v; }
bool logAllowedIp() const { return m_logAllowedIp; }
void setLogAllowedIp(bool logAllowedIp) { m_logAllowedIp = logAllowedIp; }
void setLogAllowedIp(bool v) { m_logAllowedIp = v; }
bool logBlockedIp() const { return m_logBlockedIp; }
void setLogBlockedIp(bool logBlockedIp) { m_logBlockedIp = logBlockedIp; }
void setLogBlockedIp(bool v) { m_logBlockedIp = v; }
bool logAlertedBlockedIp() const { return m_logAlertedBlockedIp; }
void setLogAlertedBlockedIp(bool logAlertedBlockedIp)
{
m_logAlertedBlockedIp = logAlertedBlockedIp;
}
void setLogAlertedBlockedIp(bool v) { m_logAlertedBlockedIp = v; }
bool appBlockAll() const { return m_appBlockAll; }
void setAppBlockAll(bool appBlockAll) { m_appBlockAll = appBlockAll; }
@ -110,18 +107,20 @@ public:
static QStringList filterModeIconPaths();
bool activePeriodEnabled() const { return m_activePeriodEnabled; }
void setActivePeriodEnabled(bool activePeriodEnabled);
void setActivePeriodEnabled(bool v) { m_activePeriodEnabled = v; }
QString activePeriodFrom() const { return m_activePeriodFrom; }
void setActivePeriodFrom(const QString &activePeriodFrom);
void setActivePeriodFrom(const QString &v) { m_activePeriodFrom = v; }
QString activePeriodTo() const { return m_activePeriodTo; }
void setActivePeriodTo(const QString &activePeriodTo);
void setActivePeriodTo(const QString &v) { m_activePeriodTo = v; }
quint32 appGroupBits() const { return m_appGroupBits; }
void setAppGroupBits(quint32 groupBits);
void setAppGroupBits(quint32 v) { m_appGroupBits = v; }
void setupAppGroupBits(quint32 groupBits);
quint32 activeGroupBits() const { return m_appGroupBits & m_groupActivePeriodBits; }
void setupAppGroupBits(quint32 v);
bool appGroupEnabled(int groupIndex) const;
@ -168,11 +167,15 @@ public slots:
void prepareToSave();
void afterSaved();
bool updateGroupPeriods(bool onlyFlags);
private:
void setupAddressGroups();
void setAppGroupsEdited(int from, int to);
void loadGroupPeriodBits();
void loadAppGroupBits();
void applyAppGroupBits();
@ -213,8 +216,10 @@ private:
uint m_appAllowAll : 1 = false;
uint m_activePeriodEnabled : 1 = false;
uint m_anyGroupPeriodEnabled : 1 = false;
quint32 m_appGroupBits = 0;
quint32 m_groupActivePeriodBits = quint32(-1); // transient
QString m_activePeriodFrom;
QString m_activePeriodTo;

2
src/ui/conf/inioptions.h
View File

@ -3,7 +3,7 @@
#include <util/ini/mapsettings.h>
#define DEFAULT_APP_GROUP_BITS 0xFFFF
#define DEFAULT_APP_GROUP_BITS quint32(-1)
#define DEFAULT_MONTH_START 1
#define DEFAULT_TRAF_HOUR_KEEP_DAYS 90 // ~3 months
#define DEFAULT_TRAF_DAY_KEEP_DAYS 365 // ~1 year

74
src/ui/fortmanager.cpp
View File

@ -216,10 +216,9 @@ void FortManager::setupLogger()
logger->setForceDebug(settings->forceDebug());
}
void FortManager::updateLogger(const FirewallConf *conf)
void FortManager::updateLogger()
{
if (!conf->iniEdited())
return;
const FirewallConf *conf = IoC<ConfManager>()->conf();
Logger *logger = Logger::instance();
@ -333,22 +332,16 @@ bool FortManager::removeDriver()
bool FortManager::setupDriver()
{
auto driverManager = IoC<DriverManager>();
auto confManager = IoC<ConfManager>();
bool ok = driverManager->openDevice();
if (!driverManager->openDevice())
return false;
if (ok && !confManager->validateDriver()) {
if (!setupDriverConf()) {
driverManager->closeDevice();
ok = false;
return false;
}
if (ok) {
confManager->updateServices();
updateTaskManager();
}
return ok;
return true;
}
void FortManager::closeDriver()
@ -415,12 +408,12 @@ void FortManager::setupConfManager()
connect(confManager, &ConfManager::imported, IoC<WindowManager>(),
&WindowManager::closeAllWindows);
connect(confManager, &ConfManager::confChanged, this, [&](bool onlyFlags) {
const FirewallConf *conf = IoC<ConfManager>()->conf();
connect(confManager, &ConfManager::confChanged, this, [&](bool onlyFlags, uint editedFlags) {
if (!onlyFlags && (editedFlags & FirewallConf::IniEdited) != 0) {
updateLogger();
}
updateLogger(conf);
if (!onlyFlags || conf->flagsEdited()) {
if (!onlyFlags || (editedFlags & FirewallConf::FlagsEdited) != 0) {
updateDriverConf(onlyFlags);
}
});
@ -491,7 +484,6 @@ void FortManager::processRestartRequired(const QString &info)
void FortManager::loadConf()
{
const auto settings = IoC<FortSettings>();
const auto confManager = IoC<ConfManager>();
// Validate migration
QString viaVersion;
@ -501,14 +493,35 @@ void FortManager::loadConf()
exit(-1); // Exit the program
}
if (!confManager->load()) {
showErrorMessage(tr("Cannot load Settings"));
}
qCDebug(LC) << "Started as"
<< (settings->isService() ? "Service"
: settings->hasService() ? "Client"
: "Program");
if (!IoC<ConfManager>()->load()) {
showErrorMessage(tr("Cannot load Settings"));
}
}
bool FortManager::setupDriverConf()
{
auto confManager = IoC<ConfManager>();
if (!confManager->validateDriver())
return false;
// Services
confManager->updateServices();
// Zones
{
auto zd = IoC<TaskManager>()->taskInfoZoneDownloader();
IoC<ConfZoneManager>()->updateDriverZones(
zd->dataZonesMask(), zd->enabledMask(), zd->dataSize(), zd->zonesData());
}
return true;
}
bool FortManager::updateDriverConf(bool onlyFlags)
@ -525,19 +538,6 @@ bool FortManager::updateDriverConf(bool onlyFlags)
return res;
}
void FortManager::updateTaskManager()
{
auto taskManager = IoC<TaskManager>();
// Zones
{
auto zd = taskManager->taskInfoZoneDownloader();
IoC<ConfZoneManager>()->updateDriverZones(
zd->dataZonesMask(), zd->enabledMask(), zd->dataSize(), zd->zonesData());
}
}
void FortManager::updateLogManager(bool active)
{
IoC<LogManager>()->setActive(active);

4
src/ui/fortmanager.h
View File

@ -39,7 +39,7 @@ private:
void setupThreadPool();
void setupLogger();
void updateLogger(const FirewallConf *conf);
void updateLogger();
void createManagers();
void deleteManagers();
@ -60,9 +60,9 @@ private:
void loadConf();
bool setupDriverConf();
bool updateDriverConf(bool onlyFlags = false);
void updateTaskManager();
void updateLogManager(bool active);
void updateStatManager(FirewallConf *conf);

44
src/ui/rpc/confmanagerrpc.cpp
View File

@ -7,7 +7,6 @@
#include <fortsettings.h>
#include <manager/windowmanager.h>
#include <rpc/rpcmanager.h>
#include <task/taskmanager.h>
#include <util/ioc/ioccontainer.h>
#include <util/variantutil.h>
@ -76,21 +75,6 @@ ConfManagerRpc::ConfManagerRpc(const QString &filePath, QObject *parent) :
{
}
bool ConfManagerRpc::exportMasterBackup(const QString &path)
{
return IoC<RpcManager>()->doOnServer(Control::Rpc_ConfManager_exportMasterBackup, { path });
}
bool ConfManagerRpc::importMasterBackup(const QString &path)
{
return IoC<RpcManager>()->doOnServer(Control::Rpc_ConfManager_importMasterBackup, { path });
}
bool ConfManagerRpc::checkPassword(const QString &password)
{
return IoC<RpcManager>()->doOnServer(Control::Rpc_ConfManager_checkPassword, { password });
}
bool ConfManagerRpc::saveConf(FirewallConf &newConf)
{
Q_ASSERT(&newConf == conf() || &newConf == confToEdit()); // else newConf.deleteLater()
@ -117,6 +101,21 @@ bool ConfManagerRpc::saveConf(FirewallConf &newConf)
return true;
}
bool ConfManagerRpc::exportMasterBackup(const QString &path)
{
return IoC<RpcManager>()->doOnServer(Control::Rpc_ConfManager_exportMasterBackup, { path });
}
bool ConfManagerRpc::importMasterBackup(const QString &path)
{
return IoC<RpcManager>()->doOnServer(Control::Rpc_ConfManager_importMasterBackup, { path });
}
bool ConfManagerRpc::checkPassword(const QString &password)
{
return IoC<RpcManager>()->doOnServer(Control::Rpc_ConfManager_checkPassword, { password });
}
void ConfManagerRpc::onConfChanged(const QVariant &confVar)
{
IoC<FortSettings>()->clearCache(); // FirewallConf::IniEdited is handled here
@ -132,10 +131,6 @@ void ConfManagerRpc::onConfChanged(const QVariant &confVar)
conf()->fromVariant(confVar, /*onlyEdited=*/true);
}
if ((editedFlags & FirewallConf::TaskEdited) != 0) {
IoC<TaskManager>()->loadSettings();
}
applySavedConf(conf());
if (!saving()) {
@ -168,10 +163,11 @@ void ConfManagerRpc::setupServerSignals(RpcManager *rpcManager)
{
auto confManager = IoC<ConfManager>();
connect(confManager, &ConfManager::confChanged, rpcManager, [=](bool onlyFlags) {
const QVariant confVar = IoC<ConfManager>()->toPatchVariant(onlyFlags);
rpcManager->invokeOnClients(Control::Rpc_ConfManager_confChanged, { confVar });
});
connect(confManager, &ConfManager::confChanged, rpcManager,
[=](bool onlyFlags, uint editedFlags) {
const QVariant confVar = IoC<ConfManager>()->toPatchVariant(onlyFlags, editedFlags);
rpcManager->invokeOnClients(Control::Rpc_ConfManager_confChanged, { confVar });
});
connect(confManager, &ConfManager::imported, rpcManager,
[=] { rpcManager->invokeOnClients(Control::Rpc_ConfManager_imported); });
}

4
src/ui/rpc/confmanagerrpc.h
View File

@ -15,6 +15,8 @@ class ConfManagerRpc : public ConfManager
public:
explicit ConfManagerRpc(const QString &filePath, QObject *parent = nullptr);
bool saveConf(FirewallConf &newConf) override;
bool exportMasterBackup(const QString &path) override;
bool importMasterBackup(const QString &path) override;
@ -28,7 +30,7 @@ public:
static void setupServerSignals(RpcManager *rpcManager);
protected:
bool saveConf(FirewallConf &newConf) override;
bool applyConfPeriods(bool /*onlyFlags*/) override { return false; }
private:
bool saving() const { return m_saving; }

64
src/ui/task/taskinfo.cpp
View File

@ -22,38 +22,6 @@ TaskManager *TaskInfo::taskManager() const
return qobject_cast<TaskManager *>(parent());
}
void TaskInfo::setEnabled(bool enabled)
{
if (m_enabled != enabled) {
m_enabled = enabled;
emit enabledChanged();
}
}
void TaskInfo::setRunOnStatup(bool runOnStatup)
{
if (m_runOnStatup != runOnStatup) {
m_runOnStatup = runOnStatup;
emit runOnStatupChanged();
}
}
void TaskInfo::setRunning(bool running)
{
if (m_running != running) {
m_running = running;
emit enabledChanged();
}
}
void TaskInfo::setIntervalHours(int intervalHours)
{
if (m_intervalHours != intervalHours) {
m_intervalHours = quint16(intervalHours);
emit intervalHoursChanged();
}
}
QString TaskInfo::title() const
{
return title(m_type);
@ -74,43 +42,11 @@ QString TaskInfo::title(TaskType type)
}
}
void TaskInfo::setType(TaskInfo::TaskType type)
{
if (m_type != type) {
m_type = type;
emit typeChanged();
}
}
void TaskInfo::setLastRun(const QDateTime &lastRun)
{
if (m_lastRun != lastRun) {
m_lastRun = lastRun;
emit lastRunChanged();
}
}
QDateTime TaskInfo::plannedRun() const
{
return m_lastRun.addSecs(m_intervalHours * 60 * 60);
}
void TaskInfo::setLastSuccess(const QDateTime &lastSuccess)
{
if (m_lastSuccess != lastSuccess) {
m_lastSuccess = lastSuccess;
emit lastSuccessChanged();
}
}
void TaskInfo::setTaskWorker(TaskWorker *taskWorker)
{
if (m_taskWorker != taskWorker) {
m_taskWorker = taskWorker;
emit taskWorkerChanged();
}
}
void TaskInfo::editFromVariant(const QVariant &v)
{
const TaskEditInfo info(v.toUInt());

25
src/ui/task/taskinfo.h
View File

@ -33,41 +33,41 @@ public:
QString name() const { return typeToString(type()); }
bool enabled() const { return m_enabled; }
void setEnabled(bool enabled);
void setEnabled(bool v) { m_enabled = v; }
bool runOnStatup() const { return m_runOnStatup; }
void setRunOnStatup(bool runOnStatup);
void setRunOnStatup(bool v) { m_runOnStatup = v; }
bool aborted() const { return m_aborted; }
bool running() const { return m_running; }
void setRunning(bool running);
void setRunning(bool v) { m_running = v; }
int intervalHours() const { return m_intervalHours; }
void setIntervalHours(int intervalHours);
void setIntervalHours(int v) { m_intervalHours = quint16(v); }
QString title() const;
static QString title(TaskType type);
TaskInfo::TaskType type() const { return m_type; }
void setType(TaskInfo::TaskType type);
void setType(TaskInfo::TaskType v) { m_type = v; }
qint64 id() const { return m_id; }
void setId(qint64 id) { m_id = id; }
QDateTime lastRun() const { return m_lastRun; }
void setLastRun(const QDateTime &lastRun);
void setLastRun(const QDateTime &v) { m_lastRun = v; }
QDateTime plannedRun() const;
QDateTime lastSuccess() const { return m_lastSuccess; }
void setLastSuccess(const QDateTime &lastSuccess);
void setLastSuccess(const QDateTime &v) { m_lastSuccess = v; }
virtual QByteArray data() const { return QByteArray(); }
virtual void setData(const QByteArray &data) { Q_UNUSED(data); }
TaskWorker *taskWorker() const { return m_taskWorker; }
void setTaskWorker(TaskWorker *taskWorker);
void setTaskWorker(TaskWorker *v) { m_taskWorker = v; }
void editFromVariant(const QVariant &v);
@ -77,15 +77,6 @@ public:
static TaskInfo::TaskType stringToType(const QString &name);
signals:
void enabledChanged();
void runOnStatupChanged();
void runningChanged();
void intervalHoursChanged();
void typeChanged();
void lastRunChanged();
void lastSuccessChanged();
void taskWorkerChanged();
void workStarted();
void workFinished(bool success);

14
src/ui/task/taskmanager.cpp
View File

@ -1,6 +1,7 @@
#include "taskmanager.h"
#include <conf/confmanager.h>
#include <conf/firewallconf.h>
#include <util/dateutil.h>
#include <util/ioc/ioccontainer.h>
@ -38,10 +39,19 @@ TaskInfo *TaskManager::taskInfoAt(int row) const
void TaskManager::setUp()
{
auto confManager = IoCDependency<ConfManager>();
loadSettings();
initializeTasks();
setupTimer();
connect(confManager, &ConfManager::confChanged, this, [&](bool onlyFlags, uint editedFlags) {
if (onlyFlags || (editedFlags & FirewallConf::TaskEdited) == 0)
return;
loadSettings();
});
}
void TaskManager::initializeTasks()
@ -79,9 +89,7 @@ void TaskManager::appendTaskInfo(TaskInfo *taskInfo)
void TaskManager::loadSettings()
{
auto confManager = IoCDependency<ConfManager>();
confManager->loadTasks(taskInfoList());
IoC<ConfManager>()->loadTasks(taskInfoList());
}
bool TaskManager::saveSettings()

2
src/ui/util/conf/confutil.cpp
View File

@ -78,7 +78,7 @@ void writeConfFlags(const FirewallConf &conf, PFORT_CONF_FLAGS confFlags)
confFlags->log_blocked_ip = conf.logBlockedIp();
confFlags->log_alerted_blocked_ip = conf.logAlertedBlockedIp();
confFlags->group_bits = conf.appGroupBits();
confFlags->group_bits = conf.activeGroupBits();
}
void writeAppGroupFlags(PFORT_CONF_GROUP out, const FirewallConf &conf)