[stable-33.0] fix(upload): skip locked files during upload to avoid errors

src/csync/csync_exclude.cpp

@@ -1,3 +1,3 @@
 /*
  * libcsync -- a library to sync a directory with another
  *
@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 
 #include "config_csync.h"
 #include <qglobal.h>
 
 #ifndef _GNU_SOURCE
@@ -27,6 +27,9 @@
 #include <QFileInfo>
 #include <QDir>
 #include <QVariant>
+#include <QLoggingCategory>
+
+Q_LOGGING_CATEGORY(lcCsyncExclude, "nextcloud.csync.exclude", QtInfoMsg)
 
 /** Expands C-like escape sequences (in place)
  */
@@ -163,10 +166,16 @@
     // not allow to sync those to avoid file loss/ambiguities (#416)
     if (blen > 1) {
         if (bname.at(blen - 1) == QLatin1Char('.')) {
+
             return CSYNC_FILE_EXCLUDE_INVALID_CHAR;
         }
     }
 
+    if (OCC::FileSystem::isFileLocked(path, OCC::FileSystem::LockMode::SharedRead)) {
+        qCWarning(lcCsyncExclude) << path << "is locked" << "exluding it from sync";
+        return CSYNC_FILE_LOCKED_SILENTLY_EXCLUDED;
+    }
+
     if (csync_is_windows_reserved_word(bname)) {
         return CSYNC_FILE_SILENTLY_EXCLUDED;
     }

src/csync/csync_exclude.h

@@ -10,7 +10,7 @@
 #ifndef _CSYNC_EXCLUDE_H
 #define _CSYNC_EXCLUDE_H
 
 #include "ocsynclib.h"
 
 #include "csync.h"
 
@@ -37,6 +37,7 @@
   CSYNC_FILE_EXCLUDE_SERVER_BLACKLISTED,
   CSYNC_FILE_EXCLUDE_LEADING_SPACE,
   CSYNC_FILE_EXCLUDE_LEADING_AND_TRAILING_SPACE,
+  CSYNC_FILE_LOCKED_SILENTLY_EXCLUDED,
 };
 
 class ExcludedFilesTest;

src/gui/folder.cpp

@@ -1,10 +1,10 @@
 /*
  * SPDX-FileCopyrightText: 2018 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2014 ownCloud GmbH
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "common/syncjournaldb.h"
 #include "config.h"
 
 #include "account.h"
@@ -1001,6 +1001,11 @@
         return true;
     }
 
+    if (OCC::FileSystem::isFileLocked(path, OCC::FileSystem::LockMode::SharedRead)) {
+        qCDebug(lcFolder) << path << "is locked" << "skip syncing it";
+        return true;
+    }
+
 #ifndef OWNCLOUD_TEST
     if (isFileExcludedAbsolute(path) && !Utility::isConflictFile(path)) {
         qCDebug(lcFolder) << "* Ignoring file" << path;

src/libsync/discovery.cpp

@@ -1,3 +1,3 @@
 /*
  * SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2018 ownCloud GmbH
@@ -253,7 +253,7 @@
     QTimer::singleShot(0, _discoveryData, &DiscoveryPhase::scheduleMoreJobs);
 }
 
 bool ProcessDirectoryJob::handleExcluded(const QString &path, const Entries &entries, const std::map<QString, Entries> &allEntries, const bool isHidden, const bool isBlacklisted)
 {
     const auto isDirectory = entries.localEntry.isDirectory || entries.serverEntry.isDirectory;
 
@@ -354,6 +354,14 @@
         }
     }
 
+    if (excluded == CSYNC_NOT_EXCLUDED && OCC::FileSystem::isFileLocked(_discoveryData->_localDir + path, OCC::FileSystem::LockMode::SharedRead) &&
+        (!entries.dbEntry.isValid() || !entries.serverEntry.isValid() || entries.serverEntry.etag == entries.dbEntry._etag)) {
+        qCInfo(lcDisco) << _discoveryData->_localDir + path << "is locked" << "exluding it from sync";
+        excluded = CSYNC_FILE_LOCKED_SILENTLY_EXCLUDED;
+
+        emit _discoveryData->seenLockedFile(_discoveryData->_localDir + path);
+    }
+
     if (excluded == CSYNC_NOT_EXCLUDED && !entries.localEntry.isSymLink) {
         return false;
     } else if (excluded == CSYNC_FILE_SILENTLY_EXCLUDED || excluded == CSYNC_FILE_EXCLUDE_AND_REMOVE) {
@@ -384,6 +392,9 @@
         case CSYNC_FILE_EXCLUDE_AND_REMOVE:
             qCFatal(lcDisco) << "These were handled earlier";
             break;
+        case CSYNC_FILE_LOCKED_SILENTLY_EXCLUDED:
+            item->_errorString = tr("File is locked by another application.");
+            break;
         case CSYNC_FILE_EXCLUDE_LIST:
             item->_errorString = tr("File is listed on the ignore list.");
             break;
@@ -2456,6 +2467,7 @@
     switch (excludeReason)
     {
     case CSYNC_NOT_EXCLUDED:
+    case CSYNC_FILE_LOCKED_SILENTLY_EXCLUDED:
     case CSYNC_FILE_EXCLUDE_CASE_CLASH_CONFLICT:
     case CSYNC_FILE_EXCLUDE_AND_REMOVE:
     case CSYNC_FILE_EXCLUDE_CANNOT_ENCODE:

src/libsync/discoveryphase.h

@@ -345,6 +345,9 @@
     void addErrorToGui(const OCC::SyncFileItem::Status status, const QString &errorMessage, const QString &subject, const OCC::ErrorCategory category);
 
     void remnantReadOnlyFolderDiscovered(const OCC::SyncFileItemPtr &item);
+
+    /** Emitted when propagation would have problems with a locked file. */
+    void seenLockedFile(const QString &fileName);
 private slots:
     void slotItemDiscovered(const OCC::SyncFileItemPtr &item);
 };

src/libsync/propagateuploadng.cpp

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "config.h"
 #include "propagateupload.h"
 #include "owncloudpropagator_p.h"
 #include "networkjobs.h"
@@ -355,15 +355,19 @@
     }
 
     const auto fileName = _fileToUpload._path;
+    if (FileSystem::isFileLocked(fileName, FileSystem::LockMode::SharedRead)) {
+        // If the file is currently locked, we want to retry the sync
+        // when it becomes available again.
+        emit propagator()->seenLockedFile(fileName);
+
+        // Soft error because this is likely caused by the user modifying his files while syncing
+        abortWithError(SyncFileItem::FileLocked, tr("File is locked preventing syncing it", "Generic warning message when a locked file cannot be synced"));
+        return;
+    }
     auto device = std::make_unique<UploadDevice>(fileName, _sent, _currentChunkSize, &propagator()->_bandwidthManager);
-    if (auto isLocked = FileSystem::isFileLocked(fileName, FileSystem::LockMode::SharedRead); isLocked || !device->open(QIODevice::ReadOnly)) {
+    if (!device->open(QIODevice::ReadOnly)) {
         qCWarning(lcPropagateUploadNG) << "Could not prepare upload device: " << device->errorString();
 
-        // If the file is currently locked, we want to retry the sync
-        // when it becomes available again.
-        if (isLocked) {
-            emit propagator()->seenLockedFile(fileName);
-        }
         // Soft error because this is likely caused by the user modifying his files while syncing
         abortWithError(SyncFileItem::SoftError, device->errorString());
         return;

src/libsync/propagateuploadv1.cpp

@@ -1,10 +1,10 @@
 /*
  * SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2016 ownCloud GmbH
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "config.h"
 #include "propagateupload.h"
 #include "owncloudpropagator_p.h"
 #include "networkjobs.h"
@@ -74,7 +74,7 @@
     startNextChunk();
 }
 
 void PropagateUploadFileV1::startNextChunk()
 {
     if (propagator()->_abortRequested)
         return;
@@ -134,16 +134,19 @@
     }
 
     const QString fileName = _fileToUpload._path;
+    if (FileSystem::isFileLocked(fileName, FileSystem::LockMode::SharedRead)) {
+        emit propagator()->seenLockedFile(fileName);
+
+               // Soft error because this is likely caused by the user modifying his files while syncing
+        abortWithError(SyncFileItem::FileLocked, tr("File is locked preventing syncing it", "Generic warning message when a locked file cannot be synced"));
+        return;
+    }
+
     auto device = std::make_unique<UploadDevice>(
             fileName, chunkStart, currentChunkSize, &propagator()->_bandwidthManager);
-    if (auto isLocked = FileSystem::isFileLocked(fileName, FileSystem::LockMode::SharedRead); isLocked || !device->open(QIODevice::ReadOnly)) {
+    if (!device->open(QIODevice::ReadOnly)) {
         qCWarning(lcPropagateUploadV1) << "Could not prepare upload device: " << device->errorString();
 
-        // If the file is currently locked, we want to retry the sync
-        // when it becomes available again.
-        if (isLocked) {
-            emit propagator()->seenLockedFile(fileName);
-        }
         // Soft error because this is likely caused by the user modifying his files while syncing
         abortWithError(SyncFileItem::SoftError, device->errorString());
         return;

src/libsync/syncengine.cpp

@@ -708,6 +708,7 @@ void SyncEngine::startSync()
     connect(_discoveryPhase.get(), &DiscoveryPhase::silentlyExcluded,
         _syncFileStatusTracker.data(), &SyncFileStatusTracker::slotAddSilentlyExcluded);
     connect(_discoveryPhase.get(), &DiscoveryPhase::remnantReadOnlyFolderDiscovered, this, &SyncEngine::remnantReadOnlyFolderDiscovered);
+    connect(_discoveryPhase.get(), &DiscoveryPhase::seenLockedFile, this, &SyncEngine::seenLockedFile);
 
     ProcessDirectoryJob *discoveryJob = nullptr;
 

test/testlockedfiles.cpp

@@ -8,7 +8,7 @@
  * any purpose.
  */
 
 #include <QtTest>
 #include "syncenginetestutils.h"
 #include "lockwatcher.h"
 #include <syncengine.h>
@@ -137,15 +137,15 @@
 
         fakeFolder.syncEngine().setLocalDiscoveryOptions(LocalDiscoveryStyle::DatabaseAndFilesystem, tracker.localDiscoveryPaths());
         tracker.startSyncPartialDiscovery();
-        QVERIFY(!fakeFolder.syncOnce());
+        QVERIFY(fakeFolder.syncOnce());
 
         QVERIFY(seenLockedFiles.contains(fakeFolder.localPath() + "A/a1"));
         QVERIFY(seenLockedFiles.size() == 1);
-        QVERIFY(hasLocalDiscoveryPath("A/a1"));
+        QVERIFY(!hasLocalDiscoveryPath("A/a1"));
 
         CloseHandle(h1);
 
-        fakeFolder.syncEngine().setLocalDiscoveryOptions(LocalDiscoveryStyle::DatabaseAndFilesystem, tracker.localDiscoveryPaths());
+        fakeFolder.syncEngine().setLocalDiscoveryOptions(LocalDiscoveryStyle::DatabaseAndFilesystem, {"A/a1"});
         tracker.startSyncPartialDiscovery();
         QVERIFY(fakeFolder.syncOnce());
         QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());