Martchus
d99fadd1f1
This is the same as the feature already present in the launcher and connection settings. Not sure how much sense it makes for systemd services as they run rather independently from the UI but maybe it is useful.
738 lines
26 KiB
C++
738 lines
26 KiB
C++
#ifdef LIB_SYNCTHING_CONNECTOR_SUPPORT_SYSTEMD
|
|
|
|
#include "./syncthingservice.h"
|
|
#include "./utils.h"
|
|
|
|
#include "loginmanagerinterface.h"
|
|
#include "managerinterface.h"
|
|
#include "propertiesinterface.h"
|
|
#include "serviceinterface.h"
|
|
#include "unitinterface.h"
|
|
|
|
#include <QDBusArgument>
|
|
#include <QDBusConnection>
|
|
#include <QDBusMetaType>
|
|
#include <QDBusObjectPath>
|
|
#include <QDBusPendingCallWatcher>
|
|
#include <QDBusPendingReply>
|
|
#include <QDBusServiceWatcher>
|
|
|
|
#ifdef SYNCTHINGCONNECTION_SUPPORT_METERED
|
|
#include <QNetworkInformation>
|
|
#endif
|
|
|
|
#include <functional>
|
|
|
|
using namespace std;
|
|
using namespace std::placeholders;
|
|
using namespace CppUtilities;
|
|
|
|
namespace Data {
|
|
|
|
/*!
|
|
* \class SyncthingService
|
|
* \brief The SyncthingService class controls and monitors a Syncthing as systemd user service.
|
|
* \remarks Internally systemd's D-Bus interface is used. So the service "org.freedesktop.systemd1" must
|
|
* be running on the user-session D-Bus.
|
|
*
|
|
* This class is actually not Syncthing-specific. It could be used to control and monitor any systemd
|
|
* user service.
|
|
*/
|
|
|
|
/// \cond
|
|
|
|
QDBusArgument &operator<<(QDBusArgument &argument, const ManagerDBusUnitFileChange &unitFileChange)
|
|
{
|
|
argument.beginStructure();
|
|
argument << unitFileChange.type << unitFileChange.path << unitFileChange.source;
|
|
argument.endStructure();
|
|
return argument;
|
|
}
|
|
|
|
const QDBusArgument &operator>>(const QDBusArgument &argument, ManagerDBusUnitFileChange &unitFileChange)
|
|
{
|
|
argument.beginStructure();
|
|
argument >> unitFileChange.type >> unitFileChange.path >> unitFileChange.source;
|
|
argument.endStructure();
|
|
return argument;
|
|
}
|
|
|
|
constexpr DateTime dateTimeFromSystemdTimeStamp(qulonglong timeStamp)
|
|
{
|
|
return DateTime(DateTime::unixEpochStart().totalTicks() + timeStamp * 10);
|
|
}
|
|
|
|
SyncthingService *SyncthingService::s_mainInstance = nullptr;
|
|
OrgFreedesktopSystemd1ManagerInterface *SyncthingService::s_systemdUserInterface = nullptr;
|
|
OrgFreedesktopSystemd1ManagerInterface *SyncthingService::s_systemdSystemInterface = nullptr;
|
|
OrgFreedesktopLogin1ManagerInterface *SyncthingService::s_loginManager = nullptr;
|
|
DateTime SyncthingService::s_lastWakeUp = DateTime();
|
|
bool SyncthingService::s_fallingAsleep = false;
|
|
|
|
/// \endcond
|
|
|
|
/*!
|
|
* \brief Creates a new SyncthingService instance.
|
|
*/
|
|
SyncthingService::SyncthingService(SystemdScope scope, QObject *parent)
|
|
: QObject(parent)
|
|
, m_unit(nullptr)
|
|
, m_service(nullptr)
|
|
, m_properties(nullptr)
|
|
, m_currentSystemdInterface(nullptr)
|
|
, m_scope(scope)
|
|
, m_manuallyStopped(false)
|
|
, m_stoppedMetered(false)
|
|
, m_unitAvailable(false)
|
|
, m_stopOnMeteredConnection(false)
|
|
{
|
|
setupFreedesktopLoginInterface();
|
|
|
|
#ifdef LIB_SYNCTHING_CONNECTOR_SERVICE_MOCKED
|
|
// let the mocked service initially be stopped and simulate start after 5 seconds, then stop after 10 seconds and start after 15 seconds
|
|
QTimer::singleShot(5000, this, [this] {
|
|
m_activeSince = DateTime::gmtNow() - TimeSpan::fromMilliseconds(250);
|
|
handlePropertiesChanged(QStringLiteral("syncthing.mocked-service"),
|
|
QVariantMap{ { QStringLiteral("ActiveState"), QStringLiteral("active") }, { QStringLiteral("SubState"), QStringLiteral("running") },
|
|
{ QStringLiteral("Description"), QStringLiteral("This service is fake.") } },
|
|
QStringList());
|
|
});
|
|
QTimer::singleShot(10000, this, [this] {
|
|
m_activeSince = DateTime();
|
|
handlePropertiesChanged(QStringLiteral("syncthing.mocked-service"),
|
|
QVariantMap{ { QStringLiteral("ActiveState"), QStringLiteral("inactive") }, { QStringLiteral("SubState"), QStringLiteral("dead") },
|
|
{ QStringLiteral("Description"), QStringLiteral("This service is still fake.") } },
|
|
QStringList());
|
|
});
|
|
QTimer::singleShot(15000, this, [this] {
|
|
m_activeSince = DateTime::gmtNow();
|
|
handlePropertiesChanged(QStringLiteral("syncthing.mocked-service"),
|
|
QVariantMap{ { QStringLiteral("ActiveState"), QStringLiteral("active") }, { QStringLiteral("SubState"), QStringLiteral("running") },
|
|
{ QStringLiteral("Description"), QStringLiteral("This service is alive again!") } },
|
|
QStringList());
|
|
});
|
|
#endif
|
|
|
|
// initialize handling of metered connections
|
|
#ifdef SYNCTHINGCONNECTION_SUPPORT_METERED
|
|
if (const auto *const networkInformation = loadNetworkInformationBackendForMetered()) {
|
|
connect(networkInformation, &QNetworkInformation::isMeteredChanged, this, [this](bool isMetered) { setNetworkConnectionMetered(isMetered); });
|
|
setNetworkConnectionMetered(networkInformation->isMetered());
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* \brief Initializes m_currentSystemdInterface and its connection and service watcher for the current m_scope.
|
|
*/
|
|
void SyncthingService::setupSystemdInterface()
|
|
{
|
|
#ifndef LIB_SYNCTHING_CONNECTOR_SERVICE_MOCKED
|
|
clearSystemdInterface();
|
|
|
|
// ensure the static systemd interface for the current scope is initialized
|
|
const auto isUserScope = m_scope == SystemdScope::User;
|
|
OrgFreedesktopSystemd1ManagerInterface *&staticSystemdInterface = isUserScope ? s_systemdUserInterface : s_systemdSystemInterface;
|
|
if (!staticSystemdInterface) {
|
|
// register custom data types
|
|
qDBusRegisterMetaType<ManagerDBusUnitFileChange>();
|
|
qDBusRegisterMetaType<ManagerDBusUnitFileChangeList>();
|
|
|
|
staticSystemdInterface = new OrgFreedesktopSystemd1ManagerInterface(QStringLiteral("org.freedesktop.systemd1"),
|
|
QStringLiteral("/org/freedesktop/systemd1"), isUserScope ? QDBusConnection::sessionBus() : QDBusConnection::systemBus());
|
|
|
|
// enable systemd to emit signals
|
|
staticSystemdInterface->Subscribe();
|
|
}
|
|
|
|
// use the static systemd interface for the current scope
|
|
m_currentSystemdInterface = staticSystemdInterface;
|
|
connect(m_currentSystemdInterface, &OrgFreedesktopSystemd1ManagerInterface::UnitNew, this, &SyncthingService::handleUnitAdded);
|
|
connect(m_currentSystemdInterface, &OrgFreedesktopSystemd1ManagerInterface::UnitRemoved, this, &SyncthingService::handleUnitRemoved);
|
|
connect(m_currentSystemdInterface, &OrgFreedesktopSystemd1ManagerInterface::Reloading, this, &SyncthingService::handleReloading);
|
|
m_serviceWatcher = new QDBusServiceWatcher(m_currentSystemdInterface->service(), m_currentSystemdInterface->connection());
|
|
connect(m_serviceWatcher, &QDBusServiceWatcher::serviceRegistered, this, &SyncthingService::handleServiceRegisteredChanged);
|
|
connect(m_serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, &SyncthingService::handleServiceRegisteredChanged);
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* \brief Initializes s_loginManager.
|
|
*/
|
|
void SyncthingService::setupFreedesktopLoginInterface()
|
|
{
|
|
#ifndef LIB_SYNCTHING_CONNECTOR_SERVICE_MOCKED
|
|
// ensure the static login interface is initialized and use it
|
|
if (s_loginManager) {
|
|
return;
|
|
}
|
|
s_loginManager = new OrgFreedesktopLogin1ManagerInterface(
|
|
QStringLiteral("org.freedesktop.login1"), QStringLiteral("/org/freedesktop/login1"), QDBusConnection::systemBus());
|
|
connect(s_loginManager, &OrgFreedesktopLogin1ManagerInterface::PrepareForSleep, &SyncthingService::handlePrepareForSleep);
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* \brief Registers the specified D-Bus \a call to invoke \a handler when it has been concluded.
|
|
*/
|
|
template <typename HandlerType> void SyncthingService::makeAsyncCall(const QDBusPendingCall &call, HandlerType &&handler, bool removeHandler)
|
|
{
|
|
if (m_currentSystemdInterface && removeHandler) {
|
|
// disconnect from unit add/removed signals because these seem to be spammed when waiting for permissions
|
|
disconnect(m_currentSystemdInterface, &OrgFreedesktopSystemd1ManagerInterface::UnitNew, this, &SyncthingService::handleUnitAdded);
|
|
disconnect(m_currentSystemdInterface, &OrgFreedesktopSystemd1ManagerInterface::UnitRemoved, this, &SyncthingService::handleUnitRemoved);
|
|
}
|
|
auto *const watcher = new QDBusPendingCallWatcher(call, this);
|
|
m_pendingCalls.emplace(watcher);
|
|
connect(watcher, &QDBusPendingCallWatcher::finished, this, handler);
|
|
}
|
|
|
|
/*!
|
|
* \brief Registers a generic error handler for the specifeid D-Bus \a call.
|
|
*/
|
|
void SyncthingService::registerErrorHandler(const QDBusPendingCall &call, const char *context, bool reload, bool removeHandler)
|
|
{
|
|
makeAsyncCall(call, bind(&SyncthingService::handleError, this, context, _1, reload), removeHandler);
|
|
}
|
|
|
|
/*!
|
|
* \brief Determines whether the specified \a watcher is still relevant and ensures it is being deleted later.
|
|
*/
|
|
bool SyncthingService::concludeAsyncCall(QDBusPendingCallWatcher *watcher, bool reload)
|
|
{
|
|
watcher->deleteLater();
|
|
|
|
const auto i = m_pendingCalls.find(watcher);
|
|
const auto resultStillRelevant = i != m_pendingCalls.cend();
|
|
if (resultStillRelevant) {
|
|
m_pendingCalls.erase(i);
|
|
}
|
|
if (m_currentSystemdInterface) {
|
|
if (m_pendingCalls.empty()) {
|
|
// ensure we listen to unit add/removed signals again if there are no pending calls anymore
|
|
connect(m_currentSystemdInterface, &OrgFreedesktopSystemd1ManagerInterface::UnitNew, this, &SyncthingService::handleUnitAdded);
|
|
connect(m_currentSystemdInterface, &OrgFreedesktopSystemd1ManagerInterface::UnitRemoved, this, &SyncthingService::handleUnitRemoved);
|
|
}
|
|
if (reload && !watcher->isError()) {
|
|
if (m_scope != SystemdScope::System) {
|
|
// reload unit files if reload flag was set (for enable/disable to make the change immediately apparent)
|
|
reloadAllUnitFiles();
|
|
} else {
|
|
// we don't have the permission; at least try to refresh the unit again
|
|
queryUnitFromSystemdInterface();
|
|
}
|
|
}
|
|
}
|
|
return resultStillRelevant;
|
|
}
|
|
|
|
/*!
|
|
* \brief Unties the current instance from its current systemd interface.
|
|
*/
|
|
void Data::SyncthingService::clearSystemdInterface()
|
|
{
|
|
m_pendingCalls.clear();
|
|
if (m_currentSystemdInterface) {
|
|
disconnect(m_currentSystemdInterface, &OrgFreedesktopSystemd1ManagerInterface::UnitNew, this, &SyncthingService::handleUnitAdded);
|
|
disconnect(m_currentSystemdInterface, &OrgFreedesktopSystemd1ManagerInterface::UnitRemoved, this, &SyncthingService::handleUnitRemoved);
|
|
disconnect(m_currentSystemdInterface, &OrgFreedesktopSystemd1ManagerInterface::Reloading, this, &SyncthingService::handleReloading);
|
|
delete m_serviceWatcher;
|
|
m_currentSystemdInterface = nullptr;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Clears everything we know about the systemd unit.
|
|
*/
|
|
void SyncthingService::clearUnitData()
|
|
{
|
|
// clean up data from previous unit
|
|
delete m_service;
|
|
m_service = nullptr;
|
|
delete m_unit;
|
|
m_unit = nullptr;
|
|
delete m_properties;
|
|
m_properties = nullptr;
|
|
}
|
|
|
|
/*!
|
|
* \brief Queries m_unit from m_currentSystemdInterface.
|
|
*/
|
|
void Data::SyncthingService::queryUnitFromSystemdInterface()
|
|
{
|
|
clearUnitData();
|
|
setProperties(false, QString(), QString(), QString(), QString());
|
|
|
|
#ifndef LIB_SYNCTHING_CONNECTOR_SERVICE_MOCKED
|
|
if (!m_currentSystemdInterface) {
|
|
setupSystemdInterface();
|
|
}
|
|
if (!m_currentSystemdInterface->isValid()) {
|
|
return;
|
|
}
|
|
makeAsyncCall(m_currentSystemdInterface->GetUnit(m_unitName), &SyncthingService::handleUnitGet);
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the \a unitName of the systemd user service to be controlled/monitored, e.g. "syncthing.service".
|
|
*/
|
|
void SyncthingService::setUnitName(const QString &unitName)
|
|
{
|
|
if (m_unitName == unitName) {
|
|
return;
|
|
}
|
|
m_unitName = unitName;
|
|
|
|
if (!m_unitName.isEmpty()) {
|
|
queryUnitFromSystemdInterface();
|
|
}
|
|
emit unitNameChanged(unitName);
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the \a scope and \a unitName (see scope() and unitName()).
|
|
*/
|
|
void SyncthingService::setScopeAndUnitName(SystemdScope scope, const QString &unitName)
|
|
{
|
|
const auto scopeChanged = m_scope != scope;
|
|
const auto unitNameChanged = m_unitName != unitName;
|
|
if (!scopeChanged && !unitNameChanged) {
|
|
return;
|
|
}
|
|
if (scopeChanged) {
|
|
m_scope = scope;
|
|
clearSystemdInterface();
|
|
}
|
|
if (unitNameChanged) {
|
|
m_unitName = unitName;
|
|
}
|
|
if (!unitName.isEmpty()) {
|
|
queryUnitFromSystemdInterface();
|
|
}
|
|
if (scopeChanged) {
|
|
emit this->scopeChanged(scope);
|
|
}
|
|
if (unitNameChanged) {
|
|
emit this->unitNameChanged(unitName);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether systemd (and specifically its D-Bus interface for user services) is available.
|
|
* \remarks The availability might not be instantly detected and may change at any time. Use the systemdAvailableChanged()
|
|
* to react to availability changes.
|
|
*/
|
|
bool SyncthingService::isSystemdAvailable() const
|
|
{
|
|
#ifndef LIB_SYNCTHING_CONNECTOR_SERVICE_MOCKED
|
|
return m_currentSystemdInterface && m_currentSystemdInterface->isValid();
|
|
#else
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether the unit specified with \a unitName is available.
|
|
* \remarks
|
|
* - The availability might not be instantly detected and may change at any time. Use the unitAvailableChanged()
|
|
* to react to availability changes.
|
|
* - Unless this function returns true the other unit-related functions will return false/empty values.
|
|
*/
|
|
bool SyncthingService::isUnitAvailable() const
|
|
{
|
|
#ifndef LIB_SYNCTHING_CONNECTOR_SERVICE_MOCKED
|
|
return m_unit && m_unit->isValid();
|
|
#else
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether \a activeSince or the last standby-wake-up is longer ago than \a atLeastSeconds.
|
|
*/
|
|
bool SyncthingService::isActiveWithoutSleepFor(DateTime activeSince, unsigned int atLeastSeconds)
|
|
{
|
|
if (!atLeastSeconds) {
|
|
return true;
|
|
}
|
|
if (activeSince.isNull() || s_fallingAsleep) {
|
|
return false;
|
|
}
|
|
|
|
const DateTime now(DateTime::gmtNow());
|
|
return ((now - activeSince).totalSeconds() > atLeastSeconds) && (s_lastWakeUp.isNull() || ((now - s_lastWakeUp).totalSeconds() > atLeastSeconds));
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the scope the current instance is tuned to.
|
|
*/
|
|
void SyncthingService::setScope(SystemdScope scope)
|
|
{
|
|
if (m_scope == scope) {
|
|
return;
|
|
}
|
|
m_scope = scope;
|
|
clearSystemdInterface();
|
|
queryUnitFromSystemdInterface();
|
|
emit scopeChanged(scope);
|
|
}
|
|
|
|
/*!
|
|
* \brief Starts the unit if \a running is true and stops the unit if \a running is false.
|
|
*/
|
|
void SyncthingService::setRunning(bool running)
|
|
{
|
|
#ifndef LIB_SYNCTHING_CONNECTOR_SERVICE_MOCKED
|
|
m_manuallyStopped = !running;
|
|
m_stoppedMetered = false;
|
|
if (!m_currentSystemdInterface) {
|
|
setupSystemdInterface();
|
|
}
|
|
if (running) {
|
|
registerErrorHandler(
|
|
m_currentSystemdInterface->StartUnit(m_unitName, QStringLiteral("replace")), QT_TR_NOOP_UTF8("start unit"), m_activeState.isEmpty());
|
|
} else {
|
|
registerErrorHandler(m_currentSystemdInterface->StopUnit(m_unitName, QStringLiteral("replace")), QT_TR_NOOP_UTF8("stop unit"));
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* \brief Enables the unit if \a enabled is true and disables the unit if \a enabled is false.
|
|
*/
|
|
void SyncthingService::setEnabled(bool enabled)
|
|
{
|
|
#ifndef LIB_SYNCTHING_CONNECTOR_SERVICE_MOCKED
|
|
if (!m_currentSystemdInterface) {
|
|
setupSystemdInterface();
|
|
}
|
|
if (enabled) {
|
|
registerErrorHandler(m_currentSystemdInterface->EnableUnitFiles(QStringList(m_unitName), false, true), QT_TR_NOOP_UTF8("enable unit"), true);
|
|
} else {
|
|
registerErrorHandler(m_currentSystemdInterface->DisableUnitFiles(QStringList(m_unitName), false), QT_TR_NOOP_UTF8("disable unit"), true);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* \brief Reload all unit files.
|
|
*/
|
|
void SyncthingService::reloadAllUnitFiles()
|
|
{
|
|
registerErrorHandler(m_currentSystemdInterface->Reload(), QT_TR_NOOP_UTF8("reload all unit files"), false, false);
|
|
}
|
|
|
|
/*!
|
|
* \brief Handles when a new unit is added to react if it matches the name of the unit we're monitoring.
|
|
*/
|
|
void SyncthingService::handleUnitAdded(const QString &unitName, const QDBusObjectPath &unitPath)
|
|
{
|
|
if (unitName == m_unitName) {
|
|
setUnit(unitPath);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Handles when a unit is removed to react if it matches the name of the unit we're monitoring.
|
|
*/
|
|
void SyncthingService::handleUnitRemoved(const QString &unitName, const QDBusObjectPath &unitPath)
|
|
{
|
|
Q_UNUSED(unitPath)
|
|
if (unitName == m_unitName) {
|
|
setUnit(QDBusObjectPath());
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Handles when unit files have been reloaded.
|
|
*/
|
|
void SyncthingService::handleReloading(bool started)
|
|
{
|
|
if (!started) {
|
|
queryUnitFromSystemdInterface();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Consumes the results of the s_manager->GetUnit() call (in setUnitName()).
|
|
*/
|
|
void SyncthingService::handleUnitGet(QDBusPendingCallWatcher *watcher)
|
|
{
|
|
if (!concludeAsyncCall(watcher)) {
|
|
return;
|
|
}
|
|
setUnit(QDBusPendingReply<QDBusObjectPath>(*watcher).value());
|
|
}
|
|
|
|
/*!
|
|
* \brief Consumes the results of the s_manager->GetUnitFileState() call (in setUnitName()).
|
|
*/
|
|
void SyncthingService::handleGetUnitFileState(QDBusPendingCallWatcher *watcher)
|
|
{
|
|
if (!concludeAsyncCall(watcher)) {
|
|
return;
|
|
}
|
|
auto fileState = QString();
|
|
if (!watcher->isError()) {
|
|
if (const auto &args = watcher->reply().arguments(); !args.empty()) {
|
|
fileState = args.at(0).toString();
|
|
}
|
|
}
|
|
clearUnitData();
|
|
setProperties(!fileState.isEmpty(), QString(), QString(), fileState, QString());
|
|
}
|
|
|
|
/*!
|
|
* \brief Handles when properties of the monitored unit change.
|
|
*/
|
|
void SyncthingService::handlePropertiesChanged(
|
|
const QString &interface, const QVariantMap &changedProperties, const QStringList &invalidatedProperties)
|
|
{
|
|
#ifndef LIB_SYNCTHING_CONNECTOR_SERVICE_MOCKED
|
|
if (interface != m_unit->interface()) {
|
|
return;
|
|
}
|
|
#else
|
|
if (interface != QStringLiteral("syncthing.mocked-service")) {
|
|
return;
|
|
}
|
|
#endif
|
|
handlePropertyChanged(m_activeSince, QStringLiteral("ActiveEnterTimestamp"), changedProperties, invalidatedProperties);
|
|
|
|
const auto wasRunningBefore = isRunning();
|
|
const auto activeStateChanged = handlePropertyChanged(
|
|
m_activeState, &SyncthingService::activeStateChanged, QStringLiteral("ActiveState"), changedProperties, invalidatedProperties);
|
|
const auto subStateChanged
|
|
= handlePropertyChanged(m_subState, &SyncthingService::subStateChanged, QStringLiteral("SubState"), changedProperties, invalidatedProperties);
|
|
if (activeStateChanged || subStateChanged) {
|
|
emit stateChanged(m_activeState, m_subState, m_activeSince);
|
|
}
|
|
const bool currentlyRunning = isRunning();
|
|
if (wasRunningBefore != currentlyRunning) {
|
|
if (currentlyRunning) {
|
|
m_manuallyStopped = false;
|
|
m_stoppedMetered = false;
|
|
}
|
|
emit runningChanged(currentlyRunning);
|
|
}
|
|
|
|
const bool wasEnabledBefore = isEnabled();
|
|
handlePropertyChanged(
|
|
m_unitFileState, &SyncthingService::unitFileStateChanged, QStringLiteral("UnitFileState"), changedProperties, invalidatedProperties);
|
|
if (wasEnabledBefore != isEnabled()) {
|
|
emit enabledChanged(isEnabled());
|
|
}
|
|
|
|
handlePropertyChanged(
|
|
m_description, &SyncthingService::descriptionChanged, QStringLiteral("Description"), changedProperties, invalidatedProperties);
|
|
}
|
|
|
|
/*!
|
|
* \brief Handles D-Bus errors.
|
|
*/
|
|
void SyncthingService::handleError(const char *context, QDBusPendingCallWatcher *watcher, bool reload)
|
|
{
|
|
if (!concludeAsyncCall(watcher, reload)) {
|
|
return;
|
|
}
|
|
const QDBusError error = watcher->error();
|
|
if (error.isValid()) {
|
|
emit errorOccurred(tr(context), error.name(), error.message());
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Handles when the service availability changes.
|
|
*/
|
|
void SyncthingService::handleServiceRegisteredChanged(const QString &service)
|
|
{
|
|
if (m_currentSystemdInterface && service == m_currentSystemdInterface->service()) {
|
|
emit systemdAvailableChanged(m_currentSystemdInterface->isValid());
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Logs the moment before when standby is enabled and the time of the last standby-wakeup.
|
|
*/
|
|
void SyncthingService::handlePrepareForSleep(bool rightBefore)
|
|
{
|
|
if (!(s_fallingAsleep = rightBefore)) {
|
|
s_lastWakeUp = DateTime::gmtNow();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Internal helper to handle property changes for QString-properties.
|
|
*/
|
|
bool SyncthingService::handlePropertyChanged(QString &variable, void (SyncthingService::*signal)(const QString &), const QString &propertyName,
|
|
const QVariantMap &changedProperties, const QStringList &invalidatedProperties)
|
|
{
|
|
const auto valueVariant = changedProperties.find(propertyName);
|
|
if (valueVariant != changedProperties.end()) {
|
|
auto valueString = valueVariant->toString();
|
|
if (valueString != variable) {
|
|
emit(this->*signal)(variable = std::move(valueString));
|
|
return true;
|
|
}
|
|
} else if (invalidatedProperties.contains(propertyName) && !variable.isEmpty()) {
|
|
variable.clear();
|
|
emit(this->*signal)(variable);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*!
|
|
* \brief Internal helper to handle property changes for DateTime-properties.
|
|
*/
|
|
bool SyncthingService::handlePropertyChanged(
|
|
DateTime &variable, const QString &propertyName, const QVariantMap &changedProperties, const QStringList &invalidatedProperties)
|
|
{
|
|
const auto valueVariant = changedProperties.find(propertyName);
|
|
if (valueVariant != changedProperties.end()) {
|
|
bool ok;
|
|
const qulonglong valueInt = valueVariant->toULongLong(&ok);
|
|
if (ok) {
|
|
variable = dateTimeFromSystemdTimeStamp(valueInt);
|
|
return true;
|
|
}
|
|
} else if (invalidatedProperties.contains(propertyName) && !variable.isNull()) {
|
|
variable = DateTime();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*!
|
|
* \brief Internal helper to stop the service when the network connection becomes metered.
|
|
*/
|
|
void SyncthingService::stopDueToMeteredConnection()
|
|
{
|
|
if (isRunning()) {
|
|
setRunning(false);
|
|
}
|
|
m_stoppedMetered = true;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the current unit data.
|
|
*/
|
|
void SyncthingService::setUnit(const QDBusObjectPath &objectPath)
|
|
{
|
|
clearUnitData();
|
|
|
|
if (!m_currentSystemdInterface) {
|
|
setProperties(false, QString(), QString(), QString(), QString());
|
|
return;
|
|
}
|
|
|
|
const auto path = objectPath.path();
|
|
if (path.isEmpty()) {
|
|
// fallback to querying unit file state
|
|
makeAsyncCall(m_currentSystemdInterface->GetUnitFileState(m_unitName), &SyncthingService::handleGetUnitFileState);
|
|
return;
|
|
}
|
|
|
|
// init unit
|
|
m_unit = new OrgFreedesktopSystemd1UnitInterface(m_currentSystemdInterface->service(), path, m_currentSystemdInterface->connection());
|
|
m_unit->setTimeout(2000);
|
|
if (m_unit->isValid()) {
|
|
m_activeSince = dateTimeFromSystemdTimeStamp(m_unit->activeEnterTimestamp());
|
|
setProperties(true, m_unit->activeState(), m_unit->subState(), m_unit->unitFileState(), m_unit->description());
|
|
// handle metered network connection: if the connection is metered and we care about it, then …
|
|
if (isStoppingOnMeteredConnection() && isNetworkConnectionMetered().value_or(false)) {
|
|
if (isRunning()) {
|
|
// stop an already running service immediately
|
|
stopDueToMeteredConnection();
|
|
} else {
|
|
// consider an already stopped service as stopped due to a metered connection; so we will start it as soon as the connection
|
|
// is no longer metered
|
|
m_stoppedMetered = true;
|
|
}
|
|
}
|
|
} else {
|
|
// fallback to querying unit file state
|
|
makeAsyncCall(m_currentSystemdInterface->GetUnitFileState(m_unitName), &SyncthingService::handleGetUnitFileState);
|
|
}
|
|
|
|
// init properties
|
|
m_properties = new OrgFreedesktopDBusPropertiesInterface(m_currentSystemdInterface->service(), path, m_currentSystemdInterface->connection());
|
|
connect(m_properties, &OrgFreedesktopDBusPropertiesInterface::PropertiesChanged, this, &SyncthingService::handlePropertiesChanged);
|
|
}
|
|
|
|
/*!
|
|
* \brief Updates the properties for the current unit.
|
|
*/
|
|
void SyncthingService::setProperties(
|
|
bool unitAvailable, const QString &activeState, const QString &subState, const QString &unitFileState, const QString &description)
|
|
{
|
|
if (m_unitAvailable != unitAvailable) {
|
|
emit unitAvailableChanged(m_unitAvailable = unitAvailable);
|
|
}
|
|
|
|
const bool running = isRunning();
|
|
bool anyStateChanged = false;
|
|
if (m_activeState != activeState) {
|
|
emit activeStateChanged(m_activeState = activeState);
|
|
anyStateChanged = true;
|
|
}
|
|
if (m_subState != subState) {
|
|
emit subStateChanged(m_subState = subState);
|
|
anyStateChanged = true;
|
|
}
|
|
if (anyStateChanged) {
|
|
emit stateChanged(m_activeState, m_subState, m_activeSince);
|
|
}
|
|
if (running != isRunning()) {
|
|
emit runningChanged(isRunning());
|
|
}
|
|
|
|
const bool enabled = isEnabled();
|
|
if (m_unitFileState != unitFileState) {
|
|
emit unitFileStateChanged(m_unitFileState = unitFileState);
|
|
}
|
|
if (enabled != isEnabled()) {
|
|
emit enabledChanged(isEnabled());
|
|
}
|
|
if (m_description != description) {
|
|
emit descriptionChanged(m_description = description);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets whether the current network connection is metered and stops/starts Syncthing accordingly as needed.
|
|
* \remarks
|
|
* - This is detected and monitored automatically. A manually set value will be overridden again on the next change.
|
|
* - One may set this manually for testing purposes or in case the automatic detection is not supported (then
|
|
* isNetworkConnectionMetered() returns a std::optional<bool> without value).
|
|
*/
|
|
void SyncthingService::setNetworkConnectionMetered(std::optional<bool> metered)
|
|
{
|
|
if (metered != m_metered) {
|
|
m_metered = metered;
|
|
if (m_stopOnMeteredConnection) {
|
|
if (metered.value_or(false)) {
|
|
stopDueToMeteredConnection();
|
|
} else if (!metered.value_or(true) && m_stoppedMetered) {
|
|
start();
|
|
}
|
|
}
|
|
emit networkConnectionMeteredChanged(metered);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets whether Syncthing should automatically be stopped as long as the network connection is metered.
|
|
*/
|
|
void SyncthingService::setStoppingOnMeteredConnection(bool stopOnMeteredConnection)
|
|
{
|
|
if ((stopOnMeteredConnection != m_stopOnMeteredConnection) && (m_stopOnMeteredConnection = stopOnMeteredConnection) && m_metered) {
|
|
stopDueToMeteredConnection();
|
|
}
|
|
}
|
|
|
|
} // namespace Data
|
|
|
|
#endif
|