Poll interval from capabilities

changelog/unreleased/8780

@@ -0,0 +1,9 @@
+Enhancement: Consider a remote poll interval coming with the server capabilities
+
+This way, admins can configure the remote sync poll interval of clients through
+the capabilities settings of the server. Note that the setting in the server
+capabilities needs to be done in milliseconds. Default is 30 seconds.
+
+https://github.com/owncloud/client/issues/5947
+https://github.com/owncloud/client/issues/8780
+https://github.com/owncloud/client/pull/8777

src/gui/accountstate.cpp

@@ -266,7 +266,8 @@ void AccountState::checkConnectivity(bool blockJobs)
 
     // IF the account is connected the connection check can be skipped
     // if the last successful etag check job is not so long ago.
-    const auto polltime = std::chrono::duration_cast<std::chrono::seconds>(ConfigFile().remotePollInterval());
+    const auto pta = account()->capabilities().remotePollInterval();
+    const auto polltime = std::chrono::duration_cast<std::chrono::seconds>(ConfigFile().remotePollInterval(pta));
     const auto elapsed = _timeOfLastETagCheck.secsTo(QDateTime::currentDateTimeUtc());
     if (!blockJobs && isConnected() && _timeOfLastETagCheck.isValid()
         && elapsed <= polltime.count()) {

src/gui/folder.cpp

@@ -68,6 +68,7 @@ Folder::Folder(const FolderDefinition &definition,
 {
     _timeSinceLastSyncStart.start();
     _timeSinceLastSyncDone.start();
+    _timeSinceLastEtagCheckDone.start();
 
     SyncResult::Status status = SyncResult::NotYetStarted;
     if (definition.paused) {
@@ -285,6 +286,27 @@ bool Folder::canSync() const
     return !syncPaused() && accountState()->isConnected();
 }
 
+bool Folder::dueToSync() const
+{
+    // conditions taken from previous folderman implementation
+    if (isSyncRunning() || etagJob() || isBusy() || !canSync()) {
+        return false;
+    }
+
+    ConfigFile cfg;
+    // the default poll time of 30 seconds as it had been in the client forever.
+    // Now with https://github.com/owncloud/client/pull/8777 also the server capabilities are considered.
+    const auto pta = accountState()->account()->capabilities().remotePollInterval();
+    const auto polltime = cfg.remotePollInterval(pta);
+
+    const auto timeSinceLastSync = std::chrono::milliseconds(_timeSinceLastEtagCheckDone.elapsed());
+    qCInfo(lcFolder) << "dueToSync:" << alias() << timeSinceLastSync.count() << " < " << polltime.count();
+    if (timeSinceLastSync >= polltime) {
+        return true;
+    }
+    return false;
+}
+
 void Folder::setSyncPaused(bool paused)
 {
     if (paused == _definition.paused) {
@@ -343,6 +365,7 @@ void Folder::slotRunEtagJob()
     _requestEtagJob->setTimeout(60 * 1000);
     // check if the etag is different when retrieved
     QObject::connect(_requestEtagJob.data(), &RequestEtagJob::etagRetreived, this, &Folder::etagRetreived);
+    QObject::connect(_requestEtagJob.data(), &RequestEtagJob::finishedWithResult, this, [=](const HttpResult<QByteArray>) { _timeSinceLastEtagCheckDone.start(); });
     FolderMan::instance()->slotScheduleETagJob(alias(), _requestEtagJob);
     // The _requestEtagJob is auto deleting itself on finish. Our guard pointer _requestEtagJob will then be null.
 }

src/gui/folder.h

@@ -183,6 +183,12 @@ class Folder : public QObject
      */
     bool canSync() const;
 
+    /**
+     *  Returns true if the folder needs sync poll interval wise, and can
+     *  sync due to its internal state
+     */
+    bool dueToSync() const;
+
     void prepareToSync();
 
     /**
@@ -224,7 +230,7 @@ class Folder : public QObject
     SyncEngine &syncEngine() { return *_engine; }
     Vfs &vfs() { return *_vfs; }
 
-    RequestEtagJob *etagJob() { return _requestEtagJob; }
+    RequestEtagJob *etagJob() const { return _requestEtagJob; }
     std::chrono::milliseconds msecSinceLastSync() const { return std::chrono::milliseconds(_timeSinceLastSyncDone.elapsed()); }
     std::chrono::milliseconds msecLastSyncDuration() const { return _lastSyncDuration; }
     int consecutiveFollowUpSyncs() const { return _consecutiveFollowUpSyncs; }
@@ -307,6 +313,8 @@ class Folder : public QObject
 
 public slots:
 
+    void slotRunEtagJob();
+
     /**
        * terminate the current sync run
        */
@@ -373,7 +381,6 @@ private slots:
     void slotTransmissionProgress(const ProgressInfo &pi);
     void slotItemCompleted(const SyncFileItemPtr &);
 
-    void slotRunEtagJob();
     void etagRetreived(const QByteArray &, const QDateTime &tp);
     void etagRetrievedFromSyncEngine(const QByteArray &, const QDateTime &time);
 
@@ -445,6 +452,7 @@ private slots:
     QScopedPointer<SyncEngine> _engine;
     QPointer<RequestEtagJob> _requestEtagJob;
     QByteArray _lastEtag;
+    QElapsedTimer _timeSinceLastEtagCheckDone;
     QElapsedTimer _timeSinceLastSyncDone;
     QElapsedTimer _timeSinceLastSyncStart;
     QElapsedTimer _timeSinceLastFullLocalDiscovery;

src/gui/folderman.cpp

@@ -112,10 +112,10 @@ FolderMan::FolderMan(QObject *parent)
 
     _socketApi.reset(new SocketApi);
 
-    ConfigFile cfg;
-    std::chrono::milliseconds polltime = cfg.remotePollInterval();
-    qCInfo(lcFolderMan) << "setting remote poll timer interval to" << polltime.count() << "msec";
-    _etagPollTimer.setInterval(polltime.count());
+    // Set the remote poll interval fixed to 10 seconds.
+    // That does not mean that it polls every 10 seconds, but it checks every 10 secs
+    // if one of the folders is due to sync.
+    _etagPollTimer.setInterval(1000);
     QObject::connect(&_etagPollTimer, &QTimer::timeout, this, &FolderMan::slotEtagPollTimerTimeout);
     _etagPollTimer.start();
 
@@ -833,29 +833,19 @@ void FolderMan::slotStartScheduledFolderSync()
 
 void FolderMan::slotEtagPollTimerTimeout()
 {
-    ConfigFile cfg;
-    auto polltime = cfg.remotePollInterval();
-
     for (auto *f : qAsConst(_folderMap)) {
         if (!f) {
             continue;
         }
-        if (f->isSyncRunning()) {
-            continue;
-        }
         if (_scheduledFolders.contains(f)) {
             continue;
         }
         if (_disabledFolders.contains(f)) {
             continue;
         }
-        if (f->etagJob() || f->isBusy() || !f->canSync()) {
-            continue;
-        }
-        if (f->msecSinceLastSync() < polltime) {
-            continue;
+        if (f->dueToSync()) {
+            QMetaObject::invokeMethod(f, &Folder::slotRunEtagJob, Qt::QueuedConnection);
         }
-        QMetaObject::invokeMethod(f, "slotRunEtagJob", Qt::QueuedConnection);
     }
 }
 
@@ -916,7 +906,8 @@ void FolderMan::slotScheduleFolderByTime()
         auto msecsSinceSync = f->msecSinceLastSync();
 
         // Possibly it's just time for a new sync run
-        bool forceSyncIntervalExpired = msecsSinceSync > ConfigFile().forceSyncInterval();
+        const auto pta = f->accountState()->account()->capabilities().remotePollInterval();
+        bool forceSyncIntervalExpired = msecsSinceSync > ConfigFile().forceSyncInterval(pta);
         if (forceSyncIntervalExpired) {
             qCInfo(lcFolderMan) << "Scheduling folder" << f->alias()
                                 << "because it has been" << msecsSinceSync.count() << "ms "

src/libsync/capabilities.cpp

@@ -103,6 +103,11 @@ int Capabilities::defaultPermissions() const
     return _fileSharingCapabilities.value(QStringLiteral("default_permissions"), 1).toInt();
 }
 
+std::chrono::seconds Capabilities::remotePollInterval() const
+{
+    return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::milliseconds(_capabilities.value(QStringLiteral("core")).toMap().value(QStringLiteral("pollinterval")).toInt()));
+}
+
 bool Capabilities::notificationsAvailable() const
 {
     // We require the OCS style API in 9.x, can't deal with the REST one only found in 8.2

src/libsync/capabilities.h

@@ -75,6 +75,12 @@ class OWNCLOUDSYNC_EXPORT Capabilities
     bool sharePublicLinkEnforceExpireDate() const;
     bool sharePublicLinkMultiple() const;
     bool shareResharing() const;
+    /** Remote Poll interval.
+     *
+     *  returns the requested poll interval in seconds to be used by the client.
+     *  @returns 0 if no capability is set.
+     */
+    std::chrono::seconds remotePollInterval() const;
 
     // TODO: return SharePermission
     int defaultPermissions() const;

src/libsync/configfile.cpp

@@ -40,7 +40,6 @@
 #include <QOperatingSystemVersion>
 #include <QStandardPaths>
 
-#define DEFAULT_REMOTE_POLL_INTERVAL 30000 // default remote poll time in milliseconds
 #define DEFAULT_MAX_LOG_LINES 20000
 
 namespace OCC {
@@ -94,6 +93,7 @@ const QString moveToTrashC() { return QStringLiteral("moveToTrash"); }
 }
 
 QString ConfigFile::_confDir = QString();
+const std::chrono::seconds DefaultRemotePollInterval { 30 }; // default remote poll time in milliseconds
 
 static chrono::milliseconds millisecondsValue(const QSettings &setting, const QString &key,
     chrono::milliseconds defaultValue)
@@ -404,7 +404,7 @@ bool ConfigFile::dataExists(const QString &group, const QString &key) const
     return settings.contains(key);
 }
 
-chrono::milliseconds ConfigFile::remotePollInterval(const QString &connection) const
+chrono::milliseconds ConfigFile::remotePollInterval(std::chrono::seconds defaultVal, const QString &connection) const
 {
     QString con(connection);
     if (connection.isEmpty())
@@ -413,11 +413,18 @@ chrono::milliseconds ConfigFile::remotePollInterval(const QString &connection) c
     QSettings settings(configFile(), QSettings::IniFormat);
     settings.beginGroup(con);
 
-    auto defaultPollInterval = chrono::milliseconds(DEFAULT_REMOTE_POLL_INTERVAL);
+    auto defaultPollInterval { DefaultRemotePollInterval };
+
+    // The server default-capabilities is set to 60, which is, if interpreted in milliseconds,
+    // pretty small. If the value is above 5 seconds, it was set intentionally.
+    // Server admins have to set the value in Milliseconds!
+    if (defaultVal > chrono::seconds(5)) {
+        defaultPollInterval = defaultVal;
+    }
     auto remoteInterval = millisecondsValue(settings, remotePollIntervalC(), defaultPollInterval);
     if (remoteInterval < chrono::seconds(5)) {
-        qCWarning(lcConfigFile) << "Remote Interval is less than 5 seconds, reverting to" << DEFAULT_REMOTE_POLL_INTERVAL;
         remoteInterval = defaultPollInterval;
+        qCWarning(lcConfigFile) << "Remote Interval is less than 5 seconds, reverting to" << remoteInterval.count();
     }
     return remoteInterval;
 }
@@ -438,9 +445,9 @@ void ConfigFile::setRemotePollInterval(chrono::milliseconds interval, const QStr
     settings.sync();
 }
 
-chrono::milliseconds ConfigFile::forceSyncInterval(const QString &connection) const
+chrono::milliseconds ConfigFile::forceSyncInterval(std::chrono::seconds remoteFromCapabilities, const QString &connection) const
 {
-    auto pollInterval = remotePollInterval(connection);
+    auto pollInterval = remotePollInterval(remoteFromCapabilities, connection);
 
     QString con(connection);
     if (connection.isEmpty())

src/libsync/configfile.h

@@ -64,15 +64,15 @@ class OWNCLOUDSYNC_EXPORT ConfigFile
     bool passwordStorageAllowed(const QString &connection = QString());
 
     /* Server poll interval in milliseconds */
-    std::chrono::milliseconds remotePollInterval(const QString &connection = QString()) const;
+    std::chrono::milliseconds remotePollInterval(std::chrono::seconds defaultVal, const QString &connection = QString()) const;
     /* Set poll interval. Value in milliseconds has to be larger than 5000 */
     void setRemotePollInterval(std::chrono::milliseconds interval, const QString &connection = QString());
 
     /* Interval to check for new notifications */
     std::chrono::milliseconds notificationRefreshInterval(const QString &connection = QString()) const;
 
     /* Force sync interval, in milliseconds */
-    std::chrono::milliseconds forceSyncInterval(const QString &connection = QString()) const;
+    std::chrono::milliseconds forceSyncInterval(std::chrono::seconds remoteFromCapabilities, const QString &connection = QString()) const;
 
     /**
      * Interval in milliseconds within which full local discovery is required