diff options
Diffstat (limited to 'algorithm.cpp')
| -rw-r--r-- | algorithm.cpp | 637 |
1 files changed, 213 insertions, 424 deletions
diff --git a/algorithm.cpp b/algorithm.cpp index 771fcaea..6de28baa 100644 --- a/algorithm.cpp +++ b/algorithm.cpp @@ -14,7 +14,6 @@ #include <zen/recycler.h> #include <wx/msgdlg.h> #include "lib/norm_filter.h" -#include <wx+/string_conv.h> #include "lib/db_file.h" #include <zen/scope_guard.h> #include "lib/cmp_filetime.h" @@ -31,8 +30,10 @@ void zen::swapGrids(const MainConfiguration& config, FolderComparison& folderCmp redetermineSyncDirection(config, folderCmp, [](const std::wstring&) {}); } - //---------------------------------------------------------------------------------------------- + +namespace +{ class Redetermine { public: @@ -77,17 +78,15 @@ private: fileObj.setSyncDir(dirCfg.different); break; case FILE_CONFLICT: + case FILE_DIFFERENT_METADATA: //use setting from "conflict/cannot categorize" if (dirCfg.conflict == SYNC_DIR_NONE) - fileObj.setSyncDirConflict(fileObj.getCatConflict()); //take over category conflict + fileObj.setSyncDirConflict(getCategoryDescription(fileObj)); //take over category conflict else fileObj.setSyncDir(dirCfg.conflict); break; case FILE_EQUAL: fileObj.setSyncDir(SYNC_DIR_NONE); break; - case FILE_DIFFERENT_METADATA: - fileObj.setSyncDir(dirCfg.conflict); //use setting from "conflict/cannot categorize" - break; } } @@ -108,8 +107,9 @@ private: linkObj.setSyncDir(dirCfg.rightNewer); break; case SYMLINK_CONFLICT: + case SYMLINK_DIFFERENT_METADATA: //use setting from "conflict/cannot categorize" if (dirCfg.conflict == SYNC_DIR_NONE) - linkObj.setSyncDirConflict(linkObj.getCatConflict()); //take over category conflict + linkObj.setSyncDirConflict(getCategoryDescription(linkObj)); //take over category conflict else linkObj.setSyncDir(dirCfg.conflict); break; @@ -119,10 +119,6 @@ private: case SYMLINK_EQUAL: linkObj.setSyncDir(SYNC_DIR_NONE); break; - case SYMLINK_DIFFERENT_METADATA: - linkObj.setSyncDir(dirCfg.conflict); //use setting from "conflict/cannot categorize" - break; - } } @@ -139,8 +135,11 @@ private: case DIR_EQUAL: dirObj.setSyncDir(SYNC_DIR_NONE); break; - case DIR_DIFFERENT_METADATA: - dirObj.setSyncDir(dirCfg.conflict); //use setting from "conflict/cannot categorize" + case DIR_DIFFERENT_METADATA: //use setting from "conflict/cannot categorize" + if (dirCfg.conflict == SYNC_DIR_NONE) + dirObj.setSyncDirConflict(getCategoryDescription(dirObj)); //take over category conflict + else + dirObj.setSyncDir(dirCfg.conflict); break; } @@ -171,210 +170,137 @@ struct AllEqual //test if non-equal items exist in scanned data }); //directories } }; - +} bool zen::allElementsEqual(const FolderComparison& folderCmp) { return std::all_of(begin(folderCmp), end(folderCmp), AllEqual()); } -//--------------------------------------------------------------------------------------------------------------- +//--------------------------------------------------------------------------------------------------------------- -class DataSetFile +namespace { -public: - DataSetFile() {} +template <SelectedSide side> inline +const FileDescriptor& getDescriptor(const InSyncFile& dbFile) { return dbFile.left; } - DataSetFile(const Zstring& name, const FileDescriptor& fileDescr) - { - shortName = name; - lastWriteTime = fileDescr.lastWriteTimeRaw; - fileSize = fileDescr.fileSize; - } +template <> inline +const FileDescriptor& getDescriptor<RIGHT_SIDE>(const InSyncFile& dbFile) { return dbFile.right; } - DataSetFile(const FileMapping& fileObj, Int2Type<LEFT_SIDE>) - { - init<LEFT_SIDE>(fileObj); - } - DataSetFile(const FileMapping& fileObj, Int2Type<RIGHT_SIDE>) - { - init<RIGHT_SIDE>(fileObj); - } +//check whether database entry and current item match: *irrespective* of current comparison settings +template <SelectedSide side> inline +bool isEqual(const FileMapping& fileObj, const InSyncDir::FileList::value_type* dbFile) +{ + if (fileObj.isEmpty<side>()) + return !dbFile; + else if (!dbFile) + return false; + + const Zstring& shortNameDb = dbFile->first; + const FileDescriptor& descrDb = getDescriptor<side>(dbFile->second); + + return fileObj.getShortName<side>() == shortNameDb && //detect changes in case (windows) + //respect 2 second FAT/FAT32 precision! copying a file to a FAT32 drive changes it's modification date by up to 2 seconds + sameFileTime(fileObj.getLastWriteTime<side>(), descrDb.lastWriteTimeRaw, 2) && + fileObj.getFileSize<side>() == descrDb.fileSize; + //note: we do *not* consider FileId here, but are only interested in *visual* changes. Consider user moving data to some other medium, this is not a change! +} - inline friend - bool operator==(const DataSetFile& lhs, const DataSetFile& rhs) - { - if (lhs.shortName.empty()) - return rhs.shortName.empty(); - else if (rhs.shortName.empty()) - return false; - - return lhs.shortName == rhs.shortName && //detect changes in case (windows) - //respect 2 second FAT/FAT32 precision! copying a file to a FAT32 drive changes it's modification date by up to 2 seconds - sameFileTime(lhs.lastWriteTime, rhs.lastWriteTime, 2) && - lhs.fileSize == rhs.fileSize; - } -private: - template <SelectedSide side> - void init(const FileMapping& fileObj) - { - if (!fileObj.isEmpty<side>()) - { - shortName = fileObj.getShortName<side>(); - lastWriteTime = fileObj.getLastWriteTime<side>(); - fileSize = fileObj.getFileSize<side>(); - } +//check whether database entry is in sync considering *current* comparison settings +inline +bool stillInSync(const InSyncFile& dbFile, CompareVariant compareVar, size_t fileTimeTolerance) +{ + switch (compareVar) + { + case CMP_BY_TIME_SIZE: + return dbFile.inSyncType == InSyncFile::IN_SYNC_BINARY_EQUAL || //special rule: this is already "good enough" for CMP_BY_TIME_SIZE! + //case-sensitive short name match is a database invariant! + (CmpFileTime::getResult(dbFile.left.lastWriteTimeRaw, dbFile.right.lastWriteTimeRaw, fileTimeTolerance) == CmpFileTime::TIME_EQUAL && + dbFile.left.fileSize == dbFile.right.fileSize); + + case CMP_BY_CONTENT: + //case-sensitive short name match is a database invariant! + return dbFile.inSyncType == InSyncFile::IN_SYNC_BINARY_EQUAL; + //in contrast to comparison, we don't care about modification time here! } + assert(false); + return false; +} - Zstring shortName; //empty if object not existing - zen::Int64 lastWriteTime; - zen::UInt64 fileSize; - - //note: we do *not* consider FileId here, but are only interested in *visual* changes. Consider user moving data to some other medium, this is not a change! -}; +//-------------------------------------------------------------------- +template <SelectedSide side> inline +const LinkDescriptor& getDescriptor(const InSyncSymlink& dbLink) { return dbLink.left; } -//-------------------------------------------------------------------- -class DataSetSymlink -{ -public: - DataSetSymlink() -#ifdef FFS_WIN - : type(LinkDescriptor::TYPE_FILE) //dummy value -#endif - {} +template <> inline +const LinkDescriptor& getDescriptor<RIGHT_SIDE>(const InSyncSymlink& dbLink) { return dbLink.right; } - DataSetSymlink(const Zstring& name, const LinkDescriptor& linkDescr) - { - shortName = name; - lastWriteTime = linkDescr.lastWriteTimeRaw; - targetPath = linkDescr.targetPath; -#ifdef FFS_WIN //type of symbolic link is relevant for Windows only - type = linkDescr.type; -#endif - } - DataSetSymlink(const SymLinkMapping& linkObj, Int2Type<LEFT_SIDE>) - { - init<LEFT_SIDE>(linkObj); - } +//check whether database entry and current item match: *irrespective* of current comparison settings +template <SelectedSide side> inline +bool isEqual(const SymLinkMapping& linkObj, const InSyncDir::LinkList::value_type* dbLink) +{ + if (linkObj.isEmpty<side>()) + return !dbLink; + else if (!dbLink) + return false; - DataSetSymlink(const SymLinkMapping& linkObj, Int2Type<RIGHT_SIDE>) - { - init<RIGHT_SIDE>(linkObj); - } + const Zstring& shortNameDb = dbLink->first; + const LinkDescriptor& descrDb = getDescriptor<side>(dbLink->second); - inline friend - bool operator==(const DataSetSymlink& lhs, const DataSetSymlink& rhs) - { - if (lhs.shortName.empty()) //test if object is existing at all - return rhs.shortName.empty(); - else if (rhs.shortName.empty()) - return false; - - return lhs.shortName == rhs.shortName && - //respect 2 second FAT/FAT32 precision! copying a file to a FAT32 drive changes it's modification date by up to 2 seconds - sameFileTime(lhs.lastWriteTime, rhs.lastWriteTime, 2) && + return linkObj.getShortName<side>() == shortNameDb && + //respect 2 second FAT/FAT32 precision! copying a file to a FAT32 drive changes it's modification date by up to 2 seconds + sameFileTime(linkObj.getLastWriteTime<side>(), descrDb.lastWriteTimeRaw, 2) && #ifdef FFS_WIN //comparison of symbolic link type is relevant for Windows only - lhs.type == rhs.type && + linkObj.getLinkType<side>() == descrDb.type && #endif - lhs.targetPath == rhs.targetPath; - } + linkObj.getTargetPath<side>() == descrDb.targetPath; +} -private: - template <SelectedSide side> - void init(const SymLinkMapping& linkObj) - { -#ifdef FFS_WIN - type = LinkDescriptor::TYPE_FILE; //always initialize -#endif - if (!linkObj.isEmpty<side>()) - { - shortName = linkObj.getShortName<side>(); - lastWriteTime = linkObj.getLastWriteTime<side>(); - targetPath = linkObj.getTargetPath<side>(); +//check whether database entry is in sync considering *current* comparison settings +inline +bool stillInSync(const InSyncSymlink& dbLink, CompareVariant compareVar) +{ + return !dbLink.left .targetPath.empty() && //if one of these is empty, we can't make a statement whether both sides are in sync + !dbLink.right.targetPath.empty() && // #ifdef FFS_WIN //type of symbolic link is relevant for Windows only - type = linkObj.getLinkType<side>(); + dbLink.left.type == dbLink.right.type && #endif - } - } + dbLink.left.targetPath == dbLink.right.targetPath; + //case-sensitive short name match is a database invariant! + //in contrast to comparison, we don't care about modification time! +} - Zstring shortName; //empty if object not existing - zen::Int64 lastWriteTime; - Zstring targetPath; -#ifdef FFS_WIN - LinkDescriptor::LinkType type; -#endif -}; //-------------------------------------------------------------------- - -class DataSetDir +//check whether database entry and current item match: *irrespective* of current comparison settings +template <SelectedSide side> inline +bool isEqual(const DirMapping& dirObj, const InSyncDir::DirList::value_type* dbDir) { -public: - DataSetDir() {} - - DataSetDir(const Zstring& name) : - shortName(name) {} + if (dirObj.isEmpty<side>()) + return !dbDir || dbDir->second.status == InSyncDir::STATUS_STRAW_MAN; + else if (!dbDir || dbDir->second.status == InSyncDir::STATUS_STRAW_MAN) + return false; - DataSetDir(const DirMapping& dirObj, Int2Type<LEFT_SIDE>) : - shortName(dirObj.getShortName<LEFT_SIDE>()) {} + const Zstring& shortNameDb = dbDir->first; - DataSetDir(const DirMapping& dirObj, Int2Type<RIGHT_SIDE>) : - shortName(dirObj.getShortName<RIGHT_SIDE>()) {} - - inline friend - bool operator==(const DataSetDir& lhs, const DataSetDir& rhs) - { - return lhs.shortName == rhs.shortName; - } - -private: - Zstring shortName; //empty if object not existing -}; -//-------------------------------------------------------------------------------------------------------- - -DataSetFile retrieveDataSetFile(const Zstring& objShortName, const DirContainer* dbDirectory) -{ - if (dbDirectory) - { - DirContainer::FileList::const_iterator iter = dbDirectory->files.find(objShortName); - if (iter != dbDirectory->files.end()) - return DataSetFile(iter->first, iter->second); - } - - return DataSetFile(); //object not found -} - -DataSetSymlink retrieveDataSetSymlink(const Zstring& objShortName, const DirContainer* dbDirectory) -{ - if (dbDirectory) - { - DirContainer::LinkList::const_iterator iter = dbDirectory->links.find(objShortName); - if (iter != dbDirectory->links.end()) - return DataSetSymlink(iter->first, iter->second); - } - - return DataSetSymlink(); //object not found + return dirObj.getShortName<side>() == shortNameDb; } -std::pair<DataSetDir, const DirContainer*> retrieveDataSetDir(const Zstring& objShortName, const DirContainer* dbDirectory) +inline +bool stillInSync(const InSyncDir& dbDir) { - if (dbDirectory) - { - DirContainer::DirList::const_iterator iter = dbDirectory->dirs.find(objShortName); - if (iter != dbDirectory->dirs.end()) - return std::make_pair(DataSetDir(iter->first), &iter->second); - } - - return std::make_pair(DataSetDir(), nullptr); //object not found + //case-sensitive short name match is a database invariant! + //InSyncDir::STATUS_STRAW_MAN considered + return true; } //---------------------------------------------------------------------------------------------- + class RedetermineAuto { public: @@ -387,17 +313,17 @@ private: RedetermineAuto(BaseDirMapping& baseDirectory, std::function<void(const std::wstring&)> reportWarning) : txtBothSidesChanged(_("Both sides have changed since last synchronization!")), txtNoSideChanged(_("Cannot determine sync-direction:") + L" \n" + _("No change since last synchronization!")), - txtFilterChanged(_("Cannot determine sync-direction:") + L" \n" + _("Filter settings have changed!")), - txtLastSyncFail (_("Cannot determine sync-direction:") + L" \n" + _("The file was not processed by last synchronization!")), + txtDbNotInSync(_("Cannot determine sync-direction:") + L" \n" + _("The corresponding database entries are not in sync considering current settings.")), + cmpVar(baseDirectory.getCompVariant()), + fileTimeTolerance(baseDirectory.getFileTimeTolerance()), reportWarning_(reportWarning) { if (AllEqual()(baseDirectory)) //nothing to do: abort and don't show any nag-screens return; //try to load sync-database files - std::pair<DirInfoPtr, DirInfoPtr> dirInfo = loadDBFile(baseDirectory); - if (dirInfo.first.get() == nullptr || - dirInfo.second.get() == nullptr) + std::shared_ptr<InSyncDir> lastSyncState = loadDBFile(baseDirectory); + if (!lastSyncState) { //set conservative "two-way" directions DirectionSet twoWayCfg = getTwoWaySet(); @@ -406,48 +332,24 @@ private: return; } - const DirInformation& dirInfoLeft = *dirInfo.first; - const DirInformation& dirInfoRight = *dirInfo.second; - //-> considering filter not relevant: //if narrowing filter: all ok; if widening filter (if file ex on both sides -> conflict, fine; if file ex. on one side: copy to other side: fine) - /* - //save db filter (if it needs to be considered only): - if (respectFiltering(baseDirectory, dirInfoLeft)) - dbFilterLeft = dirInfoLeft.filter.get(); - - if (respectFiltering(baseDirectory, dirInfoRight)) - dbFilterRight = dirInfoRight.filter.get(); - */ - recurse(baseDirectory, - &dirInfoLeft.baseDirContainer, - &dirInfoRight.baseDirContainer); + + recurse(baseDirectory, &*lastSyncState); //----------- detect renamed files ----------------- if (!exLeftOnly.empty() && !exRightOnly.empty()) { - findEqualDbEntries(dirInfoLeft .baseDirContainer, //fill map "onceEqual" - dirInfoRight.baseDirContainer); - + collectEqualDbEntries(*lastSyncState); //fill map "onceEqual" detectRenamedFiles(); } } - /* - static bool respectFiltering(const BaseDirMapping& baseDirectory, const DirInformation& dirInfo) - { - //respect filtering if sync-DB filter is active && different from baseDir's filter: - // in all other cases "view on files" is smaller for baseDirectory(current) than it was for dirInfo(old) - // => dirInfo can be queried as if it were a scan without filters - return !dirInfo.filter->isNull() && *dirInfo.filter != *baseDirectory.getFilter(); - } - */ - - std::pair<DirInfoPtr, DirInfoPtr> loadDBFile(const BaseDirMapping& baseDirectory) //return nullptr on failure + std::shared_ptr<InSyncDir> loadDBFile(const BaseDirMapping& baseMap) //return nullptr on failure { try { - return loadFromDisk(baseDirectory); + return loadLastSynchronousState(baseMap); //throw FileError, FileErrorDatabaseNotExisting } catch (FileErrorDatabaseNotExisting&) {} //let's ignore these errors for now... catch (FileError& error) //e.g. incompatible database version @@ -455,43 +357,17 @@ private: reportWarning_(error.toString() + L" \n\n" + _("Setting default synchronization directions: Old files will be overwritten with newer files.")); } - return std::pair<DirInfoPtr, DirInfoPtr>(); + return nullptr; } - /* - bool filterFileConflictFound(const Zstring& relativeName) const - { - //if filtering would have excluded file during database creation, then we can't say anything about its former state - return (dbFilterLeft && !dbFilterLeft ->passFileFilter(relativeName)) || - (dbFilterRight && !dbFilterRight->passFileFilter(relativeName)); - } - - - bool filterDirConflictFound(const Zstring& relativeName) const - { - //if filtering would have excluded directory during database creation, then we can't say anything about its former state - return (dbFilterLeft && !dbFilterLeft ->passDirFilter(relativeName, nullptr)) || - (dbFilterRight && !dbFilterRight->passDirFilter(relativeName, nullptr)); - } - */ - - void recurse(HierarchyObject& hierObj, - const DirContainer* dbDirectoryLeft, - const DirContainer* dbDirectoryRight) + void recurse(HierarchyObject& hierObj, const InSyncDir* dbContainer) { - std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), - [&](FileMapping& fileMap) { processFile(fileMap, dbDirectoryLeft, dbDirectoryRight); }); - - std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), - [&](SymLinkMapping& linkMap) { processSymlink(linkMap, dbDirectoryLeft, dbDirectoryRight); }); - - std::for_each(hierObj.refSubDirs().begin(), hierObj.refSubDirs().end(), - [&](DirMapping& dirMap) { processDir(dirMap, dbDirectoryLeft, dbDirectoryRight); }); + std::for_each(hierObj.refSubFiles().begin(), hierObj.refSubFiles().end(), [&](FileMapping& fileMap) { processFile (fileMap, dbContainer); }); + std::for_each(hierObj.refSubLinks().begin(), hierObj.refSubLinks().end(), [&](SymLinkMapping& linkMap) { processSymlink(linkMap, dbContainer); }); + std::for_each(hierObj.refSubDirs ().begin(), hierObj.refSubDirs ().end(), [&](DirMapping& dirMap) { processDir (dirMap, dbContainer); }); } - void processFile(FileMapping& fileObj, - const DirContainer* dbDirectoryLeft, - const DirContainer* dbDirectoryRight) + void processFile(FileMapping& fileObj, const InSyncDir* dbContainer) { const CompareFilesResult cat = fileObj.getCategory(); if (cat == FILE_EQUAL) @@ -511,245 +387,138 @@ private: //---------------------------------------------------------------------- //##################### schedule old temporary files for deletion #################### - if (cat == FILE_LEFT_SIDE_ONLY && endsWith(fileObj.getShortName<LEFT_SIDE>(), zen::TEMP_FILE_ENDING)) + if (cat == FILE_LEFT_SIDE_ONLY && endsWith(fileObj.getShortName<LEFT_SIDE>(), TEMP_FILE_ENDING)) { fileObj.setSyncDir(SYNC_DIR_LEFT); return; } - else if (cat == FILE_RIGHT_SIDE_ONLY && endsWith(fileObj.getShortName<RIGHT_SIDE>(), zen::TEMP_FILE_ENDING)) + else if (cat == FILE_RIGHT_SIDE_ONLY && endsWith(fileObj.getShortName<RIGHT_SIDE>(), TEMP_FILE_ENDING)) { fileObj.setSyncDir(SYNC_DIR_RIGHT); return; } //#################################################################################### - /* - if (filterFileConflictFound(fileObj.getObjRelativeName())) - { - if (cat == FILE_LEFT_SIDE_ONLY) - fileObj.setSyncDir(SYNC_DIR_RIGHT); - else if (cat == FILE_RIGHT_SIDE_ONLY) - fileObj.setSyncDir(SYNC_DIR_LEFT); - else - fileObj.setSyncDirConflict(txtFilterChanged); - return; - } - */ - - //determine datasets for change detection - const DataSetFile dataDbLeft = retrieveDataSetFile(fileObj.getObjShortName(), dbDirectoryLeft); - const DataSetFile dataDbRight = retrieveDataSetFile(fileObj.getObjShortName(), dbDirectoryRight); - - const DataSetFile dataCurrentLeft (fileObj, Int2Type<LEFT_SIDE >()); - const DataSetFile dataCurrentRight(fileObj, Int2Type<RIGHT_SIDE>()); + //try to find corresponding database entry + const InSyncDir::FileList::value_type* dbEntry = nullptr; + if (dbContainer) + { + auto iter = dbContainer->files.find(fileObj.getObjShortName()); + if (iter != dbContainer->files.end()) + dbEntry = &*iter; + } //evaluation - const bool changeOnLeft = dataDbLeft != dataCurrentLeft; - const bool changeOnRight = dataDbRight != dataCurrentRight; + const bool changeOnLeft = !isEqual<LEFT_SIDE >(fileObj, dbEntry); + const bool changeOnRight = !isEqual<RIGHT_SIDE>(fileObj, dbEntry); - if (dataDbLeft == dataDbRight) //we have a "last synchronous state" => last sync seems to have been successful + if (changeOnLeft != changeOnRight) { - if (changeOnLeft) - { - if (changeOnRight) - fileObj.setSyncDirConflict(txtBothSidesChanged); - else - fileObj.setSyncDir(SYNC_DIR_RIGHT); - } + //if database entry not in sync according to current settings! -> do not set direction based on async status! + if (dbEntry && !stillInSync(dbEntry->second, cmpVar, fileTimeTolerance)) + fileObj.setSyncDirConflict(txtDbNotInSync); else - { - if (changeOnRight) - fileObj.setSyncDir(SYNC_DIR_LEFT); - else - fileObj.setSyncDirConflict(txtNoSideChanged); - } + fileObj.setSyncDir(changeOnLeft ? SYNC_DIR_RIGHT : SYNC_DIR_LEFT); } - else //object did not complete last sync: important check: user may have changed comparison variant, so what was in sync according to last variant is not any longer! + else { - if (changeOnLeft && changeOnRight) + if (changeOnLeft) fileObj.setSyncDirConflict(txtBothSidesChanged); else - { - // if (cat == FILE_LEFT_SIDE_ONLY) - // fileObj.setSyncDir(SYNC_DIR_RIGHT); - // else if (cat == FILE_RIGHT_SIDE_ONLY) - // fileObj.setSyncDir(SYNC_DIR_LEFT); - // else - fileObj.setSyncDirConflict(txtLastSyncFail); - } + fileObj.setSyncDirConflict(txtNoSideChanged); } } - - void processSymlink(SymLinkMapping& linkObj, - const DirContainer* dbDirectoryLeft, - const DirContainer* dbDirectoryRight) + void processSymlink(SymLinkMapping& linkObj, const InSyncDir* dbContainer) { const CompareSymlinkResult cat = linkObj.getLinkCategory(); if (cat == SYMLINK_EQUAL) return; - /* - if (filterFileConflictFound(linkObj.getObjRelativeName())) //always use file filter: Link type may not be "stable" on Linux! - { - if (cat == SYMLINK_LEFT_SIDE_ONLY) - linkObj.setSyncDir(SYNC_DIR_RIGHT); - else if (cat == SYMLINK_RIGHT_SIDE_ONLY) - linkObj.setSyncDir(SYNC_DIR_LEFT); - else - linkObj.setSyncDirConflict(txtFilterChanged); - return; - } - */ - - //determine datasets for change detection - const DataSetSymlink dataDbLeft = retrieveDataSetSymlink(linkObj.getObjShortName(), dbDirectoryLeft); - const DataSetSymlink dataDbRight = retrieveDataSetSymlink(linkObj.getObjShortName(), dbDirectoryRight); - - const DataSetSymlink dataCurrentLeft( linkObj, Int2Type<LEFT_SIDE>()); - const DataSetSymlink dataCurrentRight(linkObj, Int2Type<RIGHT_SIDE>()); + //try to find corresponding database entry + const InSyncDir::LinkList::value_type* dbEntry = nullptr; + if (dbContainer) + { + auto iter = dbContainer->symlinks.find(linkObj.getObjShortName()); + if (iter != dbContainer->symlinks.end()) + dbEntry = &*iter; + } //evaluation - const bool changeOnLeft = dataDbLeft != dataCurrentLeft; - const bool changeOnRight = dataDbRight != dataCurrentRight; + const bool changeOnLeft = !isEqual<LEFT_SIDE >(linkObj, dbEntry); + const bool changeOnRight = !isEqual<RIGHT_SIDE>(linkObj, dbEntry); - if (dataDbLeft == dataDbRight) //last sync seems to have been successful + if (changeOnLeft != changeOnRight) { - if (changeOnLeft) - { - if (changeOnRight) - linkObj.setSyncDirConflict(txtBothSidesChanged); - else - linkObj.setSyncDir(SYNC_DIR_RIGHT); - } + //if database entry not in sync according to current settings! -> do not set direction based on async status! + if (dbEntry && !stillInSync(dbEntry->second, cmpVar)) + linkObj.setSyncDirConflict(txtDbNotInSync); else - { - if (changeOnRight) - linkObj.setSyncDir(SYNC_DIR_LEFT); - else - linkObj.setSyncDirConflict(txtNoSideChanged); - } + linkObj.setSyncDir(changeOnLeft ? SYNC_DIR_RIGHT : SYNC_DIR_LEFT); } - else //object did not complete last sync + else { - if (changeOnLeft && changeOnRight) + if (changeOnLeft) linkObj.setSyncDirConflict(txtBothSidesChanged); else - linkObj.setSyncDirConflict(txtLastSyncFail); + linkObj.setSyncDirConflict(txtNoSideChanged); } } - - void processDir(DirMapping& dirObj, - const DirContainer* dbDirectoryLeft, - const DirContainer* dbDirectoryRight) + void processDir(DirMapping& dirObj, const InSyncDir* dbContainer) { const CompareDirResult cat = dirObj.getDirCategory(); - /* - if (filterDirConflictFound(dirObj.getObjRelativeName())) - { - switch (cat) - { - case DIR_LEFT_SIDE_ONLY: - dirObj.setSyncDir(SYNC_DIR_RIGHT); - break; - case DIR_RIGHT_SIDE_ONLY: - dirObj.setSyncDir(SYNC_DIR_LEFT); - break; - case DIR_EQUAL: - ; - } - - SetDirChangedFilter().recurse(dirObj); //filter issue for this directory => treat subfiles/-dirs the same - return; - } - */ - //determine datasets for change detection - const std::pair<DataSetDir, const DirContainer*> dataDbLeftStuff = retrieveDataSetDir(dirObj.getObjShortName(), dbDirectoryLeft); - const std::pair<DataSetDir, const DirContainer*> dataDbRightStuff = retrieveDataSetDir(dirObj.getObjShortName(), dbDirectoryRight); + //try to find corresponding database entry + const InSyncDir::DirList::value_type* dbEntry = nullptr; + if (dbContainer) + { + auto iter = dbContainer->dirs.find(dirObj.getObjShortName()); + if (iter != dbContainer->dirs.end()) + dbEntry = &*iter; + } if (cat != DIR_EQUAL) { - const DataSetDir dataCurrentLeft( dirObj, Int2Type<LEFT_SIDE>()); - const DataSetDir dataCurrentRight(dirObj, Int2Type<RIGHT_SIDE>()); - //evaluation - const bool changeOnLeft = dataDbLeftStuff.first != dataCurrentLeft; - const bool changeOnRight = dataDbRightStuff.first != dataCurrentRight; + const bool changeOnLeft = !isEqual<LEFT_SIDE >(dirObj, dbEntry); + const bool changeOnRight = !isEqual<RIGHT_SIDE>(dirObj, dbEntry); - if (dataDbLeftStuff.first == dataDbRightStuff.first) //last sync seems to have been successful + if (changeOnLeft != changeOnRight) { - if (changeOnLeft) - { - if (changeOnRight) - dirObj.setSyncDirConflict(txtBothSidesChanged); - else - dirObj.setSyncDir(SYNC_DIR_RIGHT); - } + //if database entry not in sync according to current settings! -> do not set direction based on async status! + if (dbEntry && !stillInSync(dbEntry->second)) + dirObj.setSyncDirConflict(txtDbNotInSync); else - { - if (changeOnRight) - dirObj.setSyncDir(SYNC_DIR_LEFT); - else - { - assert(false); - dirObj.setSyncDirConflict(txtNoSideChanged); - } - } + dirObj.setSyncDir(changeOnLeft ? SYNC_DIR_RIGHT : SYNC_DIR_LEFT); } - else //object did not complete last sync + else { - if (changeOnLeft && changeOnRight) + if (changeOnLeft) dirObj.setSyncDirConflict(txtBothSidesChanged); else - { - // switch (cat) - // { - // case DIR_LEFT_SIDE_ONLY: - // dirObj.setSyncDir(SYNC_DIR_RIGHT); - // break; - // case DIR_RIGHT_SIDE_ONLY: - // dirObj.setSyncDir(SYNC_DIR_LEFT); - // break; - // case DIR_EQUAL: - // assert(false); - // } - - dirObj.setSyncDirConflict(txtLastSyncFail); - } + dirObj.setSyncDirConflict(txtNoSideChanged); } } - recurse(dirObj, dataDbLeftStuff.second, dataDbRightStuff.second); //recursion + recurse(dirObj, dbEntry ? &dbEntry->second : nullptr); //recursion } - - void findEqualDbEntries(const DirContainer& dbDirectoryLeft, - const DirContainer& dbDirectoryRight) + void collectEqualDbEntries(const InSyncDir& container) { //note: we cannot integrate this traversal into "recurse()" since it may take a *slightly* different path: e.g. file renamed on both sides - std::for_each(dbDirectoryLeft.files.begin(), dbDirectoryLeft.files.end(), - [&](const DirContainer::FileList::value_type& entryLeft) + std::for_each(container.files.begin(), container.files.end(), + [&](const std::pair<Zstring, InSyncFile>& filePair) { - auto iterRight = dbDirectoryRight.files.find(entryLeft.first); - if (iterRight != dbDirectoryRight.files.end()) - { - if (entryLeft. second.id != FileId() && - iterRight->second.id != FileId() && - DataSetFile(entryLeft.first, entryLeft.second) == DataSetFile(iterRight->first, iterRight->second)) - onceEqual.insert(std::make_pair(getFileIdKey(entryLeft.second), getFileIdKey(iterRight->second))); - } + if (filePair.second.left .id != FileId() && + filePair.second.right.id != FileId() && + stillInSync(filePair.second, cmpVar, fileTimeTolerance)) + onceEqual.insert(std::make_pair(getFileIdKey(filePair.second.left), getFileIdKey(filePair.second.right))); }); - std::for_each(dbDirectoryLeft.dirs.begin(), dbDirectoryLeft.dirs.end(), - [&](const DirContainer::DirList::value_type& entryLeft) - { - auto iterRight = dbDirectoryRight.dirs.find(entryLeft.first); - if (iterRight != dbDirectoryRight.dirs.end()) - findEqualDbEntries(entryLeft.second, iterRight->second); - }); + std::for_each(container.dirs.begin(), container.dirs.end(), + [&](const std::pair<Zstring, InSyncDir>& dirPair) { collectEqualDbEntries(dirPair.second); }); } typedef std::tuple<Int64, UInt64, FileId> FileIdKey; //(date, size, file ID) @@ -793,11 +562,12 @@ private: }); } - const std::wstring txtBothSidesChanged; const std::wstring txtNoSideChanged; - const std::wstring txtFilterChanged; - const std::wstring txtLastSyncFail; + const std::wstring txtDbNotInSync; + + const CompareVariant cmpVar; + const size_t fileTimeTolerance; std::function<void(const std::wstring&)> reportWarning_; @@ -849,12 +619,31 @@ private: FAT caveat: File Ids are generally not stable when file is either moved or renamed! => 1. Move/rename operations on FAT cannot be detected reliably. - => 2. database generally contains wrong file ID on FAT after renaming from .ffs_tmp files => correct file Ids in database after next sync + => 2. database generally contains wrong file ID on FAT after renaming from .ffs_tmp files => correct file Ids in database only after next sync + => 3. even exFAT screws up (but less than FAT) and changes IDs after file move. Did they learn nothing from the past? + + Possible refinement + ------------------- + If the file ID is wrong (FAT) or not available, we could at least allow direct association by name, instead of breaking the chain completely: support NTFS -> FAT + + 1. find equal entries in database: + std::hash_map: DB* |-> DB* onceEqual + + 2. build alternative mappings if file Id is available for database entries: + std::map: FielId |-> DB* leftIdToDbRight + std::map: FielId |-> DB* rightIdToDbRight + + 3. collect files on one side during determination of sync directions: + std::vector<FileMapping*, DB*> exLeftOnlyToDbRight -> first try to use file Id, if failed associate via file name instead + std::hash_map<DB*, FileMapping*> dbRightToexRightOnly -> + + 4. find renamed pairs */ }; - +} //--------------------------------------------------------------------------------------------------------------- + std::vector<DirectionConfig> zen::extractDirectionCfg(const MainConfiguration& mainCfg) { //merge first and additional pairs @@ -1415,7 +1204,7 @@ void deleteFromGridAndHDOneSide(InputIterator first, InputIterator last, { if (useRecycleBin) { - if (zen::moveToRecycleBin(fsObj.getFullName<side>())) //throw FileError + if (zen::recycleOrDelete(fsObj.getFullName<side>())) //throw FileError statusHandler.notifyDeletion(fsObj.getFullName<side>()); } else |