diff options
Diffstat (limited to 'synchronization.cpp')
| -rw-r--r-- | synchronization.cpp | 1423 |
1 files changed, 864 insertions, 559 deletions
diff --git a/synchronization.cpp b/synchronization.cpp index 66c7d262..8a5027be 100644 --- a/synchronization.cpp +++ b/synchronization.cpp @@ -8,7 +8,7 @@ #include <memory> #include <deque> #include <stdexcept> -#include <wx/msgdlg.h> +#include <wx/utils.h> #include <wx/log.h> #include <wx/file.h> #include <wx+/string_conv.h> @@ -32,36 +32,55 @@ using namespace zen; +namespace +{ +inline +int getCUD(const SyncStatistics& stat) +{ + return stat.getCreate() + + stat.getUpdate() + + stat.getDelete(); +} +} + void SyncStatistics::init() { - createLeft = 0; - createRight = 0; - overwriteLeft = 0; - overwriteRight = 0; - deleteLeft = 0; - deleteRight = 0; - conflict = 0; - rowsTotal = 0; + createLeft = 0; + createRight = 0; + updateLeft = 0; + updateRight = 0; + deleteLeft = 0; + deleteRight = 0; + conflict = 0; + rowsTotal = 0; } SyncStatistics::SyncStatistics(const FolderComparison& folderCmp) { init(); - std::for_each(begin(folderCmp), end(folderCmp), [&](const BaseDirMapping& baseMap) { getNumbersRecursively(baseMap); }); + std::for_each(begin(folderCmp), end(folderCmp), [&](const BaseDirMapping& baseMap) { recurse(baseMap); }); } SyncStatistics::SyncStatistics(const HierarchyObject& hierObj) { init(); - getNumbersRecursively(hierObj); + recurse(hierObj); +} + + +SyncStatistics::SyncStatistics(const FileMapping& fileObj) +{ + init(); + getFileNumbers(fileObj); + rowsTotal += 1; } inline -void SyncStatistics::getNumbersRecursively(const HierarchyObject& hierObj) +void SyncStatistics::recurse(const HierarchyObject& hierObj) { std::for_each(hierObj.refSubDirs().begin(), hierObj.refSubDirs().end(), [&](const DirMapping& dirObj) { getDirNumbers(dirObj); }); @@ -101,13 +120,25 @@ void SyncStatistics::getFileNumbers(const FileMapping& fileObj) ++deleteRight; break; + case SO_MOVE_LEFT_TARGET: + ++updateLeft; + break; + + case SO_MOVE_RIGHT_TARGET: + ++updateRight; + break; + + case SO_MOVE_LEFT_SOURCE: //ignore + case SO_MOVE_RIGHT_SOURCE: // + break; + case SO_OVERWRITE_LEFT: - ++overwriteLeft; + ++updateLeft; dataToProcess += fileObj.getFileSize<RIGHT_SIDE>(); break; case SO_OVERWRITE_RIGHT: - ++overwriteRight; + ++updateRight; dataToProcess += fileObj.getFileSize<LEFT_SIDE>(); break; @@ -118,11 +149,11 @@ void SyncStatistics::getFileNumbers(const FileMapping& fileObj) break; case SO_COPY_METADATA_TO_LEFT: - ++overwriteLeft; + ++updateLeft; break; case SO_COPY_METADATA_TO_RIGHT: - ++overwriteRight; + ++updateRight; break; case SO_DO_NOTHING: @@ -155,12 +186,12 @@ void SyncStatistics::getLinkNumbers(const SymLinkMapping& linkObj) case SO_OVERWRITE_LEFT: case SO_COPY_METADATA_TO_LEFT: - ++overwriteLeft; + ++updateLeft; break; case SO_OVERWRITE_RIGHT: case SO_COPY_METADATA_TO_RIGHT: - ++overwriteRight; + ++updateRight; break; case SO_UNRESOLVED_CONFLICT: @@ -169,6 +200,11 @@ void SyncStatistics::getLinkNumbers(const SymLinkMapping& linkObj) firstConflicts.push_back(std::make_pair(linkObj.getObjRelativeName(), linkObj.getSyncOpConflict())); break; + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_RIGHT_SOURCE: + case SO_MOVE_LEFT_TARGET: + case SO_MOVE_RIGHT_TARGET: + assert(false); case SO_DO_NOTHING: case SO_EQUAL: break; @@ -209,20 +245,24 @@ void SyncStatistics::getDirNumbers(const DirMapping& dirObj) break; case SO_COPY_METADATA_TO_LEFT: - ++overwriteLeft; + ++updateLeft; break; case SO_COPY_METADATA_TO_RIGHT: - ++overwriteRight; + ++updateRight; break; + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_RIGHT_SOURCE: + case SO_MOVE_LEFT_TARGET: + case SO_MOVE_RIGHT_TARGET: + assert(false); case SO_DO_NOTHING: case SO_EQUAL: break; } - //recurse into sub-dirs - getNumbersRecursively(dirObj); + recurse(dirObj); } @@ -245,7 +285,7 @@ std::vector<zen::FolderPairSyncCfg> zen::extractSyncCfg(const MainConfiguration& output.push_back( FolderPairSyncCfg(syncCfg.directionCfg.var == DirectionConfig::AUTOMATIC, syncCfg.handleDeletion, - toZ(syncCfg.customDeletionDirectory))); + syncCfg.customDeletionDirectory)); } return output; @@ -257,7 +297,7 @@ namespace bool synchronizationNeeded(const SyncStatistics& statisticsTotal) { return statisticsTotal.getCreate() + - statisticsTotal.getOverwrite() + + statisticsTotal.getUpdate() + statisticsTotal.getDelete() + //conflicts (unless excluded) justify a sync! Also note: if this method returns false, no warning about unresolved conflicts were shown! statisticsTotal.getConflict() != 0; @@ -269,18 +309,18 @@ bool synchronizationNeeded(const SyncStatistics& statisticsTotal) bool significantDifferenceDetected(const SyncStatistics& folderPairStat) { //initial file copying shall not be detected as major difference - if (folderPairStat.getCreate<LEFT_SIDE>() == 0 && - folderPairStat.getOverwrite() == 0 && - folderPairStat.getDelete() == 0 && - folderPairStat.getConflict() == 0) return false; + if (folderPairStat.getCreate<LEFT_SIDE>() == 0 && + folderPairStat.getUpdate () == 0 && + folderPairStat.getDelete () == 0 && + folderPairStat.getConflict() == 0) return false; if (folderPairStat.getCreate<RIGHT_SIDE>() == 0 && - folderPairStat.getOverwrite() == 0 && - folderPairStat.getDelete() == 0 && - folderPairStat.getConflict() == 0) return false; + folderPairStat.getUpdate () == 0 && + folderPairStat.getDelete () == 0 && + folderPairStat.getConflict() == 0) return false; - const int changedRows = folderPairStat.getCreate() + - folderPairStat.getOverwrite() + - folderPairStat.getDelete() + + const int changedRows = folderPairStat.getCreate () + + folderPairStat.getUpdate () + + folderPairStat.getDelete () + folderPairStat.getConflict(); return changedRows >= 10 && changedRows > 0.5 * folderPairStat.getRowCount(); @@ -361,10 +401,10 @@ SyncProcess::SyncProcess(xmlAccess::OptionalDialogs& warnings, transactionalFileCopy_(transactionalFileCopy), m_warnings(warnings), procCallback(handler) - { -if (runWithBackgroundPriority) -procBackground.reset(new ScheduleForBackgroundProcessing); - } +{ + if (runWithBackgroundPriority) + procBackground.reset(new ScheduleForBackgroundProcessing); +} //-------------------------------------------------------------------------------------------------------------- namespace @@ -377,7 +417,7 @@ class DeletionHandling //e.g. generate name of alternate deletion directory (uni public: DeletionHandling(DeletionPolicy handleDel, const Zstring& custDelFolder, - const Zstring& baseDir, //with separator postfix + const Zstring& baseDirPf, //with separator postfix ProcessCallback& procCallback); ~DeletionHandling(); //always (try to) clean up, even if synchronization is aborted! @@ -387,9 +427,9 @@ public: void removeFile (const Zstring& relativeName) const; //throw FileError void removeFolder(const Zstring& relativeName) const; //throw FileError - const wxString& getTxtRemovingFile () const { return txtRemovingFile; } // - const wxString& getTxtRemovingSymLink() const { return txtRemovingSymlink; } //status text templates - const wxString& getTxtRemovingDir () const { return txtRemovingDirectory; } // + const std::wstring& getTxtRemovingFile () const { return txtRemovingFile; } // + const std::wstring& getTxtRemovingSymLink() const { return txtRemovingSymlink; } //status text templates + const std::wstring& getTxtRemovingDir () const { return txtRemovingDirectory; } // //evaluate whether a deletion will actually free space within a volume bool deletionFreesSpace() const; @@ -401,12 +441,12 @@ private: Zstring sessionDelDir; //target deletion folder for current folder pair (with timestamp, ends with path separator) - Zstring baseDir_; //with separator postfix + Zstring baseDirPf_; //with separator postfix //preloaded status texts: - wxString txtRemovingFile; - wxString txtRemovingSymlink; - wxString txtRemovingDirectory; + std::wstring txtRemovingFile; + std::wstring txtRemovingSymlink; + std::wstring txtRemovingDirectory; bool cleanedUp; }; @@ -414,41 +454,41 @@ private: DeletionHandling::DeletionHandling(DeletionPolicy handleDel, const Zstring& custDelFolder, - const Zstring& baseDir, //with separator postfix + const Zstring& baseDirPf, //with separator postfix ProcessCallback& procCallback) : deletionType(handleDel), procCallback_(&procCallback), - baseDir_(baseDir), + baseDirPf_(baseDirPf), cleanedUp(false) { #ifdef FFS_WIN - if (baseDir.empty() || - (deletionType == MOVE_TO_RECYCLE_BIN && recycleBinStatus(baseDir) != STATUS_REC_EXISTS)) + if (baseDirPf.empty() || + (deletionType == MOVE_TO_RECYCLE_BIN && recycleBinStatus(baseDirPf) != STATUS_REC_EXISTS)) deletionType = DELETE_PERMANENTLY; //Windows' ::SHFileOperation() will do this anyway, but we have a better and faster deletion routine (e.g. on networks) #endif switch (deletionType) { case DELETE_PERMANENTLY: - txtRemovingFile = replaceCpy(_("Deleting file %x" ), L"%x", L"\n\"%x\"", false); - txtRemovingDirectory = replaceCpy(_("Deleting folder %x" ), L"%x", L"\n\"%x\"", false); - txtRemovingSymlink = replaceCpy(_("Deleting symbolic link %x"), L"%x", L"\n\"%x\"", false); + txtRemovingFile = replaceCpy(_("Deleting file %x" ), L"%x", L"\"%x\"", false); + txtRemovingDirectory = replaceCpy(_("Deleting folder %x" ), L"%x", L"\"%x\"", false); + txtRemovingSymlink = replaceCpy(_("Deleting symbolic link %x"), L"%x", L"\"%x\"", false); break; case MOVE_TO_RECYCLE_BIN: - sessionDelDir = getSessionDeletionDir(baseDir_, Zstr("FFS ")); + sessionDelDir = getSessionDeletionDir(baseDirPf_, Zstr("FFS ")); - txtRemovingFile = replaceCpy(_("Moving file %x to recycle bin" ), L"%x", L"\n\"%x\"", false); - txtRemovingDirectory = replaceCpy(_("Moving folder %x to recycle bin" ), L"%x", L"\n\"%x\"", false); - txtRemovingSymlink = replaceCpy(_("Moving symbolic link %x to recycle bin"), L"%x", L"\n\"%x\"", false); + txtRemovingFile = replaceCpy(_("Moving file %x to recycle bin" ), L"%x", L"\"%x\"", false); + txtRemovingDirectory = replaceCpy(_("Moving folder %x to recycle bin" ), L"%x", L"\"%x\"", false); + txtRemovingSymlink = replaceCpy(_("Moving symbolic link %x to recycle bin"), L"%x", L"\"%x\"", false); break; case MOVE_TO_CUSTOM_DIRECTORY: sessionDelDir = getSessionDeletionDir(custDelFolder); - txtRemovingFile = replaceCpy(replaceCpy(_("Moving file %x to %y" ), L"%x", L"\n\"%x\"", false), L"%y", L"\"" + utf8CvrtTo<wxString>(custDelFolder) + L"\"", false); - txtRemovingDirectory = replaceCpy(replaceCpy(_("Moving folder %x to %y" ), L"%x", L"\n\"%x\"", false), L"%y", L"\"" + utf8CvrtTo<wxString>(custDelFolder) + L"\"", false); - txtRemovingSymlink = replaceCpy(replaceCpy(_("Moving symbolic link %x to %y"), L"%x", L"\n\"%x\"", false), L"%y", L"\"" + utf8CvrtTo<wxString>(custDelFolder) + L"\"", false); + txtRemovingFile = replaceCpy(replaceCpy(_("Moving file %x to %y" ), L"%x", L"\"%x\"", false), L"%y", L"\"" + utf8CvrtTo<std::wstring>(custDelFolder) + L"\"", false); + txtRemovingDirectory = replaceCpy(replaceCpy(_("Moving folder %x to %y" ), L"%x", L"\"%x\"", false), L"%y", L"\"" + utf8CvrtTo<std::wstring>(custDelFolder) + L"\"", false); + txtRemovingSymlink = replaceCpy(replaceCpy(_("Moving symbolic link %x to %y"), L"%x", L"\"%x\"", false), L"%y", L"\"" + utf8CvrtTo<std::wstring>(custDelFolder) + L"\"", false); break; } } @@ -497,12 +537,12 @@ struct CallbackRemoveDirImpl : public CallbackRemoveDir virtual void notifyFileDeletion(const Zstring& filename) { - delHandling_.procCallback_->reportStatus(replaceCpy(delHandling_.getTxtRemovingFile(), L"%x", utf8CvrtTo<wxString>(filename))); + delHandling_.procCallback_->reportStatus(replaceCpy(delHandling_.getTxtRemovingFile(), L"%x", utf8CvrtTo<std::wstring>(filename))); } virtual void notifyDirDeletion(const Zstring& dirname) { - delHandling_.procCallback_->reportStatus(replaceCpy(delHandling_.getTxtRemovingDir(), L"%x", utf8CvrtTo<wxString>(dirname))); + delHandling_.procCallback_->reportStatus(replaceCpy(delHandling_.getTxtRemovingDir(), L"%x", utf8CvrtTo<std::wstring>(dirname))); } private: @@ -513,7 +553,7 @@ private: void DeletionHandling::removeFile(const Zstring& relativeName) const { - const Zstring fullName = baseDir_ + relativeName; + const Zstring fullName = baseDirPf_ + relativeName; switch (deletionType) { @@ -562,7 +602,7 @@ void DeletionHandling::removeFile(const Zstring& relativeName) const void DeletionHandling::removeFolder(const Zstring& relativeName) const { - const Zstring fullName = baseDir_ + relativeName; + const Zstring fullName = baseDirPf_ + relativeName; switch (deletionType) { @@ -621,7 +661,7 @@ bool DeletionHandling::deletionFreesSpace() const case MOVE_TO_RECYCLE_BIN: return false; //in general... (unless Recycle Bin is full) case MOVE_TO_CUSTOM_DIRECTORY: - switch (zen::onSameVolume(baseDir_, sessionDelDir)) + switch (zen::onSameVolume(baseDirPf_, sessionDelDir)) { case IS_SAME_YES: return false; @@ -642,20 +682,21 @@ namespace class DiskSpaceNeeded { public: - DiskSpaceNeeded(const BaseDirMapping& baseObj, bool freeSpaceDelLeft, bool freeSpaceDelRight) : - freeSpaceDelLeft_(freeSpaceDelLeft), - freeSpaceDelRight_(freeSpaceDelRight) + static std::pair<Int64, Int64> calculate(const BaseDirMapping& baseObj, bool freeSpaceDelLeft, bool freeSpaceDelRight) { - processRecursively(baseObj); + DiskSpaceNeeded inst(baseObj, freeSpaceDelLeft, freeSpaceDelRight); + return std::make_pair(inst.spaceNeededLeft, inst.spaceNeededRight); } - std::pair<zen::Int64, zen::Int64> getSpaceTotal() const +private: + DiskSpaceNeeded(const BaseDirMapping& baseObj, bool freeSpaceDelLeft, bool freeSpaceDelRight) : + freeSpaceDelLeft_(freeSpaceDelLeft), + freeSpaceDelRight_(freeSpaceDelRight) { - return std::make_pair(spaceNeededLeft, spaceNeededRight); + recurse(baseObj); } -private: - void processRecursively(const HierarchyObject& hierObj) + void recurse(const HierarchyObject& hierObj) { //don't process directories @@ -664,33 +705,33 @@ private: switch (i->getSyncOperation()) //evaluate comparison result and sync direction { case SO_CREATE_NEW_LEFT: - spaceNeededLeft += to<zen::Int64>(i->getFileSize<RIGHT_SIDE>()); + spaceNeededLeft += to<Int64>(i->getFileSize<RIGHT_SIDE>()); break; case SO_CREATE_NEW_RIGHT: - spaceNeededRight += to<zen::Int64>(i->getFileSize<LEFT_SIDE>()); + spaceNeededRight += to<Int64>(i->getFileSize<LEFT_SIDE>()); break; case SO_DELETE_LEFT: if (freeSpaceDelLeft_) - spaceNeededLeft -= to<zen::Int64>(i->getFileSize<LEFT_SIDE>()); + spaceNeededLeft -= to<Int64>(i->getFileSize<LEFT_SIDE>()); break; case SO_DELETE_RIGHT: if (freeSpaceDelRight_) - spaceNeededRight -= to<zen::Int64>(i->getFileSize<RIGHT_SIDE>()); + spaceNeededRight -= to<Int64>(i->getFileSize<RIGHT_SIDE>()); break; case SO_OVERWRITE_LEFT: if (freeSpaceDelLeft_) - spaceNeededLeft -= to<zen::Int64>(i->getFileSize<LEFT_SIDE>()); - spaceNeededLeft += to<zen::Int64>(i->getFileSize<RIGHT_SIDE>()); + spaceNeededLeft -= to<Int64>(i->getFileSize<LEFT_SIDE>()); + spaceNeededLeft += to<Int64>(i->getFileSize<RIGHT_SIDE>()); break; case SO_OVERWRITE_RIGHT: if (freeSpaceDelRight_) - spaceNeededRight -= to<zen::Int64>(i->getFileSize<RIGHT_SIDE>()); - spaceNeededRight += to<zen::Int64>(i->getFileSize<LEFT_SIDE>()); + spaceNeededRight -= to<Int64>(i->getFileSize<RIGHT_SIDE>()); + spaceNeededRight += to<Int64>(i->getFileSize<LEFT_SIDE>()); break; case SO_DO_NOTHING: @@ -698,6 +739,10 @@ private: case SO_UNRESOLVED_CONFLICT: case SO_COPY_METADATA_TO_LEFT: case SO_COPY_METADATA_TO_RIGHT: + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_RIGHT_SOURCE: + case SO_MOVE_LEFT_TARGET: + case SO_MOVE_RIGHT_TARGET: break; } @@ -705,78 +750,20 @@ private: //[...] //recurse into sub-dirs - std::for_each(hierObj.refSubDirs().begin(), hierObj.refSubDirs().end(), [&](const HierarchyObject& subDir) { this->processRecursively(subDir); }); + std::for_each(hierObj.refSubDirs().begin(), hierObj.refSubDirs().end(), [&](const HierarchyObject& subDir) { this->recurse(subDir); }); //for (auto& subDir : hierObj.refSubDirs()) - // processRecursively(subDir); + // recurse(subDir); } const bool freeSpaceDelLeft_; const bool freeSpaceDelRight_; - zen::Int64 spaceNeededLeft; - zen::Int64 spaceNeededRight; + Int64 spaceNeededLeft; + Int64 spaceNeededRight; }; } //---------------------------------------------------------------------------------------- -//test if current sync-line will result in deletion of files or -//big file is overwritten by smaller one -> used to avoid disc space bottlenecks (at least if permanent deletion is active) -inline -bool diskSpaceIsReduced(const FileMapping& fileObj) -{ - switch (fileObj.getSyncOperation()) //evaluate comparison result and sync direction - { - case SO_DELETE_LEFT: - case SO_DELETE_RIGHT: - return true; - - case SO_OVERWRITE_LEFT: - return fileObj.getFileSize<LEFT_SIDE>() > fileObj.getFileSize<RIGHT_SIDE>(); - - case SO_OVERWRITE_RIGHT: - return fileObj.getFileSize<LEFT_SIDE>() < fileObj.getFileSize<RIGHT_SIDE>(); - - case SO_CREATE_NEW_LEFT: - case SO_CREATE_NEW_RIGHT: - case SO_DO_NOTHING: - case SO_EQUAL: - case SO_UNRESOLVED_CONFLICT: - case SO_COPY_METADATA_TO_LEFT: - case SO_COPY_METADATA_TO_RIGHT: - return false; - } - assert(false); - return false; //dummy -} - - -inline -bool diskSpaceIsReduced(const DirMapping& dirObj) -{ - switch (dirObj.getSyncOperation()) //evaluate comparison result and sync direction - { - case SO_DELETE_LEFT: - case SO_DELETE_RIGHT: - return true; - - case SO_OVERWRITE_LEFT: - case SO_OVERWRITE_RIGHT: - assert(false); - case SO_CREATE_NEW_LEFT: - case SO_CREATE_NEW_RIGHT: - case SO_DO_NOTHING: - case SO_EQUAL: - case SO_UNRESOLVED_CONFLICT: - case SO_COPY_METADATA_TO_LEFT: - case SO_COPY_METADATA_TO_RIGHT: - return false; - } - assert(false); - return false; //dummy -} -//--------------------------------------------------------------------------------------------------------------- - - class zen::SynchronizeFolderPair { public: @@ -801,36 +788,58 @@ public: txtOverwritingFile (replaceCpy(_("Overwriting file %x" ), L"%x", L"\"%x\"", false)), txtOverwritingLink (replaceCpy(_("Overwriting symbolic link %x"), L"%x", L"\"%x\"", false)), txtVerifying (replaceCpy(_("Verifying file %x" ), L"%x", L"\"%x\"", false)), - txtWritingAttributes(replaceCpy(_("Updating attributes of %x" ), L"%x", L"\"%x\"", false)) {} + txtWritingAttributes(replaceCpy(_("Updating attributes of %x" ), L"%x", L"\"%x\"", false)), + txtMovingFile (replaceCpy(replaceCpy(_("Moving file %x to %y"), L"%x", L"\"%x\"", false), L"%y", L"\"%y\"", false)) {} void startSync(BaseDirMapping& baseMap) { - //loop through all files twice; reason: first delete files (or overwrite big ones with smaller ones), then copy rest - execute<FIRST_PASS >(baseMap); - execute<SECOND_PASS>(baseMap); + runZeroPass(baseMap); //first process file moves + runPass<PASS_ONE>(baseMap); //delete files (or overwrite big ones with smaller ones) + runPass<PASS_TWO>(baseMap); //copy rest } private: enum PassId { - FIRST_PASS, //delete files - SECOND_PASS //create, modify + PASS_ONE, //delete files + PASS_TWO, //create, modify + PASS_NEVER //skip }; + static PassId getPass(const FileMapping& fileObj); + static PassId getPass(const SymLinkMapping& linkObj); + static PassId getPass(const DirMapping& dirObj); + + template <SelectedSide side> + void prepare2StepMove(FileMapping& sourceObj, FileMapping& targetObj); //throw FileError + bool createParentDir(FileSystemObject& fsObj); //throw FileError + template <SelectedSide side> + void manageFileMove(FileMapping& sourceObj, FileMapping& targetObj); //throw FileError + + void runZeroPass(HierarchyObject& hierObj); template <PassId pass> - void execute(HierarchyObject& hierObj); + void runPass(HierarchyObject& hierObj); + + void synchronizeFile(FileMapping& fileObj) const; + template <SelectedSide side> void synchronizeFileInt(FileMapping& fileObj, SyncOperation syncOp) const; + + void synchronizeLink(SymLinkMapping& linkObj) const; + template <SelectedSide sideTrg> void synchronizeLinkInt(SymLinkMapping& linkObj, SyncOperation syncOp) const; + + void synchronizeFolder(DirMapping& dirObj) const; + template <SelectedSide sideTrg> void synchronizeFolderInt(DirMapping& dirObj, SyncOperation syncOp) const; - void synchronizeFile (FileMapping& fileObj) const; - void synchronizeLink (SymLinkMapping& linkObj) const; - void synchronizeFolder(DirMapping& dirObj) const; + void reportInfo (const std::wstring& rawText, const Zstring& objname) const { procCallback_.reportInfo (replaceCpy(rawText, L"%x", utf8CvrtTo<std::wstring>(objname))); }; + void reportStatus(const std::wstring& rawText, const Zstring& objname) const { procCallback_.reportStatus(replaceCpy(rawText, L"%x", utf8CvrtTo<std::wstring>(objname))); }; //more low level helper - template <zen::SelectedSide side> - void deleteSymlink(const SymLinkMapping& linkObj) const; template <SelectedSide side, class DelTargetCommand> - void copyFileUpdatingTo(const FileMapping& fileObj, const DelTargetCommand& cmd, FileDescriptor& sourceAttr) const; + void copyFileUpdatingTo(const FileMapping& fileObj, const DelTargetCommand& cmd, FileAttrib& newAttr) const; void verifyFileCopy(const Zstring& source, const Zstring& target) const; + template <SelectedSide side> + const DeletionHandling& getDelHandling() const; + ProcessCallback& procCallback_; #ifdef FFS_WIN shadow::ShadowCopy* shadowCopyHandler_; //optional! @@ -843,198 +852,556 @@ private: const bool transactionalFileCopy; //preload status texts - const wxString txtCreatingFile; - const wxString txtCreatingLink; - const wxString txtCreatingFolder; - const wxString txtOverwritingFile; - const wxString txtOverwritingLink; - const wxString txtVerifying; - const wxString txtWritingAttributes; + const std::wstring txtCreatingFile; + const std::wstring txtCreatingLink; + const std::wstring txtCreatingFolder; + const std::wstring txtOverwritingFile; + const std::wstring txtOverwritingLink; + const std::wstring txtVerifying; + const std::wstring txtWritingAttributes; + const std::wstring txtMovingFile; }; +//--------------------------------------------------------------------------------------------------------------- +namespace zen +{ +template <> inline +const DeletionHandling& SynchronizeFolderPair::getDelHandling<LEFT_SIDE>() const { return delHandlingLeft_; } + +template <> inline +const DeletionHandling& SynchronizeFolderPair::getDelHandling<RIGHT_SIDE>() const { return delHandlingRight_; } +} + + +/* +__________________________ +|Move algorithm, 0th pass| +-------------------------- +1. loop over hierarchy and find "move source" + +2. check whether parent directory of "move source" is going to be deleted or location of "move source" may lead to name clash with other dir/symlink + -> no: delay move until 2nd pass + +3. create move target's parent directory recursively + execute move + do we have name clash? + -> prepare a 2-step move operation: 1. move source to root and update "move target" accordingly 2. delay move until 2nd pass + +4. If any of the operations above did not succeed (even after retry), update statistics and revert to "copy + delete" + Note: first pass may delete "move source"!!! + +__________________ +|killer-scenarios| +------------------ +propagate the following move sequences: +I) a -> a/a caveat sync'ing parent directory first leads to circular dependency! + +II) a/a -> a caveat: fixing name clash will remove source! + +III) c -> d caveat: move-sequence needs to be processed in correct order! + b -> c/b + a -> b/a +*/ + +namespace +{ +template <class Mapping> inline +bool haveNameClash(const Zstring& shortname, Mapping& m) +{ + return std::find_if(m.begin(), m.end(), + [&](const typename Mapping::value_type& obj) { return EqualFilename()(obj.getObjShortName(), shortname); }) != m.end(); +} + + +Zstring findUniqueTempName(const Zstring& filename) +{ + Zstring output = filename + zen::TEMP_FILE_ENDING; + + //ensure uniqueness + for (int i = 1; somethingExists(output); ++i) + output = filename + Zchar('_') + toString<Zstring>(i) + zen::TEMP_FILE_ENDING; + + return output; +} +} + + +template <SelectedSide side> +void SynchronizeFolderPair::prepare2StepMove(FileMapping& sourceObj, + FileMapping& targetObj) //throw FileError +{ + const Zstring& source = sourceObj.getFullName<side>(); + const Zstring& tmpTarget = findUniqueTempName(sourceObj.getBaseDirPf<side>() + sourceObj.getShortName<side>()); + //this could still lead to a name-clash in obscure cases, if some file ex. on the other side with + //the very same (.ffs_tmp) name and is copied before the second step of the move is executed + //good news: even in this pathologic case, this may only prevent the copy of the other file, but not the move + + reportInfo(replaceCpy(txtMovingFile, L"%y", utf8CvrtTo<std::wstring>(tmpTarget)), source); + + renameFile(source, tmpTarget); //throw FileError; + + //update file hierarchy + const FileDescriptor descrSource(sourceObj.getLastWriteTime<side>(), + sourceObj.getFileSize <side>(), + sourceObj.getFileId <side>()); + + sourceObj.removeObject<side>(); + + FileMapping& tempFile = sourceObj.root().addSubFile<side>(afterLast(tmpTarget, FILE_NAME_SEPARATOR), descrSource); + + //prepare move in second pass + tempFile.setSyncDir(side == LEFT_SIDE ? SYNC_DIR_LEFT : SYNC_DIR_RIGHT); + + targetObj.setMoveRef(tempFile .getId()); + tempFile .setMoveRef(targetObj.getId()); + + //NO statistics update! + procCallback_.requestUiRefresh(); //may throw +} + + +bool SynchronizeFolderPair::createParentDir(FileSystemObject& fsObj) //throw FileError, "false" on name clash +{ + if (DirMapping* parentDir = dynamic_cast<DirMapping*>(&fsObj.parent())) + { + if (!createParentDir(*parentDir)) + return false; + + //detect (and try to resolve) file type conflicts: 1. symlinks 2. files + const Zstring& shortname = parentDir->getObjShortName(); + if (haveNameClash(shortname, parentDir->parent().refSubLinks()) || + haveNameClash(shortname, parentDir->parent().refSubFiles())) + return false; + + //in this context "parentDir" cannot be scheduled for deletion since it contains a "move target"! + //note: if parentDir were deleted, we'd end up destroying "fsObj"! + assert(parentDir->getSyncOperation() != SO_DELETE_LEFT && + parentDir->getSyncOperation() != SO_DELETE_RIGHT); + + synchronizeFolder(*parentDir); //throw FileError + } + return true; +} + + +template <SelectedSide side> +void SynchronizeFolderPair::manageFileMove(FileMapping& sourceObj, + FileMapping& targetObj) //throw FileError +{ + assert((sourceObj.getSyncOperation() == SO_MOVE_LEFT_SOURCE && targetObj.getSyncOperation() == SO_MOVE_LEFT_TARGET && side == LEFT_SIDE) || + (sourceObj.getSyncOperation() == SO_MOVE_RIGHT_SOURCE && targetObj.getSyncOperation() == SO_MOVE_RIGHT_TARGET && side == RIGHT_SIDE)); + + const bool sourceWillBeDeleted = [&]() -> bool + { + if (DirMapping* parentDir = dynamic_cast<DirMapping*>(&sourceObj.parent())) + { + switch (parentDir->getSyncOperation()) //evaluate comparison result and sync direction + { + case SO_DELETE_LEFT: + case SO_DELETE_RIGHT: + return true; //we need to do something about it + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_RIGHT_SOURCE: + case SO_MOVE_LEFT_TARGET: + case SO_MOVE_RIGHT_TARGET: + case SO_OVERWRITE_LEFT: + case SO_OVERWRITE_RIGHT: + case SO_CREATE_NEW_LEFT: + case SO_CREATE_NEW_RIGHT: + case SO_DO_NOTHING: + case SO_EQUAL: + case SO_UNRESOLVED_CONFLICT: + case SO_COPY_METADATA_TO_LEFT: + case SO_COPY_METADATA_TO_RIGHT: + break; + } + } + return false; + }(); + + auto haveNameClash = [](const FileMapping& fileObj) + { + return ::haveNameClash(fileObj.getObjShortName(), fileObj.parent().refSubLinks()) || + ::haveNameClash(fileObj.getObjShortName(), fileObj.parent().refSubDirs()); + }; + + if (sourceWillBeDeleted || haveNameClash(sourceObj)) + { + //prepare for move now: - revert to 2-step move on name clashes + if (haveNameClash(targetObj) || + !createParentDir(targetObj)) //throw FileError + return prepare2StepMove<side>(sourceObj, targetObj); //throw FileError + + //finally start move! this should work now: + synchronizeFile(sourceObj); //throw FileError + } + //else: sourceObj will not be deleted, and is not standing in the way => delay to second pass + //note: this case may include "move sources" from two-step sub-routine! +} + + +void SynchronizeFolderPair::runZeroPass(HierarchyObject& hierObj) +{ + //search for file move-operations + + for (auto iter = hierObj.refSubFiles().begin(); iter != hierObj.refSubFiles().end(); ++iter) //VS 2010 crashes if we use for_each + lambda here... + { + FileMapping& fileObj = *iter; + + const SyncOperation syncOp = fileObj.getSyncOperation(); + switch (syncOp) //evaluate comparison result and sync direction + { + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_RIGHT_SOURCE: + { + FileMapping* sourceObj = &fileObj; + if (FileMapping* targetObj = dynamic_cast<FileMapping*>(FileSystemObject::retrieve(fileObj.getMoveRef()))) + { + if (!tryReportingError(procCallback_, [&] { return syncOp == SO_MOVE_LEFT_SOURCE ? this->manageFileMove<LEFT_SIDE>(*sourceObj, *targetObj) : this->manageFileMove<RIGHT_SIDE>(*sourceObj, *targetObj); })) + { + //move operation has failed! We cannot allow to continue and have move source's parent directory deleted, messing up statistics! + // => revert to ordinary "copy + delete" + + auto getStat = [&]() -> std::pair<int, Int64> + { + SyncStatistics statSrc(*sourceObj); + SyncStatistics statTrg(*targetObj); + + return std::make_pair(getCUD(statSrc) + getCUD(statTrg), + to<Int64>(statSrc.getDataToProcess() + statTrg.getDataToProcess())); + }; + + const auto statBefore = getStat(); + sourceObj->setMoveRef(NULL); + targetObj->setMoveRef(NULL); + const auto statAfter = getStat(); + //fix statistics to match "copy + delete" + procCallback_.updateProcessedData(statBefore.first - statAfter.first, statBefore.second - statAfter.second); + } + } + } + break; + case SO_MOVE_LEFT_TARGET: //it's enough to try each move-pair *once* + case SO_MOVE_RIGHT_TARGET: // + case SO_DELETE_LEFT: + case SO_DELETE_RIGHT: + case SO_OVERWRITE_LEFT: + case SO_OVERWRITE_RIGHT: + case SO_CREATE_NEW_LEFT: + case SO_CREATE_NEW_RIGHT: + case SO_DO_NOTHING: + case SO_EQUAL: + case SO_UNRESOLVED_CONFLICT: + case SO_COPY_METADATA_TO_LEFT: + case SO_COPY_METADATA_TO_RIGHT: + break; + } + } + + std::for_each(hierObj.refSubDirs().begin(), hierObj.refSubDirs().end(), + [&](DirMapping& dirObj) { this->runZeroPass(dirObj); /*recurse */ }); +} +//--------------------------------------------------------------------------------------------------------------- + + +//1st, 2nd pass requirements: +// - avoid disk space shortage: 1. delete files, 2. overwrite big with small files first +// - support change in type: overwrite file by directory, symlink by file, ect. + +inline +SynchronizeFolderPair::PassId SynchronizeFolderPair::getPass(const FileMapping& fileObj) +{ + switch (fileObj.getSyncOperation()) //evaluate comparison result and sync direction + { + case SO_DELETE_LEFT: + case SO_DELETE_RIGHT: + return PASS_ONE; + + case SO_OVERWRITE_LEFT: + return fileObj.getFileSize<LEFT_SIDE>() > fileObj.getFileSize<RIGHT_SIDE>() ? PASS_ONE : PASS_TWO; + + case SO_OVERWRITE_RIGHT: + return fileObj.getFileSize<LEFT_SIDE>() < fileObj.getFileSize<RIGHT_SIDE>() ? PASS_ONE : PASS_TWO; + + case SO_MOVE_LEFT_SOURCE: // + case SO_MOVE_RIGHT_SOURCE: // [!] + return PASS_NEVER; + case SO_MOVE_LEFT_TARGET: // + case SO_MOVE_RIGHT_TARGET: //to be processed in second pass, after "move target" parent directory was created! + return PASS_TWO; + + case SO_CREATE_NEW_LEFT: + case SO_CREATE_NEW_RIGHT: + case SO_DO_NOTHING: + case SO_EQUAL: + case SO_UNRESOLVED_CONFLICT: + case SO_COPY_METADATA_TO_LEFT: + case SO_COPY_METADATA_TO_RIGHT: + return PASS_TWO; + } + assert(false); + return PASS_TWO; //dummy +} + + +inline +SynchronizeFolderPair::PassId SynchronizeFolderPair::getPass(const SymLinkMapping& linkObj) +{ + switch (linkObj.getSyncOperation()) //evaluate comparison result and sync direction + { + case SO_DELETE_LEFT: + case SO_DELETE_RIGHT: + return PASS_ONE; //make sure to delete symlinks in first pass, and equally named file or dir in second pass: usecase "overwrite symlink with regular file"! + + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_RIGHT_SOURCE: + case SO_MOVE_LEFT_TARGET: + case SO_MOVE_RIGHT_TARGET: + assert(false); + case SO_OVERWRITE_LEFT: + case SO_OVERWRITE_RIGHT: + case SO_CREATE_NEW_LEFT: + case SO_CREATE_NEW_RIGHT: + case SO_DO_NOTHING: + case SO_EQUAL: + case SO_UNRESOLVED_CONFLICT: + case SO_COPY_METADATA_TO_LEFT: + case SO_COPY_METADATA_TO_RIGHT: + return PASS_TWO; + } + assert(false); + return PASS_TWO; //dummy +} + + +inline +SynchronizeFolderPair::PassId SynchronizeFolderPair::getPass(const DirMapping& dirObj) +{ + switch (dirObj.getSyncOperation()) //evaluate comparison result and sync direction + { + case SO_DELETE_LEFT: + case SO_DELETE_RIGHT: + return PASS_ONE; + + case SO_OVERWRITE_LEFT: + case SO_OVERWRITE_RIGHT: + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_RIGHT_SOURCE: + case SO_MOVE_LEFT_TARGET: + case SO_MOVE_RIGHT_TARGET: + assert(false); + case SO_CREATE_NEW_LEFT: + case SO_CREATE_NEW_RIGHT: + case SO_DO_NOTHING: + case SO_EQUAL: + case SO_UNRESOLVED_CONFLICT: + case SO_COPY_METADATA_TO_LEFT: + case SO_COPY_METADATA_TO_RIGHT: + return PASS_TWO; + } + assert(false); + return PASS_TWO; //dummy +} template <SynchronizeFolderPair::PassId pass> -void SynchronizeFolderPair::execute(HierarchyObject& hierObj) +void SynchronizeFolderPair::runPass(HierarchyObject& hierObj) { //synchronize files: std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), [&](FileMapping& fileObj) { - const bool letsDoThis = (pass == FIRST_PASS) == diskSpaceIsReduced(fileObj); //to be deleted files on first pass, rest on second! - if (letsDoThis) - tryReportingError(procCallback_, [&]() { synchronizeFile(fileObj); }); + if (pass == getPass(fileObj)) + tryReportingError(procCallback_, [&] { synchronizeFile(fileObj); }); }); - //synchronize symbolic links: (process in second step only) - if (pass == SECOND_PASS) - std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), - [&](SymLinkMapping& linkObj) { tryReportingError(procCallback_, [&]() { synchronizeLink(linkObj); }); }); + //synchronize symbolic links: + std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), + [&](SymLinkMapping& linkObj) + { + if (pass == getPass(linkObj)) + tryReportingError(procCallback_, [&] { synchronizeLink(linkObj); }); + }); //synchronize folders: std::for_each(hierObj.refSubDirs().begin(), hierObj.refSubDirs().end(), [&](DirMapping& dirObj) { - const bool letsDoThis = (pass == FIRST_PASS) == diskSpaceIsReduced(dirObj); //to be deleted dirs on first pass, rest on second! - if (letsDoThis) //if we created all folders on first pass it would look strange for initial mirror sync when all folders are created at once - tryReportingError(procCallback_, [&]() { synchronizeFolder(dirObj); }); + if (pass == getPass(dirObj)) + tryReportingError(procCallback_, [&] { synchronizeFolder(dirObj); }); - //recursion! - this->execute<pass>(dirObj); + this->runPass<pass>(dirObj); //recurse }); } +//--------------------------------------------------------------------------------------------------------------- -void SynchronizeFolderPair::synchronizeFile(FileMapping& fileObj) const +namespace { - wxString logText; - Zstring target; - - switch (fileObj.getSyncOperation()) //evaluate comparison result and sync direction +inline +bool getTargetDir(SyncOperation syncOp, SelectedSide* side) +{ + switch (syncOp) { case SO_CREATE_NEW_LEFT: - target = fileObj.getBaseDirPf<LEFT_SIDE>() + fileObj.getRelativeName<RIGHT_SIDE>(); //can't use "getFullName" as target is not yet existing + case SO_DELETE_LEFT: + case SO_OVERWRITE_LEFT: + case SO_COPY_METADATA_TO_LEFT: + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_LEFT_TARGET: + *side = LEFT_SIDE; + return true; - logText = txtCreatingFile; - replace(logText, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); + case SO_CREATE_NEW_RIGHT: + case SO_DELETE_RIGHT: + case SO_OVERWRITE_RIGHT: + case SO_COPY_METADATA_TO_RIGHT: + case SO_MOVE_RIGHT_SOURCE: + case SO_MOVE_RIGHT_TARGET: + *side = RIGHT_SIDE; + return true; - try - { - FileDescriptor sourceAttr; - copyFileUpdatingTo<LEFT_SIDE>(fileObj, - []() {}, //no target to delete - sourceAttr); + case SO_DO_NOTHING: + case SO_EQUAL: + case SO_UNRESOLVED_CONFLICT: + break; //nothing to do + } + return false; +} +} - fileObj.copyTo<LEFT_SIDE>(&sourceAttr); //update FileMapping - } - catch (FileError&) - { - if (fileExists(fileObj.getFullName<RIGHT_SIDE>())) - throw; - //source deleted meanwhile... - procCallback_.updateProcessedData(0, to<zen::Int64>(fileObj.getFileSize<RIGHT_SIDE>())); - fileObj.removeObject<RIGHT_SIDE>(); - } - break; +inline +void SynchronizeFolderPair::synchronizeFile(FileMapping& fileObj) const +{ + const SyncOperation syncOp = fileObj.getSyncOperation(); + + SelectedSide sideTrg = LEFT_SIDE; + + if (getTargetDir(syncOp, &sideTrg)) + { + if (sideTrg == LEFT_SIDE) + synchronizeFileInt<LEFT_SIDE>(fileObj, syncOp); + else + synchronizeFileInt<RIGHT_SIDE>(fileObj, syncOp); + } +} + + +template <SelectedSide sideTrg> +void SynchronizeFolderPair::synchronizeFileInt(FileMapping& fileObj, SyncOperation syncOp) const +{ + static const SelectedSide sideSrc = OtherSide<sideTrg>::result; + + switch (syncOp) + { + case SO_CREATE_NEW_LEFT: case SO_CREATE_NEW_RIGHT: - target = fileObj.getBaseDirPf<RIGHT_SIDE>() + fileObj.getRelativeName<LEFT_SIDE>(); + { + const Zstring& target = fileObj.getBaseDirPf<sideTrg>() + fileObj.getRelativeName<sideSrc>(); //can't use "getFullName" as target is not yet existing - logText = txtCreatingFile; - replace(logText, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); + reportInfo(txtCreatingFile, target); try { - FileDescriptor sourceAttr; - copyFileUpdatingTo<RIGHT_SIDE>(fileObj, - []() {}, //no target to delete - sourceAttr); + FileAttrib newAttr; + copyFileUpdatingTo<sideTrg>(fileObj, [] {}, /*no target to delete*/ newAttr); - fileObj.copyTo<RIGHT_SIDE>(&sourceAttr); //update FileMapping + 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 } catch (FileError&) { - if (fileExists(fileObj.getFullName<LEFT_SIDE>())) + if (fileExists(fileObj.getFullName<sideSrc>())) throw; //source deleted meanwhile... - procCallback_.updateProcessedData(0, to<zen::Int64>(fileObj.getFileSize<LEFT_SIDE>())); - fileObj.removeObject<LEFT_SIDE>(); + procCallback_.updateProcessedData(0, to<zen::Int64>(fileObj.getFileSize<sideSrc>())); + fileObj.removeObject<sideSrc>(); } - break; + } + break; case SO_DELETE_LEFT: - logText = replaceCpy(delHandlingLeft_.getTxtRemovingFile(), L"%x", utf8CvrtTo<wxString>(fileObj.getFullName<LEFT_SIDE>())); - procCallback_.reportInfo(logText); + case SO_DELETE_RIGHT: + reportInfo(getDelHandling<sideTrg>().getTxtRemovingFile(), fileObj.getFullName<sideTrg>()); - delHandlingLeft_.removeFile(fileObj.getObjRelativeName()); //throw FileError - fileObj.removeObject<LEFT_SIDE>(); //update FileMapping + getDelHandling<sideTrg>().removeFile(fileObj.getObjRelativeName()); //throw FileError + fileObj.removeObject<sideTrg>(); //update FileMapping break; - case SO_DELETE_RIGHT: - logText = replaceCpy(delHandlingRight_.getTxtRemovingFile(), L"%x", utf8CvrtTo<wxString>(fileObj.getFullName<RIGHT_SIDE>())); - procCallback_.reportInfo(logText); + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_LEFT_TARGET: + case SO_MOVE_RIGHT_SOURCE: + case SO_MOVE_RIGHT_TARGET: + if (FileMapping* targetObj = dynamic_cast<FileMapping*>(FileSystemObject::retrieve(fileObj.getMoveRef()))) + { + FileMapping* sourceObj = &fileObj; - delHandlingRight_.removeFile(fileObj.getObjRelativeName()); //throw FileError - fileObj.removeObject<RIGHT_SIDE>(); //update FileMapping - break; + if (syncOp != SO_MOVE_LEFT_SOURCE && syncOp != SO_MOVE_RIGHT_SOURCE) + std::swap(sourceObj, targetObj); - case SO_OVERWRITE_LEFT: - { - target = fileObj.getBaseDirPf<LEFT_SIDE>() + fileObj.getRelativeName<RIGHT_SIDE>(); //respect differences in case of source object + assert((sourceObj->getSyncOperation() == SO_MOVE_LEFT_SOURCE && targetObj->getSyncOperation() == SO_MOVE_LEFT_TARGET && sideTrg == LEFT_SIDE) || + (sourceObj->getSyncOperation() == SO_MOVE_RIGHT_SOURCE && targetObj->getSyncOperation() == SO_MOVE_RIGHT_TARGET && sideTrg == RIGHT_SIDE)); - logText = txtOverwritingFile; - replace(logText, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); + const Zstring& source = sourceObj->getFullName<sideTrg>(); + const Zstring& target = targetObj->getBaseDirPf<sideTrg>() + targetObj->getRelativeName<sideSrc>(); - FileDescriptor sourceAttr; - copyFileUpdatingTo<LEFT_SIDE>(fileObj, - [&]() //delete target at appropriate time - { - procCallback_.reportStatus(replaceCpy(delHandlingLeft_.getTxtRemovingFile(), L"%x", utf8CvrtTo<wxString>(fileObj.getFullName<LEFT_SIDE>()))); + reportInfo(replaceCpy(txtMovingFile, L"%y", utf8CvrtTo<std::wstring>(target)), source); - delHandlingLeft_.removeFile(fileObj.getObjRelativeName()); //throw FileError - fileObj.removeObject<LEFT_SIDE>(); //remove file from FileMapping, to keep in sync (if subsequent copying fails!!) + renameFile(source, target); //throw FileError; - procCallback_.reportStatus(logText); //restore status text copy file - }, sourceAttr); + const FileDescriptor descrTarget(sourceObj->getLastWriteTime<sideTrg>(), + sourceObj->getFileSize <sideTrg>(), + sourceObj->getFileId <sideTrg>()); - fileObj.copyTo<LEFT_SIDE>(&sourceAttr); //update FileMapping - } - break; + sourceObj->removeObject<sideTrg>(); // + targetObj->syncTo<sideTrg>(descrTarget); //update FileMapping + } + break; + case SO_OVERWRITE_LEFT: case SO_OVERWRITE_RIGHT: { - target = fileObj.getBaseDirPf<RIGHT_SIDE>() + fileObj.getRelativeName<LEFT_SIDE>(); //respect differences in case of source object + const Zstring& target = fileObj.getBaseDirPf<sideTrg>() + fileObj.getRelativeName<sideSrc>(); //respect differences in case of source object - logText = txtOverwritingFile; - replace(logText, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); + reportInfo(txtOverwritingFile, target); - FileDescriptor sourceAttr; - copyFileUpdatingTo<RIGHT_SIDE>(fileObj, - [&]() //delete target at appropriate time + FileAttrib newAttr; + copyFileUpdatingTo<sideTrg>(fileObj, + [&] //delete target at appropriate time { - procCallback_.reportStatus(replaceCpy(delHandlingRight_.getTxtRemovingFile(), L"%x", utf8CvrtTo<wxString>(fileObj.getFullName<RIGHT_SIDE>()))); + reportStatus(this->getDelHandling<sideTrg>().getTxtRemovingFile(), fileObj.getFullName<sideTrg>()); - delHandlingRight_.removeFile(fileObj.getObjRelativeName()); //throw FileError - fileObj.removeObject<RIGHT_SIDE>(); //remove file from FileMapping, to keep in sync (if subsequent copying fails!!) + this->getDelHandling<sideTrg>().removeFile(fileObj.getObjRelativeName()); //throw FileError + fileObj.removeObject<sideTrg>(); //remove file from FileMapping, to keep in sync (if subsequent copying fails!!) - procCallback_.reportStatus(logText); //restore status text copy file - }, sourceAttr); + reportStatus(txtOverwritingFile, target); //restore status text copy file + }, newAttr); - fileObj.copyTo<RIGHT_SIDE>(&sourceAttr); //update FileMapping + 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 } break; case SO_COPY_METADATA_TO_LEFT: - logText = replaceCpy(txtWritingAttributes, L"%x", utf8CvrtTo<wxString>(fileObj.getFullName<LEFT_SIDE>())); - procCallback_.reportInfo(logText); - - if (fileObj.getShortName<LEFT_SIDE>() != fileObj.getShortName<RIGHT_SIDE>()) //adapt difference in case (windows only) - renameFile(fileObj.getFullName<LEFT_SIDE>(), - beforeLast(fileObj.getFullName<LEFT_SIDE>(), FILE_NAME_SEPARATOR) + FILE_NAME_SEPARATOR + fileObj.getShortName<RIGHT_SIDE>()); //throw FileError; - - if (!sameFileTime(fileObj.getLastWriteTime<LEFT_SIDE>(), fileObj.getLastWriteTime<RIGHT_SIDE>(), 2)) //respect 2 second FAT/FAT32 precision - setFileTime(fileObj.getFullName<LEFT_SIDE>(), fileObj.getLastWriteTime<RIGHT_SIDE>(), SYMLINK_FOLLOW); //throw FileError - //do NOT read *current* source file time, but use buffered value which corresponds to time of comparison! - - fileObj.copyTo<LEFT_SIDE>(NULL); //-> both sides *should* be completely equal now... - break; - case SO_COPY_METADATA_TO_RIGHT: - logText = replaceCpy(txtWritingAttributes, L"%x", utf8CvrtTo<wxString>(fileObj.getFullName<RIGHT_SIDE>())); - procCallback_.reportInfo(logText); + { + reportInfo(txtWritingAttributes, fileObj.getFullName<sideTrg>()); - if (fileObj.getShortName<LEFT_SIDE>() != fileObj.getShortName<RIGHT_SIDE>()) //adapt difference in case (windows only) - renameFile(fileObj.getFullName<RIGHT_SIDE>(), - beforeLast(fileObj.getFullName<RIGHT_SIDE>(), FILE_NAME_SEPARATOR) + FILE_NAME_SEPARATOR + fileObj.getShortName<LEFT_SIDE>()); //throw FileError; + if (fileObj.getShortName<sideTrg>() != fileObj.getShortName<sideSrc>()) //adapt difference in case (windows only) + renameFile(fileObj.getFullName<sideTrg>(), + beforeLast(fileObj.getFullName<sideTrg>(), FILE_NAME_SEPARATOR) + FILE_NAME_SEPARATOR + fileObj.getShortName<sideSrc>()); //throw FileError; - if (!sameFileTime(fileObj.getLastWriteTime<LEFT_SIDE>(), fileObj.getLastWriteTime<RIGHT_SIDE>(), 2)) //respect 2 second FAT/FAT32 precision - setFileTime(fileObj.getFullName<RIGHT_SIDE>(), fileObj.getLastWriteTime<LEFT_SIDE>(), SYMLINK_FOLLOW); //throw FileError + if (!sameFileTime(fileObj.getLastWriteTime<sideTrg>(), fileObj.getLastWriteTime<sideSrc>(), 2)) //respect 2 second FAT/FAT32 precision + setFileTime(fileObj.getFullName<sideTrg>(), fileObj.getLastWriteTime<sideSrc>(), SYMLINK_FOLLOW); //throw FileError + //do NOT read *current* source file time, but use buffered value which corresponds to time of comparison! - fileObj.copyTo<RIGHT_SIDE>(NULL); //-> both sides *should* be completely equal now... - break; + const FileDescriptor descrTarget(fileObj.getLastWriteTime<sideSrc>(), + fileObj.getFileSize <sideTrg >(), + fileObj.getFileId <sideTrg >()); + fileObj.syncTo<sideTrg>(descrTarget); //-> both sides *should* be completely equal now... + } + break; case SO_DO_NOTHING: case SO_EQUAL: @@ -1049,137 +1416,112 @@ void SynchronizeFolderPair::synchronizeFile(FileMapping& fileObj) const } +inline void SynchronizeFolderPair::synchronizeLink(SymLinkMapping& linkObj) const { - wxString logText; - Zstring target; + const SyncOperation syncOp = linkObj.getSyncOperation(); - switch (linkObj.getSyncOperation()) //evaluate comparison result and sync direction + SelectedSide sideTrg = LEFT_SIDE; + + if (getTargetDir(syncOp, &sideTrg)) { - case SO_CREATE_NEW_LEFT: - target = linkObj.getBaseDirPf<LEFT_SIDE>() + linkObj.getRelativeName<RIGHT_SIDE>(); + if (sideTrg == LEFT_SIDE) + synchronizeLinkInt<LEFT_SIDE>(linkObj, syncOp); + else + synchronizeLinkInt<RIGHT_SIDE>(linkObj, syncOp); + } +} - logText = txtCreatingLink; - replace(logText, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); - try - { - zen::copySymlink(linkObj.getFullName<RIGHT_SIDE>(), target, copyFilePermissions); //throw FileError +template <SelectedSide sideTrg> +void SynchronizeFolderPair::synchronizeLinkInt(SymLinkMapping& linkObj, SyncOperation syncOp) const +{ + static const SelectedSide sideSrc = OtherSide<sideTrg>::result; - linkObj.copyTo<LEFT_SIDE>(); //update SymLinkMapping - } - catch (FileError&) - { - if (fileExists(linkObj.getFullName<RIGHT_SIDE>())) - throw; - //source deleted meanwhile... - linkObj.removeObject<RIGHT_SIDE>(); - } - break; + 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: case SO_CREATE_NEW_RIGHT: - target = linkObj.getBaseDirPf<RIGHT_SIDE>() + linkObj.getRelativeName<LEFT_SIDE>(); + { + const Zstring& target = linkObj.getBaseDirPf<sideTrg>() + linkObj.getRelativeName<sideSrc>(); - logText = txtCreatingLink; - replace(logText, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); + reportInfo(txtCreatingLink, target); try { - zen::copySymlink(linkObj.getFullName<LEFT_SIDE>(), target, copyFilePermissions); //throw FileError + zen::copySymlink(linkObj.getFullName<sideSrc>(), target, copyFilePermissions); //throw FileError - linkObj.copyTo<RIGHT_SIDE>(); //update SymLinkMapping + linkObj.copyTo<sideTrg>(); //update SymLinkMapping } catch (FileError&) { - if (fileExists(linkObj.getFullName<LEFT_SIDE>())) + if (fileExists(linkObj.getFullName<sideSrc>())) throw; //source deleted meanwhile... - linkObj.removeObject<LEFT_SIDE>(); + linkObj.removeObject<sideSrc>(); } - break; + } + break; case SO_DELETE_LEFT: - logText = replaceCpy(delHandlingLeft_.getTxtRemovingSymLink(), L"%x", utf8CvrtTo<wxString>(linkObj.getFullName<LEFT_SIDE>())); - procCallback_.reportInfo(logText); - - deleteSymlink<LEFT_SIDE>(linkObj); //throw FileError - - linkObj.removeObject<LEFT_SIDE>(); //update SymLinkMapping - break; - case SO_DELETE_RIGHT: - logText = replaceCpy(delHandlingRight_.getTxtRemovingSymLink(), L"%x", utf8CvrtTo<wxString>(linkObj.getFullName<RIGHT_SIDE>())); - procCallback_.reportInfo(logText); + reportInfo(getDelHandling<sideTrg>().getTxtRemovingSymLink(), linkObj.getFullName<sideTrg>()); - deleteSymlink<RIGHT_SIDE>(linkObj); //throw FileError + deleteSymlink(); //throw FileError - linkObj.removeObject<RIGHT_SIDE>(); //update SymLinkMapping + linkObj.removeObject<sideTrg>(); //update SymLinkMapping break; case SO_OVERWRITE_LEFT: - target = linkObj.getBaseDirPf<LEFT_SIDE>() + linkObj.getRelativeName<RIGHT_SIDE>(); //respect differences in case of source object - - logText = txtOverwritingLink; - replace(logText, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); - - procCallback_.reportStatus(replaceCpy(delHandlingLeft_.getTxtRemovingSymLink(), L"%x", utf8CvrtTo<wxString>(linkObj.getFullName<LEFT_SIDE>()))); - deleteSymlink<LEFT_SIDE>(linkObj); //throw FileError - linkObj.removeObject<LEFT_SIDE>(); //remove file from FileMapping, to keep in sync (if subsequent copying fails!!) - - procCallback_.reportStatus(logText); //restore status text - zen::copySymlink(linkObj.getFullName<RIGHT_SIDE>(), target, copyFilePermissions); //throw FileError - - linkObj.copyTo<LEFT_SIDE>(); //update SymLinkMapping - break; - case SO_OVERWRITE_RIGHT: - target = linkObj.getBaseDirPf<RIGHT_SIDE>() + linkObj.getRelativeName<LEFT_SIDE>(); //respect differences in case of source object - - logText = txtOverwritingLink; - replace(logText, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); + { + const Zstring& target = linkObj.getBaseDirPf<sideTrg>() + linkObj.getRelativeName<sideSrc>(); //respect differences in case of source object - procCallback_.reportStatus(replaceCpy(delHandlingRight_.getTxtRemovingSymLink(), L"%x", utf8CvrtTo<wxString>(linkObj.getFullName<RIGHT_SIDE>()))); - deleteSymlink<RIGHT_SIDE>(linkObj); //throw FileError - linkObj.removeObject<RIGHT_SIDE>(); //remove file from FileMapping, to keep in sync (if subsequent copying fails!!) + reportInfo(txtOverwritingLink, target); - procCallback_.reportStatus(logText); //restore status text - zen::copySymlink(linkObj.getFullName<LEFT_SIDE>(), target, copyFilePermissions); //throw FileError + reportStatus(getDelHandling<sideTrg>().getTxtRemovingSymLink(), linkObj.getFullName<sideTrg>()); + deleteSymlink(); //throw FileError + linkObj.removeObject<sideTrg>(); //remove file from FileMapping, to keep in sync (if subsequent copying fails!!) - linkObj.copyTo<RIGHT_SIDE>(); //update SymLinkMapping - break; + reportStatus(txtOverwritingLink, target); //restore status text + zen::copySymlink(linkObj.getFullName<sideSrc>(), target, copyFilePermissions); //throw FileError + linkObj.copyTo<sideTrg>(); //update SymLinkMapping + } + break; case SO_COPY_METADATA_TO_LEFT: - logText = replaceCpy(txtWritingAttributes, L"%x", utf8CvrtTo<wxString>(linkObj.getFullName<LEFT_SIDE>())); - procCallback_.reportInfo(logText); - - if (linkObj.getShortName<LEFT_SIDE>() != linkObj.getShortName<RIGHT_SIDE>()) //adapt difference in case (windows only) - renameFile(linkObj.getFullName<LEFT_SIDE>(), - beforeLast(linkObj.getFullName<LEFT_SIDE>(), FILE_NAME_SEPARATOR) + FILE_NAME_SEPARATOR + linkObj.getShortName<RIGHT_SIDE>()); //throw FileError; - - if (!sameFileTime(linkObj.getLastWriteTime<LEFT_SIDE>(), linkObj.getLastWriteTime<RIGHT_SIDE>(), 2)) //respect 2 second FAT/FAT32 precision - setFileTime(linkObj.getFullName<LEFT_SIDE>(), linkObj.getLastWriteTime<RIGHT_SIDE>(), SYMLINK_DIRECT); //throw FileError - - linkObj.copyTo<LEFT_SIDE>(); //-> both sides *should* be completely equal now... - break; - case SO_COPY_METADATA_TO_RIGHT: - logText = replaceCpy(txtWritingAttributes, L"%x", utf8CvrtTo<wxString>(linkObj.getFullName<RIGHT_SIDE>())); - procCallback_.reportInfo(logText); + reportInfo(txtWritingAttributes, linkObj.getFullName<sideTrg>()); - if (linkObj.getShortName<LEFT_SIDE>() != linkObj.getShortName<RIGHT_SIDE>()) //adapt difference in case (windows only) - renameFile(linkObj.getFullName<RIGHT_SIDE>(), - beforeLast(linkObj.getFullName<RIGHT_SIDE>(), FILE_NAME_SEPARATOR) + FILE_NAME_SEPARATOR + linkObj.getShortName<LEFT_SIDE>()); //throw FileError; + if (linkObj.getShortName<sideTrg>() != linkObj.getShortName<sideSrc>()) //adapt difference in case (windows only) + renameFile(linkObj.getFullName<sideTrg>(), + beforeLast(linkObj.getFullName<sideTrg>(), FILE_NAME_SEPARATOR) + FILE_NAME_SEPARATOR + linkObj.getShortName<sideSrc>()); //throw FileError; - if (!sameFileTime(linkObj.getLastWriteTime<LEFT_SIDE>(), linkObj.getLastWriteTime<RIGHT_SIDE>(), 2)) //respect 2 second FAT/FAT32 precision - setFileTime(linkObj.getFullName<RIGHT_SIDE>(), linkObj.getLastWriteTime<LEFT_SIDE>(), SYMLINK_DIRECT); //throw FileError + 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<RIGHT_SIDE>(); //-> both sides *should* be completely equal now... + linkObj.copyTo<sideTrg>(); //-> both sides *should* be completely equal now... break; + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_RIGHT_SOURCE: + case SO_MOVE_LEFT_TARGET: + case SO_MOVE_RIGHT_TARGET: + assert(false); case SO_DO_NOTHING: case SO_EQUAL: case SO_UNRESOLVED_CONFLICT: @@ -1193,126 +1535,89 @@ void SynchronizeFolderPair::synchronizeLink(SymLinkMapping& linkObj) const } +inline void SynchronizeFolderPair::synchronizeFolder(DirMapping& dirObj) const { - wxString logText; - Zstring target; + const SyncOperation syncOp = dirObj.getSyncOperation(); - //synchronize folders: - switch (dirObj.getSyncOperation()) //evaluate comparison result and sync direction - { - case SO_CREATE_NEW_LEFT: - //some check to catch the error that directory on source has been deleted externally after "compare"... - if (!dirExists(dirObj.getFullName<RIGHT_SIDE>())) - { - // throw FileError(_ ("Source directory does not exist anymore:") + "\n\"" + dirObj.getFullName<RIGHT_SIDE>() + "\""); - const SyncStatistics subObjects(dirObj); //DON'T forget to notify about implicitly deleted objects! - procCallback_.updateProcessedData(subObjects.getCreate() + subObjects.getOverwrite() + subObjects.getDelete(), to<zen::Int64>(subObjects.getDataToProcess())); + SelectedSide sideTrg = LEFT_SIDE; - dirObj.refSubFiles().clear(); //...then remove sub-objects - dirObj.refSubLinks().clear(); // - dirObj.refSubDirs ().clear(); // - dirObj.removeObject<RIGHT_SIDE>(); - } - else - { - target = dirObj.getBaseDirPf<LEFT_SIDE>() + dirObj.getRelativeName<RIGHT_SIDE>(); + if (getTargetDir(syncOp, &sideTrg)) + { + if (sideTrg == LEFT_SIDE) + synchronizeFolderInt<LEFT_SIDE>(dirObj, syncOp); + else + synchronizeFolderInt<RIGHT_SIDE>(dirObj, syncOp); + } +} - logText = replaceCpy(txtCreatingFolder, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); - createDirectory(target, dirObj.getFullName<RIGHT_SIDE>(), copyFilePermissions); //no symlink copying! - dirObj.copyTo<LEFT_SIDE>(); //update DirMapping - } - break; +template <SelectedSide sideTrg> +void SynchronizeFolderPair::synchronizeFolderInt(DirMapping& dirObj, SyncOperation syncOp) const +{ + static const SelectedSide sideSrc = OtherSide<sideTrg>::result; + switch (syncOp) + { + case SO_CREATE_NEW_LEFT: case SO_CREATE_NEW_RIGHT: - //some check to catch the error that directory on source has been deleted externally after "compare"... - if (!dirExists(dirObj.getFullName<LEFT_SIDE>())) + if (dirExists(dirObj.getFullName<sideSrc>())) { - //throw FileError(_ ("Source directory does not exist anymore:") + "\n\"" + dirObj.getFullName<LEFT_SIDE>() + "\""); - const SyncStatistics subObjects(dirObj); //DON'T forget to notify about implicitly deleted objects! - procCallback_.updateProcessedData(subObjects.getCreate() + subObjects.getOverwrite() + subObjects.getDelete(), to<zen::Int64>(subObjects.getDataToProcess())); + const Zstring& target = dirObj.getBaseDirPf<sideTrg>() + dirObj.getRelativeName<sideSrc>(); - dirObj.refSubFiles().clear(); //...then remove sub-objects - dirObj.refSubLinks().clear(); // - dirObj.refSubDirs ().clear(); // - dirObj.removeObject<LEFT_SIDE>(); + reportInfo(txtCreatingFolder, target); + createDirectory(target, dirObj.getFullName<sideSrc>(), copyFilePermissions); //no symlink copying! + dirObj.copyTo<sideTrg>(); //update DirMapping } - else + else //source directory has been deleted externally after "compare"... { - target = dirObj.getBaseDirPf<RIGHT_SIDE>() + dirObj.getRelativeName<LEFT_SIDE>(); - - logText = replaceCpy(txtCreatingFolder, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); + // throw FileError(_ ("Source directory does not exist anymore:") + "\n\"" + dirObj.getFullName<sideSrc>() + "\""); + const SyncStatistics subStats(dirObj); //DON'T forget to notify about implicitly deleted objects! + procCallback_.updateProcessedData(getCUD(subStats), to<zen::Int64>(subStats.getDataToProcess())); - createDirectory(target, dirObj.getFullName<LEFT_SIDE>(), copyFilePermissions); //no symlink copying! - dirObj.copyTo<RIGHT_SIDE>(); //update DirMapping + dirObj.refSubFiles().clear(); //...then remove sub-objects + dirObj.refSubLinks().clear(); // + dirObj.refSubDirs ().clear(); // + dirObj.removeObject<sideSrc>(); } break; case SO_COPY_METADATA_TO_LEFT: - logText = replaceCpy(txtWritingAttributes, L"%x", utf8CvrtTo<wxString>(dirObj.getFullName<LEFT_SIDE>())); - procCallback_.reportInfo(logText); - - if (dirObj.getShortName<LEFT_SIDE>() != dirObj.getShortName<RIGHT_SIDE>()) //adapt difference in case (windows only) - renameFile(dirObj.getFullName<LEFT_SIDE>(), - beforeLast(dirObj.getFullName<LEFT_SIDE>(), FILE_NAME_SEPARATOR) + FILE_NAME_SEPARATOR + dirObj.getShortName<RIGHT_SIDE>()); //throw FileError; - //copyFileTimes(dirObj.getFullName<RIGHT_SIDE>(), dirObj.getFullName<LEFT_SIDE>(), true); //throw FileError -> is executed after sub-objects have finished synchronization - - dirObj.copyTo<LEFT_SIDE>(); //-> both sides *should* be completely equal now... - break; - case SO_COPY_METADATA_TO_RIGHT: - logText = replaceCpy(txtWritingAttributes, L"%x", utf8CvrtTo<wxString>(dirObj.getFullName<RIGHT_SIDE>())); - procCallback_.reportInfo(logText); + reportInfo(txtWritingAttributes, dirObj.getFullName<sideTrg>()); - if (dirObj.getShortName<LEFT_SIDE>() != dirObj.getShortName<RIGHT_SIDE>()) //adapt difference in case (windows only) - renameFile(dirObj.getFullName<RIGHT_SIDE>(), - beforeLast(dirObj.getFullName<RIGHT_SIDE>(), FILE_NAME_SEPARATOR) + FILE_NAME_SEPARATOR + dirObj.getShortName<LEFT_SIDE>()); //throw FileError; - //copyFileTimes(dirObj.getFullName<LEFT_SIDE>(), dirObj.getFullName<RIGHT_SIDE>(), true); //throw FileError -> is executed after sub-objects have finished synchronization + 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 - dirObj.copyTo<RIGHT_SIDE>(); //-> both sides *should* be completely equal now... + dirObj.copyTo<sideTrg>(); //-> both sides *should* be completely equal now... break; case SO_DELETE_LEFT: - //status information - logText = replaceCpy(delHandlingLeft_.getTxtRemovingDir(), L"%x", utf8CvrtTo<wxString>(dirObj.getFullName<LEFT_SIDE>())); - procCallback_.reportInfo(logText); + case SO_DELETE_RIGHT: + { + reportInfo(getDelHandling<sideTrg>().getTxtRemovingDir(), dirObj.getFullName<sideTrg>()); - delHandlingLeft_.removeFolder(dirObj.getObjRelativeName()); //throw FileError - { - //progress indicator update: DON'T forget to notify about implicitly deleted objects! - const SyncStatistics subObjects(dirObj); - //...then remove everything - dirObj.refSubFiles().clear(); - dirObj.refSubLinks().clear(); - dirObj.refSubDirs ().clear(); - procCallback_.updateProcessedData(subObjects.getCreate() + subObjects.getOverwrite() + subObjects.getDelete(), to<zen::Int64>(subObjects.getDataToProcess())); - } - dirObj.removeObject<LEFT_SIDE>(); //update DirMapping - break; + getDelHandling<sideTrg>().removeFolder(dirObj.getObjRelativeName()); //throw FileError - case SO_DELETE_RIGHT: - //status information - logText = replaceCpy(delHandlingRight_.getTxtRemovingDir(), L"%x", utf8CvrtTo<wxString>(dirObj.getFullName<RIGHT_SIDE>())); - procCallback_.reportInfo(logText); + //progress indicator update: DON'T forget to notify about implicitly deleted objects! + const SyncStatistics subStats(dirObj); + dirObj.refSubFiles().clear(); //...then remove everything + dirObj.refSubLinks().clear(); + dirObj.refSubDirs ().clear(); + procCallback_.updateProcessedData(getCUD(subStats), to<zen::Int64>(subStats.getDataToProcess())); - delHandlingRight_.removeFolder(dirObj.getObjRelativeName()); //throw FileError - { - //progress indicator update: DON'T forget to notify about implicitly deleted objects! - const SyncStatistics subObjects(dirObj); - //...then remove everything - dirObj.refSubFiles().clear(); - dirObj.refSubLinks().clear(); - dirObj.refSubDirs ().clear(); - procCallback_.updateProcessedData(subObjects.getCreate() + subObjects.getOverwrite() + subObjects.getDelete(), to<zen::Int64>(subObjects.getDataToProcess())); - } - dirObj.removeObject<RIGHT_SIDE>(); //update DirMapping - break; + dirObj.removeObject<sideTrg>(); //update DirMapping + } + break; case SO_OVERWRITE_RIGHT: case SO_OVERWRITE_LEFT: + case SO_MOVE_LEFT_SOURCE: + case SO_MOVE_RIGHT_SOURCE: + case SO_MOVE_LEFT_TARGET: + case SO_MOVE_RIGHT_TARGET: assert(false); case SO_UNRESOLVED_CONFLICT: case SO_DO_NOTHING: @@ -1336,31 +1641,27 @@ void makeSameLength(std::wstring& first, std::wstring& second) second.resize(maxPref, L' '); } + +/* struct LessDependentDirectory : public std::binary_function<Zstring, Zstring, bool> { +-> a *very* bad idea: this is NOT a strict weak ordering! No transitivity of equivalence! + bool operator()(const Zstring& lhs, const Zstring& rhs) const { return LessFilename()(Zstring(lhs.c_str(), std::min(lhs.length(), rhs.length())), Zstring(rhs.c_str(), std::min(lhs.length(), rhs.length()))); } }; - -struct EqualDependentDirectory : public std::binary_function<Zstring, Zstring, bool> -{ - bool operator()(const Zstring& lhs, const Zstring& rhs) const - { - return EqualFilename()(Zstring(lhs.c_str(), std::min(lhs.length(), rhs.length())), - Zstring(rhs.c_str(), std::min(lhs.length(), rhs.length()))); - } -}; +*/ } void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCfg>& syncConfig, FolderComparison& folderCmp) { - //prevent shutdown while synchronization is in progress - DisableStandby dummy; - (void)dummy; + //prevent shutdown while synchronization is in progress + PreventStandby dummy; + (void)dummy; #ifdef NDEBUG wxLogNull noWxLogs; //prevent wxWidgets logging @@ -1371,12 +1672,11 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf if (syncConfig.size() != folderCmp.size()) throw std::logic_error("Programming Error: Contract violation!"); - //inform about the total amount of data that will be processed from now on const SyncStatistics statisticsTotal(folderCmp); //keep at beginning so that all gui elements are initialized properly - procCallback.initNewProcess(statisticsTotal.getCreate() + statisticsTotal.getOverwrite() + statisticsTotal.getDelete(), + procCallback.initNewProcess(getCUD(statisticsTotal), to<zen::Int64>(statisticsTotal.getDataToProcess()), ProcessCallback::PROCESS_SYNCHRONIZING); @@ -1404,12 +1704,34 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf //-------------------some basic checks:------------------------------------------ + auto dependentDir = [](const Zstring& lhs, const Zstring& rhs) //note: this is NOT an equivalence relation! + { + return EqualFilename()(Zstring(lhs.c_str(), std::min(lhs.length(), rhs.length())), + Zstring(rhs.c_str(), std::min(lhs.length(), rhs.length()))); + }; //aggregate information - typedef std::set<Zstring, LessDependentDirectory> DirReadSet; //count (at least one) read access - typedef std::map<Zstring, size_t, LessDependentDirectory> DirWriteMap; //count (read+)write accesses - DirReadSet dirReadCount; - DirWriteMap dirWriteCount; + std::map<Zstring, std::pair<size_t, size_t>> dirReadWriteCount; //count read/write accesses + auto incReadCount = [&](const Zstring& baseDir) + { + dirReadWriteCount[baseDir]; //create entry + for (auto iter = dirReadWriteCount.begin(); iter != dirReadWriteCount.end(); ++iter) + { + auto& countRef = iter->second; + if (dependentDir(baseDir, iter->first)) + ++countRef.first; + } + }; + auto incWriteCount = [&](const Zstring& baseDir) + { + dirReadWriteCount[baseDir]; //create entry + for (auto iter = dirReadWriteCount.begin(); iter != dirReadWriteCount.end(); ++iter) + { + auto& countRef = iter->second; + if (dependentDir(baseDir, iter->first)) + ++countRef.second; + } + }; typedef std::vector<std::pair<Zstring, Zstring> > DirPairList; DirPairList significantDiff; @@ -1417,8 +1739,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf typedef std::vector<std::pair<Zstring, std::pair<zen::Int64, zen::Int64> > > DirSpaceRequAvailList; //dirname / space required / space available DirSpaceRequAvailList diskSpaceMissing; - typedef std::set<Zstring, LessDependentDirectory> DirRecyclerMissing; - DirRecyclerMissing recyclMissing; + std::set<Zstring> recyclMissing; //start checking folder pairs for (auto j = begin(folderCmp); j != end(folderCmp); ++j) @@ -1435,13 +1756,13 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf const SyncStatistics folderPairStat(*j); //aggregate basic information - const bool writeLeft = folderPairStat.getCreate <LEFT_SIDE>() + - folderPairStat.getOverwrite<LEFT_SIDE>() + - folderPairStat.getDelete <LEFT_SIDE>() > 0; + const bool writeLeft = folderPairStat.getCreate<LEFT_SIDE>() + + folderPairStat.getUpdate<LEFT_SIDE>() + + folderPairStat.getDelete<LEFT_SIDE>() > 0; - const bool writeRight = folderPairStat.getCreate <RIGHT_SIDE>() + - folderPairStat.getOverwrite<RIGHT_SIDE>() + - folderPairStat.getDelete <RIGHT_SIDE>() > 0; + const bool writeRight = folderPairStat.getCreate<RIGHT_SIDE>() + + folderPairStat.getUpdate<RIGHT_SIDE>() + + folderPairStat.getDelete<RIGHT_SIDE>() > 0; //skip folder pair if there is nothing to do (except for automatic mode, where data base needs to be written even in this case) if (!writeLeft && !writeRight && @@ -1453,7 +1774,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf //check empty input fields: basically this only makes sense if empty field is not target (and not automatic mode: because of db file creation) - if ((j->getBaseDirPf<LEFT_SIDE>(). empty() && (writeLeft || folderPairCfg.inAutomaticMode)) || + if ((j->getBaseDirPf<LEFT_SIDE >().empty() && (writeLeft || folderPairCfg.inAutomaticMode)) || (j->getBaseDirPf<RIGHT_SIDE>().empty() && (writeRight || folderPairCfg.inAutomaticMode))) { procCallback.reportFatalError(_("Target directory name must not be empty!")); @@ -1462,30 +1783,32 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf } //aggregate information of folders used by multiple pairs in read/write access - if (!EqualDependentDirectory()(j->getBaseDirPf<LEFT_SIDE>(), j->getBaseDirPf<RIGHT_SIDE>())) //true in general + if (!dependentDir(j->getBaseDirPf<LEFT_SIDE>(), j->getBaseDirPf<RIGHT_SIDE>())) //true in general { - if (writeLeft) + if (writeLeft && writeRight) + { + incWriteCount(j->getBaseDirPf<LEFT_SIDE >()); + incWriteCount(j->getBaseDirPf<RIGHT_SIDE>()); + } + else if (writeLeft) { - ++dirWriteCount[j->getBaseDirPf<LEFT_SIDE>()]; - if (writeRight) - ++dirWriteCount[j->getBaseDirPf<RIGHT_SIDE>()]; - else - dirReadCount.insert(j->getBaseDirPf<RIGHT_SIDE>()); + incWriteCount(j->getBaseDirPf<LEFT_SIDE>()); + incReadCount (j->getBaseDirPf<RIGHT_SIDE>()); } else if (writeRight) { - dirReadCount.insert(j->getBaseDirPf<LEFT_SIDE>()); - ++dirWriteCount[j->getBaseDirPf<RIGHT_SIDE>()]; + incReadCount (j->getBaseDirPf<LEFT_SIDE>()); + incWriteCount(j->getBaseDirPf<RIGHT_SIDE>()); } } else //if folder pair contains two dependent folders, a warning was already issued after comparison; in this context treat as one write access at most { if (writeLeft || writeRight) - ++dirWriteCount[j->getBaseDirPf<LEFT_SIDE>()]; + incWriteCount(j->getBaseDirPf<LEFT_SIDE>()); } - if (folderPairStat.getOverwrite() + folderPairStat.getDelete() > 0) + if (folderPairStat.getUpdate() + folderPairStat.getDelete() > 0) { if (folderPairCfg.handleDeletion == zen::MOVE_TO_CUSTOM_DIRECTORY) { @@ -1500,7 +1823,9 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf } //avoid data loss when source directory doesn't (temporarily?) exist anymore AND user chose to ignore errors (else we wouldn't arrive here) - if (folderPairStat.getCreate() + folderPairStat.getOverwrite() + folderPairStat.getConflict() == 0 && + if (folderPairStat.getCreate() + + folderPairStat.getUpdate() + + folderPairStat.getConflict() == 0 && folderPairStat.getDelete() > 0) //deletions only... (respect filtered items!) { Zstring missingSrcDir; @@ -1522,9 +1847,8 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf significantDiff.push_back(std::make_pair(j->getBaseDirPf<LEFT_SIDE>(), j->getBaseDirPf<RIGHT_SIDE>())); //check for sufficient free diskspace in left directory - const std::pair<zen::Int64, zen::Int64> spaceNeeded = DiskSpaceNeeded(*j, - delHandlerFp.first.deletionFreesSpace(), - delHandlerFp.second.deletionFreesSpace()).getSpaceTotal(); + const std::pair<Int64, Int64> spaceNeeded = DiskSpaceNeeded::calculate(*j, delHandlerFp.first.deletionFreesSpace(), + delHandlerFp.second.deletionFreesSpace()); wxLongLong freeDiskSpaceLeft; if (wxGetDiskSpace(toWx(j->getBaseDirPf<LEFT_SIDE>()), NULL, &freeDiskSpaceLeft)) { @@ -1546,14 +1870,14 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf #ifdef FFS_WIN if (folderPairCfg.handleDeletion == MOVE_TO_RECYCLE_BIN) { - if (folderPairStat.getOverwrite<LEFT_SIDE>() + - folderPairStat.getDelete <LEFT_SIDE>() > 0 && + if (folderPairStat.getUpdate<LEFT_SIDE>() + + folderPairStat.getDelete<LEFT_SIDE>() > 0 && recycleBinStatus(j->getBaseDirPf<LEFT_SIDE>()) != STATUS_REC_EXISTS) recyclMissing.insert(j->getBaseDirPf<LEFT_SIDE>()); - if (folderPairStat.getOverwrite<RIGHT_SIDE>() + - folderPairStat.getDelete <RIGHT_SIDE>() > 0 && + if (folderPairStat.getUpdate<RIGHT_SIDE>() + + folderPairStat.getDelete<RIGHT_SIDE>() > 0 && recycleBinStatus(j->getBaseDirPf<RIGHT_SIDE>()) != STATUS_REC_EXISTS) recyclMissing.insert(j->getBaseDirPf<RIGHT_SIDE>()); @@ -1565,20 +1889,20 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf if (statisticsTotal.getConflict() > 0) { //show the first few conflicts in warning message also: - wxString warningMessage = wxString(_("Unresolved conflicts existing!")) + - wxT(" (") + toStringSep(statisticsTotal.getConflict()) + wxT(")\n\n"); + std::wstring warningMessage = _("Unresolved conflicts existing!") + + L" (" + toStringSep(statisticsTotal.getConflict()) + L")\n\n"; const SyncStatistics::ConflictTexts& firstConflicts = statisticsTotal.getFirstConflicts(); //get first few sync conflicts for (SyncStatistics::ConflictTexts::const_iterator i = firstConflicts.begin(); i != firstConflicts.end(); ++i) { - wxString conflictDescription = i->second; + std::wstring conflictDescription = i->second; //conflictDescription.Replace(wxT("\n"), wxT(" ")); //remove line-breaks warningMessage += std::wstring(L"\"") + i->first + L"\": " + conflictDescription + L"\n\n"; } if (statisticsTotal.getConflict() > static_cast<int>(firstConflicts.size())) - warningMessage += wxT("[...]\n\n"); + warningMessage += L"[...]\n\n"; warningMessage += _("You can ignore conflicts and continue synchronization."); @@ -1589,13 +1913,14 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf //check if more than 50% of total number of files/dirs are to be created/overwritten/deleted if (!significantDiff.empty()) { - wxString warningMessage = _("Significant difference detected:"); + std::wstring warningMessage = _("Significant difference detected:"); for (DirPairList::const_iterator i = significantDiff.begin(); i != significantDiff.end(); ++i) warningMessage += std::wstring(L"\n\n") + i->first + L" <-> " + L"\n" + i->second; - warningMessage += wxString(L"\n\n") + _("More than 50% of the total number of files will be copied or deleted!"); + 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); } @@ -1604,13 +1929,13 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf //check for sufficient free diskspace if (!diskSpaceMissing.empty()) { - wxString warningMessage = _("Not enough free disk space available in:"); + std::wstring warningMessage = _("Not enough free disk space available in:"); for (auto i = diskSpaceMissing.begin(); i != diskSpaceMissing.end(); ++i) warningMessage += std::wstring(L"\n\n") + L"\"" + i->first + L"\"\n" + - _("Free disk space required:") + wxT(" ") + filesizeToShortString(to<UInt64>(i->second.first)) + L"\n" + - _("Free disk space available:") + wxT(" ") + filesizeToShortString(to<UInt64>(i->second.second)); + _("Free disk space required:") + L" " + filesizeToShortString(to<UInt64>(i->second.first)) + L"\n" + + _("Free disk space available:") + L" " + filesizeToShortString(to<UInt64>(i->second.second)); procCallback.reportWarning(warningMessage, m_warnings.warningNotEnoughDiskSpace); } @@ -1620,11 +1945,11 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf #ifdef FFS_WIN if (!recyclMissing.empty()) { - wxString warningMessage = _("Recycle Bin is not available for the following paths! Files will be deleted permanently instead:"); + std::wstring warningMessage = _("Recycle Bin is not available for the following paths! Files will be deleted permanently instead:"); warningMessage += L"\n"; std::for_each(recyclMissing.begin(), recyclMissing.end(), - [&](const Zstring& path) { warningMessage += L"\n" + toWx(path); }); + [&](const Zstring& path) { warningMessage += L"\n" + utf8CvrtTo<std::wstring>(path); }); procCallback.reportWarning(warningMessage, m_warnings.warningRecyclerMissing); } @@ -1632,15 +1957,18 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf //check if folders are used by multiple pairs in read/write access std::vector<Zstring> conflictDirs; - for (DirWriteMap::const_iterator i = dirWriteCount.begin(); i != dirWriteCount.end(); ++i) - if (i->second >= 2 || //multiple write accesses - (i->second == 1 && dirReadCount.find(i->first) != dirReadCount.end())) //read/write access - conflictDirs.push_back(i->first); + for (auto iter = dirReadWriteCount.cbegin(); iter != dirReadWriteCount.cend(); ++iter) + { + const auto& countRef = iter->second; + if (countRef.second >= 2 || //multiple write accesses + (countRef.second == 1 && countRef.first >= 1)) //read/write access + conflictDirs.push_back(iter->first); + } if (!conflictDirs.empty()) { - wxString warningMessage = wxString(_("A directory will be modified which is part of multiple folder pairs! Please review synchronization settings!")) + wxT("\n"); - for (std::vector<Zstring>::const_iterator i = conflictDirs.begin(); i != conflictDirs.end(); ++i) + std::wstring warningMessage = _("A directory 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 += std::wstring(L"\n") + L"\"" + *i + L"\""; procCallback.reportWarning(warningMessage, m_warnings.warningMultiFolderWriteAccess); @@ -1677,8 +2005,8 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf makeSameLength(left, right); const std::wstring statusTxt = _("Processing folder pair:") + L" \n" + - L"\t" + left + L"\"" + j->getBaseDirPf<LEFT_SIDE>() + L"\"" + L" \n" + - L"\t" + right + L"\"" + j->getBaseDirPf<RIGHT_SIDE>() + L"\""; + L" " + left + L"\"" + j->getBaseDirPf<LEFT_SIDE>() + L"\"" + L" \n" + + L" " + right + L"\"" + j->getBaseDirPf<RIGHT_SIDE>() + L"\""; procCallback.reportInfo(statusTxt); //------------------------------------------------------------------------------------------ @@ -1725,7 +2053,6 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf if (folderPairCfg.inAutomaticMode) { procCallback.reportStatus(_("Generating database...")); - procCallback.forceUiRefresh(); tryReportingError(procCallback, [&]() { zen::saveToDisk(*j); }); //throw FileError guardUpdateDb.dismiss(); @@ -1737,7 +2064,7 @@ void SyncProcess::startSynchronizationProcess(const std::vector<FolderPairSyncCf } catch (const std::exception& e) { - procCallback.reportFatalError(wxString::FromUTF8(e.what())); + procCallback.reportFatalError(utf8CvrtTo<std::wstring>(e.what())); } } @@ -1768,7 +2095,7 @@ public: } private: - UInt64& bytesReported_; + UInt64& bytesReported_; ProcessCallback& statusHandler_; DelTargetCommand cmd_; }; @@ -1776,13 +2103,13 @@ private: //copy file while refreshing UI template <SelectedSide side, class DelTargetCommand> -void SynchronizeFolderPair::copyFileUpdatingTo(const FileMapping& fileObj, const DelTargetCommand& cmd, FileDescriptor& sourceAttr) const +void SynchronizeFolderPair::copyFileUpdatingTo(const FileMapping& fileObj, const DelTargetCommand& cmd, FileAttrib& newAttr) const { const UInt64 totalBytesToCpy = fileObj.getFileSize<OtherSide<side>::result>(); Zstring source = fileObj.getFullName<OtherSide<side>::result>(); const Zstring& target = fileObj.getBaseDirPf<side>() + fileObj.getRelativeName<OtherSide<side>::result>(); - auto copyOperation = [&]() + auto copyOperation = [&] { //start of (possibly) long-running copy process: ensure status updates are performed regularly UInt64 bytesReported; @@ -1790,16 +2117,13 @@ void SynchronizeFolderPair::copyFileUpdatingTo(const FileMapping& fileObj, const zen::ScopeGuard guardStatistics = zen::makeGuard([&]() { procCallback_.updateProcessedData(0, -1 * to<Int64>(bytesReported)); }); WhileCopying<DelTargetCommand> callback(bytesReported, procCallback_, cmd); - FileAttrib fileAttr; zen::copyFile(source, //type File implicitly means symlinks need to be dereferenced! - target, - copyFilePermissions, - transactionalFileCopy, - &callback, - &fileAttr); //throw FileError, ErrorFileLocked - - sourceAttr = FileDescriptor(fileAttr.modificationTime, fileAttr.fileSize); + target, + copyFilePermissions, + transactionalFileCopy, + &callback, + &newAttr); //throw FileError, ErrorFileLocked //inform about the (remaining) processed amount of data procCallback_.updateProcessedData(0, to<Int64>(totalBytesToCpy) - to<Int64>(bytesReported)); @@ -1851,24 +2175,6 @@ void SynchronizeFolderPair::copyFileUpdatingTo(const FileMapping& fileObj, const } -template <zen::SelectedSide side> -void SynchronizeFolderPair::deleteSymlink(const SymLinkMapping& linkObj) const -{ - const DeletionHandling& delHandling = side == LEFT_SIDE ? delHandlingLeft_ : delHandlingRight_; - - switch (linkObj.getLinkType<side>()) - { - case LinkDescriptor::TYPE_DIR: - delHandling.removeFolder(linkObj.getObjRelativeName()); //throw FileError - break; - - case LinkDescriptor::TYPE_FILE: //Windows: true file symlink; Linux: file-link or broken link - delHandling.removeFile(linkObj.getObjRelativeName()); //throw FileError - break; - } -} - - //--------------------- data verification ------------------------- //callback functionality for status updates while verifying @@ -1936,8 +2242,7 @@ private: void SynchronizeFolderPair::verifyFileCopy(const Zstring& source, const Zstring& target) const { - wxString logText = replaceCpy(txtVerifying, L"%x", utf8CvrtTo<wxString>(target)); - procCallback_.reportInfo(logText); + procCallback_.reportInfo(replaceCpy(txtVerifying, L"%x", utf8CvrtTo<std::wstring>(target))); VerifyStatusUpdater callback(procCallback_); |