bisync: fix listings missing concurrent modifications - fixes rclone#8359

nielash · ncw · commit 3b49fd24d4e9 · 2025-02-11T11:21:02.000Z
Before this change, there was a bug affecting listing files when:

- a given bisync run had changes in the 2to1 direction
AND
- the run had NO changes in the 1to2 direction
AND
- at least one of the changed files changed AGAIN during the run
(specifically, after the initial march and before the transfers.)

In this situation, the listings on one side would still retain the prior version
of the changed file, potentially causing conflicts or errors.

This change fixes the issue by making sure that if we're updating the listings
on one side, we must also update the other. (We previously tried to skip it for
efficiency, but this failed to account for the possibility that a changed file
could change again during the run.)
diff --git a/cmd/bisync/bisync_test.go b/cmd/bisync/bisync_test.go
@@ -746,6 +746,16 @@ func (b *bisyncTest) runTestStep(ctx context.Context, line string) (err error) {
 	case "test-func":
 		b.TestFn = testFunc
 		return
+	case "concurrent-func":
+		b.TestFn = func() {
+			src := filepath.Join(b.dataDir, "file7.txt")
+			dst := "file1.txt"
+			err := b.copyFile(ctx, src, b.replaceHex(b.path2), dst)
+			if err != nil {
+				fs.Errorf(src, "error copying file: %v", err)
+			}
+		}
+		return
 	case "fix-names":
 		// in case the local os converted any filenames
 		ci.NoUnicodeNormalization = true
diff --git a/cmd/bisync/deltas.go b/cmd/bisync/deltas.go
@@ -286,7 +286,7 @@ func (b *bisyncRun) findDeltas(fctx context.Context, f fs.Fs, oldListing string,
 }
 
 // applyDeltas
-func (b *bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 *deltaSet) (changes1, changes2 bool, results2to1, results1to2 []Results, queues queues, err error) {
+func (b *bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 *deltaSet) (results2to1, results1to2 []Results, queues queues, err error) {
 	path1 := bilib.FsPath(b.fs1)
 	path2 := bilib.FsPath(b.fs2)
 
@@ -367,7 +367,7 @@ func (b *bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 *deltaSet) (change
 		}
 	}
 
-	//if there are potential conflicts to check, check them all here (outside the loop) in one fell swoop
+	// if there are potential conflicts to check, check them all here (outside the loop) in one fell swoop
 	matches, err := b.checkconflicts(ctxCheck, filterCheck, b.fs1, b.fs2)
 
 	for _, file := range ds1.sort() {
@@ -392,7 +392,7 @@ func (b *bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 *deltaSet) (change
 			} else if d2.is(deltaOther) {
 				b.indent("!WARNING", file, "New or changed in both paths")
 
-				//if files are identical, leave them alone instead of renaming
+				// if files are identical, leave them alone instead of renaming
 				if (dirs1.has(file) || dirs1.has(alias)) && (dirs2.has(file) || dirs2.has(alias)) {
 					fs.Infof(nil, "This is a directory, not a file. Skipping equality check and will not rename: %s", file)
 					ls1.getPut(file, skippedDirs1)
@@ -486,7 +486,6 @@ func (b *bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 *deltaSet) (change
 
 	// Do the batch operation
 	if copy2to1.NotEmpty() && !b.InGracefulShutdown {
-		changes1 = true
 		b.indent("Path2", "Path1", "Do queued copies to")
 		ctx = b.setBackupDir(ctx, 1)
 		results2to1, err = b.fastCopy(ctx, b.fs2, b.fs1, copy2to1, "copy2to1")
@@ -498,12 +497,11 @@ func (b *bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 *deltaSet) (change
 			return
 		}
 
-		//copy empty dirs from path2 to path1 (if --create-empty-src-dirs)
+		// copy empty dirs from path2 to path1 (if --create-empty-src-dirs)
 		b.syncEmptyDirs(ctx, b.fs1, copy2to1, dirs2, &results2to1, "make")
 	}
 
 	if copy1to2.NotEmpty() && !b.InGracefulShutdown {
-		changes2 = true
 		b.indent("Path1", "Path2", "Do queued copies to")
 		ctx = b.setBackupDir(ctx, 2)
 		results1to2, err = b.fastCopy(ctx, b.fs1, b.fs2, copy1to2, "copy1to2")
@@ -515,23 +513,23 @@ func (b *bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 *deltaSet) (change
 			return
 		}
 
-		//copy empty dirs from path1 to path2 (if --create-empty-src-dirs)
+		// copy empty dirs from path1 to path2 (if --create-empty-src-dirs)
 		b.syncEmptyDirs(ctx, b.fs2, copy1to2, dirs1, &results1to2, "make")
 	}
 
 	if delete1.NotEmpty() && !b.InGracefulShutdown {
 		if err = b.saveQueue(delete1, "delete1"); err != nil {
 			return
 		}
-		//propagate deletions of empty dirs from path2 to path1 (if --create-empty-src-dirs)
+		// propagate deletions of empty dirs from path2 to path1 (if --create-empty-src-dirs)
 		b.syncEmptyDirs(ctx, b.fs1, delete1, dirs1, &results2to1, "remove")
 	}
 
 	if delete2.NotEmpty() && !b.InGracefulShutdown {
 		if err = b.saveQueue(delete2, "delete2"); err != nil {
 			return
 		}
-		//propagate deletions of empty dirs from path1 to path2 (if --create-empty-src-dirs)
+		// propagate deletions of empty dirs from path1 to path2 (if --create-empty-src-dirs)
 		b.syncEmptyDirs(ctx, b.fs2, delete2, dirs2, &results1to2, "remove")
 	}
 
diff --git a/cmd/bisync/operations.go b/cmd/bisync/operations.go
@@ -359,8 +359,6 @@ func (b *bisyncRun) runLocked(octx context.Context) (err error) {
 
 	// Determine and apply changes to Path1 and Path2
 	noChanges := ds1.empty() && ds2.empty()
-	changes1 := false // 2to1
-	changes2 := false // 1to2
 	results2to1 := []Results{}
 	results1to2 := []Results{}
 
@@ -370,7 +368,7 @@ func (b *bisyncRun) runLocked(octx context.Context) (err error) {
 		fs.Infof(nil, "No changes found")
 	} else {
 		fs.Infof(nil, "Applying changes")
-		changes1, changes2, results2to1, results1to2, queues, err = b.applyDeltas(octx, ds1, ds2)
+		results2to1, results1to2, queues, err = b.applyDeltas(octx, ds1, ds2)
 		if err != nil {
 			if b.InGracefulShutdown && (err == context.Canceled || err == accounting.ErrorMaxTransferLimitReachedGraceful || strings.Contains(err.Error(), "context canceled")) {
 				fs.Infof(nil, "Ignoring sync error due to Graceful Shutdown: %v", err)
@@ -395,21 +393,11 @@ func (b *bisyncRun) runLocked(octx context.Context) (err error) {
 	}
 	b.saveOldListings()
 	// save new listings
-	// NOTE: "changes" in this case does not mean this run vs. last run, it means start of this run vs. end of this run.
-	// i.e. whether we can use the March lst-new as this side's lst without modifying it.
 	if noChanges {
 		b.replaceCurrentListings()
 	} else {
-		if changes1 || b.InGracefulShutdown { // 2to1
-			err1 = b.modifyListing(fctx, b.fs2, b.fs1, results2to1, queues, false)
-		} else {
-			err1 = bilib.CopyFileIfExists(b.newListing1, b.listing1)
-		}
-		if changes2 || b.InGracefulShutdown { // 1to2
-			err2 = b.modifyListing(fctx, b.fs1, b.fs2, results1to2, queues, true)
-		} else {
-			err2 = bilib.CopyFileIfExists(b.newListing2, b.listing2)
-		}
+		err1 = b.modifyListing(fctx, b.fs2, b.fs1, results2to1, queues, false) // 2to1
+		err2 = b.modifyListing(fctx, b.fs1, b.fs2, results1to2, queues, true)  // 1to2
 	}
 	if b.DebugName != "" {
 		l1, _ := b.loadListing(b.listing1)
diff --git a/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.copy2to1.que b/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.copy2to1.que
@@ -0,0 +1 @@
+"file1.txt"
diff --git a/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path1.lst b/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path1.lst
@@ -0,0 +1,10 @@
+# bisync listing v1 from test
+-      109 - - 2000-01-01T00:00:00.000000000+0000 "RCLONE_TEST"
+-       19 - - 2023-08-26T00:00:00.000000000+0000 "file1.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file2.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file3.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file4.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file5.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file6.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file7.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file8.txt"
diff --git a/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path1.lst-new b/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path1.lst-new
@@ -0,0 +1,10 @@
+# bisync listing v1 from test
+-      109 - - 2000-01-01T00:00:00.000000000+0000 "RCLONE_TEST"
+-       19 - - 2023-08-26T00:00:00.000000000+0000 "file1.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file2.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file3.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file4.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file5.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file6.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file7.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file8.txt"
diff --git a/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path1.lst-old b/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path1.lst-old
@@ -0,0 +1,10 @@
+# bisync listing v1 from test
+-      109 - - 2000-01-01T00:00:00.000000000+0000 "RCLONE_TEST"
+-       19 - - 2023-08-26T00:00:00.000000000+0000 "file1.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file2.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file3.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file4.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file5.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file6.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file7.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file8.txt"
diff --git a/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path2.lst b/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path2.lst
@@ -0,0 +1,10 @@
+# bisync listing v1 from test
+-      109 - - 2000-01-01T00:00:00.000000000+0000 "RCLONE_TEST"
+-       19 - - 2023-08-26T00:00:00.000000000+0000 "file1.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file2.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file3.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file4.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file5.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file6.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file7.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file8.txt"
diff --git a/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path2.lst-new b/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path2.lst-new
@@ -0,0 +1,10 @@
+# bisync listing v1 from test
+-      109 - - 2000-01-01T00:00:00.000000000+0000 "RCLONE_TEST"
+-       19 - - 2023-08-26T00:00:00.000000000+0000 "file1.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file2.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file3.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file4.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file5.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file6.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file7.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file8.txt"
diff --git a/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path2.lst-old b/cmd/bisync/testdata/test_concurrent/golden/_testdir_path1.._testdir_path2.path2.lst-old
@@ -0,0 +1,10 @@
+# bisync listing v1 from test
+-      109 - - 2000-01-01T00:00:00.000000000+0000 "RCLONE_TEST"
+-       19 - - 2023-08-26T00:00:00.000000000+0000 "file1.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file2.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file3.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file4.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file5.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file6.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file7.txt"
+-        0 - - 2000-01-01T00:00:00.000000000+0000 "file8.txt"
diff --git a/cmd/bisync/testdata/test_concurrent/golden/test.log b/cmd/bisync/testdata/test_concurrent/golden/test.log
@@ -0,0 +1,73 @@
+[36m(01)  :[0m [34mtest concurrent[0m
+
+[36m(02)  :[0m [34mtest initial bisync[0m
+[36m(03)  :[0m [34mbisync resync[0m
+INFO  : [2mSetting --ignore-listing-checksum as neither --checksum nor --compare checksum are set.[0m
+INFO  : Bisyncing with Comparison Settings:
+{
+"Modtime": true,
+"Size": true,
+"Checksum": false,
+"NoSlowHash": false,
+"SlowHashSyncOnly": false,
+"DownloadHash": false
+}
+INFO  : Synching Path1 "{path1/}" with Path2 "{path2/}"
+INFO  : Copying Path2 files to Path1
+INFO  : - [34mPath2[0m    [35mResync is copying files to[0m         - [36mPath1[0m
+INFO  : - [36mPath1[0m    [35mResync is copying files to[0m         - [36mPath2[0m
+INFO  : Resync updating listings
+INFO  : Validating listings for Path1 "{path1/}" vs Path2 "{path2/}"
+INFO  : [32mBisync successful[0m
+
+[36m(04)  :[0m [34mtest changed on one path - file1[0m
+[36m(05)  :[0m [34mtouch-glob 2001-01-02 {datadir/} file5R.txt[0m
+[36m(06)  :[0m [34mtouch-glob 2023-08-26 {datadir/} file7.txt[0m
+[36m(07)  :[0m [34mcopy-as {datadir/}file5R.txt {path2/} file1.txt[0m
+
+[36m(08)  :[0m [34mtest bisync with file changed during[0m
+[36m(09)  :[0m [34mconcurrent-func[0m
+[36m(10)  :[0m [34mbisync[0m
+INFO  : [2mSetting --ignore-listing-checksum as neither --checksum nor --compare checksum are set.[0m
+INFO  : Bisyncing with Comparison Settings:
+{
+"Modtime": true,
+"Size": true,
+"Checksum": false,
+"NoSlowHash": false,
+"SlowHashSyncOnly": false,
+"DownloadHash": false
+}
+INFO  : Synching Path1 "{path1/}" with Path2 "{path2/}"
+INFO  : Building Path1 and Path2 listings
+INFO  : Path1 checking for diffs
+INFO  : Path2 checking for diffs
+INFO  : - [34mPath2[0m    [35m[33mFile changed: [35msize (larger)[0m, [35mtime (newer)[0m[0m[0m - [36mfile1.txt[0m
+INFO  : Path2:    1 changes: [32m   0 new[0m, [33m   1 modified[0m, [31m   0 deleted[0m
+INFO  : ([33mModified[0m: [36m   1 newer[0m, [34m   0 older[0m, [36m   1 larger[0m, [34m   0 smaller[0m)
+INFO  : Applying changes
+INFO  : - [34mPath2[0m    [35m[32mQueue copy to[0m Path1[0m       - [36m{path1/}file1.txt[0m
+INFO  : - [34mPath2[0m    [35mDo queued copies to[0m                - [36mPath1[0m
+INFO  : Updating listings
+INFO  : Validating listings for Path1 "{path1/}" vs Path2 "{path2/}"
+INFO  : [32mBisync successful[0m
+
+[36m(11)  :[0m [34mbisync[0m
+INFO  : [2mSetting --ignore-listing-checksum as neither --checksum nor --compare checksum are set.[0m
+INFO  : Bisyncing with Comparison Settings:
+{
+"Modtime": true,
+"Size": true,
+"Checksum": false,
+"NoSlowHash": false,
+"SlowHashSyncOnly": false,
+"DownloadHash": false
+}
+INFO  : Synching Path1 "{path1/}" with Path2 "{path2/}"
+INFO  : Building Path1 and Path2 listings
+INFO  : Path1 checking for diffs
+INFO  : Path2 checking for diffs
+INFO  : No changes found
+INFO  : Updating listings
+INFO  : Validating listings for Path1 "{path1/}" vs Path2 "{path2/}"
+INFO  : [32mBisync successful[0m
diff --git a/cmd/bisync/testdata/test_concurrent/initial/RCLONE_TEST b/cmd/bisync/testdata/test_concurrent/initial/RCLONE_TEST
@@ -0,0 +1 @@
+This file is used for testing the health of rclone accesses to the local/remote file system.  Do not delete.
diff --git a/cmd/bisync/testdata/test_concurrent/initial/file1.txt b/cmd/bisync/testdata/test_concurrent/initial/file1.txt
diff --git a/cmd/bisync/testdata/test_concurrent/initial/file2.txt b/cmd/bisync/testdata/test_concurrent/initial/file2.txt
diff --git a/cmd/bisync/testdata/test_concurrent/initial/file3.txt b/cmd/bisync/testdata/test_concurrent/initial/file3.txt
diff --git a/cmd/bisync/testdata/test_concurrent/initial/file4.txt b/cmd/bisync/testdata/test_concurrent/initial/file4.txt
diff --git a/cmd/bisync/testdata/test_concurrent/initial/file5.txt b/cmd/bisync/testdata/test_concurrent/initial/file5.txt
diff --git a/cmd/bisync/testdata/test_concurrent/initial/file6.txt b/cmd/bisync/testdata/test_concurrent/initial/file6.txt
diff --git a/cmd/bisync/testdata/test_concurrent/initial/file7.txt b/cmd/bisync/testdata/test_concurrent/initial/file7.txt
diff --git a/cmd/bisync/testdata/test_concurrent/initial/file8.txt b/cmd/bisync/testdata/test_concurrent/initial/file8.txt
diff --git a/cmd/bisync/testdata/test_concurrent/modfiles/dummy.txt b/cmd/bisync/testdata/test_concurrent/modfiles/dummy.txt
diff --git a/cmd/bisync/testdata/test_concurrent/modfiles/file1.txt b/cmd/bisync/testdata/test_concurrent/modfiles/file1.txt
@@ -0,0 +1 @@
+This file is newer
diff --git a/cmd/bisync/testdata/test_concurrent/modfiles/file10.txt b/cmd/bisync/testdata/test_concurrent/modfiles/file10.txt
@@ -0,0 +1 @@
+This file is newer
diff --git a/cmd/bisync/testdata/test_concurrent/modfiles/file11.txt b/cmd/bisync/testdata/test_concurrent/modfiles/file11.txt
@@ -0,0 +1 @@
+This file is newer
diff --git a/cmd/bisync/testdata/test_concurrent/modfiles/file2.txt b/cmd/bisync/testdata/test_concurrent/modfiles/file2.txt
@@ -0,0 +1 @@
+Newer version
diff --git a/cmd/bisync/testdata/test_concurrent/modfiles/file5L.txt b/cmd/bisync/testdata/test_concurrent/modfiles/file5L.txt
@@ -0,0 +1 @@
+This file is newer and not equal to 5R
diff --git a/cmd/bisync/testdata/test_concurrent/modfiles/file5R.txt b/cmd/bisync/testdata/test_concurrent/modfiles/file5R.txt
@@ -0,0 +1 @@
+This file is newer and not equal to 5L
diff --git a/cmd/bisync/testdata/test_concurrent/modfiles/file6.txt b/cmd/bisync/testdata/test_concurrent/modfiles/file6.txt
@@ -0,0 +1 @@
+This file is newer
diff --git a/cmd/bisync/testdata/test_concurrent/modfiles/file7.txt b/cmd/bisync/testdata/test_concurrent/modfiles/file7.txt
@@ -0,0 +1 @@
+This file is newer
diff --git a/cmd/bisync/testdata/test_concurrent/scenario.txt b/cmd/bisync/testdata/test_concurrent/scenario.txt
@@ -0,0 +1,15 @@
+test concurrent
+
+test initial bisync
+bisync resync
+
+test changed on one path - file1
+touch-glob 2001-01-02 {datadir/} file5R.txt
+touch-glob 2023-08-26 {datadir/} file7.txt
+copy-as {datadir/}file5R.txt {path2/} file1.txt
+
+test bisync with file changed during
+concurrent-func
+bisync
+
+bisync
diff --git a/docs/content/bisync.md b/docs/content/bisync.md
@@ -1815,6 +1815,9 @@ about _Unison_ and synchronization in general.
 
 ## Changelog
 
+### `v1.69.1`
+* Fixed an issue causing listings to not capture concurrent modifications under certain conditions
+
 ### `v1.68`
 * Fixed an issue affecting backends that round modtimes to a lower precision.
 

Original file line number	Diff line number	Diff line change
`@@ -286,7 +286,7 @@ func (b *bisyncRun) findDeltas(fctx context.Context, f fs.Fs, oldListing string,`
`286`	`286`	`}`
`287`	`287`
`288`	`288`	`// applyDeltas`
`289`		`-func (b bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 deltaSet) (changes1, changes2 bool, results2to1, results1to2 []Results, queues queues, err error) {`
	`289`	`+func (b bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 deltaSet) (results2to1, results1to2 []Results, queues queues, err error) {`
`290`	`290`	`path1 := bilib.FsPath(b.fs1)`
`291`	`291`	`path2 := bilib.FsPath(b.fs2)`
`292`	`292`
`@@ -367,7 +367,7 @@ func (b bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 deltaSet) (change`
`367`	`367`	`}`
`368`	`368`	`}`
`369`	`369`
`370`		`- //if there are potential conflicts to check, check them all here (outside the loop) in one fell swoop`
	`370`	`+ // if there are potential conflicts to check, check them all here (outside the loop) in one fell swoop`
`371`	`371`	`matches, err := b.checkconflicts(ctxCheck, filterCheck, b.fs1, b.fs2)`
`372`	`372`
`373`	`373`	`for _, file := range ds1.sort() {`
`@@ -392,7 +392,7 @@ func (b bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 deltaSet) (change`
`392`	`392`	`} else if d2.is(deltaOther) {`
`393`	`393`	`b.indent("!WARNING", file, "New or changed in both paths")`
`394`	`394`
`395`		`- //if files are identical, leave them alone instead of renaming`
	`395`	`+ // if files are identical, leave them alone instead of renaming`
`396`	`396`	`if (dirs1.has(file) \|\| dirs1.has(alias)) && (dirs2.has(file) \|\| dirs2.has(alias)) {`
`397`	`397`	`fs.Infof(nil, "This is a directory, not a file. Skipping equality check and will not rename: %s", file)`
`398`	`398`	`ls1.getPut(file, skippedDirs1)`
`@@ -486,7 +486,6 @@ func (b bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 deltaSet) (change`
`486`	`486`
`487`	`487`	`// Do the batch operation`
`488`	`488`	`if copy2to1.NotEmpty() && !b.InGracefulShutdown {`
`489`		`- changes1 = true`
`490`	`489`	`b.indent("Path2", "Path1", "Do queued copies to")`
`491`	`490`	`ctx = b.setBackupDir(ctx, 1)`
`492`	`491`	`results2to1, err = b.fastCopy(ctx, b.fs2, b.fs1, copy2to1, "copy2to1")`
`@@ -498,12 +497,11 @@ func (b bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 deltaSet) (change`
`498`	`497`	`return`
`499`	`498`	`}`
`500`	`499`
`501`		`- //copy empty dirs from path2 to path1 (if --create-empty-src-dirs)`
	`500`	`+ // copy empty dirs from path2 to path1 (if --create-empty-src-dirs)`
`502`	`501`	`b.syncEmptyDirs(ctx, b.fs1, copy2to1, dirs2, &results2to1, "make")`
`503`	`502`	`}`
`504`	`503`
`505`	`504`	`if copy1to2.NotEmpty() && !b.InGracefulShutdown {`
`506`		`- changes2 = true`
`507`	`505`	`b.indent("Path1", "Path2", "Do queued copies to")`
`508`	`506`	`ctx = b.setBackupDir(ctx, 2)`
`509`	`507`	`results1to2, err = b.fastCopy(ctx, b.fs1, b.fs2, copy1to2, "copy1to2")`
`@@ -515,23 +513,23 @@ func (b bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 deltaSet) (change`
`515`	`513`	`return`
`516`	`514`	`}`
`517`	`515`
`518`		`- //copy empty dirs from path1 to path2 (if --create-empty-src-dirs)`
	`516`	`+ // copy empty dirs from path1 to path2 (if --create-empty-src-dirs)`
`519`	`517`	`b.syncEmptyDirs(ctx, b.fs2, copy1to2, dirs1, &results1to2, "make")`
`520`	`518`	`}`
`521`	`519`
`522`	`520`	`if delete1.NotEmpty() && !b.InGracefulShutdown {`
`523`	`521`	`if err = b.saveQueue(delete1, "delete1"); err != nil {`
`524`	`522`	`return`
`525`	`523`	`}`
`526`		`- //propagate deletions of empty dirs from path2 to path1 (if --create-empty-src-dirs)`
	`524`	`+ // propagate deletions of empty dirs from path2 to path1 (if --create-empty-src-dirs)`
`527`	`525`	`b.syncEmptyDirs(ctx, b.fs1, delete1, dirs1, &results2to1, "remove")`
`528`	`526`	`}`
`529`	`527`
`530`	`528`	`if delete2.NotEmpty() && !b.InGracefulShutdown {`
`531`	`529`	`if err = b.saveQueue(delete2, "delete2"); err != nil {`
`532`	`530`	`return`
`533`	`531`	`}`
`534`		`- //propagate deletions of empty dirs from path1 to path2 (if --create-empty-src-dirs)`
	`532`	`+ // propagate deletions of empty dirs from path1 to path2 (if --create-empty-src-dirs)`
`535`	`533`	`b.syncEmptyDirs(ctx, b.fs2, delete2, dirs2, &results1to2, "remove")`
`536`	`534`	`}`
`537`	`535`