diff options
Diffstat (limited to 'synchronization.cpp')
| -rw-r--r-- | synchronization.cpp | 716 |
1 files changed, 341 insertions, 375 deletions
diff --git a/synchronization.cpp b/synchronization.cpp index 38a6e32c..b3eaf4e4 100644 --- a/synchronization.cpp +++ b/synchronization.cpp @@ -6,6 +6,7 @@ #include "synchronization.h" #include <memory> +#include <random> #include <deque> #include <stdexcept> #include <wx/file.h> //get rid!? @@ -43,7 +44,6 @@ int getCUD(const SyncStatistics& stat) } } - void SyncStatistics::init() { createLeft = 0; @@ -52,7 +52,6 @@ void SyncStatistics::init() updateRight = 0; deleteLeft = 0; deleteRight = 0; - //conflict = 0; rowsTotal = 0; } @@ -138,8 +137,6 @@ void SyncStatistics::calcStats(const FileMapping& fileObj) break; case SO_UNRESOLVED_CONFLICT: - //++conflict; - //if (conflictMsgs.size() < MAX_CONFLICTS) //save the first conflict texts conflictMsgs.push_back(std::make_pair(fileObj.getObjRelativeName(), fileObj.getSyncOpConflict())); break; @@ -190,8 +187,6 @@ void SyncStatistics::calcStats(const SymLinkMapping& linkObj) break; case SO_UNRESOLVED_CONFLICT: - //++conflict; - //if (conflictMsgs.size() < MAX_CONFLICTS) //save the first conflict texts conflictMsgs.push_back(std::make_pair(linkObj.getObjRelativeName(), linkObj.getSyncOpConflict())); break; @@ -228,14 +223,7 @@ void SyncStatistics::calcStats(const DirMapping& dirObj) ++deleteRight; break; - case SO_OVERWRITE_LEFT: - case SO_OVERWRITE_RIGHT: - assert(false); - break; - case SO_UNRESOLVED_CONFLICT: - //++conflict; - //if (conflictMsgs.size() < MAX_CONFLICTS) //save the first conflict texts conflictMsgs.push_back(std::make_pair(dirObj.getObjRelativeName(), dirObj.getSyncOpConflict())); break; @@ -247,6 +235,8 @@ void SyncStatistics::calcStats(const DirMapping& dirObj) ++updateRight; break; + case SO_OVERWRITE_LEFT: + case SO_OVERWRITE_RIGHT: case SO_MOVE_LEFT_SOURCE: case SO_MOVE_RIGHT_SOURCE: case SO_MOVE_LEFT_TARGET: @@ -274,9 +264,9 @@ std::vector<zen::FolderPairSyncCfg> zen::extractSyncCfg(const MainConfiguration& std::vector<FolderPairSyncCfg> output; //process all pairs - for (auto i = allPairs.begin(); i != allPairs.end(); ++i) + for (auto it = allPairs.begin(); it != allPairs.end(); ++it) { - SyncConfig syncCfg = i->altSyncConfig.get() ? *i->altSyncConfig : mainCfg.syncCfg; + SyncConfig syncCfg = it->altSyncConfig.get() ? *it->altSyncConfig : mainCfg.syncCfg; output.push_back( FolderPairSyncCfg(syncCfg.directionCfg.var == DirectionConfig::AUTOMATIC, @@ -286,8 +276,8 @@ std::vector<zen::FolderPairSyncCfg> zen::extractSyncCfg(const MainConfiguration& } return output; } -//------------------------------------------------------------------------------------------------------------ +//------------------------------------------------------------------------------------------------------------ //test if user accidentally selected the wrong folders to sync bool significantDifferenceDetected(const SyncStatistics& folderPairStat) @@ -301,140 +291,28 @@ bool significantDifferenceDetected(const SyncStatistics& folderPairStat) return false; const int nonMatchingRows = folderPairStat.getCreate() + - //folderPairStat.getUpdate() + -> not relevant when testing for "wrong folder selected" - folderPairStat.getDelete () + - folderPairStat.getConflict(); //? + folderPairStat.getDelete(); + //folderPairStat.getUpdate() + -> not relevant when testing for "wrong folder selected" + //folderPairStat.getConflict(); return nonMatchingRows >= 10 && nonMatchingRows > 0.5 * folderPairStat.getRowCount(); } //################################################################################################################# -/* -class PhysicalStatistics //counts *physical* operations, actual items processed (NOT disk accesses) and bytes transferred -{ -public: - PhysicalStatistics(const FolderComparison& folderCmp) : items(0) - { - delType =; - std::for_each(begin(folderCmp), end(folderCmp), [&](const BaseDirMapping& baseMap) { recurse(baseMap); }); - } - - int getItems() const { return items; } - Int64 getBytes() const { return bytes; } - -private: - enum DeletionType -{ - DEL_PERMANENTLY, - DEL_RECYCLE_BIN, - VERSIONING_SAME_VOL, - VERSIONING_DIFF_VOL, -}; - - void recurse(const HierarchyObject& hierObj) - { - std::for_each(hierObj.refSubDirs ().begin(), hierObj.refSubDirs ().end(), [&](const DirMapping& dirObj ) { calcStats(dirObj ); }); - std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), [&](const FileMapping& fileObj) { calcStats(fileObj); }); - std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), [&](const SymLinkMapping& linkObj) { calcStats(linkObj); }); - } - - void calcStats(const FileMapping& fileObj) - { - switch (fileObj.getSyncOperation()) //evaluate comparison result and sync direction - { - case SO_CREATE_NEW_LEFT: - items += 2; - bytes += to<Int64>(fileObj.getFileSize<RIGHT_SIDE>()); - break; - - case SO_CREATE_NEW_RIGHT: - ++items; - bytes += to<Int64>(fileObj.getFileSize<LEFT_SIDE>()); - break; - - case SO_DELETE_LEFT: - switch (delType) - { - case DEL_INSTANTLY: - ++items; - break; - case DEL_COPY_DELETE: - break; - } - break; - - case SO_DELETE_RIGHT: - ++items; - break; - - case SO_MOVE_LEFT_TARGET: - case SO_MOVE_RIGHT_TARGET: - ++items; - break; - - case SO_MOVE_LEFT_SOURCE: //ignore; already counted - case SO_MOVE_RIGHT_SOURCE: // - break; - - case SO_OVERWRITE_LEFT: - //todo: delete - items += 2; //read + write - bytes += to<Int64>(fileObj.getFileSize<RIGHT_SIDE>()); - break; - - case SO_OVERWRITE_RIGHT: - //todo: delete - items += 2; //read + write - bytes += to<Int64>(fileObj.getFileSize<LEFT_SIDE>()); - break; - - case SO_COPY_METADATA_TO_LEFT: - case SO_COPY_METADATA_TO_RIGHT: - ++items; - break; - - case SO_UNRESOLVED_CONFLICT: - case SO_DO_NOTHING: - case SO_EQUAL: - break; - } - } - - void calcStats(const SymLinkMapping& linkObj) - { - - } - - void calcStats(const DirMapping& dirObj) - { - //since we model physical stats, we recurse only if deletion variant is "permanently" or "user-defined + different volume", - //else deletion is done as a single physical operation - } - - int items; - Int64 bytes; - -DeletionType delType; -}; -*/ - -//-------------------------------------------------------------------------------------------------------------- - -class DeletionHandling //e.g. generate name of alternate deletion directory (unique for session AND folder pair) +class DeletionHandling //abstract deletion variants: permanently, recycle bin, user-defined directory { public: DeletionHandling(DeletionPolicy handleDel, //nothrow! const Zstring& versioningDir, VersioningStyle versioningStyle, const TimeComp& timeStamp, - size_t folderIndex, const Zstring& baseDirPf, //with separator postfix ProcessCallback& procCallback); ~DeletionHandling() { - try { tryCleanup(false); } //always (try to) clean up, even if synchronization is aborted! - catch (...) {} + try { tryCleanup(false); } + catch (...) {} //always (try to) clean up, even if synchronization is aborted! /* do not allow user callback: - make sure this stays non-blocking! @@ -445,10 +323,9 @@ public: //clean-up temporary directory (recycle bin optimization) void tryCleanup(bool allowUserCallback = true); //throw FileError -> call this in non-exceptional coding, i.e. somewhere after sync! - 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! + template <class Function> void removeFileUpdating(const Zstring& relativeName, Int64 bytesExpected, Function notifyItemDeletion); //throw FileError + template <class Function> void removeDirUpdating (const Zstring& relativeName, Int64 bytesExpected, Function notifyItemDeletion); //reports ONLY data delta via updateProcessedData()! + template <class Function> void removeLinkUpdating(const Zstring& relativeName, Int64 bytesExpected, Function notifyItemDeletion, LinkDescriptor::LinkType lt); // const std::wstring& getTxtRemovingFile () const { return txtRemovingFile; } // const std::wstring& getTxtRemovingSymLink() const { return txtRemovingSymlink; } //buffered status texts @@ -464,7 +341,6 @@ private: DeletionHandling(const DeletionHandling&); DeletionHandling& operator=(const DeletionHandling&); - void removeFolderInt(const Zstring& relativeName, const int* objectsExpected, const Int64* dataExpected); //throw FileError void setDeletionPolicy(DeletionPolicy newPolicy); FileVersioner& getOrCreateVersioner() //throw FileError! => dont create in DeletionHandling()!!! @@ -481,8 +357,9 @@ private: const TimeComp timeStamp_; #ifdef FFS_WIN - Zstring recyclerTmpDirPf; //temporary folder holding files/folders for *deferred* recycling (postfixed with file name separator) - std::vector<Zstring> toBeRecycled; //full path of files located in temporary folder, waiting to be recycled + Zstring getOrCreateRecyclerTempDirPf(); //throw FileError + Zstring recyclerTmpDir; //temporary folder holding files/folders for *deferred* recycling + std::vector<Zstring> toBeRecycled; //full path of files located in temporary folder, waiting for batch-recycling bool recFallbackDelPermantently; #endif @@ -499,12 +376,28 @@ private: bool cleanedUp; }; +namespace +{ +#ifdef FFS_WIN +//recycleBinStatus() blocks seriously if recycle bin is really full and drive is slow +StatusRecycler recycleBinStatusUpdating(const Zstring& dirname, ProcessCallback& procCallback) +{ + procCallback.reportStatus(replaceCpy(_("Checking recycle bin availability for folder %x..."), L"%x", fmtFileName(dirname), false)); + + auto ft = async([=] { return recycleBinStatus(dirname); }); + + while (!ft.timed_wait(boost::posix_time::milliseconds(UI_UPDATE_INTERVAL / 2))) + procCallback.requestUiRefresh(); //may throw! + return ft.get(); +} +#endif +} + DeletionHandling::DeletionHandling(DeletionPolicy handleDel, //nothrow! const Zstring& versioningDir, VersioningStyle versioningStyle, const TimeComp& timeStamp, - size_t folderIndex, const Zstring& baseDirPf, //with separator postfix ProcessCallback& procCallback) : procCallback_(procCallback), @@ -520,21 +413,11 @@ DeletionHandling::DeletionHandling(DeletionPolicy handleDel, //nothrow! { #ifdef FFS_WIN if (!baseDirPf.empty()) - if (handleDel == DELETE_TO_RECYCLER && recycleBinStatus(baseDirPf) != STATUS_REC_EXISTS) + if (handleDel == DELETE_TO_RECYCLER && recycleBinStatusUpdating(baseDirPf, procCallback_) != 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; } - - //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); - } #endif setDeletionPolicy(handleDel); @@ -590,6 +473,51 @@ private: ProcessCallback& statusHandler_; const std::wstring txtRecyclingFile; }; + +Zstring createUniqueRandomTempDir(const Zstring& baseDirPf) //throw FileError +{ + assert(endsWith(baseDirPf, FILE_NAME_SEPARATOR)); + + //1. generate random directory name + static std::default_random_engine rng(std::time(nullptr)); //a pseudo-random number engine with seconds-precision seed is sufficient! + //the alternative std::random_device may not always be available and can even throw an exception! + + const Zstring chars(Zstr("abcdefghijklmnopqrstuvwxyz") + Zstr("1234567890")); + std::uniform_int_distribution<size_t> distrib(0, chars.size() - 1); //takes closed range + + auto generatePath = [&]() -> Zstring //e.g. C:\Source\3vkf74fq.ffs_tmp + { + Zstring path = baseDirPf; + for (int i = 0; i < 8; ++i) + path += chars[distrib(rng)]; + return path + TEMP_FILE_ENDING; + }; + + //2. ensure uniqueness (at least for this base directory) + for (;;) + try + { + Zstring dirname = generatePath(); + makeNewDirectory(dirname, Zstring(), false); //FileError, ErrorTargetExisting + return dirname; + } + catch (const ErrorTargetExisting&) {} +} +} + +//create + returns temporary directory postfixed with file name separator +//to support later cleanup if automatic deletion fails for whatever reason +Zstring DeletionHandling::getOrCreateRecyclerTempDirPf() //throw FileError +{ + assert(!baseDirPf_.empty()); + if (baseDirPf_.empty()) + return Zstring(); + + if (recyclerTmpDir.empty()) + recyclerTmpDir = createUniqueRandomTempDir(baseDirPf_); //throw FileError + //assemble temporary recycle bin directory with random name and .ffs_tmp ending + return appendSeparator(recyclerTmpDir); } #endif @@ -604,14 +532,14 @@ void DeletionHandling::tryCleanup(bool allowUserCallback) //throw FileError case DELETE_TO_RECYCLER: #ifdef FFS_WIN - if (!recyclerTmpDirPf.empty()) + if (!recyclerTmpDir.empty()) { //move content of temporary directory to recycle bin in a single call CallbackMassRecycling cbmr(procCallback_); recycleOrDelete(toBeRecycled, allowUserCallback ? &cbmr : nullptr); //throw FileError //clean up temp directory itself (should contain remnant empty directories only) - removeDirectory(beforeLast(recyclerTmpDirPf, FILE_NAME_SEPARATOR)); //throw FileError + removeDirectory(recyclerTmpDir); //throw FileError } #endif break; @@ -634,169 +562,178 @@ void DeletionHandling::tryCleanup(bool allowUserCallback) //throw FileError } } - namespace { -class CallbackMoveFileImpl : public CallbackMoveFile +template <class Function> +struct CallbackRemoveDirImpl : public CallbackRemoveDir { -public: - CallbackMoveFileImpl(ProcessCallback& statusHandler, - int* objectsReported) : - statusHandler_ (statusHandler), - objectsReported_(objectsReported), - txtMovingFile (_("Moving file %x to %y")), - txtMovingFolder (_("Moving folder %x to %y")) {} + CallbackRemoveDirImpl(ProcessCallback& statusHandler, + const DeletionHandling& delHandling, + Function notifyItemDeletion) : + statusHandler_(statusHandler), + notifyItemDeletion_(notifyItemDeletion), + txtDeletingFile (delHandling.getTxtRemovingFile()), + txtDeletingFolder(delHandling.getTxtRemovingDir ()) {} 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 - { - if (objectsReported_) - { - statusHandler_.updateProcessedData(1, 0); - ++*objectsReported_; - } - } + virtual void onBeforeFileDeletion(const Zstring& filename) { notifyDeletion(txtDeletingFile, filename); } + virtual void onBeforeDirDeletion (const Zstring& dirname ) { notifyDeletion(txtDeletingFolder, dirname ); } - virtual void updateStatus(Int64 bytesDelta) + void notifyDeletion(const std::wstring& statusText, const Zstring& objName) { - //statusHandler_.updateProcessedData(0, bytesDelta); - //bytesReported_ += bytesDelta; -> statistics model *logical* operations! as such a file delete is only (1 obj/0 bytes)! Doesn't matter if it's actually copy + delete - - statusHandler_.requestUiRefresh(); + notifyItemDeletion_(); //it would be more correct to report *after* work was done! + statusHandler_.reportStatus(replaceCpy(statusText, L"%x", fmtFileName(objName))); } - void reportStatus(const std::wstring& statusText, const Zstring& fileFrom, const Zstring& fileTo) const - { - statusHandler_.reportStatus(replaceCpy(replaceCpy(statusText, L"%x", fmtFileName(fileFrom)), L"%y", fmtFileName(fileTo))); - }; - ProcessCallback& statusHandler_; - int* objectsReported_; //optional - - const std::wstring txtMovingFile; - const std::wstring txtMovingFolder; + Function notifyItemDeletion_; + const std::wstring txtDeletingFile; + const std::wstring txtDeletingFolder; }; -struct CallbackRemoveDirImpl : public CallbackRemoveDir +template <class Function> +class CallbackMoveDirImpl : public CallbackMoveDir { - CallbackRemoveDirImpl(ProcessCallback& statusHandler, - const DeletionHandling& delHandling, - int* objectsReported) : - statusHandler_(statusHandler), - delHandling_(delHandling), - objectsReported_(objectsReported) {} +public: + CallbackMoveDirImpl(ProcessCallback& callback, + Int64& bytesReported, + Function notifyItemDeletion) : + callback_ (callback), + bytesReported_(bytesReported), + notifyItemDeletion_(notifyItemDeletion), + txtMovingFile (_("Moving file %x to %y")), + txtMovingFolder (_("Moving folder %x to %y")) {} private: - virtual void notifyFileDeletion(const Zstring& filename) { processSingleObject(delHandling_.getTxtRemovingFile(), filename); } - virtual void notifyDirDeletion (const Zstring& dirname ) { processSingleObject(delHandling_.getTxtRemovingDir (), dirname ); } + virtual void onBeforeFileMove(const Zstring& fileFrom, const Zstring& fileTo) { notifyMove(txtMovingFile, fileFrom, fileTo); } + virtual void onBeforeDirMove (const Zstring& dirFrom, const Zstring& dirTo ) { notifyMove(txtMovingFolder, dirFrom, dirTo); } - void processSingleObject(const std::wstring& statusText, const Zstring& objName) + void notifyMove(const std::wstring& statusText, const Zstring& fileFrom, const Zstring& fileTo) const { - statusHandler_.reportStatus(replaceCpy(statusText, L"%x", fmtFileName(objName))); + notifyItemDeletion_(); //it would be more correct to report *after* work was done! + callback_.reportStatus(replaceCpy(replaceCpy(statusText, L"%x", fmtFileName(fileFrom)), L"%y", fmtFileName(fileTo))); + }; - if (objectsReported_) - { - statusHandler_.updateProcessedData(1, 0); - ++*objectsReported_; - } + virtual void updateStatus(Int64 bytesDelta) + { + callback_.updateProcessedData(0, bytesDelta); //throw()! -> ensure client and service provider are in sync! + bytesReported_ += bytesDelta; // + + callback_.requestUiRefresh(); //may throw } - ProcessCallback& statusHandler_; - const DeletionHandling& delHandling_; - int* objectsReported_; //optional + ProcessCallback& callback_; + Int64& bytesReported_; + Function notifyItemDeletion_; + const std::wstring txtMovingFile; + const std::wstring txtMovingFolder; }; } -void DeletionHandling::removeFile(const Zstring& relativeName) +template <class Function> +void DeletionHandling::removeDirUpdating(const Zstring& relativeName, Int64 bytesExpected, Function notifyItemDeletion) //throw FileError { + assert(!baseDirPf_.empty()); const Zstring fullName = baseDirPf_ + relativeName; + Int64 bytesReported; + ScopeGuard guardStatistics = makeGuard([&] { procCallback_.updateTotalData(0, bytesReported); }); //error = unexpected increase of total workload + switch (deletionPolicy_) { case DELETE_PERMANENTLY: - zen::removeFile(fullName); - //[!] scope specifier resolves nameclash! - break; + { + CallbackRemoveDirImpl<Function> remDirCallback(procCallback_, *this, notifyItemDeletion); + removeDirectory(fullName, &remDirCallback); + } + break; case DELETE_TO_RECYCLER: + { #ifdef FFS_WIN - { - const Zstring targetFile = recyclerTmpDirPf + relativeName; //ends with path separator + const Zstring targetDir = getOrCreateRecyclerTempDirPf() + relativeName; //throw FileError + bool deleted = false; - auto moveToTempDir = [&] - { - //performance optimization: Instead of moving each object into recycle bin separately, - //we rename them one by one into a temporary directory and batch-recycle this directory after sync - renameFile(fullName, targetFile); //throw FileError - toBeRecycled.push_back(targetFile); - }; + auto moveToTempDir = [&] + { + //performance optimization: Instead of moving each object into recycle bin separately, + //we rename them one by one into a temporary directory and batch-recycle this directory after sync + renameFile(fullName, targetDir); //throw FileError + this->toBeRecycled.push_back(targetDir); + deleted = true; + }; - try - { - moveToTempDir(); //throw FileError - } - catch (FileError&) + try + { + moveToTempDir(); //throw FileError + } + catch (FileError&) + { + if (somethingExists(fullName)) { - if (somethingExists(fullName)) + const Zstring targetSuperDir = beforeLast(targetDir, FILE_NAME_SEPARATOR); + if (!dirExists(targetSuperDir)) { - const Zstring targetDir = beforeLast(targetFile, FILE_NAME_SEPARATOR); - if (!dirExists(targetDir)) - { - makeDirectory(targetDir); //throw FileError -> may legitimately fail on Linux if permissions are missing - moveToTempDir(); //throw FileError -> this should work now! - } - else - throw; + makeDirectory(targetSuperDir); //throw FileError -> may legitimately fail on Linux if permissions are missing + moveToTempDir(); //throw FileError -> this should work now! } + else + throw; } } #elif defined FFS_LINUX - recycleOrDelete(fullName); //throw FileError + const bool deleted = recycleOrDelete(fullName); //throw FileError #endif - break; + if (deleted) + notifyItemDeletion(); //moving to recycler is ONE logical operation, irrespective of the number of child elements! + } + break; case DELETE_TO_VERSIONING: { - CallbackMoveFileImpl callback(procCallback_, nullptr); //we do *not* report statistics in this method - getOrCreateVersioner().revisionFile(fullName, relativeName, callback); //throw FileError + CallbackMoveDirImpl<Function> callback(procCallback_, bytesReported, notifyItemDeletion); + getOrCreateVersioner().revisionDir(fullName, relativeName, callback); //throw FileError } break; } + + //update statistics to consider the real amount of data + guardStatistics.dismiss(); + if (bytesReported != bytesExpected) + procCallback_.updateTotalData(0, bytesReported - bytesExpected); //noexcept! } -void DeletionHandling::removeFolderInt(const Zstring& relativeName, const int* objectsExpected, const Int64* dataExpected) //throw FileError +template <class Function> +void DeletionHandling::removeFileUpdating(const Zstring& relativeName, Int64 bytesExpected, Function notifyItemDeletion) //throw FileError { + assert(!baseDirPf_.empty()); 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); }); + Int64 bytesReported; + auto guardStatistics = makeGuard([&] { procCallback_.updateTotalData(0, bytesReported); }); //error = unexpected increase of total workload + bool deleted = false; switch (deletionPolicy_) { case DELETE_PERMANENTLY: - { - CallbackRemoveDirImpl remDirCallback(procCallback_, *this, objectsExpected ? &objectsReported : nullptr); - removeDirectory(fullName, &remDirCallback); - } - break; + deleted = zen::removeFile(fullName); //[!] scope specifier resolves nameclash! + break; case DELETE_TO_RECYCLER: #ifdef FFS_WIN { - const Zstring targetDir = recyclerTmpDirPf + relativeName; + const Zstring targetFile = getOrCreateRecyclerTempDirPf() + relativeName; //throw FileError auto moveToTempDir = [&] { //performance optimization: Instead of moving each object into recycle bin separately, //we rename them one by one into a temporary directory and batch-recycle this directory after sync - renameFile(fullName, targetDir); //throw FileError - toBeRecycled.push_back(targetDir); + renameFile(fullName, targetFile); //throw FileError + this->toBeRecycled.push_back(targetFile); + deleted = true; }; try @@ -807,10 +744,10 @@ void DeletionHandling::removeFolderInt(const Zstring& relativeName, const int* o { if (somethingExists(fullName)) { - const Zstring targetSuperDir = beforeLast(targetDir, FILE_NAME_SEPARATOR); - if (!dirExists(targetSuperDir)) + const Zstring targetDir = beforeLast(targetFile, FILE_NAME_SEPARATOR); + if (!dirExists(targetDir)) { - makeDirectory(targetSuperDir); //throw FileError -> may legitimately fail on Linux if permissions are missing + makeDirectory(targetDir); //throw FileError -> may legitimately fail on Linux if permissions are missing moveToTempDir(); //throw FileError -> this should work now! } else @@ -819,31 +756,51 @@ void DeletionHandling::removeFolderInt(const Zstring& relativeName, const int* o } } #elif defined FFS_LINUX - recycleOrDelete(fullName); //throw FileError + deleted = recycleOrDelete(fullName); //throw FileError #endif - - if (objectsExpected) //even though we have only one disk access, we completed "objectsExpected" logical operations! - { - procCallback_.updateProcessedData(*objectsExpected, 0); - objectsReported += *objectsExpected; - } break; case DELETE_TO_VERSIONING: { - CallbackMoveFileImpl callback(procCallback_, objectsExpected ? &objectsReported : nullptr); - getOrCreateVersioner().revisionDir(fullName, relativeName, callback); //throw FileError + struct CallbackMoveFileImpl : public CallbackMoveFile + { + CallbackMoveFileImpl(ProcessCallback& callback, Int64& bytes) : callback_(callback), bytesReported_(bytes) {} + + private: + virtual void updateStatus(Int64 bytesDelta) + { + callback_.updateProcessedData(0, bytesDelta); //throw()! -> ensure client and service provider are in sync! + bytesReported_ += bytesDelta; // + + callback_.requestUiRefresh(); //may throw + } + ProcessCallback& callback_; + Int64& bytesReported_; + } cb(procCallback_, bytesReported); + + deleted = getOrCreateVersioner().revisionFile(fullName, relativeName, cb); //throw FileError } break; } + if (deleted) + notifyItemDeletion(); + + //update statistics to consider the real amount of data + guardStatistics.dismiss(); + if (bytesReported != bytesExpected) + procCallback_.updateTotalData(0, bytesReported - bytesExpected); //noexcept! +} - //inform about the (remaining) processed amount of data - if (objectsExpected && dataExpected) +template <class Function> inline +void DeletionHandling::removeLinkUpdating(const Zstring& relativeName, Int64 bytesExpected, Function notifyItemDeletion, LinkDescriptor::LinkType lt) //throw FileError +{ + switch (lt) { - guardStatistics.dismiss(); + case LinkDescriptor::TYPE_DIR: + return removeDirUpdating(relativeName, bytesExpected, notifyItemDeletion); //throw FileError - if (*objectsExpected != objectsReported || *dataExpected != 0) //adjust total: may have changed after comparison! - procCallback_.updateTotalData(objectsReported - *objectsExpected, -*dataExpected); + case LinkDescriptor::TYPE_FILE: //Windows: true file symlink; Linux: file-link or broken link + return removeFileUpdating(relativeName, bytesExpected, notifyItemDeletion); //throw FileError } } @@ -1033,9 +990,8 @@ private: 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))); }; - //more low level helper - template <SelectedSide side, class DelTargetCommand> - void copyFileUpdatingTo(const FileMapping& fileObj, const DelTargetCommand& cmd, FileAttrib& newAttr) const; + template <SelectedSide sideTrg, class Function> + FileAttrib copyFileUpdatingTo(const FileMapping& fileObj, Function delTargetCommand) const; //throw FileError; reports data delta via updateProcessedData() void verifyFileCopy(const Zstring& source, const Zstring& target) const; template <SelectedSide side> @@ -1115,7 +1071,7 @@ Zstring findUnusedTempName(const Zstring& filename) { Zstring output = filename + zen::TEMP_FILE_ENDING; - //ensure uniqueness + //ensure uniqueness (+ minor file system race condition!) for (int i = 1; somethingExists(output); ++i) output = filename + Zchar('_') + numberTo<Zstring>(i) + zen::TEMP_FILE_ENDING; @@ -1437,8 +1393,8 @@ void SynchronizeFolderPair::runPass(HierarchyObject& hierObj) this->runPass<pass>(dirObj); //recurse }); } -//--------------------------------------------------------------------------------------------------------------- +//--------------------------------------------------------------------------------------------------------------- namespace { @@ -1503,26 +1459,25 @@ void SynchronizeFolderPair::synchronizeFileInt(FileMapping& fileObj, SyncOperati case SO_CREATE_NEW_RIGHT: { const Zstring& target = fileObj.getBaseDirPf<sideTrg>() + fileObj.getRelativeName<sideSrc>(); //can't use "getFullName" as target is not yet existing - reportInfo(txtCreatingFile, target); try { - FileAttrib newAttr; - copyFileUpdatingTo<sideTrg>(fileObj, [] {}, /*no target to delete*/ newAttr); //throw FileError - procCallback_.updateProcessedData(1, 0); //processed data is communicated in copyFileUpdatingTo()! + const FileAttrib newAttr = copyFileUpdatingTo<sideTrg>(fileObj, [] {} /*no target to delete*/); //throw FileError const FileDescriptor descrSource(newAttr.modificationTime, newAttr.fileSize, newAttr.sourceFileId); const FileDescriptor descrTarget(newAttr.modificationTime, newAttr.fileSize, newAttr.targetFileId); fileObj.syncTo<sideTrg>(descrTarget, &descrSource); //update FileMapping + + procCallback_.updateProcessedData(1, 0); //processed bytes are reported in copyFileUpdatingTo()! } catch (FileError&) { - if (somethingExists(fileObj.getFullName<sideSrc>())) //do not check on type (symlink, file, folder) -> if there is a type change, FFS should not be quiet about it! + if (somethingExists(fileObj.getFullName<sideSrc>())) //do not check on type (symlink, file, folder) -> if there is a type change, FFS should error out! throw; //source deleted meanwhile...nothing was done (logical point of view!) - procCallback_.updateTotalData(-1, -to<zen::Int64>(fileObj.getFileSize<sideSrc>())); fileObj.removeObject<sideSrc>(); + procCallback_.updateTotalData(-1, -to<zen::Int64>(fileObj.getFileSize<sideSrc>())); } } break; @@ -1530,11 +1485,23 @@ void SynchronizeFolderPair::synchronizeFileInt(FileMapping& fileObj, SyncOperati case SO_DELETE_LEFT: case SO_DELETE_RIGHT: reportInfo(getDelHandling<sideTrg>().getTxtRemovingFile(), fileObj.getFullName<sideTrg>()); + { + int objectsReported = 0; + auto guardStatistics = makeGuard([&] { procCallback_.updateTotalData(objectsReported, 0); }); //error = unexpected increase of total workload + const int objectsExpected = 1; + const Int64 bytesExpected = 0; - getDelHandling<sideTrg>().removeFile(fileObj.getObjRelativeName()); //throw FileError - fileObj.removeObject<sideTrg>(); //update FileMapping + getDelHandling<sideTrg>().removeFileUpdating(fileObj.getObjRelativeName(), bytesExpected, [&] //throw FileError + { + procCallback_.updateProcessedData(1, 0); //noexcept + ++objectsReported; + }); - procCallback_.updateProcessedData(1, 0); + guardStatistics.dismiss(); //update statistics to consider the real amount of data + if (objectsReported != objectsExpected) + procCallback_.updateTotalData(objectsReported - objectsExpected, 0); //noexcept! + } + fileObj.removeObject<sideTrg>(); //update FileMapping break; case SO_MOVE_LEFT_SOURCE: @@ -1562,8 +1529,8 @@ void SynchronizeFolderPair::synchronizeFileInt(FileMapping& fileObj, SyncOperati sourceObj->getFileSize <sideTrg>(), sourceObj->getFileId <sideTrg>()); - sourceObj->removeObject<sideTrg>(); // - targetObj->syncTo<sideTrg>(descrTarget); //update FileMapping + sourceObj->removeObject<sideTrg>(); //update FileMapping + targetObj->syncTo<sideTrg>(descrTarget); // procCallback_.updateProcessedData(1, 0); } @@ -1573,25 +1540,24 @@ void SynchronizeFolderPair::synchronizeFileInt(FileMapping& fileObj, SyncOperati case SO_OVERWRITE_RIGHT: { const Zstring& target = fileObj.getBaseDirPf<sideTrg>() + fileObj.getRelativeName<sideSrc>(); //respect differences in case of source object - reportInfo(txtOverwritingFile, target); - FileAttrib newAttr; - copyFileUpdatingTo<sideTrg>(fileObj, [&] //delete target at appropriate time + const FileAttrib newAttr = copyFileUpdatingTo<sideTrg>(fileObj, [&] //delete target at appropriate time { reportStatus(this->getDelHandling<sideTrg>().getTxtRemovingFile(), fileObj.getFullName<sideTrg>()); - this->getDelHandling<sideTrg>().removeFile(fileObj.getObjRelativeName()); //throw FileError - fileObj.removeObject<sideTrg>(); //remove file from FileMapping, to keep in sync (if subsequent copying fails!!) + this->getDelHandling<sideTrg>().removeFileUpdating(fileObj.getObjRelativeName(), 0, []{}); //throw FileError; + //no (logical) item count update desired - but total byte count may change, e.g. move(copy) deleted file to versioning dir + fileObj.removeObject<sideTrg>(); //update FileMapping reportStatus(txtOverwritingFile, target); //restore status text copy file - }, newAttr); + }); const FileDescriptor descrSource(newAttr.modificationTime, newAttr.fileSize, newAttr.sourceFileId); const FileDescriptor descrTarget(newAttr.modificationTime, newAttr.fileSize, newAttr.targetFileId); fileObj.syncTo<sideTrg>(descrTarget, &descrSource); //update FileMapping - procCallback_.updateProcessedData(1, 0); + procCallback_.updateProcessedData(1, 0); //we model "delete + copy" as ONE logical operation } break; @@ -1649,20 +1615,6 @@ void SynchronizeFolderPair::synchronizeLinkInt(SymLinkMapping& linkObj, SyncOper { static const SelectedSide sideSrc = OtherSide<sideTrg>::result; - auto deleteSymlink = [&] - { - switch (linkObj.getLinkType<sideTrg>()) - { - case LinkDescriptor::TYPE_DIR: - this->getDelHandling<sideTrg>().removeFolder(linkObj.getObjRelativeName()); //throw FileError - break; - - case LinkDescriptor::TYPE_FILE: //Windows: true file symlink; Linux: file-link or broken link - this->getDelHandling<sideTrg>().removeFile(linkObj.getObjRelativeName()); //throw FileError - break; - } - }; - switch (syncOp) { case SO_CREATE_NEW_LEFT: @@ -1675,17 +1627,17 @@ void SynchronizeFolderPair::synchronizeLinkInt(SymLinkMapping& linkObj, SyncOper try { zen::copySymlink(linkObj.getFullName<sideSrc>(), target, copyFilePermissions_); //throw FileError - procCallback_.updateProcessedData(1, 0); - linkObj.copyTo<sideTrg>(); //update SymLinkMapping + + procCallback_.updateProcessedData(1, 0); } catch (FileError&) { if (somethingExists(linkObj.getFullName<sideSrc>())) //do not check on type (symlink, file, folder) -> if there is a type change, FFS should not be quiet about it! throw; //source deleted meanwhile...nothing was done (logical point of view!) - procCallback_.updateTotalData(-1, 0); linkObj.removeObject<sideSrc>(); + procCallback_.updateTotalData(-1, 0); } } break; @@ -1693,12 +1645,23 @@ void SynchronizeFolderPair::synchronizeLinkInt(SymLinkMapping& linkObj, SyncOper case SO_DELETE_LEFT: case SO_DELETE_RIGHT: reportInfo(getDelHandling<sideTrg>().getTxtRemovingSymLink(), linkObj.getFullName<sideTrg>()); + { + int objectsReported = 0; + auto guardStatistics = makeGuard([&] { procCallback_.updateTotalData(objectsReported, 0); }); //error = unexpected increase of total workload + const int objectsExpected = 1; + const Int64 bytesExpected = 0; - deleteSymlink(); //throw FileError + getDelHandling<sideTrg>().removeLinkUpdating(linkObj.getObjRelativeName(), bytesExpected, [&] //throw FileError + { + procCallback_.updateProcessedData(1, 0); //noexcept + ++objectsReported; + }, linkObj.getLinkType<sideTrg>()); + guardStatistics.dismiss(); //update statistics to consider the real amount of data + if (objectsReported != objectsExpected) + procCallback_.updateTotalData(objectsReported - objectsExpected, 0); //noexcept! + } linkObj.removeObject<sideTrg>(); //update SymLinkMapping - - procCallback_.updateProcessedData(1, 0); break; case SO_OVERWRITE_LEFT: @@ -1709,14 +1672,14 @@ void SynchronizeFolderPair::synchronizeLinkInt(SymLinkMapping& linkObj, SyncOper reportInfo(txtOverwritingLink, target); reportStatus(getDelHandling<sideTrg>().getTxtRemovingSymLink(), linkObj.getFullName<sideTrg>()); - deleteSymlink(); //throw FileError + getDelHandling<sideTrg>().removeLinkUpdating(linkObj.getObjRelativeName(), 0, []{}, linkObj.getLinkType<sideTrg>()); //throw FileError linkObj.removeObject<sideTrg>(); //remove file from FileMapping, to keep in sync (if subsequent copying fails!!) reportStatus(txtOverwritingLink, target); //restore status text zen::copySymlink(linkObj.getFullName<sideSrc>(), target, copyFilePermissions_); //throw FileError linkObj.copyTo<sideTrg>(); //update SymLinkMapping - procCallback_.updateProcessedData(1, 0); + procCallback_.updateProcessedData(1, 0); //we model "delete + copy" as ONE logical operation } break; @@ -1730,7 +1693,6 @@ void SynchronizeFolderPair::synchronizeLinkInt(SymLinkMapping& linkObj, SyncOper if (!sameFileTime(linkObj.getLastWriteTime<sideTrg>(), linkObj.getLastWriteTime<sideSrc>(), 2)) //respect 2 second FAT/FAT32 precision setFileTime(linkObj.getFullName<sideTrg>(), linkObj.getLastWriteTime<sideSrc>(), SYMLINK_DIRECT); //throw FileError - linkObj.copyTo<sideTrg>(); //-> both sides *should* be completely equal now... procCallback_.updateProcessedData(1, 0); @@ -1777,32 +1739,57 @@ void SynchronizeFolderPair::synchronizeFolderInt(DirMapping& dirObj, SyncOperati { case SO_CREATE_NEW_LEFT: case SO_CREATE_NEW_RIGHT: - if (somethingExists(dirObj.getFullName<sideSrc>())) //do not check on type (symlink, file, folder) -> if there is a type change, FFS should not be quiet about it! + if (somethingExists(dirObj.getFullName<sideSrc>())) //do not check on type (symlink, file, folder) -> if there is a type change, FFS should error out! { const Zstring& target = dirObj.getBaseDirPf<sideTrg>() + dirObj.getRelativeName<sideSrc>(); reportInfo(txtCreatingFolder, target); try { - makeNewDirectory(target, dirObj.getFullName<sideSrc>(), copyFilePermissions_); //no symlink copying! + makeNewDirectory(target, dirObj.getFullName<sideSrc>(), copyFilePermissions_); //throw FileError, ErrorTargetExisting } - catch (const ErrorTargetExisting&) { if (!dirExists(target)) throw; } //clash with file (dir-symlink is okay) - + catch (const ErrorTargetExisting&) { if (!dirExists(target)) throw; } //detect clash with file (dir-symlink OTOH is okay) dirObj.copyTo<sideTrg>(); //update DirMapping procCallback_.updateProcessedData(1, 0); } else //source deleted meanwhile...nothing was done (logical point of view!) -> uh....what about a temporary network drop??? { - // throw FileError + dirObj.refSubFiles().clear(); // + dirObj.refSubLinks().clear(); //update DirMapping + dirObj.refSubDirs ().clear(); // + dirObj.removeObject<sideSrc>(); // + const SyncStatistics subStats(dirObj); procCallback_.updateTotalData(-getCUD(subStats) - 1, -subStats.getDataToProcess()); + } + break; - dirObj.refSubFiles().clear(); //...then remove sub-objects - dirObj.refSubLinks().clear(); // - dirObj.refSubDirs ().clear(); // - dirObj.removeObject<sideSrc>(); + case SO_DELETE_LEFT: + case SO_DELETE_RIGHT: + reportInfo(getDelHandling<sideTrg>().getTxtRemovingDir(), dirObj.getFullName<sideTrg>()); + { + int objectsReported = 0; + auto guardStatistics = makeGuard([&] { procCallback_.updateTotalData(objectsReported, 0); }); //error = unexpected increase of total workload + const SyncStatistics subStats(dirObj); //counts sub-objects only! + const int objectsExpected = 1 + getCUD(subStats); + const Int64 bytesExpected = subStats.getDataToProcess(); + assert(bytesExpected == 0); + + getDelHandling<sideTrg>().removeDirUpdating(dirObj.getObjRelativeName(), bytesExpected, [&] //throw FileError + { + procCallback_.updateProcessedData(1, 0); //noexcept + ++objectsReported; + }); + + guardStatistics.dismiss(); //update statistics to consider the real amount of data + if (objectsReported != objectsExpected) + procCallback_.updateTotalData(objectsReported - objectsExpected, 0); //noexcept! } + dirObj.refSubFiles().clear(); // + dirObj.refSubLinks().clear(); //update DirMapping + dirObj.refSubDirs ().clear(); // + dirObj.removeObject<sideTrg>(); // break; case SO_COPY_METADATA_TO_LEFT: @@ -1812,29 +1799,12 @@ void SynchronizeFolderPair::synchronizeFolderInt(DirMapping& dirObj, SyncOperati if (dirObj.getShortName<sideTrg>() != dirObj.getShortName<sideSrc>()) //adapt difference in case (windows only) renameFile(dirObj.getFullName<sideTrg>(), beforeLast(dirObj.getFullName<sideTrg>(), FILE_NAME_SEPARATOR) + FILE_NAME_SEPARATOR + dirObj.getShortName<sideSrc>()); //throw FileError - //copyFileTimes -> useless at this time: modification time changes with each child-object creation/deletion - + //copyFileTimes -> useless: modification time changes with each child-object creation/deletion dirObj.copyTo<sideTrg>(); //-> both sides *should* be completely equal now... procCallback_.updateProcessedData(1, 0); break; - case SO_DELETE_LEFT: - case SO_DELETE_RIGHT: - { - reportInfo(getDelHandling<sideTrg>().getTxtRemovingDir(), dirObj.getFullName<sideTrg>()); - - const SyncStatistics subStats(dirObj); //counts sub-objects only! - getDelHandling<sideTrg>().removeFolderUpdateStatistics(dirObj.getObjRelativeName(), 1 + getCUD(subStats), subStats.getDataToProcess()); //throw FileError - //this call covers progress indicator updates for dir + sub-objects! - - dirObj.refSubFiles().clear(); //...then remove everything - dirObj.refSubLinks().clear(); // - dirObj.refSubDirs ().clear(); // - dirObj.removeObject<sideTrg>(); // - } - break; - case SO_OVERWRITE_RIGHT: case SO_OVERWRITE_LEFT: case SO_MOVE_LEFT_SOURCE: @@ -1936,7 +1906,7 @@ void zen::synchronize(const TimeComp& timeStamp, //specify process and resource handling priorities std::unique_ptr<ScheduleForBackgroundProcessing> backgroundPrio; if (runWithBackgroundPriority) - backgroundPrio.reset(new ScheduleForBackgroundProcessing); + backgroundPrio = make_unique<ScheduleForBackgroundProcessing>(); //prevent operating system going into sleep state PreventStandby dummy; @@ -1971,7 +1941,6 @@ void zen::synchronize(const TimeComp& timeStamp, folderPairCfg.versioningFolder, folderPairCfg.versioningStyle_, timeStamp, - folderIndex, j->getBaseDirPf<LEFT_SIDE>(), callback); @@ -1979,7 +1948,6 @@ void zen::synchronize(const TimeComp& timeStamp, folderPairCfg.versioningFolder, folderPairCfg.versioningStyle_, timeStamp, - folderIndex, j->getBaseDirPf<RIGHT_SIDE>(), callback); } @@ -2209,11 +2177,11 @@ void zen::synchronize(const TimeComp& timeStamp, { std::wstring warningMessage = _("Not enough free disk space available in:"); - for (auto i = diskSpaceMissing.begin(); i != diskSpaceMissing.end(); ++i) + for (auto it = diskSpaceMissing.begin(); it != diskSpaceMissing.end(); ++it) warningMessage += std::wstring(L"\n\n") + - fmtFileName(i->first) + L"\n" + - _("Required:") + L" " + filesizeToShortString(i->second.first) + L"\n" + - _("Available:") + L" " + filesizeToShortString(i->second.second); + fmtFileName(it->first) + L"\n" + + _("Required:") + L" " + filesizeToShortString(it->second.first) + L"\n" + + _("Available:") + L" " + filesizeToShortString(it->second.second); callback.reportWarning(warningMessage, warnings.warningNotEnoughDiskSpace); } @@ -2246,8 +2214,8 @@ void zen::synchronize(const TimeComp& timeStamp, if (!conflictDirs.empty()) { 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); + for (auto it = conflictDirs.begin(); it != conflictDirs.end(); ++it) + warningMessage += L"\n" + fmtFileName(*it); callback.reportWarning(warningMessage, warnings.warningFolderPairRaceCondition); } @@ -2343,61 +2311,58 @@ void zen::synchronize(const TimeComp& timeStamp, } } - //########################################################################################### -//callback functionality for smooth progress indicators -template <class DelTargetCommand> +template <class Function> class WhileCopying : public zen::CallbackCopyFile { public: WhileCopying(Int64& bytesReported, ProcessCallback& statusHandler, - const DelTargetCommand& cmd) : + Function delTargetCmd) : bytesReported_(bytesReported), statusHandler_(statusHandler), - cmd_(cmd) {} + delTargetCmd_(std::move(delTargetCmd)) {} - virtual void deleteTargetFile(const Zstring& targetFile) { cmd_(); } + virtual void deleteTargetFile(const Zstring& targetFile) { delTargetCmd_(); } virtual void updateCopyStatus(Int64 bytesDelta) { - //inform about the (differential) processed amount of data - statusHandler_.updateProcessedData(0, bytesDelta); //throw()! -> this ensures client and service provider are in sync! + statusHandler_.updateProcessedData(0, bytesDelta); //throw()! -> ensure client and service provider are in sync! bytesReported_ += bytesDelta; // statusHandler_.requestUiRefresh(); //may throw } private: - Int64& bytesReported_; + Int64& bytesReported_; ProcessCallback& statusHandler_; - DelTargetCommand cmd_; + Function delTargetCmd_; }; -//copy file while refreshing UI -template <SelectedSide side, class DelTargetCommand> -void SynchronizeFolderPair::copyFileUpdatingTo(const FileMapping& fileObj, const DelTargetCommand& cmd, FileAttrib& newAttr) const +//throw FileError; reports data delta via updateProcessedData() +template <SelectedSide sideTrg, class Function> +FileAttrib SynchronizeFolderPair::copyFileUpdatingTo(const FileMapping& fileObj, Function delTargetCommand) const //returns current attributes of source file { - const Int64 expectedBytesToCpy = to<Int64>(fileObj.getFileSize<OtherSide<side>::result>()); - Zstring source = fileObj.getFullName<OtherSide<side>::result>(); - const Zstring& target = fileObj.getBaseDirPf<side>() + fileObj.getRelativeName<OtherSide<side>::result>(); + static const SelectedSide sideSrc = OtherSide<sideTrg>::result; + + FileAttrib newAttr; + const Int64 bytesExpected = to<Int64>(fileObj.getFileSize<sideSrc>()); + Zstring source = fileObj.getFullName<sideSrc>(); + const Zstring& target = fileObj.getBaseDirPf<sideTrg>() + fileObj.getRelativeName<sideSrc>(); Int64 bytesReported; auto copyOperation = [&] { - //start of (possibly) long-running copy process: ensure status updates are performed regularly - - //in error situation: undo communication of processed amount of data auto guardStatistics = makeGuard([&] { - procCallback_.updateProcessedData(0, -bytesReported); + procCallback_.updateTotalData(0, bytesReported); //error = unexpected increase of total workload bytesReported = 0; }); - WhileCopying<DelTargetCommand> callback(bytesReported, procCallback_, cmd); + WhileCopying<Function> callback(bytesReported, procCallback_, delTargetCommand); copyFile(source, //type File implicitly means symlinks need to be dereferenced! target, @@ -2415,11 +2380,10 @@ void SynchronizeFolderPair::copyFileUpdatingTo(const FileMapping& fileObj, const } //#################### /Verification ############################# - //update statistics to consider the real amount of data, e.g. more than the "file size" for ADS streams or file changed in the meantime! - if (bytesReported != expectedBytesToCpy) - procCallback_.updateTotalData(0, bytesReported - expectedBytesToCpy); - - //we model physical statistic numbers => adjust total: consider ADS, sparse, compressed files -> transferred bytes may differ from file size (which is just a rough guess)! + //update statistics to consider the real amount of data, e.g. more than the "file size" for ADS streams, + //less for sparse and compressed files, or file changed in the meantime! + if (bytesReported != bytesExpected) + procCallback_.updateTotalData(0, bytesReported - bytesExpected); //noexcept! guardStatistics.dismiss(); }; @@ -2450,6 +2414,8 @@ void SynchronizeFolderPair::copyFileUpdatingTo(const FileMapping& fileObj, const #else copyOperation(); #endif + + return newAttr; } |