fix(discovery): check quota before upload (during discovery)

src/libsync/discovery.cpp

@@ -1,3 +1,3 @@
 /*
  * SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2018 ownCloud GmbH
@@ -29,9 +29,8 @@
 namespace
 {
 constexpr const char *editorNamesForDelayedUpload[] = {"PowerPDF"};
 constexpr const char *fileExtensionsToCheckIfOpenForSigning[] = {".pdf"};
 constexpr auto delayIntervalForSyncRetryForOpenedForSigningFilesSeconds = 60;
-constexpr auto delayIntervalForSyncRetryForFilesExceedQuotaSeconds = 60;
 }
 
 namespace OCC {
@@ -61,7 +60,7 @@
     computePinState(parent->_pinState);
 }
 
 ProcessDirectoryJob::ProcessDirectoryJob(DiscoveryPhase *data, PinState basePinState, const PathTuple &path, const SyncFileItemPtr &dirItem, const SyncFileItemPtr &parentDirItem, QueryMode queryLocal, qint64 lastSyncTimestamp, QObject *parent)
         : QObject(parent)
         , _dirItem(dirItem)
         , _dirParentItem(parentDirItem)
@@ -252,7 +251,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;
 
@@ -276,7 +275,7 @@
                                             || excluded == CSYNC_FILE_EXCLUDE_TRAILING_SPACE
                                             || excluded == CSYNC_FILE_EXCLUDE_LEADING_AND_TRAILING_SPACE;
 
     const auto leadingAndTrailingSpacesFilesAllowed = !_discoveryData->_shouldEnforceWindowsFileNameCompatibility || _discoveryData->_leadingAndTrailingSpacesFilesAllowed.contains(_discoveryData->_localDir + path);
 #if defined Q_OS_WINDOWS
     if (hasLeadingOrTrailingSpaces && leadingAndTrailingSpacesFilesAllowed) {
 #else
@@ -693,7 +692,7 @@
         _pendingAsyncJobs++;
         _discoveryData->checkSelectiveSyncNewFolder(path._server,
                                                     serverEntry.remotePerm,
                                                     [=, this](bool result) {
                                                         --_pendingAsyncJobs;
                                                         if (!result) {
                                                             processFileAnalyzeLocalInfo(item, path, localEntry, serverEntry, dbEntry, _queryServer);
@@ -753,7 +752,7 @@
     if (item->_e2eEncryptionStatusRemote != SyncFileItem::EncryptionStatus::NotEncrypted) {
         Q_ASSERT(item->_e2eEncryptionStatus != SyncFileItem::EncryptionStatus::NotEncrypted);
     }
     item->_encryptedFileName = [=, this] {
         auto result = QString{};
 
         if (item->_e2eEncryptionStatus == SyncFileItem::EncryptionStatus::NotEncrypted) {
@@ -1079,7 +1078,7 @@
             // we need to make a request to the server to know that the original file is deleted on the server
             _pendingAsyncJobs++;
             const auto job = new RequestEtagJob(_discoveryData->_account, _discoveryData->_remoteFolder + originalPath, this);
             connect(job, &RequestEtagJob::finishedWithResult, this, [=, this](const HttpResult<QByteArray> &etag) mutable {
                 _pendingAsyncJobs--;
                 QTimer::singleShot(0, _discoveryData, &DiscoveryPhase::scheduleMoreJobs);
                 if (etag || etag.error().code != 404 ||
@@ -1143,27 +1142,55 @@
         return unlimitedFreeSpace;
     }
 
+    // Helper: subtract _quotaBytesReserved from a known quota value (>= 0),
+    // clamping to 0.  Negative sentinels (-1 = new unscanned folder,
+    // -2 = unknown, -3 = unlimited) are passed through unchanged so the
+    // caller's "folderQuota > -1" guard correctly skips them.
+    auto adjustForReserved = [this](const int64_t raw) {
+        return raw >= 0 ? std::max<int64_t>(0, raw - _quotaBytesReserved) : raw;
+    };
+
     if (serverEntry == FolderQuota::ServerEntry::Valid) {
         qCDebug(lcDisco) << "Returning cached _folderQuota.bytesAvailable for item quota.";
-        return _folderQuota.bytesAvailable;
+        return adjustForReserved(_folderQuota.bytesAvailable);
     }
 
+    // serverEntry == Invalid: the file is new locally and has no server-side
+    // counterpart yet.  Fall through to the DB / _dirItem fallback so the
+    // quota value stored during the previous PROPFIND cycle is used.  If quota
+    // remains unknown there too, folderBytesAvailable() returns unlimitedFreeSpace
+    // and the upload is allowed; the propagator's reactive HTTP-507 path catches
+    // the failure and blacklists the item when quota is unavailable upfront.
+
     if (!_dirItem) {
         qCDebug(lcDisco) << "Returning unlimited free space (-3) for item quota with no _dirItem.";
         return unlimitedFreeSpace;
     }
 
     qCDebug(lcDisco) << "_dirItem->_folderQuota.bytesAvailable:" << _dirItem->_folderQuota.bytesAvailable;
 
+    // Priority 1: fresh value from the current PROPFIND cycle stored in _dirItem.
+    // _dirItem is the SyncFileItem for the parent folder (e.g. "A"), whose
+    // _folderQuota was populated by processFileAnalyzeRemoteInfo() when "A"
+    // was itself processed — this happens before any child of "A" is finalized.
+    if (_dirItem->_folderQuota.bytesAvailable != -1) {
+        qCDebug(lcDisco) << "Returning _dirItem->_folderQuota.bytesAvailable for item quota (fresh PROPFIND value).";
+        return adjustForReserved(_dirItem->_folderQuota.bytesAvailable);
+    }
+
+    // Priority 2: value persisted from the previous sync cycle in the journal DB.
     SyncJournalFileRecord dirItemDbRecord;
     if (_discoveryData->_statedb->getFileRecord(_dirItem->_file, &dirItemDbRecord) && dirItemDbRecord.isValid()) {
         const auto dirDbBytesAvailable = dirItemDbRecord._folderQuota.bytesAvailable;
-        qCDebug(lcDisco) << "Returning for item quota db value dirItemDbRecord._folderQuota.bytesAvailable" << dirDbBytesAvailable;
-        return dirDbBytesAvailable;
+        if (dirDbBytesAvailable != -1) {
+            qCDebug(lcDisco) << "Returning for item quota db value dirItemDbRecord._folderQuota.bytesAvailable" << dirDbBytesAvailable;
+            return adjustForReserved(dirDbBytesAvailable);
+        }
     }
 
-    qCDebug(lcDisco) << "Returning _dirItem->_folderQuota.bytesAvailable for item quota.";
-    return _dirItem->_folderQuota.bytesAvailable;
+    // Priority 3: quota unknown, allow the upload; reactive HTTP-507 will catch it.
+    qCDebug(lcDisco) << "Returning unlimited free space (-3) for item quota: quota unknown from both dirItem and DB.";
+    return unlimitedFreeSpace;
 }
 
 void ProcessDirectoryJob::processFileAnalyzeLocalInfo(
@@ -1259,9 +1286,22 @@
                                                                                                    _currentFolder._server);
             }
 
-            item->_status = SyncFileItem::Status::NormalError;
-            _discoveryData->_anotherSyncNeeded = true;
-            _discoveryData->_filesNeedingScheduledSync.insert(path._original, delayIntervalForSyncRetryForFilesExceedQuotaSeconds);
+            // Use DetailError so the error appears in the issues tab without a
+            // prominent pop-up, matching the reactive HTTP 507 path.
+            // Do NOT set _anotherSyncNeeded or insert into _filesNeedingScheduledSync:
+            // those were the source of the 60-second retry loop.  The discovery check
+            // re-fires on every normal sync cycle, so the upload remains blocked
+            // without wasting any network bandwidth.
+            item->_status = SyncFileItem::Status::DetailError;
+        } else if (item->_direction == SyncFileItem::Up
+                   && !item->isDirectory()
+                   && (item->_instruction == CSYNC_INSTRUCTION_NEW
+                       || item->_instruction == CSYNC_INSTRUCTION_SYNC)) {
+            // Upload approved: reserve these bytes so subsequent files processed
+            // in the same discovery pass see the reduced available quota.  Without
+            // this, two files that individually fit but together exceed the quota
+            // would both be approved.
+            _quotaBytesReserved += item->_size;
         }
 
         if (item->_type != CSyncEnums::ItemTypeVirtualFile) {
@@ -1622,7 +1662,7 @@
             item->_e2eEncryptionServerCapability = EncryptionStatusEnums::fromEndToEndEncryptionApiVersion(_discoveryData->_account->capabilities().clientSideEncryptionVersion());
             if (item->_e2eEncryptionStatus != item->_e2eEncryptionServerCapability) {
                 item->_e2eEncryptionStatus = item->_e2eEncryptionServerCapability;
                 if (base._e2eEncryptionStatus != SyncJournalFileRecord::EncryptionStatus::NotEncrypted) {
                     Q_ASSERT(item->_e2eEncryptionStatus != SyncFileItem::EncryptionStatus::NotEncrypted);
                 }
             }
@@ -1638,7 +1678,7 @@
     const auto serverHasMountRootProperty = _discoveryData->_account->serverHasMountRootProperty();
     const auto isExternalStorage = base._remotePerm.hasPermission(RemotePermissions::IsMounted) && base.isDirectory();
     const auto movePerms = checkMovePermissions(base._remotePerm, originalPath, item->isDirectory());
     if (!movePerms.sourceOk || !movePerms.destinationOk || (serverHasMountRootProperty && isExternalStorage) || isE2eeMoveOnlineOnlyItemWithCfApi) {
         qCInfo(lcDisco) << "Move without permission to rename base file, "
                         << "source:" << movePerms.sourceOk
                         << ", target:" << movePerms.destinationOk
@@ -1723,7 +1763,7 @@
         if (base.isVirtualFile() && isVfsWithSuffix())
             chopVirtualFileSuffix(serverOriginalPath);
         auto job = new RequestEtagJob(_discoveryData->_account, serverOriginalPath, this);
         connect(job, &RequestEtagJob::finishedWithResult, this, [=, this](const HttpResult<QByteArray> &etag) mutable {
 
 
             if (!etag || (etag.get() != base._etag && !item->isDirectory()) || _discoveryData->isRenamed(originalPath)
@@ -1970,6 +2010,15 @@
         auto job = new ProcessDirectoryJob(path, item, recurseQueryLocal, recurseQueryServer,
             _lastSyncTimestamp, this);
         job->setInsideEncryptedTree(isInsideEncryptedTree() || item->isEncrypted());
+        // Propagate the parent folder's quota into the child job so that
+        // new-local-only files (serverEntry invalid, no DB record yet) can
+        // read a valid quota via _folderQuota in folderBytesAvailable().
+        if (item->_folderQuota.bytesAvailable != -1) {
+            OCC::FolderQuota folderQuota;
+            folderQuota.bytesUsed = item->_folderQuota.bytesUsed;
+            folderQuota.bytesAvailable = item->_folderQuota.bytesAvailable;
+            job->setFolderQuota(folderQuota);
+        }
         if (removed) {
             job->setParent(_discoveryData);
             _discoveryData->_deletedItem[path._original] = item;
@@ -2145,8 +2194,8 @@
         return matchingEditorsKeepingFileBusy;
     }
 
     const auto isMatchingFileExtension = std::find_if(std::cbegin(fileExtensionsToCheckIfOpenForSigning), std::cend(fileExtensionsToCheckIfOpenForSigning),
         [path](const auto &matchingExtension) {
             return path._local.endsWith(matchingExtension, Qt::CaseInsensitive);
         }) != std::cend(fileExtensionsToCheckIfOpenForSigning);
 
@@ -2158,8 +2207,8 @@
     const auto editorsKeepingFileBusy = Utility::queryProcessInfosKeepingFileOpen(fullLocalPath);
 
     for (const auto &detectedEditorName : editorsKeepingFileBusy) {
         const auto isMatchingEditorFound = std::find_if(std::cbegin(editorNamesForDelayedUpload), std::cend(editorNamesForDelayedUpload),
             [detectedEditorName](const auto &matchingEditorName) {
                 return detectedEditorName.processName.startsWith(matchingEditorName, Qt::CaseInsensitive);
             }) != std::cend(editorNamesForDelayedUpload);
         if (isMatchingEditorFound) {
@@ -2219,7 +2268,7 @@
     if (job->_dirItem)
         emit _discoveryData->itemDiscovered(job->_dirItem);
 
     int count = _runningJobs.removeAll(job);
     ASSERT(count == 1);
     job->deleteLater();
     QTimer::singleShot(0, _discoveryData, &DiscoveryPhase::scheduleMoreJobs);
@@ -2298,7 +2347,7 @@
     }
 }
 
 DiscoverySingleDirectoryJob *ProcessDirectoryJob::startAsyncServerQuery()
 {
     if (_dirItem && _dirItem->isEncrypted() && _dirItem->_encryptedFileName.isEmpty()) {
         _discoveryData->_topLevelE2eeFolderPaths.insert(_discoveryData->_remoteFolder + _dirItem->_file);
@@ -2481,13 +2530,13 @@
     }
 }
 
 bool ProcessDirectoryJob::maybeRenameForWindowsCompatibility(const QString &absoluteFileName,
                                                              CSYNC_EXCLUDE_TYPE excludeReason)
 {
     auto result = true;
 
     const auto leadingAndTrailingSpacesFilesAllowed = !_discoveryData->_shouldEnforceWindowsFileNameCompatibility || _discoveryData->_leadingAndTrailingSpacesFilesAllowed.contains(absoluteFileName);
     if (leadingAndTrailingSpacesFilesAllowed) {
         return result;
     }
 
@@ -2510,7 +2559,7 @@
         break;
     case CSYNC_FILE_EXCLUDE_LEADING_AND_TRAILING_SPACE:
     case CSYNC_FILE_EXCLUDE_LEADING_SPACE:
     case CSYNC_FILE_EXCLUDE_TRAILING_SPACE:
     {
         const auto removeTrailingSpaces = [] (QString string) -> QString {
             for (int n = string.size() - 1; n >= 0; -- n) {

src/libsync/discovery.h

@@ -6,7 +6,7 @@
 
 #pragma once
 
 #include <QObject>
 #include <cstdint>
 #include "csync_exclude.h"
 #include "discoveryphase.h"
@@ -249,7 +249,7 @@
      */
     void setupDbPinStateActions(SyncJournalFileRecord &record);
 
     bool maybeRenameForWindowsCompatibility(const QString &absoluteFileName,
                                             CSYNC_EXCLUDE_TYPE excludeReason);
 
     [[nodiscard]] bool checkNewDeleteConflict(const SyncFileItemPtr &item) const;
@@ -300,6 +300,11 @@
     bool _isInsideEncryptedTree = false; // this directory is encrypted or is within the tree of directories with root directory encrypted
 
     FolderQuota _folderQuota;
+    // Running total of bytes already reserved for approved uploads in this
+    // directory during the current discovery pass.  Subtracted from the quota
+    // returned by folderBytesAvailable() so that two files which individually
+    // fit but together exceed quota cannot both be approved in one pass.
+    qint64 _quotaBytesReserved = 0;
 
     int64_t folderBytesAvailable(const SyncFileItemPtr &item, const FolderQuota::ServerEntry serverEntry) const;
 

src/libsync/propagateupload.cpp

@@ -1,10 +1,10 @@
 /*
  * SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2014 ownCloud GmbH
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "config.h"
 #include "propagateupload.h"
 #include "propagateuploadencrypted.h"
 #include "owncloudpropagator_p.h"
@@ -72,7 +72,7 @@
         qCWarning(lcPutJob) << " Network error: " << reply()->errorString();
     }
 
     connect(reply(), &QNetworkReply::uploadProgress, this, [requestID] (qint64 bytesSent, qint64 bytesTotal) {
         qCDebug(lcPutJob()) << requestID << "upload progress" << bytesSent << bytesTotal;
     });
 
@@ -160,7 +160,7 @@
         _item->_fileId = json["fileId"].toString().toUtf8();
 
         if (SyncJournalFileRecord oldRecord; _journal->getFileRecord(_item->destination(), &oldRecord) && oldRecord.isValid()) {
             if (oldRecord._etag != _item->_etag) {
                 _item->updateLockStateFromDbRecord(oldRecord);
             }
         }
@@ -282,14 +282,42 @@
         return;
     }
 
-    // Check if we believe that the upload will fail due to remote quota limits
-    const qint64 quotaGuess = propagator()->_folderQuota.value(
-        QFileInfo(_fileToUpload._file).path(), std::numeric_limits<qint64>::max());
+    // Check if we believe that the upload will fail due to remote quota limits.
+    // _folderQuota is seeded at the start of each sync cycle from the quota data
+    // returned by PROPFIND during discovery (see SyncEngine::finishSync).
+    // It is also tightened reactively whenever the server returns HTTP 507.
+    //
+    // A PROPFIND quota entry applies to a directory and all its descendants.
+    // Walk up the path hierarchy to find the nearest quota entry, so that a
+    // quota set on "A" also guards uploads into "A/B/C/".
+    qint64 quotaGuess = std::numeric_limits<qint64>::max();
+    QString lookupPath = QFileInfo(_fileToUpload._file).path();
+    while (!lookupPath.isEmpty()) {
+        if (propagator()->_folderQuota.contains(lookupPath)) {
+            quotaGuess = propagator()->_folderQuota.value(lookupPath);
+            break;
+        }
+        if (lookupPath == QLatin1String(".")) {
+            lookupPath.clear(); // reached sync root with no quota entry; terminates the loop
+        } else {
+            const auto slash = lookupPath.lastIndexOf(QLatin1Char('/'));
+            lookupPath = slash >= 0 ? lookupPath.left(slash) : QStringLiteral(".");
+        }
+    }
     if (_fileToUpload._size > quotaGuess) {
-        // Necessary for blacklisting logic
+        // quotaGuess is never std::numeric_limits<qint64>::max() here: reaching
+        // this branch requires _size > quotaGuess, which is impossible when
+        // quotaGuess == max().  So Utility::octetsToString(quotaGuess) in the
+        // message below always formats a real quota value, never "max".
+        //
+        // Set httpErrorCode so blacklistUpdate creates an InsufficientRemoteStorage
+        // entry, which suppresses automatic retries until quota becomes sufficient.
         _item->_httpErrorCode = 507;
         emit propagator()->insufficientRemoteStorage();
-        done(SyncFileItem::DetailError, tr("Upload of %1 exceeds the quota for the folder").arg(Utility::octetsToString(_fileToUpload._size)));
+        done(SyncFileItem::DetailError,
+             tr("Upload of %1 exceeds %2 of remaining storage quota for this folder")
+                 .arg(Utility::octetsToString(_fileToUpload._size),
+                      Utility::octetsToString(quotaGuess)));
         return;
     }
 
@@ -696,8 +724,8 @@
         // _item when the file was discovered via local (not remote) discovery, so
         // check the DB record directly rather than guarding on _item->_lockToken.
         SyncJournalFileRecord record;
         if (propagator()->_journal->getFileRecord(_item->_file, &record) && record.isValid()
             && !record._lockstate._lockToken.isEmpty()) {
             record._lockstate._lockToken.clear();
             record._lockstate._locked = false;
             if (const auto result = propagator()->_journal->setFileRecord(record); !result) {
@@ -734,7 +762,8 @@
 
         // Set up the error
         status = SyncFileItem::DetailError;
-        errorString = tr("Upload of %1 exceeds the quota for the folder").arg(Utility::octetsToString(_fileToUpload._size));
+        errorString = tr("Upload of %1 exceeds the remaining storage quota for this folder")
+                          .arg(Utility::octetsToString(_fileToUpload._size));
         emit propagator()->insufficientRemoteStorage();
     } else if (_item->_httpErrorCode == 400) {
         const auto exception = job->errorStringParsingBodyException(replyContent);
@@ -755,7 +784,7 @@
 
     job->setTimeout(qBound(
         // Calculate 3 minutes for each gigabyte of data
         qMin(thirtyMinutes - 1, qRound64(threeMinutes * fileSize / 1e9)),
         job->timeoutMsec(),
         // Maximum of 30 minutes
         thirtyMinutes));

src/libsync/syncengine.cpp

@@ -1,3 +1,3 @@
 /*
  * SPDX-FileCopyrightText: 2020 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2014 ownCloud GmbH
@@ -241,7 +241,7 @@
 
     // Delete the stales chunk on the server.
     if (account()->capabilities().chunkingNg()) {
         for (uint transferId : std::as_const(ids)) {
             if (!transferId)
                 continue; // Was not a chunked upload
             QUrl url = Utility::concatUrlPath(account()->url(), QLatin1String("remote.php/dav/uploads/") + account()->davUser() + QLatin1Char('/') + QString::number(transferId));
@@ -397,7 +397,7 @@
 
             // Update on-disk virtual file metadata
             if (modificationHappened && item->_type == ItemTypeVirtualFile) {
                 auto r = _syncOptions._vfs->updateMetadata(*item, filePath, {});
                 if (!r) {
                     item->_status = SyncFileItem::Status::NormalError;
                     item->_instruction = CSYNC_INSTRUCTION_ERROR;
@@ -474,7 +474,7 @@
     _needsUpdate = true;
 
     // Insert sorted
     auto it = std::lower_bound( _syncItems.begin(), _syncItems.end(), item ); // the _syncItems is sorted
     _syncItems.insert( it, item );
 
     slotNewItem(item);
@@ -501,15 +501,15 @@
         const auto e2EeLockedFolders = _journal->e2EeLockedFolders();
 
         if (!e2EeLockedFolders.isEmpty()) {
             for (const auto &e2EeLockedFolder : e2EeLockedFolders) {
                 const auto folderId = e2EeLockedFolder.first;
                 qCInfo(lcEngine()) << "start unlock job for folderId:" << folderId;
                 const auto folderToken = EncryptionHelper::decryptStringAsymmetric(_account->e2e()->getCertificateInformation(), _account->e2e()->paddingMode(), *_account->e2e(), e2EeLockedFolder.second);
                 if (!folderToken) {
                     qCWarning(lcEngine()) << "decrypt failed";
                     return;
                 }
                 // TODO: We need to rollback changes done to metadata in case we have an active lock, this needs to be implemented on the server first
                 const auto unlockJob = new OCC::UnlockEncryptFolderApiJob(_account, folderId, *folderToken, _journal, this);
                 unlockJob->setShouldRollbackMetadataChanges(true);
                 unlockJob->start();
@@ -638,7 +638,7 @@
     _discoveryPhase->_account = _account;
     _discoveryPhase->_excludes = _excludedFiles.data();
     const QString excludeFilePath = _localPath + QStringLiteral(".sync-exclude.lst");
     if (FileSystem::fileExists(excludeFilePath)) {
         _discoveryPhase->_excludes->addExcludeFilePath(excludeFilePath);
         _discoveryPhase->_excludes->reloadExcludeFiles();
     }
@@ -721,7 +721,7 @@
         const auto databaseFingerprint = _journal->dataFingerprint();
         _discoveryPhase->_dataFingerprint = databaseFingerprint;
         ProcessDirectoryJob::PathTuple path = {};
         path._local = path._original = path._server = path._target = singleItemDiscoveryOptions().discoveryPath;
 
         SyncJournalFileRecord rec;
         const auto localQueryMode = _journal->getFileRecord(singleItemDiscoveryOptions().discoveryDirItem->_file, &rec) && rec.isValid()
@@ -917,7 +917,7 @@
     detectFileLock(item);
 }
 
 void SyncEngine::slotPropagationFinished(OCC::SyncFileItem::Status status)
 {
     if (_propagator->_anotherSyncNeeded && _anotherSyncNeeded == NoFollowUpSync) {
         _anotherSyncNeeded = ImmediateFollowUp;
@@ -1042,6 +1042,31 @@
     }
 }
 
+void SyncEngine::seedPropagatorQuota()
+{
+    // Seed the propagator's per-folder quota cache from the quota data gathered
+    // during the discovery phase (PROPFIND responses).  The propagator is recreated
+    // fresh every sync cycle, so without this seeding the pre-upload quota check in
+    // PropagateUploadFileCommon::startUploadFile() would always pass on the first
+    // attempt of a new cycle, causing a full upload that the server then rejects with
+    // HTTP 507 and wasting bandwidth.  By initialising the cache here, the pre-upload
+    // check can block oversized files from the very first attempt of each cycle.
+    for (const auto &syncItem : std::as_const(_syncItems)) {
+        if (!syncItem->isDirectory() || syncItem->_folderQuota.bytesAvailable < 0) {
+            continue;
+        }
+        // OwncloudPropagator keys _folderQuota by QFileInfo::path() of the file
+        // being uploaded, which yields "." for items at the root of the sync
+        // folder.  Normalise the empty-string root path accordingly.
+        const auto key = syncItem->_file.isEmpty() ? QStringLiteral(".") : syncItem->_file;
+        // Only insert when there is no tighter bound already present (e.g. set
+        // from a prior HTTP 507 reply within the same cycle).
+        if (!_propagator->_folderQuota.contains(key)) {
+            _propagator->_folderQuota.insert(key, syncItem->_folderQuota.bytesAvailable);
+        }
+    }
+}
+
 void SyncEngine::finishSync()
 {
     auto databaseFingerprint = _journal->dataFingerprint();
@@ -1094,6 +1119,10 @@
     _propagator = QSharedPointer<OwncloudPropagator>(
         new OwncloudPropagator(_account, _localPath, _remotePath, _journal, _bulkUploadBlackList));
     _propagator->setSyncOptions(_syncOptions);
+
+    // Must be called before _propagator->start(std::move(_syncItems)) below,
+    // because start() transfers ownership of _syncItems and leaves it empty.
+    seedPropagatorQuota();
     connect(_propagator.data(), &OwncloudPropagator::itemCompleted,
             this, &SyncEngine::slotItemCompleted);
     connect(_propagator.data(), &OwncloudPropagator::progress,
@@ -1167,7 +1196,7 @@
                         ++deletionCounter;
                     }
                 });
                 if (!result) {
                     qCDebug(lcEngine()) << "unable to find the number of files within a deleted folder:" << oneItem->_file;
                 }
             } else {
@@ -1177,7 +1206,7 @@
     }
     const auto filesDeletedThresholdExceeded = deletionCounter > ConfigFile().deleteFilesThreshold();
 
     if ((allFilesDeleted || filesDeletedThresholdExceeded) && displayDialog) {
         qCWarning(lcEngine) << "Many files are going to be deleted, asking the user";
         int side = 0; // > 0 means more deleted on the server.  < 0 means more deleted on the client
         for (const auto &it : std::as_const(_syncItems)) {
@@ -1228,7 +1257,7 @@
 {
     QPointer<QObject> guard = new QObject();
     QPointer<QObject> self = this;
     auto callback = [this, self, guard](bool cancel) -> void {
         // use a guard to ensure its only called once...
         // qpointer to self to ensure we still exist
         if (!guard || !self) {
@@ -1315,14 +1344,14 @@
     // This invariant is used in SyncEngine::shouldDiscoverLocally
     QString prev;
     auto it = _localDiscoveryPaths.begin();
     while(it != _localDiscoveryPaths.end()) {
         if (!prev.isNull() && it->startsWith(prev) && (prev.endsWith('/') || *it == prev || it->at(prev.size()) <= '/')) {
             it = _localDiscoveryPaths.erase(it);
         } else {
             prev = *it;
             ++it;
         }
     }
 }
 
 void SyncEngine::setSingleItemDiscoveryOptions(const SingleItemDiscoveryOptions &singleItemDiscoveryOptions)
@@ -1335,7 +1364,7 @@
     return _singleItemDiscoveryOptions;
 }
 
 void SyncEngine::setFilesystemPermissionsReliable(bool reliable)
 {
     _filesystemPermissionsReliable = reliable;
 }
@@ -1486,7 +1515,8 @@
 
 void SyncEngine::slotInsufficientRemoteStorage()
 {
-    auto msg = tr("There is insufficient space available on the server for some uploads.");
+    auto msg = tr("Upload paused: one or more files exceed your remaining Nextcloud storage quota. "
+                  "Free up server space or contact your administrator to increase your quota.");
     if (_uniqueErrors.contains(msg)) {
         return;
     }
@@ -1573,7 +1603,7 @@
          it != _discoveryPhase->_filesNeedingScheduledSync.cend();
          ++it) {
 
         const auto file = it.key();
         const auto syncScheduledSecs = it.value();
 
         // We don't want to schedule syncs again for files we have already discovered needing a

src/libsync/syncengine.h

@@ -6,7 +6,7 @@
 
 #pragma once
 
 #include <cstdint>
 
 #include <QMutex>
 #include <QThread>
@@ -125,7 +125,7 @@
     [[nodiscard]] QSharedPointer<OwncloudPropagator> getPropagator() const { return _propagator; } // for the test
     [[nodiscard]] const SyncEngine::SingleItemDiscoveryOptions &singleItemDiscoveryOptions() const;
 
     void setFilesystemPermissionsReliable(bool reliable);
 
 public slots:
     void setSingleItemDiscoveryOptions(const OCC::SyncEngine::SingleItemDiscoveryOptions &singleItemDiscoveryOptions);
@@ -152,7 +152,7 @@
      */
     void setLocalDiscoveryOptions(OCC::LocalDiscoveryEnums::LocalDiscoveryStyle style, std::set<QString> paths = {});
     void addAcceptedInvalidFileName(const QString& filePath);
     void setLocalDiscoveryEnforceWindowsFileNameCompatibility(bool value);
 
 signals:
     // During update, before reconcile
@@ -363,6 +363,8 @@
 
     void finishSync();
 
+    void seedPropagatorQuota();
+
     [[nodiscard]] bool shouldRestartSync() const;
 
     bool handleMassDeletion();

test/testlocaldiscovery.cpp

@@ -8,7 +8,7 @@
  * any purpose.
  */
 
 #include <QtTest>
 #include "syncenginetestutils.h"
 #include <syncengine.h>
 #include <localdiscoverytracker.h>
@@ -870,106 +870,83 @@
 
     void testDiscoveryUsesCorrectQuotaSource()
     {
-        //setup sync folder
+        // Verifies that the discovery-phase quota check uses the FRESH
+        // PROPFIND value (from the current sync cycle) rather than the
+        // stale value persisted in the journal DB from a previous cycle.
+
         FakeFolder fakeFolder{FileInfo{}};
 
-        // create folder
         const QString folderA("A");
         fakeFolder.localModifier().mkdir(folderA);
         fakeFolder.remoteModifier().mkdir(folderA);
         fakeFolder.remoteModifier().setFolderQuota(folderA, {0, 500});
 
-        // sync folderA
+        // Initial sync — folder A is created, DB stores quota = 500
         ItemCompletedSpy syncSpy(fakeFolder);
         QVERIFY(fakeFolder.syncOnce());
         QCOMPARE(syncSpy.findItem(folderA)->_status, SyncFileItem::Status::NoStatus);
 
-        // check db quota for folderA - bytesAvailable is 500
         SyncJournalFileRecord recordFolderA;
         QVERIFY(fakeFolder.syncJournal().getFileRecord(folderA, &recordFolderA));
         QCOMPARE(recordFolderA._folderQuota.bytesAvailable, 500);
 
-        // add fileNameA to folderA - size < quota in db
+        // ── Case 1: upload succeeds when size < fresh PROPFIND quota ──
         const QString fileNameA("A/A.data");
         fakeFolder.localModifier().insert(fileNameA, 200);
 
-        // set different quota for folderA - remote change does not change etag yet
-        fakeFolder.remoteModifier().setFolderQuota(folderA, {0, 0});
-
-        // sync filenameA - size == quota => success
         syncSpy.clear();
         QVERIFY(fakeFolder.syncOnce());
         QCOMPARE(syncSpy.findItem(fileNameA)->_status, SyncFileItem::Status::Success);
 
-        // add smallFile to folderA - size < quota in db
-        const QString smallFile("A/smallFile.data");
-        fakeFolder.localModifier().insert(smallFile, 100);
+        // ── Case 2: fresh PROPFIND value (0) wins over stale DB (500) ──
+        // Reduce quota to 0 without invalidating the etag.  The DB still
+        // holds 500, but the root PROPFIND now returns 0 for folder A.
+        // A new file must be blocked proactively.
+        fakeFolder.remoteModifier().setFolderQuota(folderA, {0, 0});
+
+        const QString fileBlocked("A/blocked.data");
+        fakeFolder.localModifier().insert(fileBlocked, 100);
 
-        // sync smallFile - size < quota in db => success => update quota in db
         syncSpy.clear();
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(syncSpy.findItem(smallFile)->_status, SyncFileItem::Status::Success);
+        QVERIFY(!fakeFolder.syncOnce());
+        QCOMPARE(syncSpy.findItem(fileBlocked)->_status, SyncFileItem::Status::DetailError);
 
-        // create remoteFileA - size > bytes available
+        // ── Case 3: downloads are not affected by upload quota ──
         const QString remoteFileA("A/remoteA.data");
         fakeFolder.remoteModifier().insert(remoteFileA, 200);
 
-        // sync remoteFile - it is a download
         syncSpy.clear();
-        QVERIFY(fakeFolder.syncOnce());
+        // Sync still fails overall (blocked.data remains blocked), but the
+        // download of remoteFileA must succeed independently.
+        QVERIFY(!fakeFolder.syncOnce());
         QCOMPARE(syncSpy.findItem(remoteFileA)->_status, SyncFileItem::Status::Success);
+        QCOMPARE(syncSpy.findItem(fileBlocked)->_status, SyncFileItem::Status::DetailError);
 
-        // check db quota for folderA - bytesAvailable have changed to 0 due to new PROPFIND
-        QVERIFY(fakeFolder.syncJournal().getFileRecord(folderA, &recordFolderA));
-        QCOMPARE(recordFolderA._folderQuota.bytesAvailable, 0);
-
-        // create local fileNameB - size < quota in db
-        const QString fileNameB("A/B.data");
-        fakeFolder.localModifier().insert(fileNameB, 0);
-
-        // set different quota for folderA - remote change does not change etag yet
+        // ── Case 4: after quota increase, previously blocked file uploads ──
         fakeFolder.remoteModifier().setFolderQuota(folderA, {500, 600});
 
-        // sync fileNameB - size < quota in db => success
         syncSpy.clear();
         QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(syncSpy.findItem(fileNameB)->_status, SyncFileItem::Status::Success);
-
-        // create remoteFileB - it is a download
-        const QString remoteFileB("A/remoteB.data");
-        fakeFolder.remoteModifier().insert(remoteFileA, 100);
+        QCOMPARE(syncSpy.findItem(fileBlocked)->_status, SyncFileItem::Status::Success);
 
-        // create local fileNameC - size < quota in db
-        const QString fileNameC("A/C.data");
-        fakeFolder.localModifier().insert(fileNameC, 0);
-
-        // sync filenameC - size < quota in db => success
-        syncSpy.clear();
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(syncSpy.findItem(fileNameC)->_status, SyncFileItem::Status::Success);
-
-        // check db quota for folderA - bytesAvailable have changed to 600 due to new PROPFIND
+        // DB now reflects the fresh PROPFIND value (600)
         QVERIFY(fakeFolder.syncJournal().getFileRecord(folderA, &recordFolderA));
         QCOMPARE(recordFolderA._folderQuota.bytesAvailable, 600);
 
-        QCOMPARE(syncSpy.findItem(remoteFileB)->_status, SyncFileItem::Status::NoStatus);
-
-        // create local fileNameD - size > quota in db
+        // ── Case 5: file exceeding fresh quota is blocked ──
         const QString fileNameD("A/D.data");
         fakeFolder.localModifier().insert(fileNameD, 700);
 
-        // sync fileNameD - size > quota in db => error
         syncSpy.clear();
         QVERIFY(!fakeFolder.syncOnce());
-        QCOMPARE(syncSpy.findItem(fileNameD)->_status, SyncFileItem::Status::NormalError);
+        QCOMPARE(syncSpy.findItem(fileNameD)->_status, SyncFileItem::Status::DetailError);
 
-        // create local fileNameE - size < quota in db
+        // ── Case 6: file within quota succeeds even while another is blocked ──
         const QString fileNameE("A/E.data");
         fakeFolder.localModifier().insert(fileNameE, 400);
 
-        // sync fileNameE - size < quota in db => success
         syncSpy.clear();
-        QVERIFY(!fakeFolder.syncOnce());
+        QVERIFY(!fakeFolder.syncOnce()); // fileNameD still blocked
         QCOMPARE(syncSpy.findItem(fileNameE)->_status, SyncFileItem::Status::Success);
     }