Merge pull request #2 from derrickstolee/dstolee/case-rename-fixes

Address review of case-rename support: ordering, rollback, observability, performance, tests

Author: erickulcyk

GVFS/FastFetch/CheckoutStage.cs

@@ -175,22 +175,7 @@ private void HandleAllDirectoryOperations()
                         {
                             if (treeOp.SourcePath != null)
                             {
-                                // Case-only rename: rename the directory from old casing to new casing
-                                string absoluteSourcePath = Path.Combine(this.enlistment.WorkingDirectoryBackingRoot, treeOp.SourcePath);
-                                if (Directory.Exists(absoluteSourcePath))
-                                {
-                                    // Directory.Move throws IOException for case-only renames,
-                                    // so use a two-step rename through a temporary name.
-                                    string tempPath = absoluteTargetPath.TrimEnd(Path.DirectorySeparatorChar) + "_caseRename_" + Guid.NewGuid().ToString("N");
-                                    Directory.Move(absoluteSourcePath.TrimEnd(Path.DirectorySeparatorChar), tempPath);
-                                    Directory.Move(tempPath, absoluteTargetPath.TrimEnd(Path.DirectorySeparatorChar));
-                                }
-                                else
-                                {
-                                    // Parent directory may have already been renamed, fixing this child's path.
-                                    // Just ensure the directory exists.
-                                    Directory.CreateDirectory(absoluteTargetPath);
-                                }
+                                this.ApplyCaseOnlyDirectoryRename(treeOp, absoluteTargetPath);
                             }
                             else
                             {
@@ -249,6 +234,62 @@ private void HandleAllDirectoryOperations()
             }
         }
 
+        /// <summary>
+        /// Apply a case-only directory rename produced by DiffHelper, where
+        /// <paramref name="treeOp"/>.SourcePath carries the old casing and
+        /// <paramref name="absoluteTargetPath"/> is the new (post-rename) absolute path.
+        ///
+        /// Directory.Move throws IOException for case-only renames on Windows, so the
+        /// rename is performed in two steps through a temporary name. If the second
+        /// move fails the directory is moved back to the original casing so a retry
+        /// sees a consistent working tree.
+        ///
+        /// If the source directory is missing it usually means an outer parent rename
+        /// has already moved the children into place (Windows preserves child casing
+        /// through a parent rename when the children's tree SHAs were unchanged); the
+        /// fallback creates the target directory so the operation is idempotent.
+        /// Exceptions propagate to the caller's existing error handler.
+        /// </summary>
+        private void ApplyCaseOnlyDirectoryRename(DiffTreeResult treeOp, string absoluteTargetPath)
+        {
+            string absoluteSourcePath = Path.Combine(this.enlistment.WorkingDirectoryBackingRoot, treeOp.SourcePath);
+            if (!Directory.Exists(absoluteSourcePath))
+            {
+                Directory.CreateDirectory(absoluteTargetPath);
+                return;
+            }
+
+            string trimmedSourcePath = absoluteSourcePath.TrimEnd(Path.DirectorySeparatorChar);
+            string trimmedTargetPath = absoluteTargetPath.TrimEnd(Path.DirectorySeparatorChar);
+            string tempPath = trimmedTargetPath + "_caseRename_" + Guid.NewGuid().ToString("N");
+
+            Directory.Move(trimmedSourcePath, tempPath);
+            try
+            {
+                Directory.Move(tempPath, trimmedTargetPath);
+            }
+            catch
+            {
+                // The first move succeeded but the second failed. Try to restore the
+                // original casing so a retry starts from a consistent state; if
+                // restoration also fails, the outer catch will log the original
+                // exception and the temp directory will be left behind for manual
+                // recovery.
+                if (Directory.Exists(tempPath) && !Directory.Exists(trimmedSourcePath))
+                {
+                    try
+                    {
+                        Directory.Move(tempPath, trimmedSourcePath);
+                    }
+                    catch
+                    {
+                    }
+                }
+
+                throw;
+            }
+        }
+
         private void HandleAllFileDeleteOperations()
         {
             string path;

GVFS/GVFS.Common/Git/DiffTreeResult.cs

@@ -39,10 +39,16 @@ public enum Operations
         public ushort TargetMode { get; set; }
 
         /// <summary>
-        /// When set, indicates this operation is a case-only rename from SourcePath to TargetPath.
-        /// Used on case-insensitive file systems to carry the old-cased path for directory renames.
+        /// Old-cased path of a case-only directory rename, set by DiffHelper when
+        /// collapsing a Delete+Add pair under the case-insensitive comparer. When
+        /// non-null the operation represents a rename from SourcePath to TargetPath
+        /// and consumers (currently CheckoutStage) must rename the directory on
+        /// disk instead of treating the operation as a plain Add. Always null for
+        /// file operations, Modify, Delete, and non-rename Add entries. The setter
+        /// is intentionally restricted to the assembly so only the parser can
+        /// produce this annotation.
         /// </summary>
-        public string SourcePath { get; set; }
+        public string SourcePath { get; internal set; }
 
         public static DiffTreeResult ParseFromDiffTreeLine(string line)
         {