diff options
Diffstat (limited to 'synchronization.cpp')
| -rw-r--r-- | synchronization.cpp | 435 |
1 files changed, 206 insertions, 229 deletions
diff --git a/synchronization.cpp b/synchronization.cpp index 73e31e68..076111be 100644 --- a/synchronization.cpp +++ b/synchronization.cpp @@ -1,7 +1,7 @@ // ************************************************************************** // * This file is part of the FreeFileSync project. It is distributed under * // * GNU General Public License: http://www.gnu.org/licenses/gpl.html * -// * Copyright (C) ZenJu (zhnmju123 AT gmx DOT de) - All Rights Reserved * +// * Copyright (C) ZenJu (zenju AT gmx DOT de) - All Rights Reserved * // ************************************************************************** #include "synchronization.h" @@ -11,6 +11,7 @@ #include <wx/file.h> //get rid!? #include <wx+/format_unit.h> #include <zen/scope_guard.h> +#include <zen/process_priority.h> #include <zen/file_handling.h> #include <zen/recycler.h> #include "lib/resolve_path.h" @@ -20,6 +21,7 @@ #include <zen/file_io.h> #include <zen/time.h> #include "lib/status_handler_impl.h" +#include "lib/versioning.h" #ifdef FFS_WIN #include <zen/long_path_prefix.h> @@ -258,6 +260,7 @@ void SyncStatistics::calcStats(const DirMapping& dirObj) recurse(dirObj); //since we model logical stats, we recurse, even if deletion variant is "recycler" or "versioning + same volume", which is a single physical operation! } +//----------------------------------------------------------------------------------------------------------- std::vector<zen::FolderPairSyncCfg> zen::extractSyncCfg(const MainConfiguration& mainCfg) { @@ -278,9 +281,9 @@ std::vector<zen::FolderPairSyncCfg> zen::extractSyncCfg(const MainConfiguration& output.push_back( FolderPairSyncCfg(syncCfg.directionCfg.var == DirectionConfig::AUTOMATIC, syncCfg.handleDeletion, - syncCfg.customDeletionDirectory)); + getFormattedDirectoryName(syncCfg.versioningDirectory), + syncCfg.versionCountLimit)); } - return output; } //------------------------------------------------------------------------------------------------------------ @@ -415,58 +418,17 @@ private: DeletionType delType; }; */ -//################################################################################################################# - -FolderPairSyncCfg::FolderPairSyncCfg(bool automaticMode, - const DeletionPolicy handleDel, - const Zstring& custDelDir) : - inAutomaticMode(automaticMode), - handleDeletion(handleDel), - custDelFolder(zen::getFormattedDirectoryName(custDelDir)) {} -//----------------------------------------------------------------------------------------------------------- -/* -add some postfix to alternate deletion directory: deletionDirectory\<prefix>2010-06-30 12-59-12\ -*/ - -Zstring findUnusedName(const Zstring& filename) -{ - //ensure that session directory does not yet exist (must be unique) - Zstring output = filename; - for (int i = 1; zen::somethingExists(output); ++i) - output = filename + Zchar('_') + numberTo<Zstring>(i); - - return output; -} - -SyncProcess::SyncProcess(const std::wstring& jobName, - const std::wstring& timestamp, - xmlAccess::OptionalDialogs& warnings, - bool verifyCopiedFiles, - bool copyLockedFiles, - bool copyFilePermissions, - bool transactionalFileCopy, - bool runWithBackgroundPriority, - ProcessCallback& handler) : - verifyCopiedFiles_(verifyCopiedFiles), - copyLockedFiles_(copyLockedFiles), - copyFilePermissions_(copyFilePermissions), - transactionalFileCopy_(transactionalFileCopy), - m_warnings(warnings), - procCallback(handler), - custDelDirShortname(utfCvrtTo<Zstring>(jobName.empty() ? timestamp : jobName + L" " + timestamp)) -{ - if (runWithBackgroundPriority) - procBackground.reset(new ScheduleForBackgroundProcessing); -} //-------------------------------------------------------------------------------------------------------------- class DeletionHandling //e.g. generate name of alternate deletion directory (unique for session AND folder pair) { public: - DeletionHandling(DeletionPolicy handleDel, - const Zstring& custDelDir, // final custom deletion directory: custDelDir + \ + subdirShort - const Zstring& subdirShort, // + DeletionHandling(DeletionPolicy handleDel, //nothrow! + const Zstring& versioningDir, + const TimeComp& timeStamp, + int versionCountLimit, + size_t folderIndex, const Zstring& baseDirPf, //with separator postfix ProcessCallback& procCallback); ~DeletionHandling() { try { tryCleanup(); } catch (...) {} /*make sure this stays non-blocking!*/ } //always (try to) clean up, even if synchronization is aborted! @@ -474,9 +436,9 @@ public: //clean-up temporary directory (recycle bin optimization) void tryCleanup(); //throw FileError -> call this in non-exceptional coding, i.e. somewhere after sync! - void removeFile (const Zstring& relativeName) const; //throw FileError - void removeFolder(const Zstring& relativeName) const { removeFolderInt(relativeName, nullptr, nullptr); }; //throw FileError - void removeFolderUpdateStatistics(const Zstring& relativeName, int objectsExpected, Int64 dataExpected) const { removeFolderInt(relativeName, &objectsExpected, &dataExpected); }; //throw FileError + void removeFile (const Zstring& relativeName); //throw FileError + void removeFolder(const Zstring& relativeName) { removeFolderInt(relativeName, nullptr, nullptr); }; //throw FileError + void removeFolderUpdateStatistics(const Zstring& relativeName, int objectsExpected, Int64 dataExpected) { removeFolderInt(relativeName, &objectsExpected, &dataExpected); }; //throw FileError //in contrast to "removeFolder()" this function will update statistics! const std::wstring& getTxtRemovingFile () const { return txtRemovingFile; } // @@ -490,15 +452,25 @@ public: #endif private: - void removeFolderInt(const Zstring& relativeName, const int* objectsExpected, const Int64* dataExpected) const; //throw FileError + DeletionHandling(const DeletionHandling&); + DeletionHandling& operator=(const DeletionHandling&); + void removeFolderInt(const Zstring& relativeName, const int* objectsExpected, const Int64* dataExpected); //throw FileError void setDeletionPolicy(DeletionPolicy newPolicy); - ProcessCallback* const procCallback_; //always bound! need assignment operator => not a reference + FileVersioner& getOrCreateVersioner() //throw FileError! => dont create in DeletionHandling()!!! + { + if (!versioner.get()) + versioner = make_unique<FileVersioner>(versioningDir_, timeStamp_, versionCountLimit_); //throw FileError + return *versioner; + }; + + ProcessCallback& procCallback_; const Zstring baseDirPf_; //ends with path separator - const Zstring custDelDir_; - const Zstring recyclerTmpDirPf; //temporary folder to move files to, before moving whole folder to recycler (postfixed with file name separator) - const Zstring versioningDirPf; //timestamped versioning folder + const Zstring versioningDir_; + const TimeComp timeStamp_; + const int versionCountLimit_; + Zstring recyclerTmpDirPf; //temporary folder to move files to, before moving whole folder to recycler (postfixed with file name separator) #ifdef FFS_WIN bool recFallbackDelPermantently; @@ -506,6 +478,7 @@ private: //magage three states: allow dynamic fallback from recycler to permanent deletion DeletionPolicy deletionPolicy_; + std::unique_ptr<FileVersioner> versioner; //used for DELETE_TO_VERSIONING; throw FileError in constructor => create on demand! //buffer status texts: std::wstring txtRemovingFile; @@ -516,31 +489,43 @@ private: }; -DeletionHandling::DeletionHandling(DeletionPolicy handleDel, - const Zstring& custDelDir, // final custom deletion directory: custDelDir + \ + subdirShort - const Zstring& subdirShort, // +DeletionHandling::DeletionHandling(DeletionPolicy handleDel, //nothrow! + const Zstring& versioningDir, + const TimeComp& timeStamp, + int versionCountLimit, + size_t folderIndex, const Zstring& baseDirPf, //with separator postfix ProcessCallback& procCallback) : - procCallback_(&procCallback), + procCallback_(procCallback), baseDirPf_(baseDirPf), - custDelDir_(custDelDir), - recyclerTmpDirPf(!baseDirPf_.empty() ? appendSeparator(findUnusedName(baseDirPf_ + Zstr("FFS ") + formatTime<Zstring>(Zstr("%Y-%m-%d %H%M%S")))) : Zstring()), - versioningDirPf (!custDelDir.empty() ? appendSeparator(findUnusedName(appendSeparator(custDelDir) + subdirShort)) : Zstring()), + versioningDir_(versioningDir), + timeStamp_(timeStamp), + versionCountLimit_(versionCountLimit), #ifdef FFS_WIN recFallbackDelPermantently(false), #endif - deletionPolicy_(MOVE_TO_RECYCLE_BIN), + deletionPolicy_(DELETE_TO_RECYCLER), cleanedUp(false) { #ifdef FFS_WIN if (!baseDirPf.empty()) - if (handleDel == MOVE_TO_RECYCLE_BIN && recycleBinStatus(baseDirPf) != STATUS_REC_EXISTS) + if (handleDel == DELETE_TO_RECYCLER && recycleBinStatus(baseDirPf) != STATUS_REC_EXISTS) { handleDel = DELETE_PERMANENTLY; //Windows' ::SHFileOperation() will do this anyway, but we have a better and faster deletion routine (e.g. on networks) recFallbackDelPermantently = true; } #endif + //assemble temporary recycler bin directory + if (!baseDirPf_.empty()) + { + Zstring tempDir = baseDirPf_ + Zstr("FFS ") + formatTime<Zstring>(Zstr("%Y-%m-%d %H%M%S"), timeStamp); + if (folderIndex > 0) + tempDir += Zstr(" [") + numberTo<Zstring>(folderIndex + 1) + Zstr("]"); //e.g. C:\Source\FFS 2012-05-15 131513 [2] + + recyclerTmpDirPf = appendSeparator(tempDir); + } + setDeletionPolicy(handleDel); } @@ -557,16 +542,16 @@ void DeletionHandling::setDeletionPolicy(DeletionPolicy newPolicy) txtRemovingSymlink = _("Deleting symbolic link %x"); break; - case MOVE_TO_RECYCLE_BIN: + case DELETE_TO_RECYCLER: txtRemovingFile = _("Moving file %x to recycle bin" ); txtRemovingDirectory = _("Moving folder %x to recycle bin" ); txtRemovingSymlink = _("Moving symbolic link %x to recycle bin"); break; - case MOVE_TO_CUSTOM_DIRECTORY: - txtRemovingFile = replaceCpy(_("Moving file %x to %y" ), L"%y", fmtFileName(custDelDir_)); - txtRemovingDirectory = replaceCpy(_("Moving folder %x to %y" ), L"%y", fmtFileName(custDelDir_)); - txtRemovingSymlink = replaceCpy(_("Moving symbolic link %x to %y"), L"%y", fmtFileName(custDelDir_)); + case DELETE_TO_VERSIONING: + txtRemovingFile = replaceCpy(_("Moving file %x to %y" ), L"%y", fmtFileName(versioningDir_)); + txtRemovingDirectory = replaceCpy(_("Moving folder %x to %y" ), L"%y", fmtFileName(versioningDir_)); + txtRemovingSymlink = replaceCpy(_("Moving symbolic link %x to %y"), L"%y", fmtFileName(versioningDir_)); break; } } @@ -576,9 +561,25 @@ void DeletionHandling::tryCleanup() //throw FileError { if (!cleanedUp) { - if (deletionPolicy_ == MOVE_TO_RECYCLE_BIN) //clean-up temporary directory (recycle bin) - if (!recyclerTmpDirPf.empty()) //empty folder input pair - recycleOrDelete(beforeLast(recyclerTmpDirPf, FILE_NAME_SEPARATOR)); //throw FileError + switch (deletionPolicy_) + { + case DELETE_PERMANENTLY: + break; + + case DELETE_TO_RECYCLER: + //clean-up temporary directory (recycle bin) + if (!recyclerTmpDirPf.empty()) //folder input pair may be empty + recycleOrDelete(beforeLast(recyclerTmpDirPf, FILE_NAME_SEPARATOR)); //throw FileError + break; + + case DELETE_TO_VERSIONING: + if (versioner.get()) + { + procCallback_.reportStatus(_("Removing old versions...")); + versioner->limitVersions([&] { procCallback_.requestUiRefresh(); }); //throw FileError + } + break; + } cleanedUp = true; } @@ -587,18 +588,17 @@ void DeletionHandling::tryCleanup() //throw FileError namespace { -class CallbackMoveFileImpl : public CallbackMoveFile //callback functionality +class CallbackMoveFileImpl : public CallbackMoveFile { public: CallbackMoveFileImpl(ProcessCallback& statusHandler, - const DeletionHandling& delHandling, int* objectsReported) : statusHandler_ (statusHandler), - delHandling_ (delHandling), objectsReported_(objectsReported), - txtMovingFile (_("Moving file %x to %y" )), - txtMovingFolder (_("Moving folder %x to %y")) {} + txtMovingFile (_("Moving file %x to %y")), + txtMovingFolder (_("Moving folder %x to %y")) {} +private: virtual void onBeforeFileMove(const Zstring& fileFrom, const Zstring& fileTo) { reportStatus(txtMovingFile, fileFrom, fileTo); } virtual void onBeforeDirMove (const Zstring& dirFrom, const Zstring& dirTo ) { reportStatus(txtMovingFolder, dirFrom, dirTo); } virtual void objectProcessed() //one call after each processed move @@ -618,14 +618,12 @@ public: statusHandler_.requestUiRefresh(); } -private: - void reportStatus(const std::wstring& rawText, const Zstring& fileFrom, const Zstring& fileTo) const + void reportStatus(const std::wstring& statusText, const Zstring& fileFrom, const Zstring& fileTo) const { - statusHandler_.reportStatus(replaceCpy(replaceCpy(rawText, L"%x", fmtFileName(fileFrom)), L"%y", fmtFileName(fileTo))); + statusHandler_.reportStatus(replaceCpy(replaceCpy(statusText, L"%x", fmtFileName(fileFrom)), L"%y", fmtFileName(fileTo))); }; ProcessCallback& statusHandler_; - const DeletionHandling& delHandling_; int* objectsReported_; //optional const std::wstring txtMovingFile; @@ -642,11 +640,11 @@ struct CallbackRemoveDirImpl : public CallbackRemoveDir delHandling_(delHandling), objectsReported_(objectsReported) {} - virtual void notifyFileDeletion(const Zstring& filename) { processSingleObject(filename, delHandling_.getTxtRemovingFile()); } - virtual void notifyDirDeletion (const Zstring& dirname ) { processSingleObject(dirname, delHandling_.getTxtRemovingDir ()); } - private: - void processSingleObject(const Zstring& objName, const std::wstring& statusText) + virtual void notifyFileDeletion(const Zstring& filename) { processSingleObject(delHandling_.getTxtRemovingFile(), filename); } + virtual void notifyDirDeletion (const Zstring& dirname ) { processSingleObject(delHandling_.getTxtRemovingDir (), dirname ); } + + void processSingleObject(const std::wstring& statusText, const Zstring& objName) { statusHandler_.reportStatus(replaceCpy(statusText, L"%x", fmtFileName(objName))); @@ -664,7 +662,7 @@ private: } -void DeletionHandling::removeFile(const Zstring& relativeName) const +void DeletionHandling::removeFile(const Zstring& relativeName) { const Zstring fullName = baseDirPf_ + relativeName; @@ -672,10 +670,10 @@ void DeletionHandling::removeFile(const Zstring& relativeName) const { case DELETE_PERMANENTLY: zen::removeFile(fullName); - //[!] resolve nameclash! + //[!] scope specifier resolves nameclash! break; - case MOVE_TO_RECYCLE_BIN: + case DELETE_TO_RECYCLER: { const Zstring targetFile = recyclerTmpDirPf + relativeName; //ends with path separator @@ -687,7 +685,7 @@ void DeletionHandling::removeFile(const Zstring& relativeName) const } catch (FileError&) { - if (fileExists(fullName)) + if (somethingExists(fullName)) //no file at all is not an error (however a directory is *not* expected!) try { const Zstring targetDir = beforeLast(targetFile, FILE_NAME_SEPARATOR); @@ -707,53 +705,34 @@ void DeletionHandling::removeFile(const Zstring& relativeName) const } break; - case MOVE_TO_CUSTOM_DIRECTORY: + case DELETE_TO_VERSIONING: { - CallbackMoveFileImpl callBack(*procCallback_, *this, nullptr); //we do *not* report statistics in this method - const Zstring targetFile = versioningDirPf + relativeName; //ends with path separator - - try //... to get away cheaply! - { - moveFile(fullName, targetFile, &callBack); //throw FileError - } - catch (FileError&) - { - if (fileExists(fullName)) - { - const Zstring targetDir = beforeLast(targetFile, FILE_NAME_SEPARATOR); - if (!dirExists(targetDir)) - { - makeDirectory(targetDir); //throw FileError - moveFile(fullName, targetFile, &callBack); //throw FileError -> this should work now! - } - else - throw; - } - } + CallbackMoveFileImpl callback(procCallback_, nullptr); //we do *not* report statistics in this method + getOrCreateVersioner().revisionFile(fullName, relativeName, callback); //throw FileError } break; } } -void DeletionHandling::removeFolderInt(const Zstring& relativeName, const int* objectsExpected, const Int64* dataExpected) const //throw FileError +void DeletionHandling::removeFolderInt(const Zstring& relativeName, const int* objectsExpected, const Int64* dataExpected) //throw FileError { const Zstring fullName = baseDirPf_ + relativeName; int objectsReported = 0; //use *only* if "objectsExpected" is bound! //in error situation: undo communication of processed amount of data - ScopeGuard guardStatistics = makeGuard([&] { procCallback_->updateProcessedData(-objectsReported, 0); }); + ScopeGuard guardStatistics = makeGuard([&] { procCallback_.updateProcessedData(-objectsReported, 0); }); switch (deletionPolicy_) { case DELETE_PERMANENTLY: { - CallbackRemoveDirImpl remDirCallback(*procCallback_, *this, objectsExpected ? &objectsReported : nullptr); + CallbackRemoveDirImpl remDirCallback(procCallback_, *this, objectsExpected ? &objectsReported : nullptr); removeDirectory(fullName, &remDirCallback); } break; - case MOVE_TO_RECYCLE_BIN: + case DELETE_TO_RECYCLER: { const Zstring targetDir = recyclerTmpDirPf + relativeName; @@ -765,7 +744,7 @@ void DeletionHandling::removeFolderInt(const Zstring& relativeName, const int* o } catch (FileError&) { - if (dirExists(fullName)) + if (somethingExists(fullName)) try { const Zstring targetSuperDir = beforeLast(targetDir, FILE_NAME_SEPARATOR); @@ -786,34 +765,15 @@ void DeletionHandling::removeFolderInt(const Zstring& relativeName, const int* o if (objectsExpected) //even though we have only one disk access, we completed "objectsExpected" logical operations! { - procCallback_->updateProcessedData(*objectsExpected, 0); + procCallback_.updateProcessedData(*objectsExpected, 0); objectsReported += *objectsExpected; } break; - case MOVE_TO_CUSTOM_DIRECTORY: + case DELETE_TO_VERSIONING: { - CallbackMoveFileImpl callBack(*procCallback_, *this, objectsExpected ? &objectsReported : nullptr); - const Zstring targetDir = versioningDirPf + relativeName; - - try //... to get away cheaply! - { - moveDirectory(fullName, targetDir, &callBack); //throw FileError - } - catch (FileError&) - { - if (dirExists(fullName)) - { - const Zstring targetSuperDir = beforeLast(targetDir, FILE_NAME_SEPARATOR); - if (!dirExists(targetSuperDir)) - { - makeDirectory(targetSuperDir); //throw FileError - moveDirectory(fullName, targetDir, &callBack); //throw FileError -> this should work now! - } - else - throw; - } - } + CallbackMoveFileImpl callback(procCallback_, objectsExpected ? &objectsReported : nullptr); + getOrCreateVersioner().revisionDir(fullName, relativeName, callback); //throw FileError } break; } @@ -824,7 +784,7 @@ void DeletionHandling::removeFolderInt(const Zstring& relativeName, const int* o guardStatistics.dismiss(); if (*objectsExpected != objectsReported || *dataExpected != 0) //adjust total: may have changed after comparison! - procCallback_->updateTotalData(objectsReported - *objectsExpected, -*dataExpected); + procCallback_.updateTotalData(objectsReported - *objectsExpected, -*dataExpected); } } @@ -836,15 +796,15 @@ bool DeletionHandling::deletionFreesSpace() const { case DELETE_PERMANENTLY: return true; - case MOVE_TO_RECYCLE_BIN: + case DELETE_TO_RECYCLER: return false; //in general... (unless Recycle Bin is full) - case MOVE_TO_CUSTOM_DIRECTORY: - switch (zen::onSameVolume(baseDirPf_, versioningDirPf)) + case DELETE_TO_VERSIONING: + switch (zen::onSameVolume(baseDirPf_, versioningDir_)) { case IS_SAME_YES: return false; case IS_SAME_NO: - return true; //but other volume (sessionDelDir) may become full... + return true; //but other volume (versioningDir) may become full... case IS_SAME_CANT_SAY: return true; //a rough guess! } @@ -852,8 +812,8 @@ bool DeletionHandling::deletionFreesSpace() const assert(false); return true; } -//------------------------------------------------------------------------------------------------------------ +//------------------------------------------------------------------------------------------------------------ namespace { @@ -952,8 +912,8 @@ public: #ifdef FFS_WIN shadow::ShadowCopy* shadowCopyHandler, #endif - const DeletionHandling& delHandlingLeft, - const DeletionHandling& delHandlingRight) : + DeletionHandling& delHandlingLeft, + DeletionHandling& delHandlingRight) : procCallback_(procCallback), #ifdef FFS_WIN shadowCopyHandler_(shadowCopyHandler), @@ -1002,14 +962,14 @@ private: template <PassId pass> void runPass(HierarchyObject& hierObj); - void synchronizeFile(FileMapping& fileObj) const; - template <SelectedSide side> void synchronizeFileInt(FileMapping& fileObj, SyncOperation syncOp) const; + void synchronizeFile(FileMapping& fileObj); + template <SelectedSide side> void synchronizeFileInt(FileMapping& fileObj, SyncOperation syncOp); - void synchronizeLink(SymLinkMapping& linkObj) const; - template <SelectedSide sideTrg> void synchronizeLinkInt(SymLinkMapping& linkObj, SyncOperation syncOp) const; + void synchronizeLink(SymLinkMapping& linkObj); + template <SelectedSide sideTrg> void synchronizeLinkInt(SymLinkMapping& linkObj, SyncOperation syncOp); - void synchronizeFolder(DirMapping& dirObj) const; - template <SelectedSide sideTrg> void synchronizeFolderInt(DirMapping& dirObj, SyncOperation syncOp) const; + void synchronizeFolder(DirMapping& dirObj); + template <SelectedSide sideTrg> void synchronizeFolderInt(DirMapping& dirObj, SyncOperation syncOp); void reportInfo (const std::wstring& rawText, const Zstring& objname) const { procCallback_.reportInfo (replaceCpy(rawText, L"%x", fmtFileName(objname))); }; void reportStatus(const std::wstring& rawText, const Zstring& objname) const { procCallback_.reportStatus(replaceCpy(rawText, L"%x", fmtFileName(objname))); }; @@ -1020,14 +980,14 @@ private: void verifyFileCopy(const Zstring& source, const Zstring& target) const; template <SelectedSide side> - const DeletionHandling& getDelHandling() const; + DeletionHandling& getDelHandling(); ProcessCallback& procCallback_; #ifdef FFS_WIN shadow::ShadowCopy* shadowCopyHandler_; //optional! #endif - const DeletionHandling& delHandlingLeft_; - const DeletionHandling& delHandlingRight_; + DeletionHandling& delHandlingLeft_; + DeletionHandling& delHandlingRight_; const bool verifyCopiedFiles_; const bool copyFilePermissions_; @@ -1047,10 +1007,10 @@ private: namespace zen { template <> inline -const DeletionHandling& SynchronizeFolderPair::getDelHandling<LEFT_SIDE>() const { return delHandlingLeft_; } +DeletionHandling& SynchronizeFolderPair::getDelHandling<LEFT_SIDE>() { return delHandlingLeft_; } template <> inline -const DeletionHandling& SynchronizeFolderPair::getDelHandling<RIGHT_SIDE>() const { return delHandlingRight_; } +DeletionHandling& SynchronizeFolderPair::getDelHandling<RIGHT_SIDE>() { return delHandlingRight_; } } @@ -1458,7 +1418,7 @@ bool getTargetDirection(SyncOperation syncOp, SelectedSide* side) inline -void SynchronizeFolderPair::synchronizeFile(FileMapping& fileObj) const +void SynchronizeFolderPair::synchronizeFile(FileMapping& fileObj) { const SyncOperation syncOp = fileObj.getSyncOperation(); @@ -1475,7 +1435,7 @@ void SynchronizeFolderPair::synchronizeFile(FileMapping& fileObj) const template <SelectedSide sideTrg> -void SynchronizeFolderPair::synchronizeFileInt(FileMapping& fileObj, SyncOperation syncOp) const +void SynchronizeFolderPair::synchronizeFileInt(FileMapping& fileObj, SyncOperation syncOp) { static const SelectedSide sideSrc = OtherSide<sideTrg>::result; @@ -1611,7 +1571,7 @@ void SynchronizeFolderPair::synchronizeFileInt(FileMapping& fileObj, SyncOperati inline -void SynchronizeFolderPair::synchronizeLink(SymLinkMapping& linkObj) const +void SynchronizeFolderPair::synchronizeLink(SymLinkMapping& linkObj) { const SyncOperation syncOp = linkObj.getSyncOperation(); @@ -1628,7 +1588,7 @@ void SynchronizeFolderPair::synchronizeLink(SymLinkMapping& linkObj) const template <SelectedSide sideTrg> -void SynchronizeFolderPair::synchronizeLinkInt(SymLinkMapping& linkObj, SyncOperation syncOp) const +void SynchronizeFolderPair::synchronizeLinkInt(SymLinkMapping& linkObj, SyncOperation syncOp) { static const SelectedSide sideSrc = OtherSide<sideTrg>::result; @@ -1735,7 +1695,7 @@ void SynchronizeFolderPair::synchronizeLinkInt(SymLinkMapping& linkObj, SyncOper inline -void SynchronizeFolderPair::synchronizeFolder(DirMapping& dirObj) const +void SynchronizeFolderPair::synchronizeFolder(DirMapping& dirObj) { const SyncOperation syncOp = dirObj.getSyncOperation(); @@ -1752,7 +1712,7 @@ void SynchronizeFolderPair::synchronizeFolder(DirMapping& dirObj) const template <SelectedSide sideTrg> -void SynchronizeFolderPair::synchronizeFolderInt(DirMapping& dirObj, SyncOperation syncOp) const +void SynchronizeFolderPair::synchronizeFolderInt(DirMapping& dirObj, SyncOperation syncOp) { static const SelectedSide sideSrc = OtherSide<sideTrg>::result; @@ -1860,9 +1820,23 @@ struct LessDependentDirectory : public std::binary_function<Zstring, Zstring, bo } -void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCfg>& syncConfig, FolderComparison& folderCmp) +void zen::synchronize(const TimeComp& timeStamp, + xmlAccess::OptionalDialogs& warnings, + bool verifyCopiedFiles, + bool copyLockedFiles, + bool copyFilePermissions, + bool transactionalFileCopy, + bool runWithBackgroundPriority, + const std::vector<FolderPairSyncCfg>& syncConfig, + FolderComparison& folderCmp, + ProcessCallback& callback) { - //prevent shutdown while synchronization is in progress + //specify process and resource handling priorities + std::unique_ptr<ScheduleForBackgroundProcessing> backgroundPrio; + if (runWithBackgroundPriority) + backgroundPrio.reset(new ScheduleForBackgroundProcessing); + + //prevent operating system going into sleep state PreventStandby dummy; (void)dummy; @@ -1875,38 +1849,40 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf const SyncStatistics statisticsTotal(folderCmp); //keep at beginning so that all gui elements are initialized properly - procCallback.initNewPhase(getCUD(statisticsTotal), - statisticsTotal.getDataToProcess(), - ProcessCallback::PHASE_SYNCHRONIZING); + callback.initNewPhase(getCUD(statisticsTotal), + statisticsTotal.getDataToProcess(), + ProcessCallback::PHASE_SYNCHRONIZING); std::deque<bool> skipFolderPair(folderCmp.size()); //folder pairs may be skipped after fatal errors were found //initialize deletion handling: already required when checking for warnings - FixedList<std::pair<DeletionHandling, DeletionHandling>> delHandler; + FixedList<DeletionHandling> delHandlerL; //we can't use a FixedList<std::pair<>> because DeletionHandling is not copy-constructable + FixedList<DeletionHandling> delHandlerR; for (auto j = begin(folderCmp); j != end(folderCmp); ++j) { const size_t folderIndex = j - folderCmp.begin(); const FolderPairSyncCfg& folderPairCfg = syncConfig[folderIndex]; - const Zstring subDirShort = folderCmp.size() <= 1 ? custDelDirShortname : custDelDirShortname + Zstr(" (") + numberTo<Zstring>(folderIndex + 1) + Zstr(")"); - //e.g. "SyncJob 2012-05-15 131513 (1)" -> enforce different custom deletion dir when using multiple folder pairs!!! - - delHandler.emplace_back(DeletionHandling(folderPairCfg.handleDeletion, - folderPairCfg.custDelFolder, - subDirShort, - j->getBaseDirPf<LEFT_SIDE>(), - procCallback), - - DeletionHandling(folderPairCfg.handleDeletion, - folderPairCfg.custDelFolder, - subDirShort, - j->getBaseDirPf<RIGHT_SIDE>(), - procCallback)); + delHandlerL.emplace_back(folderPairCfg.handleDeletion, + folderPairCfg.versioningFolder, + timeStamp, + folderPairCfg.versionCountLimit_, + folderIndex, + j->getBaseDirPf<LEFT_SIDE>(), + callback); + + delHandlerR.emplace_back(folderPairCfg.handleDeletion, + folderPairCfg.versioningFolder, + timeStamp, + folderPairCfg.versionCountLimit_, + folderIndex, + j->getBaseDirPf<RIGHT_SIDE>(), + callback); } - //-------------------execute basic all at once before starting sync-------------------------------------- + //-------------------execute basic checks all at once before starting sync-------------------------------------- auto dependentDir = [](const Zstring& lhs, const Zstring& rhs) //note: this is NOT an equivalence relation! { @@ -1949,8 +1925,9 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf //start checking folder pairs { - auto iterDelHandler = delHandler.cbegin(); - for (auto j = begin(folderCmp); j != end(folderCmp); ++j, ++iterDelHandler) + auto iterDelHandlerL = delHandlerL.cbegin(); + auto iterDelHandlerR = delHandlerR.cbegin(); + for (auto j = begin(folderCmp); j != end(folderCmp); ++j, ++iterDelHandlerL, ++iterDelHandlerR) { const size_t folderIndex = j - begin(folderCmp); @@ -1984,7 +1961,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf if ((j->getBaseDirPf<LEFT_SIDE >().empty() && (writeLeft || folderPairCfg.inAutomaticMode)) || (j->getBaseDirPf<RIGHT_SIDE>().empty() && (writeRight || folderPairCfg.inAutomaticMode))) { - procCallback.reportFatalError(_("Target folder input field must not be empty.")); + callback.reportFatalError(_("Target folder input field must not be empty.")); skipFolderPair[folderIndex] = true; continue; } @@ -2016,12 +1993,12 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf if (folderPairStat.getUpdate() + folderPairStat.getDelete() > 0 && - folderPairCfg.handleDeletion == zen::MOVE_TO_CUSTOM_DIRECTORY) + folderPairCfg.handleDeletion == zen::DELETE_TO_VERSIONING) { //check if user-defined directory for deletion was specified - if (folderPairCfg.custDelFolder.empty()) //already trimmed by getFormattedDirectoryName() + if (folderPairCfg.versioningFolder.empty()) //already trimmed by getFormattedDirectoryName() { - procCallback.reportFatalError(_("Folder input field for versioning must not be empty.")); + callback.reportFatalError(_("Folder input field for versioning must not be empty.")); skipFolderPair[folderIndex] = true; continue; } @@ -2042,7 +2019,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf { if (!wasExisting) //avoid race-condition: we need to evaluate existence status from time of comparison! { - procCallback.reportFatalError(replaceCpy(_("Source folder %x not found."), L"%x", fmtFileName(baseDirPf))); + callback.reportFatalError(replaceCpy(_("Source folder %x not found."), L"%x", fmtFileName(baseDirPf))); skipFolderPair[folderIndex] = true; return false; } @@ -2072,23 +2049,23 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf catch (FileError&) {} }; const std::pair<Int64, Int64> spaceNeeded = DiskSpaceNeeded::calculate(*j, - iterDelHandler->first .deletionFreesSpace(), - iterDelHandler->second.deletionFreesSpace()); + iterDelHandlerL->deletionFreesSpace(), + iterDelHandlerR->deletionFreesSpace()); checkSpace(j->getBaseDirPf<LEFT_SIDE >(), spaceNeeded.first); checkSpace(j->getBaseDirPf<RIGHT_SIDE>(), spaceNeeded.second); #ifdef FFS_WIN //windows: check if recycle bin really exists; if not, Windows will silently delete, which is wrong - if (folderPairCfg.handleDeletion == MOVE_TO_RECYCLE_BIN) + if (folderPairCfg.handleDeletion == DELETE_TO_RECYCLER) { if (folderPairStat.getUpdate<LEFT_SIDE>() + folderPairStat.getDelete<LEFT_SIDE>() > 0 && - iterDelHandler->first.recyclerFallbackOnDelete()) + iterDelHandlerL->recyclerFallbackOnDelete()) recyclMissing.insert(j->getBaseDirPf<LEFT_SIDE>()); if (folderPairStat.getUpdate<RIGHT_SIDE>() + folderPairStat.getDelete<RIGHT_SIDE>() > 0 && - iterDelHandler->second.recyclerFallbackOnDelete()) + iterDelHandlerR->recyclerFallbackOnDelete()) recyclMissing.insert(j->getBaseDirPf<RIGHT_SIDE>()); } #endif @@ -2111,7 +2088,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf warningMessage += _("You can ignore conflicts and continue synchronization."); - procCallback.reportWarning(warningMessage, m_warnings.warningUnresolvedConflicts); + callback.reportWarning(warningMessage, warnings.warningUnresolvedConflicts); } @@ -2127,7 +2104,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf warningMessage += L"\n\n"; warningMessage += _("More than 50% of the total number of files will be copied or deleted!"); - procCallback.reportWarning(warningMessage, m_warnings.warningSignificantDifference); + callback.reportWarning(warningMessage, warnings.warningSignificantDifference); } @@ -2142,7 +2119,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf _("Required:") + L" " + filesizeToShortString(i->second.first) + L"\n" + _("Available:") + L" " + filesizeToShortString(i->second.second); - procCallback.reportWarning(warningMessage, m_warnings.warningNotEnoughDiskSpace); + callback.reportWarning(warningMessage, warnings.warningNotEnoughDiskSpace); } @@ -2156,7 +2133,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf std::for_each(recyclMissing.begin(), recyclMissing.end(), [&](const Zstring& path) { warningMessage += L"\n" + utfCvrtTo<std::wstring>(path); }); - procCallback.reportWarning(warningMessage, m_warnings.warningRecyclerMissing); + callback.reportWarning(warningMessage, warnings.warningRecyclerMissing); } #endif @@ -2175,21 +2152,22 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf std::wstring warningMessage = _("A folder will be modified which is part of multiple folder pairs. Please review synchronization settings.") + L"\n"; for (auto i = conflictDirs.begin(); i != conflictDirs.end(); ++i) warningMessage += L"\n" + fmtFileName(*i); - procCallback.reportWarning(warningMessage, m_warnings.warningMultiFolderWriteAccess); + callback.reportWarning(warningMessage, warnings.warningMultiFolderWriteAccess); } //-------------------end of basic checks------------------------------------------ #ifdef FFS_WIN //shadow copy buffer: per sync-instance, not folder pair - std::unique_ptr<shadow::ShadowCopy> shadowCopyHandler(copyLockedFiles_ ? new shadow::ShadowCopy : nullptr); + std::unique_ptr<shadow::ShadowCopy> shadowCopyHandler(copyLockedFiles ? new shadow::ShadowCopy : nullptr); #endif try { //loop through all directory pairs - auto iterDelHandler = delHandler.begin(); - for (auto j = begin(folderCmp); j != end(folderCmp); ++j, ++iterDelHandler) + auto iterDelHandlerL = delHandlerL.begin(); + auto iterDelHandlerR = delHandlerR.begin(); + for (auto j = begin(folderCmp); j != end(folderCmp); ++j, ++iterDelHandlerL, ++iterDelHandlerR) { //exclude some pathological case (leftdir, rightdir are empty) if (EqualFilename()(j->getBaseDirPf<LEFT_SIDE>(), j->getBaseDirPf<RIGHT_SIDE>())) @@ -2201,9 +2179,9 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf std::wstring right = _("Right") + L": "; makeSameLength(left, right); - procCallback.reportInfo(_("Synchronize folder pair:") + L"\n" + - L" " + left + fmtFileName(j->getBaseDirPf<LEFT_SIDE >()) + L"\n" + - L" " + right + fmtFileName(j->getBaseDirPf<RIGHT_SIDE>())); + callback.reportInfo(_("Synchronizing folder pair:") + L"\n" + + L" " + left + fmtFileName(j->getBaseDirPf<LEFT_SIDE >()) + L"\n" + + L" " + right + fmtFileName(j->getBaseDirPf<RIGHT_SIDE>())); //------------------------------------------------------------------------------------------ const size_t folderIndex = j - begin(folderCmp); @@ -2223,9 +2201,9 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf //just convenience: exit sync right here instead of showing tons of error messages during file copy return tryReportingError([&] { - if (!dirExistsUpdating(dirname, false, procCallback)) + if (!dirExistsUpdating(dirname, false, callback)) throw FileError(replaceCpy(_("Cannot find folder %x."), L"%x", fmtFileName(dirname))); //this should really be a "fatal error" - }, procCallback); //may throw in error-callback! + }, callback); //may throw in error-callback! } else //create target directory: user presumably ignored error "dir existing" in order to have it created automatically { @@ -2241,7 +2219,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf { //TEMPORARY network drop: base directory not found during comparison, but reappears during synchronization //=> sync-directions are based on false assumptions! Abort. - procCallback.reportFatalError(replaceCpy(_("Target folder %x already existing."), L"%x", fmtFileName(baseDirPf))); + callback.reportFatalError(replaceCpy(_("Target folder %x already existing."), L"%x", fmtFileName(baseDirPf))); temporaryNetworkDrop = true; //Is it possible we're catching a "false-positive" here, could FFS have created the directory indirectly after comparison? @@ -2249,7 +2227,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf // 2. deletion handling: versioning -> " // 3. log file creates containing folder -> no, log only created in batch mode, and only *before* comparison } - }, procCallback); //may throw in error-callback! + }, callback); //may throw in error-callback! return rv && !temporaryNetworkDrop; } } @@ -2276,36 +2254,38 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf bool copyPermissionsFp = false; tryReportingError([&] { - copyPermissionsFp = copyFilePermissions_ && //copy permissions only if asked for and supported by *both* sides! + copyPermissionsFp = copyFilePermissions && //copy permissions only if asked for and supported by *both* sides! + !j->getBaseDirPf<LEFT_SIDE >().empty() && //scenario: directory selected on one side only + !j->getBaseDirPf<RIGHT_SIDE>().empty() && // supportsPermissions(beforeLast(j->getBaseDirPf<LEFT_SIDE >(), FILE_NAME_SEPARATOR)) && //throw FileError supportsPermissions(beforeLast(j->getBaseDirPf<RIGHT_SIDE>(), FILE_NAME_SEPARATOR)); - }, procCallback); //show error dialog if necessary + }, callback); //show error dialog if necessary - SynchronizeFolderPair syncFP(procCallback, verifyCopiedFiles_, copyPermissionsFp, transactionalFileCopy_, + SynchronizeFolderPair syncFP(callback, verifyCopiedFiles, copyPermissionsFp, transactionalFileCopy, #ifdef FFS_WIN shadowCopyHandler.get(), #endif - iterDelHandler->first, iterDelHandler->second); + *iterDelHandlerL, *iterDelHandlerR); syncFP.startSync(*j); - //(try to gracefully) cleanup temporary folders (Recycle bin optimization) -> will be done in ~DeletionHandling anyway... - tryReportingError([&] { iterDelHandler->first .tryCleanup(); }, procCallback); //show error dialog if necessary - tryReportingError([&] { iterDelHandler->second.tryCleanup(); }, procCallback); // + //(try to gracefully) cleanup temporary Recycle bin folders and versioning -> will be done in ~DeletionHandling anyway... + tryReportingError([&] { iterDelHandlerL->tryCleanup(); }, callback); //show error dialog if necessary + tryReportingError([&] { iterDelHandlerR->tryCleanup(); }, callback); // //(try to gracefully) write database file (will be done in ~EnforceUpdateDatabase anyway...) if (folderPairCfg.inAutomaticMode) { - procCallback.reportStatus(_("Generating database...")); - procCallback.forceUiRefresh(); + callback.reportStatus(_("Generating database...")); + callback.forceUiRefresh(); - tryReportingError([&] { zen::saveLastSynchronousState(*j); }, procCallback); //throw FileError + tryReportingError([&] { zen::saveLastSynchronousState(*j); }, callback); //throw FileError guardUpdateDb.dismiss(); } } } catch (const std::exception& e) { - procCallback.reportFatalError(utfCvrtTo<std::wstring>(e.what())); + callback.reportFatalError(utfCvrtTo<std::wstring>(e.what())); } } @@ -2314,7 +2294,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf //callback functionality for smooth progress indicators template <class DelTargetCommand> -class WhileCopying : public zen::CallbackCopyFile //callback functionality +class WhileCopying : public zen::CallbackCopyFile { public: WhileCopying(Int64& bytesReported, @@ -2420,15 +2400,12 @@ void SynchronizeFolderPair::copyFileUpdatingTo(const FileMapping& fileObj, const //--------------------- data verification ------------------------- - -//callback functionality for status updates while verifying struct VerifyCallback { virtual ~VerifyCallback() {} virtual void updateStatus() = 0; }; - void verifyFiles(const Zstring& source, const Zstring& target, VerifyCallback& callback) // throw (FileError) { static std::vector<char> memory1(1024 * 1024); //1024 kb seems to be a reasonable buffer size |