--- /dev/null
+/*
+ * Copyright (C) by Christian Kamm <mail@ckamm.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * for more details.
+ */
+
+#ifndef PINSTATE_H
+#define PINSTATE_H
+
+#include "ocsynclib.h"
+
+namespace OCC {
+
+/** Determines whether items should be available locally permanently or not
+ *
+ * The idea is that files and folders can be marked with the user intent
+ * on availability.
+ *
+ * The Inherited state is used for resetting a pin state to what its
+ * parent path would do.
+ *
+ * The pin state of a directory usually only matters for the initial pin and
+ * hydration state of new remote files. It's perfectly possible for a
+ * AlwaysLocal directory to have only OnlineOnly items. (though setting pin
+ * states is usually done recursively, so one'd need to set the folder to
+ * pinned and then each contained item to unpinned)
+ *
+ * Note: This enum intentionally mimics CF_PIN_STATE of Windows cfapi.
+ */
+enum class PinState {
+ /** The pin state is derived from the state of the parent folder.
+ *
+ * For example new remote files start out in this state, following
+ * the state of their parent folder.
+ *
+ * This state is used purely for resetting pin states to their derived
+ * value. The effective state for an item will never be "Inherited".
+ */
+ Inherited = 0,
+
+ /** The file shall be available and up to date locally.
+ *
+ * Also known as "pinned". Pinned dehydrated files shall be hydrated
+ * as soon as possible.
+ */
+ AlwaysLocal = 1,
+
+ /** File shall be a dehydrated placeholder, filled on demand.
+ *
+ * Also known as "unpinned". Unpinned hydrated files shall be dehydrated
+ * as soon as possible.
+ *
+ * If a unpinned file becomes hydrated its pin state changes to unspecified.
+ */
+ OnlineOnly = 2,
+
+ /** The user hasn't made a decision. The client or platform may hydrate or
+ * dehydrate as they see fit.
+ *
+ * New remote files in unspecified directories start unspecified, and
+ * dehydrated (which is an arbitrary decision).
+ */
+ Unspecified = 3,
+};
+
+}
+
+#endif
#include "common/ownsql.h"
#include "common/syncjournalfilerecord.h"
#include "common/result.h"
+#include "common/pinstate.h"
namespace OCC {
class SyncJournalFileRecord;
-/** Determines whether files should be available locally or not
- *
- * For new remote files the file's PinState is calculated by looking for
- * the closest parent folder that isn't Inherited.
- *
- * TODO: It seems to make sense to also store per-file PinStates.
- * Maybe these could communicate intent, similar to ItemTypeVirtualFileDownload
- * and ...FileDehydrate?
- */
-enum class PinState {
- /// Inherit the PinState of the parent directory (default)
- Inherited = 0,
- /// Download file and keep it updated.
- AlwaysLocal = 1,
- /// File shall be virtual locally.
- OnlineOnly = 2,
-};
-
/**
* @brief Class that handles the sync database
*
#include "vfs.h"
#include "plugin.h"
#include "version.h"
+#include "syncjournaldb.h"
#include <QPluginLoader>
#include <QLoggingCategory>
return {};
}
-VfsOff::VfsOff(QObject *parent)
+VfsDefaults::VfsDefaults(QObject *parent)
: Vfs(parent)
{
}
+void VfsDefaults::start(const VfsSetupParams ¶ms)
+{
+ _setupParams = params;
+}
+
+bool VfsDefaults::setPinState(const QString &folderPath, PinState state)
+{
+ auto path = folderPath.toUtf8();
+ _setupParams.journal->wipePinStateForPathAndBelow(path);
+ _setupParams.journal->setPinStateForPath(path, state);
+ return true;
+}
+
+Optional<PinState> VfsDefaults::getPinState(const QString &folderPath)
+{
+ return _setupParams.journal->effectivePinStateForPath(folderPath.toUtf8());
+}
+
+VfsOff::VfsOff(QObject *parent)
+ : VfsDefaults(parent)
+{
+}
+
VfsOff::~VfsOff() = default;
static QString modeToPluginName(Vfs::Mode mode)
#include "ocsynclib.h"
#include "result.h"
#include "syncfilestatus.h"
+#include "pinstate.h"
typedef struct csync_file_stat_s csync_file_stat_t;
*
* Note: The journal must live at least until the Vfs::stop() call.
*/
- SyncJournalDb *journal;
+ SyncJournalDb *journal = nullptr;
/// Strings potentially passed on to the platform
QString providerName;
virtual QString fileSuffix() const = 0;
- /// Must be called at least once before start(). May make sense to merge with start().
- virtual void registerFolder(const VfsSetupParams ¶ms) = 0;
-
/** Initializes interaction with the VFS provider.
*
* For example, the VFS provider might monitor files to be able to start a file
* hydration (download of a file's remote contents) when the user wants to open
* it.
+ *
+ * Usually some registration needs to be done with the backend. This function
+ * should take care of it if necessary.
*/
virtual void start(const VfsSetupParams ¶ms) = 0;
*/
virtual bool statTypeVirtualFile(csync_file_stat_t *stat, void *stat_data) = 0;
+ /** Sets the pin state for the item at a path.
+ *
+ * Usually this would forward to setting the pin state flag in the db table,
+ * but some vfs plugins will store the pin state in file attributes instead.
+ *
+ * folderPath is relative to the sync folder.
+ */
+ virtual bool setPinState(const QString &folderPath, PinState state) = 0;
+
+ /** Returns the pin state of an item at a path.
+ *
+ * Usually backed by the db's effectivePinState() function but some vfs
+ * plugins will override it to retrieve the state from elsewhere.
+ *
+ * folderPath is relative to the sync folder.
+ */
+ virtual Optional<PinState> getPinState(const QString &folderPath) = 0;
+
public slots:
/** Update in-sync state based on SyncFileStatusTracker signal.
*
void doneHydrating();
};
+class OCSYNC_EXPORT VfsDefaults : public Vfs
+{
+public:
+ explicit VfsDefaults(QObject* parent = nullptr);
+
+ // stores the params
+ void start(const VfsSetupParams ¶ms) override;
+
+ // use the journal to back the pinstates
+ bool setPinState(const QString &folderPath, PinState state) override;
+ Optional<PinState> getPinState(const QString &folderPath) override;
+
+ // access initial setup data
+ const VfsSetupParams ¶ms() const { return _setupParams; }
+
+protected:
+ VfsSetupParams _setupParams;
+};
+
/// Implementation of Vfs for Vfs::Off mode - does nothing
-class OCSYNC_EXPORT VfsOff : public Vfs
+class OCSYNC_EXPORT VfsOff : public VfsDefaults
{
Q_OBJECT
QString fileSuffix() const override { return QString(); }
- void registerFolder(const VfsSetupParams &) override {}
- void start(const VfsSetupParams &) override {}
void stop() override {}
void unregisterFolder() override {}
-
bool isHydrating() const override { return false; }
bool updateMetadata(const QString &, time_t, quint64, const QByteArray &, QString *) override { return true; }
connect(&_engine->syncFileStatusTracker(), &SyncFileStatusTracker::fileStatusChanged,
_vfs.data(), &Vfs::fileStatusChanged);
- _vfs->registerFolder(vfsParams); // Do this always?
_vfs->start(vfsParams);
}
// Used by the Socket API
SyncJournalDb *journalDb() { return &_journal; }
SyncEngine &syncEngine() { return *_engine; }
+ Vfs &vfs() { return *_vfs; }
RequestEtagJob *etagJob() { return _requestEtagJob; }
std::chrono::milliseconds msecSinceLastSync() const { return std::chrono::milliseconds(_timeSinceLastSyncDone.elapsed()); }
SecureZeroMemory(pFileNotifyBuffer, fileNotifyBufferSize);
if (!ReadDirectoryChangesW(_directory, (LPVOID)pFileNotifyBuffer,
OCC::Utility::convertSizeToDWORD(fileNotifyBufferSize), true,
- FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE,
+ FILE_NOTIFY_CHANGE_FILE_NAME
+ | FILE_NOTIFY_CHANGE_DIR_NAME
+ | FILE_NOTIFY_CHANGE_LAST_WRITE
+ | FILE_NOTIFY_CHANGE_ATTRIBUTES, // attributes are for vfs pin state changes
&dwBytesReturned,
&overlapped,
nullptr)) {
continue;
// Update the pin state on all items
- auto pinPath = data.folderRelativePathNoVfsSuffix().toUtf8();
- data.folder->journalDb()->wipePinStateForPathAndBelow(pinPath);
- data.folder->journalDb()->setPinStateForPath(pinPath, PinState::AlwaysLocal);
+ auto pinPath = data.folderRelativePathNoVfsSuffix();
+ data.folder->vfs().setPinState(pinPath, PinState::AlwaysLocal);
// Trigger the recursive download
data.folder->downloadVirtualFile(data.folderRelativePath);
continue;
// Update the pin state on all items
- auto pinPath = data.folderRelativePathNoVfsSuffix().toUtf8();
- data.folder->journalDb()->wipePinStateForPathAndBelow(pinPath);
- data.folder->journalDb()->setPinStateForPath(pinPath, PinState::OnlineOnly);
+ auto pinPath = data.folderRelativePathNoVfsSuffix();
+ data.folder->vfs().setPinState(pinPath, PinState::OnlineOnly);
// Trigger recursive dehydration
data.folder->dehydrateFile(data.folderRelativePath);
for (const auto &file : files) {
auto fileData = FileData::get(file);
auto path = fileData.folderRelativePathNoVfsSuffix();
- auto pinState = syncFolder->journalDb()->effectivePinStateForPath(path.toUtf8());
+ auto pinState = syncFolder->vfs().getPinState(path);
if (!pinState) {
// db error
hasAlwaysLocal = true;
}
// Turn new remote files into virtual files if the option is enabled.
auto &opts = _discoveryData->_syncOptions;
- if (!directoryPinState()) {
- dbError();
- return;
- }
if (!localEntry.isValid()
&& item->_type == ItemTypeFile
&& opts._vfs->mode() != Vfs::Off
- && *directoryPinState() == PinState::OnlineOnly) {
+ && _pinState != PinState::AlwaysLocal) {
item->_type = ItemTypeVirtualFile;
if (isVfsWithSuffix())
addVirtualFileSuffix(path._original);
if (!checkPermissions(item))
recurse = false;
if (recurse) {
- auto job = new ProcessDirectoryJob(item, recurseQueryLocal, recurseQueryServer, _discoveryData, this);
- job->_currentFolder = path;
+ auto job = new ProcessDirectoryJob(path, item, recurseQueryLocal, recurseQueryServer, this);
if (item->_instruction == CSYNC_INSTRUCTION_REMOVE) {
job->setParent(_discoveryData);
_discoveryData->_queuedDeletedDirectories[path._original] = job;
qCInfo(lcDisco) << "Discovered (blacklisted) " << item->_file << item->_instruction << item->_direction << item->isDirectory();
if (item->isDirectory() && item->_instruction != CSYNC_INSTRUCTION_IGNORE) {
- auto job = new ProcessDirectoryJob(item, NormalQuery, InBlackList, _discoveryData, this);
- job->_currentFolder = path;
+ auto job = new ProcessDirectoryJob(path, item, NormalQuery, InBlackList, this);
connect(job, &ProcessDirectoryJob::finished, this, &ProcessDirectoryJob::subJobFinished);
_queuedJobs.push_back(job);
} else {
return true;
}
-Optional<PinState> ProcessDirectoryJob::directoryPinState()
+bool ProcessDirectoryJob::isVfsWithSuffix() const
{
- if (!_pinStateCache) {
- _pinStateCache = _discoveryData->_statedb->effectivePinStateForPath(
- _currentFolder._original.toUtf8());
- // don't cache db errors, just retry next time
- }
- return _pinStateCache;
+ return _discoveryData->_syncOptions._vfs->mode() == Vfs::WithSuffix;
}
-bool ProcessDirectoryJob::isVfsWithSuffix() const
+void ProcessDirectoryJob::computePinState(PinState parentState)
{
- return _discoveryData->_syncOptions._vfs->mode() == Vfs::WithSuffix;
+ _pinState = parentState;
+ if (_queryLocal != ParentDontExist) {
+ if (auto state = _discoveryData->_syncOptions._vfs->getPinState(_currentFolder._local)) // ouch! pin local or original?
+ _pinState = *state;
+ }
}
}
class ProcessDirectoryJob : public QObject
{
Q_OBJECT
+
+ struct PathTuple;
public:
enum QueryMode {
NormalQuery,
InBlackList // Do not query this folder because it is in the blacklist (remote entries only)
};
Q_ENUM(QueryMode)
- explicit ProcessDirectoryJob(const SyncFileItemPtr &dirItem, QueryMode queryLocal, QueryMode queryServer,
- DiscoveryPhase *data, QObject *parent)
+
+ /** For creating the root job
+ *
+ * The base pin state is used if the root dir's pin state can't be retrieved.
+ */
+ explicit ProcessDirectoryJob(DiscoveryPhase *data, PinState basePinState, QObject *parent)
+ : QObject(parent)
+ , _discoveryData(data)
+ {
+ computePinState(basePinState);
+ }
+
+ /// For creating subjobs
+ explicit ProcessDirectoryJob(const PathTuple &path, const SyncFileItemPtr &dirItem,
+ QueryMode queryLocal, QueryMode queryServer,
+ ProcessDirectoryJob *parent)
: QObject(parent)
, _dirItem(dirItem)
, _queryServer(queryServer)
, _queryLocal(queryLocal)
- , _discoveryData(data)
+ , _discoveryData(parent->_discoveryData)
+ , _currentFolder(path)
{
+ computePinState(parent->_pinState);
}
void start();
*/
bool runLocalQuery();
- /** Retrieve and cache directory pin state */
- Optional<PinState> directoryPinState();
+ /** Sets _pinState
+ *
+ * If the folder exists locally its state is retrieved, otherwise the
+ * parent's pin state is inherited.
+ */
+ void computePinState(PinState parentState);
- QueryMode _queryServer;
- QueryMode _queryLocal;
+ QueryMode _queryServer = QueryMode::NormalQuery;
+ QueryMode _queryLocal = QueryMode::NormalQuery;
// Holds entries that resulted from a NormalQuery
QVector<RemoteInfo> _serverNormalQueryEntries;
PathTuple _currentFolder;
bool _childModified = false; // the directory contains modified item what would prevent deletion
bool _childIgnored = false; // The directory contains ignored item that would prevent deletion
- Optional<PinState> _pinStateCache; // The directories pin-state, once retrieved, see directoryPinState()
+ PinState _pinState = PinState::Unspecified; // The directory's pin-state, see setParentPinState()
signals:
void finished();
connect(_discoveryPhase.data(), &DiscoveryPhase::silentlyExcluded,
_syncFileStatusTracker.data(), &SyncFileStatusTracker::slotAddSilentlyExcluded);
- auto discoveryJob = new ProcessDirectoryJob(SyncFileItemPtr(), ProcessDirectoryJob::NormalQuery, ProcessDirectoryJob::NormalQuery,
- _discoveryPhase.data(), _discoveryPhase.data());
+ auto discoveryJob = new ProcessDirectoryJob(
+ _discoveryPhase.data(), PinState::AlwaysLocal, _discoveryPhase.data());
_discoveryPhase->startJob(discoveryJob);
connect(discoveryJob, &ProcessDirectoryJob::etag, this, &SyncEngine::slotRootEtagReceived);
}
namespace OCC {
VfsSuffix::VfsSuffix(QObject *parent)
- : Vfs(parent)
+ : VfsDefaults(parent)
{
}
return QStringLiteral(APPLICATION_DOTVIRTUALFILE_SUFFIX);
}
-void VfsSuffix::registerFolder(const VfsSetupParams &)
-{
-}
-
-void VfsSuffix::start(const VfsSetupParams &)
-{
-}
-
void VfsSuffix::stop()
{
}
namespace OCC {
-class VfsSuffix : public Vfs
+class VfsSuffix : public VfsDefaults
{
Q_OBJECT
Mode mode() const override;
QString fileSuffix() const override;
- void registerFolder(const VfsSetupParams ¶ms) override;
- void start(const VfsSetupParams ¶ms) override;
void stop() override;
void unregisterFolder() override;
#include "filesystem.h"
#include "syncengine.h"
#include "common/syncjournaldb.h"
+#include "common/vfs.h"
#include "csync_exclude.h"
#include <QDir>
// Ignore temporary files from the download. (This is in the default exclude list, but we don't load it)
_syncEngine->excludedFiles().addManualExclude("]*.~*");
+ // Ensure we have a valid VfsOff instance "running"
+ switchToVfs(_syncEngine->syncOptions()._vfs);
+
// A new folder will update the local file state database on first sync.
// To have a state matching what users will encounter, we have to a sync
// using an identical local/remote file tree first.
syncOnce();
}
+ void switchToVfs(QSharedPointer<OCC::Vfs> vfs)
+ {
+ auto opts = _syncEngine->syncOptions();
+
+ opts._vfs->stop();
+ QObject::disconnect(_syncEngine.get(), 0, opts._vfs.data(), 0);
+
+ opts._vfs = vfs;
+ _syncEngine->setSyncOptions(opts);
+
+ OCC::VfsSetupParams vfsParams;
+ vfsParams.filesystemPath = localPath();
+ vfsParams.remotePath = "";
+ vfsParams.account = _account;
+ vfsParams.journal = _journalDb.get();
+ vfsParams.providerName = "OC-TEST";
+ vfsParams.providerVersion = "0.1";
+ vfsParams.enableShellIntegration = false;
+ QObject::connect(_syncEngine.get(), &QObject::destroyed, vfs.data(), [vfs]() {
+ vfs->stop();
+ vfs->unregisterFolder();
+ });
+
+ vfs->start(vfsParams);
+ }
+
OCC::AccountPtr account() const { return _account; }
OCC::SyncEngine &syncEngine() const { return *_syncEngine; }
OCC::SyncJournalDb &syncJournal() const { return *_journalDb; }
journal.avoidReadFromDbOnNextSync(record._path);
}
-SyncOptions vfsSyncOptions(FakeFolder &fakeFolder)
+QSharedPointer<Vfs> setupVfs(FakeFolder &folder)
{
- SyncOptions options;
- options._vfs.reset(createVfsFromPlugin(Vfs::WithSuffix).release());
- fakeFolder.syncJournal().setPinStateForPath("", PinState::OnlineOnly);
- return options;
+ auto suffixVfs = QSharedPointer<Vfs>(createVfsFromPlugin(Vfs::WithSuffix).release());
+ folder.switchToVfs(suffixVfs);
+
+ // Using this directly doesn't recursively unpin everything
+ folder.syncJournal().setPinStateForPath("", PinState::OnlineOnly);
+
+ return suffixVfs;
}
class TestSyncVirtualFiles : public QObject
QFETCH(bool, doLocalDiscovery);
FakeFolder fakeFolder{ FileInfo() };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
void testVirtualFileConflict()
{
FakeFolder fakeFolder{ FileInfo() };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
void testWithNormalSync()
{
FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
void testVirtualFileDownload()
{
FakeFolder fakeFolder{ FileInfo() };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
void testVirtualFileDownloadResume()
{
FakeFolder fakeFolder{ FileInfo() };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
void testNewFilesNotVirtual()
{
FakeFolder fakeFolder{ FileInfo() };
- SyncOptions syncOptions = vfsSyncOptions(fakeFolder);
- fakeFolder.syncEngine().setSyncOptions(syncOptions);
+ setupVfs(fakeFolder);
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
fakeFolder.remoteModifier().mkdir("A");
void testDownloadRecursive()
{
FakeFolder fakeFolder{ FileInfo() };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
// Create a virtual file for remote files
void testRenameToVirtual()
{
FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
void testRenameVirtual()
{
FakeFolder fakeFolder{ FileInfo() };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
void testSyncDehydration()
{
FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
QVERIFY(fakeFolder.syncOnce());
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
void testWipeVirtualSuffixFiles()
{
FakeFolder fakeFolder{ FileInfo{} };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
// Create a suffix-vfs baseline
QVERIFY(fakeFolder.currentLocalState().find("A/a3.nextcloud"));
QVERIFY(!fakeFolder.currentLocalState().find("A/B/b1.nextcloud"));
- fakeFolder.syncEngine().setSyncOptions(SyncOptions{});
+ fakeFolder.switchToVfs(QSharedPointer<Vfs>(new VfsOff));
QVERIFY(fakeFolder.syncOnce());
QVERIFY(fakeFolder.currentRemoteState().find("A/a3.nextcloud")); // regular upload
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
void testNewVirtuals()
{
FakeFolder fakeFolder{ FileInfo() };
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
auto setPin = [&] (const QByteArray &path, PinState state) {
setPin("local", PinState::AlwaysLocal);
setPin("online", PinState::OnlineOnly);
+ setPin("unspec", PinState::Unspecified);
// Test 1: root is OnlineOnly
fakeFolder.remoteModifier().insert("file1");
QVERIFY(fakeFolder.currentLocalState().find("file2"));
QVERIFY(fakeFolder.currentLocalState().find("online/file2.nextcloud"));
QVERIFY(fakeFolder.currentLocalState().find("local/file2"));
- QVERIFY(fakeFolder.currentLocalState().find("unspec/file2"));
+ QVERIFY(fakeFolder.currentLocalState().find("unspec/file2.nextcloud"));
// file1 is unchanged
QVERIFY(fakeFolder.currentLocalState().find("file1.nextcloud"));
cleanup();
// Enable suffix vfs
- fakeFolder.syncEngine().setSyncOptions(vfsSyncOptions(fakeFolder));
+ setupVfs(fakeFolder);
// Local changes of suffixed file do nothing
fakeFolder.localModifier().appendByte("A/file1.nextcloud");
projects / nextcloud-desktop.git / commitdiff