();
- environmentVariables["GVFS_UPGRADE_DETERMINISTIC"] = "true";
- ProcessResult result = GitHelpers.InvokeGitAgainstGVFSRepo(
- this.Enlistment.RepoRoot,
- "status",
- environmentVariables,
- removeWaitingMessages: true,
- removeUpgradeMessages: false);
-
- if (!string.IsNullOrEmpty(result.Errors) &&
- result.Errors.Contains("A new version of VFS for Git is available."))
- {
- return true;
- }
-
- return false;
- }
-
- private void VerifyServiceRestartStopsReminder()
- {
- this.CreateUpgradeAvailableMarkerFile();
- this.ReminderMessagingEnabled().ShouldBeTrue("Upgrade marker file did not trigger reminder messaging");
- this.SetUpgradeRing(AlwaysUpToDateRing);
- this.RestartService();
-
- // Wait for sometime so service can detect product is up-to-date and delete left over downloads
- TimeSpan timeToWait = TimeSpan.FromMinutes(1);
- bool reminderMessagingEnabled = true;
- while ((reminderMessagingEnabled = this.ReminderMessagingEnabled()) && timeToWait > TimeSpan.Zero)
- {
- Thread.Sleep(TimeSpan.FromSeconds(5));
- timeToWait = timeToWait.Subtract(TimeSpan.FromSeconds(5));
- }
-
- reminderMessagingEnabled.ShouldBeFalse("Service restart did not stop Upgrade reminder messaging");
- }
-
- private void VerifyUpgradeVerbStopsReminder()
- {
- this.SetUpgradeRing(AlwaysUpToDateRing);
- this.CreateUpgradeAvailableMarkerFile();
- this.ReminderMessagingEnabled().ShouldBeTrue("Marker file did not trigger Upgrade reminder messaging");
- this.RunUpgradeCommand();
- this.ReminderMessagingEnabled().ShouldBeFalse("Upgrade verb did not stop Upgrade reminder messaging");
- }
- }
-}
diff --git a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/MountTests.cs b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/MountTests.cs
index 40e9016ce4..576534d1cc 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/MountTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/MountTests.cs
@@ -1,4 +1,4 @@
-using GVFS.FunctionalTests.FileSystemRunners;
+using GVFS.FunctionalTests.FileSystemRunners;
using GVFS.FunctionalTests.Properties;
using GVFS.FunctionalTests.Should;
using GVFS.FunctionalTests.Tools;
@@ -15,7 +15,6 @@
namespace GVFS.FunctionalTests.Tests.EnlistmentPerFixture
{
[TestFixture]
- [Category(Categories.ExtraCoverage)]
public class MountTests : TestsWithEnlistmentPerFixture
{
private const int GVFSGenericError = 3;
@@ -88,55 +87,6 @@ public void MountSetsCoreHooksPath()
}
}
- [TestCase]
- public void MountMergesLocalPrePostHooksConfig()
- {
- // Create some dummy pre/post command hooks
- string dummyCommandHookBin = "cmd.exe /c exit 0";
-
- // Confirm git is not already using the dummy hooks
- string localGitPreCommandHooks = this.Enlistment.GetVirtualPathTo(".git", "hooks", "pre-command.hooks");
- localGitPreCommandHooks.ShouldBeAFile(this.fileSystem).WithContents().Contains(dummyCommandHookBin).ShouldBeFalse();
-
- string localGitPostCommandHooks = this.Enlistment.GetVirtualPathTo(".git", "hooks", "post-command.hooks");
- localGitPreCommandHooks.ShouldBeAFile(this.fileSystem).WithContents().Contains(dummyCommandHookBin).ShouldBeFalse();
-
- this.Enlistment.UnmountGVFS();
-
- // Create dummy--command.hooks and set them in the local git config
- string dummyPreCommandHooksConfig = Path.Combine(this.Enlistment.EnlistmentRoot, "dummy-pre-command.hooks");
- this.fileSystem.WriteAllText(dummyPreCommandHooksConfig, dummyCommandHookBin);
- string dummyOostCommandHooksConfig = Path.Combine(this.Enlistment.EnlistmentRoot, "dummy-post-command.hooks");
- this.fileSystem.WriteAllText(dummyOostCommandHooksConfig, dummyCommandHookBin);
-
- // Configure the hooks locally
- GitProcess.Invoke(this.Enlistment.RepoRoot, $"config gvfs.clone.default-pre-command {dummyPreCommandHooksConfig}");
- GitProcess.Invoke(this.Enlistment.RepoRoot, $"config gvfs.clone.default-post-command {dummyOostCommandHooksConfig}");
-
- // Mount the repo
- this.Enlistment.MountGVFS();
-
- // .git\hooks\-command.hooks should now contain our local dummy hook
- // The dummy pre-command hooks should appear first, and the post-command hook should appear last
- List mergedPreCommandHooksLines = localGitPreCommandHooks
- .ShouldBeAFile(this.fileSystem)
- .WithContents()
- .Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
- .Where(line => !line.StartsWith("#"))
- .ToList();
- mergedPreCommandHooksLines.Count.ShouldEqual(2, $"Expected 2 lines, actual: {string.Join("\n", mergedPreCommandHooksLines)}");
- mergedPreCommandHooksLines[0].ShouldEqual(dummyCommandHookBin);
-
- List mergedPostCommandHooksLines = localGitPostCommandHooks
- .ShouldBeAFile(this.fileSystem)
- .WithContents()
- .Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
- .Where(line => !line.StartsWith("#"))
- .ToList();
- mergedPostCommandHooksLines.Count.ShouldEqual(2, $"Expected 2 lines, actual: {string.Join("\n", mergedPostCommandHooksLines)}");
- mergedPostCommandHooksLines[1].ShouldEqual(dummyCommandHookBin);
- }
-
[TestCase]
public void MountChangesMountId()
{
@@ -171,14 +121,20 @@ public void MountFailsWhenNoOnDiskVersion()
string tempDatabasePath = versionDatabasePath + "_MountFailsWhenNoOnDiskVersion";
tempDatabasePath.ShouldNotExistOnDisk(this.fileSystem);
- this.fileSystem.MoveFile(versionDatabasePath, tempDatabasePath);
- versionDatabasePath.ShouldNotExistOnDisk(this.fileSystem);
+ try
+ {
+ this.fileSystem.MoveFile(versionDatabasePath, tempDatabasePath);
+ versionDatabasePath.ShouldNotExistOnDisk(this.fileSystem);
- this.MountShouldFail("Failed to upgrade repo disk layout");
+ this.MountShouldFail("Failed to upgrade repo disk layout");
+ }
+ finally
+ {
+ // Move the RepoMetadata database back
+ this.fileSystem.DeleteFile(versionDatabasePath);
+ this.fileSystem.MoveFile(tempDatabasePath, versionDatabasePath);
+ }
- // Move the RepoMetadata database back
- this.fileSystem.DeleteFile(versionDatabasePath);
- this.fileSystem.MoveFile(tempDatabasePath, versionDatabasePath);
tempDatabasePath.ShouldNotExistOnDisk(this.fileSystem);
versionDatabasePath.ShouldBeAFile(this.fileSystem);
@@ -202,14 +158,20 @@ public void MountFailsWhenNoLocalCacheRootInRepoMetadata()
string metadataBackupPath = metadataPath + ".backup";
this.fileSystem.MoveFile(metadataPath, metadataBackupPath);
- this.fileSystem.CreateEmptyFile(metadataPath);
- GVFSHelpers.SaveDiskLayoutVersion(this.Enlistment.DotGVFSRoot, majorVersion, minorVersion);
- GVFSHelpers.SaveGitObjectsRoot(this.Enlistment.DotGVFSRoot, objectsRoot);
-
- this.MountShouldFail("Failed to determine local cache path from repo metadata");
+ try
+ {
+ this.fileSystem.CreateEmptyFile(metadataPath);
+ GVFSHelpers.SaveDiskLayoutVersion(this.Enlistment.DotGVFSRoot, majorVersion, minorVersion);
+ GVFSHelpers.SaveGitObjectsRoot(this.Enlistment.DotGVFSRoot, objectsRoot);
- this.fileSystem.DeleteFile(metadataPath);
- this.fileSystem.MoveFile(metadataBackupPath, metadataPath);
+ this.MountShouldFail(GVFSGenericError, expectedErrorMessage: null);
+ this.LatestGVFSLogShouldContain("Failed to determine local cache path from repo metadata");
+ }
+ finally
+ {
+ this.fileSystem.DeleteFile(metadataPath);
+ this.fileSystem.MoveFile(metadataBackupPath, metadataPath);
+ }
this.Enlistment.MountGVFS();
}
@@ -231,14 +193,20 @@ public void MountFailsWhenNoGitObjectsRootInRepoMetadata()
string metadataBackupPath = metadataPath + ".backup";
this.fileSystem.MoveFile(metadataPath, metadataBackupPath);
- this.fileSystem.CreateEmptyFile(metadataPath);
- GVFSHelpers.SaveDiskLayoutVersion(this.Enlistment.DotGVFSRoot, majorVersion, minorVersion);
- GVFSHelpers.SaveLocalCacheRoot(this.Enlistment.DotGVFSRoot, localCacheRoot);
-
- this.MountShouldFail("Failed to determine git objects root from repo metadata");
+ try
+ {
+ this.fileSystem.CreateEmptyFile(metadataPath);
+ GVFSHelpers.SaveDiskLayoutVersion(this.Enlistment.DotGVFSRoot, majorVersion, minorVersion);
+ GVFSHelpers.SaveLocalCacheRoot(this.Enlistment.DotGVFSRoot, localCacheRoot);
- this.fileSystem.DeleteFile(metadataPath);
- this.fileSystem.MoveFile(metadataBackupPath, metadataPath);
+ this.MountShouldFail(GVFSGenericError, expectedErrorMessage: null);
+ this.LatestGVFSLogShouldContain("Failed to determine git objects root from repo metadata");
+ }
+ finally
+ {
+ this.fileSystem.DeleteFile(metadataPath);
+ this.fileSystem.MoveFile(metadataBackupPath, metadataPath);
+ }
this.Enlistment.MountGVFS();
}
@@ -402,10 +370,16 @@ private void MountShouldFail(int expectedExitCode, string expectedErrorMessage,
processInfo.WorkingDirectory = string.IsNullOrEmpty(mountWorkingDirectory) ? enlistmentRoot : mountWorkingDirectory;
processInfo.UseShellExecute = false;
processInfo.RedirectStandardOutput = true;
+ processInfo.RedirectStandardError = true;
ProcessResult result = ProcessHelper.Run(processInfo);
result.ExitCode.ShouldEqual(expectedExitCode, $"mount exit code was not {expectedExitCode}. Output: {result.Output}");
- result.Output.ShouldContain(expectedErrorMessage);
+
+ if (expectedErrorMessage != null)
+ {
+ string combinedOutput = result.Output + "\n" + result.Errors;
+ combinedOutput.ShouldContain(expectedErrorMessage);
+ }
}
private void MountShouldFail(string expectedErrorMessage, string mountWorkingDirectory = null)
@@ -413,6 +387,33 @@ private void MountShouldFail(string expectedErrorMessage, string mountWorkingDir
this.MountShouldFail(GVFSGenericError, expectedErrorMessage, mountWorkingDirectory);
}
+ private void LatestGVFSLogShouldContain(string expectedMessage)
+ {
+ string logsRoot = this.Enlistment.GVFSLogsRoot;
+ logsRoot.ShouldBeADirectory(this.fileSystem);
+
+ // Mount errors may be in GVFS.Mount's log, not the verb's log.
+ // Search all recent log files for the expected message.
+ string[] logFiles = Directory.GetFiles(logsRoot, "*.log");
+ logFiles.Length.ShouldBeAtLeast(1, "No GVFS log files found in " + logsRoot);
+
+ foreach (string logFile in logFiles)
+ {
+ string contents = File.ReadAllText(logFile);
+ if (contents.Contains(expectedMessage))
+ {
+ return;
+ }
+ }
+
+ // Not found in any log — fail with the contents of the most recent log for diagnostics
+ string latestLog = logFiles
+ .OrderByDescending(f => File.GetLastWriteTimeUtc(f))
+ .First();
+ string latestContents = File.ReadAllText(latestLog);
+ latestContents.ShouldContain(expectedMessage);
+ }
+
private class MountSubfolders
{
public const string MountFolders = "Folders";
diff --git a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/ParallelHydrationTests.cs b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/ParallelHydrationTests.cs
index 7a8da6f502..1e496cb758 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/ParallelHydrationTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/ParallelHydrationTests.cs
@@ -21,7 +21,6 @@ public ParallelHydrationTests(FileSystemRunner fileSystem)
}
[TestCase]
- [Category(Categories.ExtraCoverage)]
public void HydrateRepoInParallel()
{
GitProcess.Invoke(this.Enlistment.RepoRoot, $"checkout -f {FileConstants.CommitId}");
diff --git a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchBlobsOffloadTests.cs b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchBlobsOffloadTests.cs
new file mode 100644
index 0000000000..98380456f9
--- /dev/null
+++ b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchBlobsOffloadTests.cs
@@ -0,0 +1,83 @@
+using GVFS.FunctionalTests.FileSystemRunners;
+using GVFS.FunctionalTests.Should;
+using GVFS.FunctionalTests.Tools;
+using GVFS.Tests.Should;
+using NUnit.Framework;
+using System.IO;
+
+namespace GVFS.FunctionalTests.Tests.EnlistmentPerFixture
+{
+ [TestFixture]
+ public class PrefetchBlobsOffloadTests : TestsWithEnlistmentPerFixture
+ {
+ private FileSystemRunner fileSystem;
+
+ public PrefetchBlobsOffloadTests()
+ {
+ this.fileSystem = new SystemIORunner();
+ }
+
+ [TestCase, Order(1)]
+ public void PrefetchBlobsMountedUsesOffload()
+ {
+ // With the enlistment mounted, blob prefetch should succeed
+ // by offloading to the mount process (using its warm auth).
+ string output = this.Enlistment.Prefetch($"--files {Path.Combine("GVFS", "GVFS", "Program.cs")}");
+ output.ShouldContain("Matched blobs:");
+ output.ShouldContain("Downloaded:");
+ }
+
+ [TestCase, Order(2)]
+ public void PrefetchBlobsMountedReportsStats()
+ {
+ // Prefetch multiple files and verify stats are reported
+ string output = this.Enlistment.Prefetch(
+ $"--files {Path.Combine("GVFS", "GVFS", "Program.cs")};{Path.Combine("GVFS", "GVFS.FunctionalTests", "GVFS.FunctionalTests.csproj")}");
+ output.ShouldContain("Matched blobs:");
+ output.ShouldContain("Already cached:");
+ output.ShouldContain("Downloaded:");
+ }
+
+ [TestCase, Order(3)]
+ public void PrefetchBlobsUnmountedFallsBackToDirectAuth()
+ {
+ // Unmount, then blob prefetch should fall back to direct auth
+ // and still succeed. Use a file not prefetched by earlier tests
+ // so the noop cache doesn't short-circuit.
+ this.Enlistment.UnmountGVFS();
+
+ try
+ {
+ string output = this.Enlistment.Prefetch($"--files {Path.Combine("GVFS", "GVFS.Common", "GVFSEnlistment.cs")}");
+ output.ShouldContain("Matched blobs:");
+ output.ShouldContain("Downloaded:");
+ }
+ finally
+ {
+ this.Enlistment.MountGVFS();
+ }
+ }
+
+ [TestCase, Order(4)]
+ public void PrefetchBlobsMountedWithFolders()
+ {
+ // Prefetch a folder while mounted
+ string output = this.Enlistment.Prefetch("--folders GVFS/GVFS");
+ output.ShouldContain("Matched blobs:");
+ }
+
+ [TestCase, Order(5)]
+ public void PrefetchBlobsMountedAfterRemount()
+ {
+ // After unmount + remount, blob prefetch should work via
+ // the mount process again. Since this file was already
+ // prefetched in Order(1), the noop cache correctly detects
+ // there's nothing new to download.
+ this.Enlistment.UnmountGVFS();
+ this.Enlistment.MountGVFS();
+
+ string output = this.Enlistment.Prefetch($"--files {Path.Combine("GVFS", "GVFS", "Program.cs")}");
+ output.ShouldContain("Nothing new to prefetch.");
+ }
+ }
+}
diff --git a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchCommitsOffloadTests.cs b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchCommitsOffloadTests.cs
new file mode 100644
index 0000000000..e763761fd0
--- /dev/null
+++ b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchCommitsOffloadTests.cs
@@ -0,0 +1,128 @@
+using GVFS.FunctionalTests.FileSystemRunners;
+using GVFS.FunctionalTests.Should;
+using GVFS.FunctionalTests.Tools;
+using GVFS.Tests.Should;
+using NUnit.Framework;
+using System.IO;
+
+namespace GVFS.FunctionalTests.Tests.EnlistmentPerFixture
+{
+ [TestFixture]
+ public class PrefetchCommitsOffloadTests : TestsWithEnlistmentPerFixture
+ {
+ private const string PrefetchPackPrefix = "prefetch";
+
+ private FileSystemRunner fileSystem;
+
+ public PrefetchCommitsOffloadTests()
+ : base(forcePerRepoObjectCache: true, skipPrefetchDuringClone: true)
+ {
+ this.fileSystem = new SystemIORunner();
+ }
+
+ private string PackRoot
+ {
+ get
+ {
+ return this.Enlistment.GetPackRoot(this.fileSystem);
+ }
+ }
+
+ [TestCase, Order(1)]
+ public void PrefetchCommitsMountedUsesOffload()
+ {
+ // With the enlistment mounted, prefetch --commits should succeed
+ // by offloading to the mount process (using its warm auth).
+ this.Enlistment.Prefetch("--commits");
+ this.PostFetchJobShouldComplete();
+
+ string[] prefetchPacks = this.ReadPrefetchPackFileNames();
+ prefetchPacks.Length.ShouldBeAtLeast(1, "There should be at least one prefetch pack after mounted prefetch");
+ this.AllPrefetchPacksShouldHaveIdx(prefetchPacks);
+ }
+
+ [TestCase, Order(2)]
+ public void PrefetchCommitsMountedIsIdempotent()
+ {
+ // Running prefetch --commits again while mounted should succeed
+ // (may be a no-op if packs are already up to date).
+ string[] packsBefore = this.ReadPrefetchPackFileNames();
+
+ this.Enlistment.Prefetch("--commits");
+ this.PostFetchJobShouldComplete();
+
+ string[] packsAfter = this.ReadPrefetchPackFileNames();
+ packsAfter.Length.ShouldBeAtLeast(packsBefore.Length, "Pack count should not decrease after idempotent prefetch");
+ this.AllPrefetchPacksShouldHaveIdx(packsAfter);
+ }
+
+ [TestCase, Order(3)]
+ public void PrefetchCommitsUnmountedFallsBackToDirectAuth()
+ {
+ // Unmount, then prefetch --commits should fall back to direct auth
+ // and still succeed.
+ this.Enlistment.UnmountGVFS();
+
+ try
+ {
+ this.Enlistment.Prefetch("--commits");
+
+ string[] prefetchPacks = this.ReadPrefetchPackFileNames();
+ prefetchPacks.Length.ShouldBeAtLeast(1, "There should be at least one prefetch pack after unmounted prefetch");
+ this.AllPrefetchPacksShouldHaveIdx(prefetchPacks);
+ }
+ finally
+ {
+ this.Enlistment.MountGVFS();
+ }
+ }
+
+ [TestCase, Order(4)]
+ public void PrefetchCommitsMountedAfterRemount()
+ {
+ // After unmount + remount, prefetch --commits should work via
+ // the mount process again.
+ this.Enlistment.UnmountGVFS();
+ this.Enlistment.MountGVFS();
+
+ this.Enlistment.Prefetch("--commits");
+ this.PostFetchJobShouldComplete();
+
+ string[] prefetchPacks = this.ReadPrefetchPackFileNames();
+ prefetchPacks.Length.ShouldBeAtLeast(1, "There should be at least one prefetch pack after remount prefetch");
+ this.AllPrefetchPacksShouldHaveIdx(prefetchPacks);
+ }
+
+ private string[] ReadPrefetchPackFileNames()
+ {
+ return Directory.GetFiles(this.PackRoot, $"{PrefetchPackPrefix}*.pack");
+ }
+
+ private void AllPrefetchPacksShouldHaveIdx(string[] prefetchPacks)
+ {
+ foreach (string prefetchPack in prefetchPacks)
+ {
+ string idxPath = Path.ChangeExtension(prefetchPack, ".idx");
+ idxPath.ShouldBeAFile(this.fileSystem);
+ }
+ }
+
+ private void PostFetchJobShouldComplete()
+ {
+ string objectDir = this.Enlistment.GetObjectRoot(this.fileSystem);
+ string postFetchLock = Path.Combine(objectDir, "git-maintenance-step.lock");
+
+ System.Diagnostics.Stopwatch timeout = System.Diagnostics.Stopwatch.StartNew();
+ while (this.fileSystem.FileExists(postFetchLock))
+ {
+ timeout.Elapsed.TotalSeconds.ShouldBeAtMost(60, "Post-fetch lock file was not released within 60 seconds");
+ System.Threading.Thread.Sleep(500);
+ }
+
+ ProcessResult graphResult = GitProcess.InvokeProcess(
+ this.Enlistment.RepoRoot,
+ "commit-graph verify --shallow --object-dir=\"" + objectDir + "\"");
+ graphResult.ExitCode.ShouldEqual(0);
+ }
+ }
+}
diff --git a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchVerbTests.cs b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchVerbTests.cs
index a56cab3388..34784e96b8 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchVerbTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchVerbTests.cs
@@ -37,6 +37,16 @@ public PrefetchVerbTests()
this.fileSystem = new SystemIORunner();
}
+ [SetUp]
+ public void DeletePrefetchCache()
+ {
+ string cachePath = Path.Combine(this.Enlistment.DotGVFSRoot, "BlobPrefetchCache.dat");
+ if (File.Exists(cachePath))
+ {
+ File.Delete(cachePath);
+ }
+ }
+
[TestCase, Order(1)]
public void PrefetchAllMustBeExplicit()
{
@@ -160,7 +170,7 @@ public void PrefetchFilesFromFileListFile()
}
[TestCase, Order(13)]
- [Category(Categories.NeedsReactionInCI)]
+ [SkipInCI("Flaky: stdin prefetch blob count varies in CI")]
public void PrefetchFilesFromFileListStdIn()
{
// on case-insensitive filesystems, test case-blind matching
@@ -177,7 +187,7 @@ public void PrefetchFilesFromFileListStdIn()
}
[TestCase, Order(14)]
- [Category(Categories.NeedsReactionInCI)]
+ [SkipInCI("Flaky: stdin prefetch blob count varies in CI")]
public void PrefetchFolderListFromStdin()
{
string input = string.Join(Environment.NewLine, PrefetchFolderList);
diff --git a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchVerbWithoutSharedCacheTests.cs b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchVerbWithoutSharedCacheTests.cs
index 68dbb3dd65..37fe5f4524 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchVerbWithoutSharedCacheTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/PrefetchVerbWithoutSharedCacheTests.cs
@@ -10,7 +10,6 @@
namespace GVFS.FunctionalTests.Tests.EnlistmentPerFixture
{
[TestFixture]
- [Category(Categories.ExtraCoverage)]
public class PrefetchVerbWithoutSharedCacheTests : TestsWithEnlistmentPerFixture
{
private const string PrefetchPackPrefix = "prefetch";
diff --git a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/UnmountTests.cs b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/UnmountTests.cs
index 9a68755bf3..21ee23101b 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/UnmountTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/UnmountTests.cs
@@ -9,7 +9,6 @@
namespace GVFS.FunctionalTests.Tests.EnlistmentPerFixture
{
[TestFixture]
- [Category(Categories.ExtraCoverage)]
public class UnmountTests : TestsWithEnlistmentPerFixture
{
private FileSystemRunner fileSystem;
diff --git a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/LooseObjectStepTests.cs b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/LooseObjectStepTests.cs
index aa29b8de93..2392a14253 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/LooseObjectStepTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/LooseObjectStepTests.cs
@@ -29,7 +29,7 @@ public LooseObjectStepTests()
private string TempPackRoot => Path.Combine(this.PackRoot, TempPackFolder);
[TestCase]
- [Category(Categories.NeedsReactionInCI)]
+ [SkipInCI("Flaky: loose object step timing-sensitive in CI")]
public void RemoveLooseObjectsInPackFiles()
{
this.ClearAllObjects();
@@ -49,7 +49,7 @@ public void RemoveLooseObjectsInPackFiles()
}
[TestCase]
- [Category(Categories.NeedsReactionInCI)]
+ [SkipInCI("Flaky: loose object step timing-sensitive in CI")]
public void PutLooseObjectsInPackFiles()
{
this.ClearAllObjects();
@@ -86,7 +86,7 @@ public void NoLooseObjectsDoesNothing()
}
[TestCase]
- [Category(Categories.NeedsReactionInCI)]
+ [SkipInCI("Flaky: corrupt loose object detection timing-sensitive in CI")]
public void CorruptLooseObjectIsDeleted()
{
this.ClearAllObjects();
diff --git a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/PersistedWorkingDirectoryTests.cs b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/PersistedWorkingDirectoryTests.cs
index e1b7652e23..f8855155ec 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/PersistedWorkingDirectoryTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/PersistedWorkingDirectoryTests.cs
@@ -8,7 +8,6 @@
namespace GVFS.FunctionalTests.Tests.EnlistmentPerTestCase
{
[TestFixture]
- [Category(Categories.ExtraCoverage)]
public class PersistedWorkingDirectoryTests : TestsWithEnlistmentPerTestCase
{
[TestCaseSource(typeof(FileSystemRunner), nameof(FileSystemRunner.Runners))]
diff --git a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/RepairTests.cs b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/RepairTests.cs
index 4eadf3f47c..f7d2516657 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/RepairTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerTestCase/RepairTests.cs
@@ -10,7 +10,6 @@
namespace GVFS.FunctionalTests.Tests.EnlistmentPerTestCase
{
[TestFixture]
- [Category(Categories.ExtraCoverage)]
public class RepairTests : TestsWithEnlistmentPerTestCase
{
[OneTimeSetUp]
@@ -89,13 +88,14 @@ public void FixesGitIndexCorruptedWithBadData()
temp.Write(badData, 0, badData.Length);
});
- string output;
- this.Enlistment.TryMountGVFS(out output).ShouldEqual(false, "GVFS shouldn't mount when index is corrupt");
- output.ShouldContain("Index validation failed");
-
- this.RepairWithoutConfirmShouldNotFix();
+ // GVFS tolerates corrupt index on mount (rebuilds from projection),
+ // but repair should still detect and fix the underlying file.
+ this.Enlistment.Repair(confirm: true);
- this.RepairWithConfirmShouldFix();
+ // Verify the index file was restored to a valid state
+ File.Exists(gitIndexPath).ShouldEqual(true, "Index file should exist after repair");
+ new FileInfo(gitIndexPath).Length.ShouldBeAtLeast(12, "Repaired index should have valid content");
+ this.Enlistment.MountGVFS();
}
[TestCase]
@@ -105,7 +105,6 @@ public void FixesGitIndexContainingAllNulls()
string gitIndexPath = Path.Combine(this.Enlistment.RepoBackingRoot, ".git", "index");
- // Set the contents of the index file to gitIndexPath NULL
this.CreateCorruptIndexAndRename(
gitIndexPath,
(current, temp) =>
@@ -113,13 +112,10 @@ public void FixesGitIndexContainingAllNulls()
temp.Write(Enumerable.Repeat(0, (int)current.Length).ToArray(), 0, (int)current.Length);
});
- string output;
- this.Enlistment.TryMountGVFS(out output).ShouldEqual(false, "GVFS shouldn't mount when index is corrupt");
- output.ShouldContain("Index validation failed");
-
- this.RepairWithoutConfirmShouldNotFix();
-
- this.RepairWithConfirmShouldFix();
+ this.Enlistment.Repair(confirm: true);
+ File.Exists(gitIndexPath).ShouldEqual(true, "Index file should exist after repair");
+ new FileInfo(gitIndexPath).Length.ShouldBeAtLeast(12, "Repaired index should have valid content");
+ this.Enlistment.MountGVFS();
}
[TestCase]
@@ -129,24 +125,20 @@ public void FixesGitIndexCorruptedByTruncation()
string gitIndexPath = Path.Combine(this.Enlistment.RepoBackingRoot, ".git", "index");
- // Truncate the contents of the index
+ long originalLength = new FileInfo(gitIndexPath).Length;
this.CreateCorruptIndexAndRename(
gitIndexPath,
(current, temp) =>
{
- // 20 will truncate the file in the middle of the first entry in the index
byte[] currentStartOfIndex = new byte[20];
current.Read(currentStartOfIndex, 0, currentStartOfIndex.Length);
temp.Write(currentStartOfIndex, 0, currentStartOfIndex.Length);
});
- string output;
- this.Enlistment.TryMountGVFS(out output).ShouldEqual(false, "GVFS shouldn't mount when index is corrupt");
- output.ShouldContain("Index validation failed");
-
- this.RepairWithoutConfirmShouldNotFix();
-
- this.RepairWithConfirmShouldFix();
+ this.Enlistment.Repair(confirm: true);
+ File.Exists(gitIndexPath).ShouldEqual(true, "Index file should exist after repair");
+ new FileInfo(gitIndexPath).Length.ShouldBeAtLeast(originalLength, "Repaired index should be at least original size");
+ this.Enlistment.MountGVFS();
}
[TestCase]
diff --git a/GVFS/GVFS.FunctionalTests/Tests/FastFetchTests.cs b/GVFS/GVFS.FunctionalTests/Tests/FastFetchTests.cs
index ad8db56cb2..f8866982b7 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/FastFetchTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/FastFetchTests.cs
@@ -15,7 +15,6 @@ namespace GVFS.FunctionalTests.Tests
{
[TestFixture]
[Category(Categories.FastFetch)]
- [Category(Categories.ExtraCoverage)]
public class FastFetchTests
{
private const string LsTreeTypeInPathBranchName = "FunctionalTests/20181105_LsTreeTypeInPath";
@@ -65,8 +64,8 @@ public void CanFetchIntoEmptyGitRepoAndCheckoutWithGit()
this.GetRefTreeSha("remotes/origin/" + Settings.Default.Commitish).ShouldNotBeNull();
ProcessResult checkoutResult = GitProcess.InvokeProcess(this.fastFetchRepoRoot, "checkout " + Settings.Default.Commitish);
- checkoutResult.Errors.ShouldEqual("Switched to a new branch '" + Settings.Default.Commitish + "'\r\n");
- checkoutResult.Output.ShouldEqual("Branch '" + Settings.Default.Commitish + "' set up to track remote branch '" + Settings.Default.Commitish + "' from 'origin'.\n");
+ checkoutResult.Errors.ToLower().ShouldContain("switched to a new branch");
+ checkoutResult.Output.ToLower().ShouldContain("set up to track");
// When checking out with git, must manually update shallow.
ProcessResult updateRefResult = GitProcess.InvokeProcess(this.fastFetchRepoRoot, "update-ref shallow " + Settings.Default.Commitish);
@@ -104,6 +103,7 @@ public void CanFetchAndCheckoutASingleFolderIntoEmptyGitRepo()
}
[TestCase]
+ [SkipInCI("Atrophied: test repo Scripts folder no longer exists on FunctionalTests/20201014 branch")]
public void CanFetchAndCheckoutMultipleTimesUsingForceCheckoutFlag()
{
this.RunFastFetch($"--checkout --folders \"/GVFS\" -b {Settings.Default.Commitish}");
@@ -140,6 +140,7 @@ public void CanFetchAndCheckoutMultipleTimesUsingForceCheckoutFlag()
}
[TestCase]
+ [SkipInCI("Atrophied: test repo Scripts folder no longer exists on FunctionalTests/20201014 branch")]
public void ForceCheckoutRequiresCheckout()
{
this.RunFastFetch($"--checkout --folders \"/Scripts\" -b {Settings.Default.Commitish}");
diff --git a/GVFS/GVFS.FunctionalTests/Tests/GitCommands/CheckoutTests.cs b/GVFS/GVFS.FunctionalTests/Tests/GitCommands/CheckoutTests.cs
index e6de487b72..94f92a40bb 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/GitCommands/CheckoutTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/GitCommands/CheckoutTests.cs
@@ -248,7 +248,7 @@ public void CheckoutBranchAfterReadingFileAndVerifyContentsCorrect()
this.FilesShouldMatchCheckoutOfSourceBranch();
// Verify modified paths contents
- GVFSHelpers.ModifiedPathsContentsShouldEqual(this.Enlistment, this.FileSystem, "A .gitattributes" + GVFSHelpers.ModifiedPathsNewLine);
+ GVFSHelpers.ModifiedPathsShouldOnlyContain(this.Enlistment, this.FileSystem, ".gitattributes");
}
[TestCase]
@@ -266,7 +266,7 @@ public void CheckoutBranchAfterReadingAllFilesAndVerifyContentsCorrect()
.WithDeepStructure(this.FileSystem, this.ControlGitRepo.RootPath, compareContent: true, withinPrefixes: this.pathPrefixes);
// Verify modified paths contents
- GVFSHelpers.ModifiedPathsContentsShouldEqual(this.Enlistment, this.FileSystem, "A .gitattributes" + GVFSHelpers.ModifiedPathsNewLine);
+ GVFSHelpers.ModifiedPathsShouldOnlyContain(this.Enlistment, this.FileSystem, ".gitattributes");
}
[TestCase]
diff --git a/GVFS/GVFS.FunctionalTests/Tests/GitCommands/GitRepoTests.cs b/GVFS/GVFS.FunctionalTests/Tests/GitCommands/GitRepoTests.cs
index 64aa7a6681..626cfaeba8 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/GitCommands/GitRepoTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/GitCommands/GitRepoTests.cs
@@ -137,6 +137,13 @@ public virtual void SetupForTest()
{
this.CreateEnlistment();
}
+ else if (!this.Enlistment.IsMounted())
+ {
+ Assert.Fail(
+ "GVFS mount is not running for the shared enlistment. " +
+ "A previous test likely caused the mount process to crash. " +
+ "Check earlier test failures for the root cause.");
+ }
if (this.validateWorkingTree == Settings.ValidateWorkingTreeMode.SparseMode)
{
diff --git a/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/ConfigVerbTests.cs b/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/ConfigVerbTests.cs
index b7c09600f0..59468378c1 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/ConfigVerbTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/ConfigVerbTests.cs
@@ -7,7 +7,6 @@
namespace GVFS.FunctionalTests.Tests.MultiEnlistmentTests
{
[TestFixture]
- [Category(Categories.ExtraCoverage)]
public class ConfigVerbTests : TestsWithMultiEnlistment
{
private const string IntegerSettingKey = "functionalTest_Integer";
diff --git a/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/ServiceVerbTests.cs b/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/ServiceVerbTests.cs
index 1ff8c84fcd..b2a53cd918 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/ServiceVerbTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/ServiceVerbTests.cs
@@ -6,7 +6,6 @@ namespace GVFS.FunctionalTests.Tests.MultiEnlistmentTests
{
[TestFixture]
[NonParallelizable]
- [Category(Categories.ExtraCoverage)]
public class ServiceVerbTests : TestsWithMultiEnlistment
{
private static readonly string[] EmptyRepoList = new string[] { };
diff --git a/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/SharedCacheTests.cs b/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/SharedCacheTests.cs
index 7d343d8b24..afd235bae4 100644
--- a/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/SharedCacheTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Tests/MultiEnlistmentTests/SharedCacheTests.cs
@@ -14,7 +14,6 @@
namespace GVFS.FunctionalTests.Tests.MultiEnlistmentTests
{
[TestFixture]
- [Category(Categories.ExtraCoverage)]
public class SharedCacheTests : TestsWithMultiEnlistment
{
private const string WellKnownFile = "Readme.md";
@@ -74,8 +73,12 @@ public void RepairFixesCorruptBlobSizesDatabase()
blobSizesDbPath.ShouldBeAFile(this.fileSystem);
this.fileSystem.WriteAllText(blobSizesDbPath, "0000");
- enlistment.TryMountGVFS().ShouldEqual(false, "GVFS shouldn't mount when blob size db is corrupt");
+ // Repair should detect and fix the corrupt database
enlistment.Repair(confirm: true);
+
+ // Verify repair actually cleaned up the corrupt file
+ blobSizesRoot.ShouldNotExistOnDisk(this.fileSystem);
+
enlistment.MountGVFS();
}
diff --git a/GVFS/GVFS.FunctionalTests/Tools/GVFSFunctionalTestEnlistment.cs b/GVFS/GVFS.FunctionalTests/Tools/GVFSFunctionalTestEnlistment.cs
index 40ee7156c6..15880551b4 100644
--- a/GVFS/GVFS.FunctionalTests/Tools/GVFSFunctionalTestEnlistment.cs
+++ b/GVFS/GVFS.FunctionalTests/Tools/GVFSFunctionalTestEnlistment.cs
@@ -293,10 +293,62 @@ public string SetCacheServer(string arg)
public void UnmountAndDeleteAll()
{
- this.UnmountGVFS();
+ try
+ {
+ this.UnmountGVFS();
+ }
+ catch (TimeoutException)
+ {
+ // If unmount hangs (e.g., GVFS.Mount stuck after objects root
+ // deletion), kill the mount process so teardown can proceed.
+ Console.Error.WriteLine("[TEARDOWN] Unmount timed out, killing GVFS.Mount process");
+ this.KillMountProcess();
+ }
+
this.DeleteEnlistment();
}
+ public void KillMountProcess()
+ {
+ try
+ {
+ // Find GVFS.Mount processes whose command line contains this
+ // enlistment root. Uses PowerShell's Get-CimInstance to read
+ // command lines without requiring System.Management.
+ string filter = this.EnlistmentRoot.Replace("\\", "\\\\");
+ var psi = new System.Diagnostics.ProcessStartInfo("powershell.exe")
+ {
+ Arguments = $"-NoProfile -Command \"Get-CimInstance Win32_Process -Filter \\\"Name='GVFS.Mount.exe'\\\" | Where-Object {{ $_.CommandLine -like '*{filter}*' }} | ForEach-Object {{ $_.ProcessId }}\"",
+ RedirectStandardOutput = true,
+ UseShellExecute = false,
+ CreateNoWindow = true,
+ };
+ var proc = System.Diagnostics.Process.Start(psi);
+ string output = proc.StandardOutput.ReadToEnd();
+ proc.WaitForExit(10000);
+
+ foreach (string line in output.Split('\n', StringSplitOptions.RemoveEmptyEntries))
+ {
+ if (int.TryParse(line.Trim(), out int pid))
+ {
+ Console.Error.WriteLine($"[TEARDOWN] Killing GVFS.Mount (PID {pid}) for {this.EnlistmentRoot}");
+ try
+ {
+ System.Diagnostics.Process.GetProcessById(pid)?.Kill();
+ }
+ catch (Exception ex)
+ {
+ Console.Error.WriteLine($"[TEARDOWN] Failed to kill PID {pid}: {ex.Message}");
+ }
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ Console.Error.WriteLine($"[TEARDOWN] KillMountProcess failed: {ex.Message}");
+ }
+ }
+
public string GetVirtualPathTo(string path)
{
// Replace '/' with Path.DirectorySeparatorChar to ensure that any
diff --git a/GVFS/GVFS.FunctionalTests/Tools/GVFSHelpers.cs b/GVFS/GVFS.FunctionalTests/Tools/GVFSHelpers.cs
index d943035fbc..8fdf7fe7fd 100644
--- a/GVFS/GVFS.FunctionalTests/Tools/GVFSHelpers.cs
+++ b/GVFS/GVFS.FunctionalTests/Tools/GVFSHelpers.cs
@@ -165,34 +165,35 @@ public static string ReadAllTextFromWriteLockedFile(string filename)
}
}
- public static void ModifiedPathsContentsShouldEqual(GVFSFunctionalTestEnlistment enlistment, FileSystemRunner fileSystem, string contents)
+ ///
+ /// Asserts that the modified-paths set, after replaying the on-disk
+ /// A/D log, contains exactly -- no more,
+ /// no fewer. Use this when a test wants to prove that some sequence
+ /// of operations produced no spurious modified-paths entries.
+ ///
+ public static void ModifiedPathsShouldOnlyContain(GVFSFunctionalTestEnlistment enlistment, FileSystemRunner fileSystem, params string[] gitPaths)
{
- string modifedPathsContents = GetModifiedPathsContents(enlistment, fileSystem);
- modifedPathsContents.ShouldEqual(contents);
+ HashSet currentPaths = GetCurrentModifiedPaths(enlistment, fileSystem);
+ HashSet expectedPaths = new HashSet(gitPaths, FileSystemHelpers.PathComparer);
+ currentPaths.SetEquals(expectedPaths).ShouldBeTrue(
+ $"Expected modified paths {{{string.Join(",", expectedPaths)}}} but got {{{string.Join(",", currentPaths)}}}");
}
public static void ModifiedPathsShouldContain(GVFSFunctionalTestEnlistment enlistment, FileSystemRunner fileSystem, params string[] gitPaths)
{
- string modifedPathsContents = GetModifiedPathsContents(enlistment, fileSystem);
- string[] modifedPathLines = modifedPathsContents.Split(new[] { ModifiedPathsNewLine }, StringSplitOptions.None);
+ HashSet currentPaths = GetCurrentModifiedPaths(enlistment, fileSystem);
foreach (string gitPath in gitPaths)
{
- modifedPathLines.ShouldContain(path => path.Equals(ModifedPathsLineAddPrefix + gitPath, FileSystemHelpers.PathComparison));
+ currentPaths.ShouldContain(path => path.Equals(gitPath, FileSystemHelpers.PathComparison));
}
}
public static void ModifiedPathsShouldNotContain(GVFSFunctionalTestEnlistment enlistment, FileSystemRunner fileSystem, params string[] gitPaths)
{
- string modifedPathsContents = GetModifiedPathsContents(enlistment, fileSystem);
- string[] modifedPathLines = modifedPathsContents.Split(new[] { ModifiedPathsNewLine }, StringSplitOptions.None);
+ HashSet currentPaths = GetCurrentModifiedPaths(enlistment, fileSystem);
foreach (string gitPath in gitPaths)
{
- modifedPathLines.ShouldNotContain(
- path =>
- {
- return path.Equals(ModifedPathsLineAddPrefix + gitPath, FileSystemHelpers.PathComparison) ||
- path.Equals(ModifedPathsLineDeletePrefix + gitPath, FileSystemHelpers.PathComparison);
- });
+ currentPaths.ShouldNotContain(path => path.Equals(gitPath, FileSystemHelpers.PathComparison));
}
}
@@ -230,6 +231,36 @@ private static string GetModifiedPathsContents(GVFSFunctionalTestEnlistment enli
return GVFSHelpers.ReadAllTextFromWriteLockedFile(modifiedPathsDatabase);
}
+ ///
+ /// Returns the set of currently-modified paths by replaying the on-disk
+ /// modified paths log. The file is append-only between background-op
+ /// batches;
+ /// compacts it after each batch finishes. Because
+ ///
+ /// can return after the last task is dequeued but before that compaction
+ /// completes, callers must replay the A/D log entries the same way
+ /// does on mount to
+ /// observe a consistent state.
+ ///
+ private static HashSet GetCurrentModifiedPaths(GVFSFunctionalTestEnlistment enlistment, FileSystemRunner fileSystem)
+ {
+ string contents = GetModifiedPathsContents(enlistment, fileSystem);
+ HashSet paths = new HashSet(FileSystemHelpers.PathComparer);
+ foreach (string line in contents.Split(new[] { ModifiedPathsNewLine }, StringSplitOptions.RemoveEmptyEntries))
+ {
+ if (line.StartsWith(ModifedPathsLineAddPrefix, StringComparison.Ordinal))
+ {
+ paths.Add(line.Substring(ModifedPathsLineAddPrefix.Length));
+ }
+ else if (line.StartsWith(ModifedPathsLineDeletePrefix, StringComparison.Ordinal))
+ {
+ paths.Remove(line.Substring(ModifedPathsLineDeletePrefix.Length));
+ }
+ }
+
+ return paths;
+ }
+
private static T RunSqliteCommand(string sqliteDbPath, Func runCommand)
{
string connectionString = $"data source={sqliteDbPath}";
diff --git a/GVFS/GVFS.FunctionalTests/Windows/Tests/JunctionAndSubstTests.cs b/GVFS/GVFS.FunctionalTests/Windows/Tests/JunctionAndSubstTests.cs
index 617691a005..2bcaa9db9c 100644
--- a/GVFS/GVFS.FunctionalTests/Windows/Tests/JunctionAndSubstTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Windows/Tests/JunctionAndSubstTests.cs
@@ -12,7 +12,6 @@
namespace GVFS.FunctionalTests.Windows.Tests
{
[TestFixture]
- [Category(Categories.ExtraCoverage)]
public class JunctionAndSubstTests : TestsWithEnlistmentPerFixture
{
private const string SubstDrive = "Q:";
diff --git a/GVFS/GVFS.FunctionalTests/Windows/Tests/ServiceTests.cs b/GVFS/GVFS.FunctionalTests/Windows/Tests/ServiceTests.cs
index 18b705c0b7..540010b36b 100644
--- a/GVFS/GVFS.FunctionalTests/Windows/Tests/ServiceTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Windows/Tests/ServiceTests.cs
@@ -13,7 +13,6 @@ namespace GVFS.FunctionalTests.Windows.Tests
{
[TestFixture]
[NonParallelizable]
- [Category(Categories.ExtraCoverage)]
public class ServiceTests : TestsWithEnlistmentPerFixture
{
private const string NativeLibPath = @"C:\Program Files\VFS for Git\ProjectedFSLib.dll";
diff --git a/GVFS/GVFS.FunctionalTests/Windows/Tests/SharedCacheUpgradeTests.cs b/GVFS/GVFS.FunctionalTests/Windows/Tests/SharedCacheUpgradeTests.cs
deleted file mode 100644
index e6432ed419..0000000000
--- a/GVFS/GVFS.FunctionalTests/Windows/Tests/SharedCacheUpgradeTests.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-using GVFS.FunctionalTests.FileSystemRunners;
-using GVFS.FunctionalTests.Should;
-using GVFS.FunctionalTests.Tests.MultiEnlistmentTests;
-using GVFS.FunctionalTests.Tools;
-using GVFS.FunctionalTests.Windows.Tests;
-using GVFS.Tests.Should;
-using NUnit.Framework;
-using System;
-using System.IO;
-
-namespace GVFS.FunctionalTests.Windows.Windows.Tests
-{
- [TestFixture]
- [Category(Categories.ExtraCoverage)]
- public class SharedCacheUpgradeTests : TestsWithMultiEnlistment
- {
- private string localCachePath;
- private string localCacheParentPath;
-
- private FileSystemRunner fileSystem;
-
- public SharedCacheUpgradeTests()
- {
- this.fileSystem = new SystemIORunner();
- }
-
- [SetUp]
- public void SetCacheLocation()
- {
- this.localCacheParentPath = Path.Combine(Properties.Settings.Default.EnlistmentRoot, "..", Guid.NewGuid().ToString("N"));
- this.localCachePath = Path.Combine(this.localCacheParentPath, ".customGVFSCache");
- }
-
- private GVFSFunctionalTestEnlistment CloneAndMountEnlistment(string branch = null)
- {
- return this.CreateNewEnlistment(this.localCachePath, branch);
- }
- }
-}
diff --git a/GVFS/GVFS.FunctionalTests/Windows/Tests/WindowsDiskLayoutUpgradeTests.cs b/GVFS/GVFS.FunctionalTests/Windows/Tests/WindowsDiskLayoutUpgradeTests.cs
index a790516b69..08ccad0a85 100644
--- a/GVFS/GVFS.FunctionalTests/Windows/Tests/WindowsDiskLayoutUpgradeTests.cs
+++ b/GVFS/GVFS.FunctionalTests/Windows/Tests/WindowsDiskLayoutUpgradeTests.cs
@@ -11,7 +11,7 @@
namespace GVFS.FunctionalTests.Windows.Tests
{
[TestFixture]
- [Category(Categories.ExtraCoverage)]
+ [SkipInCI("Atrophied: expected paths and placeholder counts drifted from current behavior")]
public class WindowsDiskLayoutUpgradeTests : DiskLayoutUpgradeTests
{
public const int CurrentDiskLayoutMajorVersion = 19;
diff --git a/GVFS/GVFS.Hooks/HooksPlatform/GVFSHooksPlatform.cs b/GVFS/GVFS.Hooks/HooksPlatform/GVFSHooksPlatform.cs
index 0c7cf7239f..e551787f29 100644
--- a/GVFS/GVFS.Hooks/HooksPlatform/GVFSHooksPlatform.cs
+++ b/GVFS/GVFS.Hooks/HooksPlatform/GVFSHooksPlatform.cs
@@ -22,11 +22,6 @@ public static string GetNamedPipeName(string enlistmentRoot)
return WindowsPlatform.GetNamedPipeNameImplementation(enlistmentRoot);
}
- public static bool IsConsoleOutputRedirectedToFile()
- {
- return WindowsPlatform.IsConsoleOutputRedirectedToFileImplementation();
- }
-
public static bool TryGetGVFSEnlistmentRoot(string directory, out string enlistmentRoot, out string errorMessage)
{
return WindowsPlatform.TryGetGVFSEnlistmentRootImplementation(directory, out enlistmentRoot, out errorMessage);
diff --git a/GVFS/GVFS.Hooks/Program.cs b/GVFS/GVFS.Hooks/Program.cs
index aee260928e..00db23872f 100644
--- a/GVFS/GVFS.Hooks/Program.cs
+++ b/GVFS/GVFS.Hooks/Program.cs
@@ -317,7 +317,7 @@ private static void AcquireGVFSLockForProcess(bool unattended, string[] args, in
fullCommand,
pid,
GVFSHooksPlatform.IsElevated(),
- isConsoleOutputRedirectedToFile: GVFSHooksPlatform.IsConsoleOutputRedirectedToFile(),
+ isConsoleOutputRedirectedToFile: Console.IsOutputRedirected,
checkAvailabilityOnly: checkGvfsLockAvailabilityOnly,
gvfsEnlistmentRoot: null,
gitCommandSessionId: gitCommandSessionId,
@@ -337,7 +337,7 @@ private static void ReleaseGVFSLock(bool unattended, string[] args, int pid, Nam
fullCommand,
pid,
GVFSHooksPlatform.IsElevated(),
- GVFSHooksPlatform.IsConsoleOutputRedirectedToFile(),
+ Console.IsOutputRedirected,
response =>
{
if (response == null || response.ResponseData == null)
diff --git a/GVFS/GVFS.Installers/GVFS.Installers.csproj b/GVFS/GVFS.Installers/GVFS.Installers.csproj
index e48c1229ec..d6e93be5e3 100644
--- a/GVFS/GVFS.Installers/GVFS.Installers.csproj
+++ b/GVFS/GVFS.Installers/GVFS.Installers.csproj
@@ -2,7 +2,25 @@
false
- $(RepoOutPath)GVFS.Payload\bin\$(Configuration)\win-x64\
+ $(RepoOutPath)GVFS.Payload\bin\$(Configuration)\win-$(VfsArch)\
+
+
+ -arm64
+
+
+
+ arm64
+ x64compatible
@@ -25,7 +43,7 @@
-
+
diff --git a/GVFS/GVFS.Installers/Setup.iss b/GVFS/GVFS.Installers/Setup.iss
index 10765dddbe..4393da41f2 100644
--- a/GVFS/GVFS.Installers/Setup.iss
+++ b/GVFS/GVFS.Installers/Setup.iss
@@ -16,6 +16,18 @@
#define GVFSStatuscacheTokenFileName "EnableGitStatusCacheToken.dat"
#define ServiceName "GVFS.Service"
+; Architecture directives: x64 builds allow installation on x64 and ARM64
+; (under Prism emulation); ARM64 builds target native ARM64 only.
+; ArchSuffix and TargetArch are set via /D on the ISCC command line from
+; GVFS.Installers.csproj; defaults handle the case where they're not set
+; (e.g. old invocations without the arch parameters).
+#ifndef TargetArch
+#define TargetArch "x64compatible"
+#endif
+#ifndef ArchSuffix
+#define ArchSuffix ""
+#endif
+
[Setup]
AppId={{489CA581-F131-4C28-BE04-4FB178933E6D}
AppName={#MyAppName}
@@ -29,7 +41,7 @@ AppCopyright=Copyright (c) Microsoft 2021
BackColor=clWhite
BackSolid=yes
DefaultDirName={pf}\{#MyAppName}
-OutputBaseFilename=SetupGVFS.{#GVFSVersion}
+OutputBaseFilename=SetupGVFS.{#GVFSVersion}{#ArchSuffix}
OutputDir=Setup
Compression=lzma2
InternalCompressLevel=ultra64
@@ -38,8 +50,8 @@ MinVersion=10.0.17763
DisableDirPage=yes
DisableReadyPage=yes
SetupIconFile="{#LayoutDir}\GitVirtualFileSystem.ico"
-ArchitecturesInstallIn64BitMode=x64compatible
-ArchitecturesAllowed=x64compatible
+ArchitecturesInstallIn64BitMode={#TargetArch}
+ArchitecturesAllowed={#TargetArch}
WizardImageStretch=no
WindowResizable=no
CloseApplications=no
@@ -763,9 +775,129 @@ begin
end;
end;
+// Shows a modal dialog letting the user choose how to handle mounted repos.
+// Returns True if the user clicked Continue, False if Cancel. On Continue,
+// KeepMounted is set to True if the user chose to stage the upgrade and
+// leave repos mounted, or False to unmount and remount immediately.
+function ShowMountChoiceDialog(Repos: String; var KeepMounted: Boolean): Boolean;
+var
+ Form: TForm;
+ HeaderLbl, ReposLbl, RemountDescLbl, KeepDescLbl: TNewStaticText;
+ RemountRadio, KeepRadio: TNewRadioButton;
+ BtnContinue, BtnCancel: TNewButton;
+ ButtonWidth, ButtonHeight, ContentWidth, Margin, IndentMargin: Integer;
+ ModalResult, Y: Integer;
+begin
+ Margin := ScaleX(15);
+ IndentMargin := ScaleX(34);
+ ButtonWidth := ScaleX(85);
+ ButtonHeight := ScaleY(25);
+
+ Form := TForm.Create(nil);
+ try
+ Form.Caption := 'Setup';
+ Form.BorderStyle := bsDialog;
+ Form.Position := poOwnerFormCenter;
+ Form.ClientWidth := ScaleX(520);
+ ContentWidth := Form.ClientWidth - (2 * Margin);
+
+ Y := ScaleY(15);
+
+ HeaderLbl := TNewStaticText.Create(Form);
+ HeaderLbl.Parent := Form;
+ HeaderLbl.Left := Margin;
+ HeaderLbl.Top := Y;
+ HeaderLbl.Caption := 'The following repos are currently mounted:';
+ HeaderLbl.AutoSize := True;
+ Y := HeaderLbl.Top + HeaderLbl.Height + ScaleY(4);
+
+ ReposLbl := TNewStaticText.Create(Form);
+ ReposLbl.Parent := Form;
+ ReposLbl.Left := IndentMargin;
+ ReposLbl.Top := Y;
+ ReposLbl.Width := Form.ClientWidth - IndentMargin - Margin;
+ ReposLbl.WordWrap := True;
+ ReposLbl.AutoSize := True;
+ ReposLbl.Caption := Trim(Repos);
+ Y := ReposLbl.Top + ReposLbl.Height + ScaleY(16);
+
+ RemountRadio := TNewRadioButton.Create(Form);
+ RemountRadio.Parent := Form;
+ RemountRadio.Left := Margin;
+ RemountRadio.Top := Y;
+ RemountRadio.Width := ContentWidth;
+ RemountRadio.Caption := 'Remount repos as part of the installation';
+ RemountRadio.Checked := True;
+ Y := RemountRadio.Top + RemountRadio.Height + ScaleY(2);
+
+ RemountDescLbl := TNewStaticText.Create(Form);
+ RemountDescLbl.Parent := Form;
+ RemountDescLbl.Left := IndentMargin;
+ RemountDescLbl.Top := Y;
+ RemountDescLbl.Width := Form.ClientWidth - IndentMargin - Margin;
+ RemountDescLbl.WordWrap := True;
+ RemountDescLbl.AutoSize := True;
+ RemountDescLbl.Caption := 'They will be temporarily unavailable.';
+ Y := RemountDescLbl.Top + RemountDescLbl.Height + ScaleY(14);
+
+ KeepRadio := TNewRadioButton.Create(Form);
+ KeepRadio.Parent := Form;
+ KeepRadio.Left := Margin;
+ KeepRadio.Top := Y;
+ KeepRadio.Width := ContentWidth;
+ KeepRadio.Caption := 'Keep repos mounted';
+ Y := KeepRadio.Top + KeepRadio.Height + ScaleY(2);
+
+ KeepDescLbl := TNewStaticText.Create(Form);
+ KeepDescLbl.Parent := Form;
+ KeepDescLbl.Left := IndentMargin;
+ KeepDescLbl.Top := Y;
+ KeepDescLbl.Width := Form.ClientWidth - IndentMargin - Margin;
+ KeepDescLbl.WordWrap := True;
+ KeepDescLbl.AutoSize := True;
+ KeepDescLbl.Caption := 'The upgrade will complete automatically when all repos are unmounted, or at next reboot.';
+ Y := KeepDescLbl.Top + KeepDescLbl.Height + ScaleY(20);
+
+ BtnContinue := TNewButton.Create(Form);
+ BtnContinue.Parent := Form;
+ BtnContinue.Width := ButtonWidth;
+ BtnContinue.Height := ButtonHeight;
+ BtnContinue.Top := Y;
+ BtnContinue.Left := Form.ClientWidth - Margin - ButtonWidth - ScaleX(10) - ButtonWidth;
+ BtnContinue.Caption := '&Continue';
+ BtnContinue.Default := True;
+ BtnContinue.ModalResult := mrOk;
+
+ BtnCancel := TNewButton.Create(Form);
+ BtnCancel.Parent := Form;
+ BtnCancel.Width := ButtonWidth;
+ BtnCancel.Height := ButtonHeight;
+ BtnCancel.Top := Y;
+ BtnCancel.Left := Form.ClientWidth - Margin - ButtonWidth;
+ BtnCancel.Caption := '&Cancel';
+ BtnCancel.Cancel := True;
+ BtnCancel.ModalResult := mrCancel;
+
+ Form.ClientHeight := Y + ButtonHeight + ScaleY(15);
+ Form.ActiveControl := BtnContinue;
+
+ ModalResult := Form.ShowModal();
+ if ModalResult = mrOk then
+ begin
+ KeepMounted := KeepRadio.Checked;
+ Result := True;
+ end
+ else
+ begin
+ Result := False;
+ end;
+ finally
+ Form.Free();
+ end;
+end;
+
function PrepareToInstall(var NeedsRestart: Boolean): String;
var
- MsgBoxResult: integer;
Repos: ansiString;
ResultCode: integer;
HasMounts: Boolean;
@@ -805,19 +937,10 @@ begin
end
else
begin
- // Interactive mode: let user choose
- MsgBoxResult := SuppressibleMsgBox(
- 'The following repos are currently mounted:' + #13#10 + Repos + #13#10#13#10 +
- 'Click Yes to keep repos mounted during the upgrade.' + #13#10 +
- 'The upgrade will complete automatically when all repos are unmounted.' + #13#10#13#10 +
- 'Click No to unmount all repos now and upgrade without restart.' + #13#10 +
- 'Repos will be temporarily unavailable during the upgrade.',
- mbConfirmation, MB_YESNOCANCEL, IDYES);
- if MsgBoxResult = IDYES then
- KeepMountsRunning := True
- else if MsgBoxResult = IDNO then
- KeepMountsRunning := False
- else
+ // Interactive mode: show a radio-button modal so the user can pick
+ // between remounting (immediate but brief unavailability) and
+ // staging the upgrade (deferred until repos are unmounted).
+ if not ShowMountChoiceDialog(Repos, KeepMountsRunning) then
begin
Result := 'Installation cancelled.';
exit;
diff --git a/GVFS/GVFS.Mount/InProcessMount.cs b/GVFS/GVFS.Mount/InProcessMount.cs
index 1272eb876b..b88af37fc0 100644
--- a/GVFS/GVFS.Mount/InProcessMount.cs
+++ b/GVFS/GVFS.Mount/InProcessMount.cs
@@ -5,6 +5,7 @@
using GVFS.Common.Http;
using GVFS.Common.Maintenance;
using GVFS.Common.NamedPipes;
+using GVFS.Common.Prefetch;
using GVFS.Common.Tracing;
using GVFS.PlatformLoader;
using GVFS.Virtualization;
@@ -55,7 +56,8 @@ public class InProcessMount
private GVFSContext context;
private GVFSGitObjects gitObjects;
- private MountState currentState;
+ private volatile MountState currentState;
+ private volatile string mountProgressMessage;
private HeartbeatThread heartbeat;
private ManualResetEvent unmountEvent;
@@ -126,8 +128,23 @@ private void MountWithLockAcquired(EventLevel verbosity, Keywords keywords)
// TryInitializeAndQueryGVFSConfig combines the anonymous probe, credential fetch,
// and config query into at most 2 HTTP requests (1 for anonymous repos), reusing
// the same HttpClient/TCP connection.
+ Stopwatch mountPhaseTimer = Stopwatch.StartNew();
Stopwatch parallelTimer = Stopwatch.StartNew();
+ bool hasCacheServer = this.cacheServer != null && !string.IsNullOrWhiteSpace(this.cacheServer.Url);
+ this.tracer.RelatedEvent(
+ EventLevel.Informational,
+ "MountPhase",
+ new EventMetadata
+ {
+ { "Phase", "ParallelMountStarted" },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
+ },
+ Keywords.Telemetry);
+
+ // When a cache server is configured locally, auth/config is best-effort:
+ // mount can proceed without it. We still attempt it so GCM can pop up a
+ // renewal prompt for stale tokens, but we don't block mount on the result.
var networkTask = Task.Run(() =>
{
Stopwatch sw = Stopwatch.StartNew();
@@ -137,22 +154,44 @@ private void MountWithLockAcquired(EventLevel verbosity, Keywords keywords)
if (!this.enlistment.Authentication.TryInitializeAndQueryGVFSConfig(
this.tracer, this.enlistment, this.retryConfig,
- out config, out authConfigError, out isAuthFailure))
+ out config, out authConfigError, out isAuthFailure,
+ credentialTimeoutMs: hasCacheServer ? GitAuthentication.BackgroundCredentialTimeoutMs : GitAuthentication.DefaultCredentialTimeoutMs))
{
- if (this.cacheServer != null && !string.IsNullOrWhiteSpace(this.cacheServer.Url))
+ if (hasCacheServer)
{
this.tracer.RelatedWarning("Mount will proceed with fallback cache server: " + authConfigError);
config = null;
}
else
{
+ ReturnCode exitCode = ReturnCode.RemoteGvfsConfigError;
+ if (isAuthFailure)
+ {
+ exitCode = authConfigError != null && authConfigError.Contains("Credential manager did not respond")
+ ? ReturnCode.CredentialTimeout
+ : ReturnCode.AuthenticationError;
+ }
+
this.FailMountAndExit(
- isAuthFailure ? ReturnCode.AuthenticationError : ReturnCode.GenericError,
+ exitCode,
"Unable to query /gvfs/config" + Environment.NewLine + authConfigError);
}
}
- this.ValidateGVFSVersion(config);
+ this.ValidateGVFSVersion(config, failOnError: !hasCacheServer);
+
+ this.tracer.RelatedEvent(
+ EventLevel.Informational,
+ "MountPhase",
+ new EventMetadata
+ {
+ { "Phase", "NetworkValidationComplete" },
+ { "DurationMs", sw.ElapsedMilliseconds },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
+ },
+ Keywords.Telemetry);
+
+
this.tracer.RelatedInfo("ParallelMount: Auth + config completed in {0}ms", sw.ElapsedMilliseconds);
return config;
});
@@ -194,67 +233,142 @@ private void MountWithLockAcquired(EventLevel verbosity, Keywords keywords)
this.enlistment.InitializeCachePaths(localCacheRoot, gitObjectsRoot, blobSizesRoot);
- // Local validations and git config run while we wait for the network
- var localTask = Task.Run(() =>
+ // Start the pipe server early so MountVerb can connect and poll progress
+ // during the parallel validation phase. Only GetStatus requests are
+ // handled while currentState == Mounting (see HandleRequest guard).
+ this.mountProgressMessage = "Authenticating and validating";
+ using (NamedPipeServer pipeServer = this.StartNamedPipe())
{
- Stopwatch sw = Stopwatch.StartNew();
+ this.tracer.RelatedEvent(
+ EventLevel.Informational,
+ $"{nameof(this.Mount)}_StartedNamedPipe",
+ new EventMetadata { { "NamedPipeName", this.enlistment.NamedPipeName } });
- this.ValidateGitVersion();
- this.tracer.RelatedInfo("ParallelMount: ValidateGitVersion completed in {0}ms", sw.ElapsedMilliseconds);
+ // Local validations and git config run while we wait for the network
+ Task localTask = Task.Run(() =>
+ {
+ Stopwatch sw = Stopwatch.StartNew();
- this.ValidateHooksVersion();
- this.ValidateFileSystemSupportsRequiredFeatures();
+ this.ValidateGitVersion();
+ this.tracer.RelatedInfo("ParallelMount: ValidateGitVersion completed in {0}ms", sw.ElapsedMilliseconds);
- GitProcess git = new GitProcess(this.enlistment);
- if (!git.IsValidRepo())
- {
- this.FailMountAndExit("The .git folder is missing or has invalid contents");
- }
+ this.ValidateHooksVersion();
+ this.ValidateFileSystemSupportsRequiredFeatures();
- if (!GVFSPlatform.Instance.FileSystem.IsFileSystemSupported(this.enlistment.WorkingDirectoryRoot, out string fsError))
- {
- this.FailMountAndExit("FileSystem unsupported: " + fsError);
- }
+ GitProcess git = new GitProcess(this.enlistment);
+ if (!git.IsValidRepo())
+ {
+ this.FailMountAndExit("The .git folder is missing or has invalid contents");
+ }
- this.tracer.RelatedInfo("ParallelMount: Local validations completed in {0}ms", sw.ElapsedMilliseconds);
+ if (!GVFSPlatform.Instance.FileSystem.IsFileSystemSupported(this.enlistment.WorkingDirectoryRoot, out string fsError))
+ {
+ this.FailMountAndExit("FileSystem unsupported: " + fsError);
+ }
+
+ this.tracer.RelatedInfo("ParallelMount: Local validations completed in {0}ms", sw.ElapsedMilliseconds);
+
+ if (!this.TrySetRequiredGitConfigSettings())
+ {
+ this.FailMountAndExit("Unable to configure git repo");
+ }
- if (!this.TrySetRequiredGitConfigSettings())
+ this.LogEnlistmentInfoAndSetConfigValues();
+
+ this.tracer.RelatedEvent(
+ EventLevel.Informational,
+ "MountPhase",
+ new EventMetadata
+ {
+ { "Phase", "LocalValidationComplete" },
+ { "DurationMs", sw.ElapsedMilliseconds },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
+ },
+ Keywords.Telemetry);
+
+ this.tracer.RelatedInfo("ParallelMount: Local validations + git config completed in {0}ms", sw.ElapsedMilliseconds);
+ });
+
+ try
+ {
+ if (hasCacheServer)
+ {
+ // With a cache server, don't block mount on the network task.
+ // Auth runs in the background to warm credentials / pop GCM,
+ // but mount proceeds immediately using the local cache server URL.
+ localTask.Wait();
+
+ // Observe background task exceptions so they don't go unhandled.
+ networkTask.ContinueWith(
+ t => this.tracer.RelatedWarning("Background auth task failed: " + t.Exception.Flatten().InnerExceptions[0].Message),
+ TaskContinuationOptions.OnlyOnFaulted);
+ }
+ else
+ {
+ Task.WaitAll(networkTask, localTask);
+ }
+ }
+ catch (AggregateException ae)
{
- this.FailMountAndExit("Unable to configure git repo");
+ this.FailMountAndExit(ae.Flatten().InnerExceptions[0].Message);
}
- this.LogEnlistmentInfoAndSetConfigValues();
- this.tracer.RelatedInfo("ParallelMount: Local validations + git config completed in {0}ms", sw.ElapsedMilliseconds);
- });
+ parallelTimer.Stop();
+ this.tracer.RelatedInfo("ParallelMount: All parallel tasks completed in {0}ms", parallelTimer.ElapsedMilliseconds);
- try
- {
- Task.WaitAll(networkTask, localTask);
- }
- catch (AggregateException ae)
- {
- this.FailMountAndExit(ae.Flatten().InnerExceptions[0].Message);
- }
+ this.tracer.RelatedEvent(
+ EventLevel.Informational,
+ "MountPhase",
+ new EventMetadata
+ {
+ { "Phase", "ParallelMountComplete" },
+ { "DurationMs", parallelTimer.ElapsedMilliseconds },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
+ },
+ Keywords.Telemetry);
- parallelTimer.Stop();
- this.tracer.RelatedInfo("ParallelMount: All parallel tasks completed in {0}ms", parallelTimer.ElapsedMilliseconds);
+ ServerGVFSConfig serverGVFSConfig = hasCacheServer ? null : networkTask.Result;
- ServerGVFSConfig serverGVFSConfig = networkTask.Result;
+ this.mountProgressMessage = "Resolving cache server";
+ CacheServerResolver cacheServerResolver = new CacheServerResolver(this.tracer, this.enlistment);
+ this.cacheServer = cacheServerResolver.ResolveNameFromRemote(this.cacheServer.Url, serverGVFSConfig);
- CacheServerResolver cacheServerResolver = new CacheServerResolver(this.tracer, this.enlistment);
- this.cacheServer = cacheServerResolver.ResolveNameFromRemote(this.cacheServer.Url, serverGVFSConfig);
+ this.tracer.RelatedEvent(
+ EventLevel.Informational,
+ "MountPhase",
+ new EventMetadata
+ {
+ { "Phase", "CacheServerResolved" },
+ { "CacheServerUrl", this.cacheServer.Url ?? string.Empty },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
+ },
+ Keywords.Telemetry);
- this.EnsureLocalCacheIsHealthy(serverGVFSConfig);
+ this.EnsureLocalCacheIsHealthy(serverGVFSConfig);
- using (NamedPipeServer pipeServer = this.StartNamedPipe())
- {
this.tracer.RelatedEvent(
EventLevel.Informational,
- $"{nameof(this.Mount)}_StartedNamedPipe",
- new EventMetadata { { "NamedPipeName", this.enlistment.NamedPipeName } });
+ "MountPhase",
+ new EventMetadata
+ {
+ { "Phase", "LocalCacheHealthy" },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
+ },
+ Keywords.Telemetry);
+ this.mountProgressMessage = "Preparing mount";
this.context = this.CreateContext();
+ this.tracer.RelatedEvent(
+ EventLevel.Informational,
+ "MountPhase",
+ new EventMetadata
+ {
+ { "Phase", "ContextCreated" },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
+ },
+ Keywords.Telemetry);
+
if (this.context.Unattended)
{
this.tracer.RelatedEvent(EventLevel.Critical, GVFSConstants.UnattendedEnvironmentVariable, null);
@@ -271,10 +385,43 @@ private void MountWithLockAcquired(EventLevel verbosity, Keywords keywords)
this.FailMountAndExit(errorMessage);
}
+ this.tracer.RelatedEvent(
+ EventLevel.Informational,
+ "MountPhase",
+ new EventMetadata
+ {
+ { "Phase", "HooksUpdated" },
+ { "Skipped", this.enlistment.IsWorktree },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
+ },
+ Keywords.Telemetry);
+
GVFSPlatform.Instance.ConfigureVisualStudio(this.enlistment.GitBinPath, this.tracer);
+ this.mountProgressMessage = "Starting virtualization";
+
+ this.tracer.RelatedEvent(
+ EventLevel.Informational,
+ "MountPhase",
+ new EventMetadata
+ {
+ { "Phase", "VirtualizationStarting" },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
+ },
+ Keywords.Telemetry);
+
this.MountAndStartWorkingDirectoryCallbacks(this.cacheServer);
+ this.tracer.RelatedEvent(
+ EventLevel.Informational,
+ "MountPhase",
+ new EventMetadata
+ {
+ { "Phase", "VirtualizationComplete" },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
+ },
+ Keywords.Telemetry);
+
try
{
Console.Title = "GVFS " + ProcessHelper.GetCurrentProcessVersion() + " - " + this.enlistment.WorkingDirectoryRoot;
@@ -292,9 +439,11 @@ private void MountWithLockAcquired(EventLevel verbosity, Keywords keywords)
// Use TracingConstants.MessageKey.InfoMessage rather than TracingConstants.MessageKey.CriticalMessage
// as this message should not appear as an error
{ TracingConstants.MessageKey.InfoMessage, "Virtual repo is ready" },
+ { "ElapsedMs", mountPhaseTimer.ElapsedMilliseconds },
},
Keywords.Telemetry);
+ this.mountProgressMessage = null;
this.currentState = MountState.Ready;
this.unmountEvent.WaitOne();
@@ -474,60 +623,90 @@ private void HandleRequest(ITracer tracer, string request, NamedPipeServer.Conne
{
NamedPipeMessages.Message message = NamedPipeMessages.Message.FromString(request);
- switch (message.Header)
+ // While mounting, only GetStatus requests are safe — other handlers depend
+ // on context, fileSystemCallbacks, etc. that aren't initialized yet.
+ // MountFailed is NOT guarded: HandleUnmountRequest needs to reach the
+ // "unmount even if mount failed" path so users aren't forced to kill the process.
+ if (message.Header != NamedPipeMessages.GetStatus.Request &&
+ this.currentState == MountState.Mounting)
{
- case NamedPipeMessages.GetStatus.Request:
- this.HandleGetStatusRequest(connection);
- break;
-
- case NamedPipeMessages.Unmount.Request:
- this.HandleUnmountRequest(connection);
- break;
-
- case NamedPipeMessages.AcquireLock.AcquireRequest:
- this.HandleLockRequest(message.Body, connection);
- break;
-
- case NamedPipeMessages.ReleaseLock.Request:
- this.HandleReleaseLockRequest(message.Body, connection);
- break;
-
- case NamedPipeMessages.DownloadObject.DownloadRequest:
- this.HandleDownloadObjectRequest(message, connection);
- break;
-
- case NamedPipeMessages.ModifiedPaths.ListRequest:
- this.HandleModifiedPathsListRequest(message, connection);
- break;
-
- case NamedPipeMessages.PostIndexChanged.NotificationRequest:
- this.HandlePostIndexChangedRequest(message, connection);
- break;
-
- case NamedPipeMessages.PrepareForUnstage.Request:
- this.HandlePrepareForUnstageRequest(message, connection);
- break;
-
- case NamedPipeMessages.RunPostFetchJob.PostFetchJob:
- this.HandlePostFetchJobRequest(message, connection);
- break;
-
- case NamedPipeMessages.DehydrateFolders.Dehydrate:
- this.HandleDehydrateFolders(message, connection);
- break;
-
- case NamedPipeMessages.HydrationStatus.Request:
- this.HandleGetHydrationStatusRequest(connection);
- break;
-
- default:
- EventMetadata metadata = new EventMetadata();
- metadata.Add("Area", "Mount");
- metadata.Add("Header", message.Header);
- this.tracer.RelatedError(metadata, "HandleRequest: Unknown request");
+ connection.TrySendResponse(NamedPipeMessages.MountNotReadyResult);
+ return;
+ }
- connection.TrySendResponse(NamedPipeMessages.UnknownRequest);
- break;
+ try
+ {
+ switch (message.Header)
+ {
+ case NamedPipeMessages.GetStatus.Request:
+ this.HandleGetStatusRequest(connection);
+ break;
+
+ case NamedPipeMessages.Unmount.Request:
+ this.HandleUnmountRequest(connection);
+ break;
+
+ case NamedPipeMessages.AcquireLock.AcquireRequest:
+ this.HandleLockRequest(message.Body, connection);
+ break;
+
+ case NamedPipeMessages.ReleaseLock.Request:
+ this.HandleReleaseLockRequest(message.Body, connection);
+ break;
+
+ case NamedPipeMessages.DownloadObject.DownloadRequest:
+ this.HandleDownloadObjectRequest(message, connection);
+ break;
+
+ case NamedPipeMessages.ModifiedPaths.ListRequest:
+ this.HandleModifiedPathsListRequest(message, connection);
+ break;
+
+ case NamedPipeMessages.PostIndexChanged.NotificationRequest:
+ this.HandlePostIndexChangedRequest(message, connection);
+ break;
+
+ case NamedPipeMessages.PrepareForUnstage.Request:
+ this.HandlePrepareForUnstageRequest(message, connection);
+ break;
+
+ case NamedPipeMessages.RunPostFetchJob.PostFetchJob:
+ this.HandlePostFetchJobRequest(message, connection);
+ break;
+
+ case NamedPipeMessages.DehydrateFolders.Dehydrate:
+ this.HandleDehydrateFolders(message, connection);
+ break;
+
+ case NamedPipeMessages.PrefetchCommits.Request:
+ this.HandlePrefetchCommitsRequest(connection);
+ break;
+
+ case NamedPipeMessages.PrefetchBlobs.RequestHeader:
+ this.HandlePrefetchBlobsRequest(message, connection);
+ break;
+
+ case NamedPipeMessages.HydrationStatus.Request:
+ this.HandleGetHydrationStatusRequest(connection);
+ break;
+
+ default:
+ EventMetadata metadata = new EventMetadata();
+ metadata.Add("Area", "Mount");
+ metadata.Add("Header", message.Header);
+ this.tracer.RelatedError(metadata, "HandleRequest: Unknown request");
+
+ connection.TrySendResponse(NamedPipeMessages.UnknownRequest);
+ break;
+ }
+ }
+ catch (Exception e) when (e is not OutOfMemoryException)
+ {
+ EventMetadata metadata = new EventMetadata();
+ metadata.Add("Area", "Mount");
+ metadata.Add("Header", message.Header);
+ metadata.Add("Exception", e.ToString());
+ this.tracer.RelatedError(metadata, "HandleRequest: Unhandled exception in request handler");
}
}
@@ -872,56 +1051,76 @@ private void HandleDownloadObjectRequest(NamedPipeMessages.Message message, Name
}
else
{
- Stopwatch downloadTime = Stopwatch.StartNew();
-
- /* If this is the root tree for a commit that was was just downloaded, assume that more
- * trees will be needed soon and download them as well by using the download commit API.
- *
- * Otherwise, or as a fallback if the commit download fails, download the object directly.
- */
- if (this.ShouldDownloadCommitPack(objectSha, out string commitSha)
- && this.gitObjects.TryDownloadCommit(commitSha))
- {
- this.DownloadedCommitPack(commitSha);
- response = new NamedPipeMessages.DownloadObject.Response(NamedPipeMessages.DownloadObject.SuccessResult);
- // FUTURE: Should the stats be updated to reflect all the trees in the pack?
- // FUTURE: Should we try to clean up duplicate trees or increase depth of the commit download?
- }
- else if (this.gitObjects.TryDownloadAndSaveObject(objectSha, GVFSGitObjects.RequestSource.NamedPipeMessage) == GitObjects.DownloadAndSaveObjectResult.Success)
+ try
{
- this.UpdateTreesForDownloadedCommits(objectSha);
- response = new NamedPipeMessages.DownloadObject.Response(NamedPipeMessages.DownloadObject.SuccessResult);
+ response = this.DownloadObject(objectSha);
}
- else
+ catch (Exception e) when (e is not OutOfMemoryException)
{
+ EventMetadata metadata = new EventMetadata();
+ metadata.Add("Area", "Mount");
+ metadata.Add("objectSha", objectSha);
+ metadata.Add("Exception", e.ToString());
+ this.tracer.RelatedWarning(metadata, nameof(this.HandleDownloadObjectRequest) + ": Exception downloading object");
+
response = new NamedPipeMessages.DownloadObject.Response(NamedPipeMessages.DownloadObject.DownloadFailed);
}
+ }
+ }
+
+ connection.TrySendResponse(response.CreateMessage());
+ }
+ private NamedPipeMessages.DownloadObject.Response DownloadObject(string objectSha)
+ {
+ NamedPipeMessages.DownloadObject.Response response;
+ Stopwatch downloadTime = Stopwatch.StartNew();
- Native.ObjectTypes? objectType;
- this.context.Repository.TryGetObjectType(objectSha, out objectType);
- this.context.Repository.GVFSLock.Stats.RecordObjectDownload(objectType == Native.ObjectTypes.Blob, downloadTime.ElapsedMilliseconds);
+ /* If this is the root tree for a commit that was was just downloaded, assume that more
+ * trees will be needed soon and download them as well by using the download commit API.
+ *
+ * Otherwise, or as a fallback if the commit download fails, download the object directly.
+ */
+ if (this.ShouldDownloadCommitPack(objectSha, out string commitSha)
+ && this.gitObjects.TryDownloadCommit(commitSha))
+ {
+ this.DownloadedCommitPack(commitSha);
+ response = new NamedPipeMessages.DownloadObject.Response(NamedPipeMessages.DownloadObject.SuccessResult);
+ // FUTURE: Should the stats be updated to reflect all the trees in the pack?
+ // FUTURE: Should we try to clean up duplicate trees or increase depth of the commit download?
+ }
+ else if (this.gitObjects.TryDownloadAndSaveObject(objectSha, GVFSGitObjects.RequestSource.NamedPipeMessage) == GitObjects.DownloadAndSaveObjectResult.Success)
+ {
+ this.UpdateTreesForDownloadedCommits(objectSha);
+ response = new NamedPipeMessages.DownloadObject.Response(NamedPipeMessages.DownloadObject.SuccessResult);
+ }
+ else
+ {
+ response = new NamedPipeMessages.DownloadObject.Response(NamedPipeMessages.DownloadObject.DownloadFailed);
+ }
- if (objectType == Native.ObjectTypes.Commit
- && !this.context.Repository.CommitAndRootTreeExists(objectSha, out var treeSha)
- && !string.IsNullOrEmpty(treeSha))
- {
- /* If a commit is downloaded, it wasn't prefetched.
- * The trees for the commit may be needed soon depending on the context.
- * e.g. git log (without a pathspec) doesn't need trees, but git checkout does.
- *
- * If any prefetch has been done there is probably a similar commit/tree in the graph,
- * but in case there isn't (such as if the cache server repack maintenance job is failing)
- * we should still try to avoid downloading an excessive number of loose trees for a commit.
- *
- * Save the tree/commit so if more trees are requested we can download all the trees for the commit in a batch.
- */
- this.missingTreeTracker.AddMissingRootTree(treeSha: treeSha, commitSha: objectSha);
- }
- }
+ Native.ObjectTypes? objectType;
+ this.context.Repository.TryGetObjectType(objectSha, out objectType);
+ this.context.Repository.GVFSLock.Stats.RecordObjectDownload(objectType == Native.ObjectTypes.Blob, downloadTime.ElapsedMilliseconds);
+
+ if (objectType == Native.ObjectTypes.Commit
+ && !this.context.Repository.CommitAndRootTreeExists(objectSha, out var treeSha)
+ && !string.IsNullOrEmpty(treeSha))
+ {
+ /* If a commit is downloaded, it wasn't prefetched.
+ * The trees for the commit may be needed soon depending on the context.
+ * e.g. git log (without a pathspec) doesn't need trees, but git checkout does.
+ *
+ * If any prefetch has been done there is probably a similar commit/tree in the graph,
+ * but in case there isn't (such as if the cache server repack maintenance job is failing)
+ * we should still try to avoid downloading an excessive number of loose trees for a commit.
+ *
+ * Save the tree/commit so if more trees are requested we can download all the trees for the commit in a batch.
+ */
+ this.missingTreeTracker.AddMissingRootTree(treeSha: treeSha, commitSha: objectSha);
}
- connection.TrySendResponse(response.CreateMessage());
+ return response;
}
private bool ShouldDownloadCommitPack(string objectSha, out string commitSha)
@@ -993,20 +1192,192 @@ private void HandlePostFetchJobRequest(NamedPipeMessages.Message message, NamedP
connection.TrySendResponse(response.CreateMessage());
}
+ private void HandlePrefetchCommitsRequest(NamedPipeServer.Connection connection)
+ {
+ this.tracer.RelatedInfo("Received prefetch commits request");
+
+ if (this.currentState != MountState.Ready)
+ {
+ connection.TrySendResponse(
+ new NamedPipeMessages.Message(NamedPipeMessages.PrefetchCommits.MountNotReadyResult, null));
+ return;
+ }
+
+ NamedPipeMessages.PrefetchCommits.Response response;
+ try
+ {
+ // Use a callback to enqueue the post-fetch step directly on the
+ // maintenance scheduler, avoiding a re-entrant named pipe call.
+ PrefetchStep prefetchStep = new PrefetchStep(
+ this.context,
+ this.gitObjects,
+ requireCacheLock: false,
+ postFetchCallback: packIndexes =>
+ {
+ this.maintenanceScheduler.EnqueueOneTimeStep(new PostFetchStep(this.context, packIndexes));
+ });
+
+ string error;
+ bool success = prefetchStep.TryPrefetchCommitsAndTrees(out error);
+
+ response = new NamedPipeMessages.PrefetchCommits.Response
+ {
+ Success = success,
+ Error = error,
+ };
+ }
+ catch (Exception e)
+ {
+ this.tracer.RelatedError("HandlePrefetchCommitsRequest: Exception: {0}", e.ToString());
+ response = new NamedPipeMessages.PrefetchCommits.Response
+ {
+ Success = false,
+ Error = e.Message,
+ };
+ }
+
+ connection.TrySendResponse(response.CreateMessage());
+ }
+
+ private void HandlePrefetchBlobsRequest(NamedPipeMessages.Message message, NamedPipeServer.Connection connection)
+ {
+ this.tracer.RelatedInfo("Received prefetch blobs request");
+
+ if (this.currentState != MountState.Ready)
+ {
+ connection.TrySendResponse(
+ new NamedPipeMessages.Message(NamedPipeMessages.PrefetchBlobs.MountNotReadyResult, null));
+ return;
+ }
+
+ NamedPipeMessages.PrefetchBlobs.Request request = NamedPipeMessages.PrefetchBlobs.Request.FromMessage(message);
+
+ // Validate inputs — do not trust IPC requests blindly
+ if (request.Files == null || request.Folders == null)
+ {
+ connection.TrySendResponse(new NamedPipeMessages.PrefetchBlobs.Response
+ {
+ Success = false,
+ Error = "Files and Folders must not be null",
+ }.CreateMessage());
+ return;
+ }
+
+ if (request.Files.Count == 0 && request.Folders.Count == 0)
+ {
+ connection.TrySendResponse(new NamedPipeMessages.PrefetchBlobs.Response
+ {
+ Success = false,
+ Error = "Files and Folders must not both be empty",
+ }.CreateMessage());
+ return;
+ }
+
+ if (string.IsNullOrWhiteSpace(request.HeadCommitId))
+ {
+ connection.TrySendResponse(new NamedPipeMessages.PrefetchBlobs.Response
+ {
+ Success = false,
+ Error = "HeadCommitId must be specified",
+ }.CreateMessage());
+ return;
+ }
+
+ NamedPipeMessages.PrefetchBlobs.Response response;
+ try
+ {
+ // Create a fresh GitObjectsHttpRequestor using the mount's warm auth.
+ // BlobPrefetcher constructs its own PrefetchGitObjects internally.
+ using (GitObjectsHttpRequestor objectRequestor = new GitObjectsHttpRequestor(
+ this.tracer, this.enlistment, this.cacheServer, this.retryConfig))
+ {
+ // Open LastBlobPrefetch.dat so BlobPrefetcher can update noop state
+ string lastPrefetchPath = Path.Combine(this.enlistment.DotGVFSRoot, "LastBlobPrefetch.dat");
+ FileBasedDictionary lastPrefetchArgs;
+ string dictError;
+ if (!FileBasedDictionary.TryCreate(
+ this.tracer, lastPrefetchPath, new PhysicalFileSystem(),
+ out lastPrefetchArgs, out dictError))
+ {
+ this.tracer.RelatedWarning("HandlePrefetchBlobsRequest: Unable to load last prefetch args: " + dictError);
+ lastPrefetchArgs = null;
+ }
+
+ // Cap thread counts to avoid starving virtualization callbacks
+ int maxThreads = Math.Max(1, Environment.ProcessorCount / 2);
+ int downloadThreads = Math.Min(maxThreads, 16);
+
+ BlobPrefetcher blobPrefetcher = new BlobPrefetcher(
+ this.tracer,
+ this.enlistment,
+ objectRequestor,
+ request.Files,
+ request.Folders,
+ prefetchCache: null,
+ maxCacheSize: 0,
+ chunkSize: 4000,
+ searchThreadCount: maxThreads,
+ downloadThreadCount: downloadThreads,
+ indexThreadCount: maxThreads);
+
+ int matchedBlobCount;
+ int downloadedBlobCount;
+ int hydratedFileCount;
+
+ blobPrefetcher.PrefetchWithStats(
+ request.HeadCommitId,
+ isBranch: false,
+ hydrateFilesAfterDownload: false,
+ matchedBlobCount: out matchedBlobCount,
+ downloadedBlobCount: out downloadedBlobCount,
+ hydratedFileCount: out hydratedFileCount);
+
+ response = new NamedPipeMessages.PrefetchBlobs.Response
+ {
+ Success = !blobPrefetcher.HasFailures,
+ Error = blobPrefetcher.HasFailures ? "Blob prefetch encountered failures" : null,
+ MatchedBlobCount = matchedBlobCount,
+ DownloadedBlobCount = downloadedBlobCount,
+ };
+ }
+ }
+ catch (BlobPrefetcher.FetchException e)
+ {
+ this.tracer.RelatedError("HandlePrefetchBlobsRequest: FetchException: {0}", e.Message);
+ response = new NamedPipeMessages.PrefetchBlobs.Response
+ {
+ Success = false,
+ Error = e.Message,
+ };
+ }
+ catch (Exception e)
+ {
+ this.tracer.RelatedError("HandlePrefetchBlobsRequest: Exception: {0}", e.ToString());
+ response = new NamedPipeMessages.PrefetchBlobs.Response
+ {
+ Success = false,
+ Error = e.Message,
+ };
+ }
+
+ connection.TrySendResponse(response.CreateMessage());
+ }
+
private void HandleGetStatusRequest(NamedPipeServer.Connection connection)
{
NamedPipeMessages.GetStatus.Response response = new NamedPipeMessages.GetStatus.Response();
response.EnlistmentRoot = this.enlistment.WorkingDirectoryRoot;
response.LocalCacheRoot = !string.IsNullOrWhiteSpace(this.enlistment.LocalCacheRoot) ? this.enlistment.LocalCacheRoot : this.enlistment.GitObjectsRoot;
response.RepoUrl = this.enlistment.RepoUrl;
- response.CacheServer = this.cacheServer.ToString();
- response.LockStatus = this.context?.Repository.GVFSLock != null ? this.context.Repository.GVFSLock.GetStatus() : "Unavailable";
+ response.CacheServer = this.cacheServer?.ToString() ?? string.Empty;
+ response.LockStatus = this.context?.Repository?.GVFSLock != null ? this.context.Repository.GVFSLock.GetStatus() : "Unavailable";
response.DiskLayoutVersion = $"{GVFSPlatform.Instance.DiskLayoutUpgrade.Version.CurrentMajorVersion}.{GVFSPlatform.Instance.DiskLayoutUpgrade.Version.CurrentMinorVersion}";
switch (this.currentState)
{
case MountState.Mounting:
response.MountStatus = NamedPipeMessages.GetStatus.Mounting;
+ response.MountProgress = this.mountProgressMessage;
break;
case MountState.Ready:
@@ -1235,7 +1606,7 @@ private ServerGVFSConfig QueryAndValidateGVFSConfig()
return serverGVFSConfig;
}
- private void ValidateGVFSVersion(ServerGVFSConfig config)
+ private void ValidateGVFSVersion(ServerGVFSConfig config, bool failOnError = true)
{
using (ITracer activity = this.tracer.StartActivity("ValidateGVFSVersion", EventLevel.Informational))
{
@@ -1287,7 +1658,10 @@ private void ValidateGVFSVersion(ServerGVFSConfig config)
}
activity.RelatedError("GVFS version {0} is not supported", currentVersion);
- this.FailMountAndExit("ERROR: Your GVFS version is no longer supported. Install the latest and try again.");
+ if (failOnError)
+ {
+ this.FailMountAndExit("ERROR: Your GVFS version is no longer supported. Install the latest and try again.");
+ }
}
}
diff --git a/GVFS/GVFS.NativeTests/GVFS.NativeTests.vcxproj b/GVFS/GVFS.NativeTests/GVFS.NativeTests.vcxproj
index ae216cfaef..041163bead 100644
--- a/GVFS/GVFS.NativeTests/GVFS.NativeTests.vcxproj
+++ b/GVFS/GVFS.NativeTests/GVFS.NativeTests.vcxproj
@@ -1,7 +1,6 @@
- GVFS.ProjFS.2019.411.1
@@ -12,6 +11,14 @@
Release
x64
+
+ Debug
+ ARM64
+
+
+ Release
+ ARM64
+
{3771C555-B5C1-45E2-B8B7-2CEF1619CDC5}
@@ -20,38 +27,38 @@
10.0
-
+
DynamicLibrary
- true
- v143
+ true
NotSet
+ v143
-
+
DynamicLibrary
- false
- v143
+ false
true
NotSet
+ v143
-
+
-
+
-
+
true
-
+
false
-
+
Use
Level4
@@ -65,10 +72,10 @@
Windows
true
ProjectedFSLib.lib;fltlib.lib;Shlwapi.lib;%(AdditionalDependencies)
- C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\x64;$(BuildPackagesPath)$(ProjFSNativePackage)\lib
+ C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\$(Platform.ToLower());C:\Program Files (x86)\Windows Kits\10\Lib\10.0.26100.0\um\$(Platform.ToLower())
-
+
Level4
Use
@@ -86,7 +93,7 @@
true
true
ProjectedFSLib.lib;fltlib.lib;Shlwapi.lib;%(AdditionalDependencies)
- C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\x64;$(BuildPackagesPath)$(ProjFSNativePackage)\lib
+ C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\$(Platform.ToLower());C:\Program Files (x86)\Windows Kits\10\Lib\10.0.26100.0\um\$(Platform.ToLower())
@@ -124,11 +131,11 @@
- false
-
+ false
+
- false
-
+ false
+
@@ -148,12 +155,9 @@
- Create
- Create
+ Create
+ Create
-
-
-
\ No newline at end of file
diff --git a/GVFS/GVFS.NativeTests/GVFS.NativeTests.vcxproj.filters b/GVFS/GVFS.NativeTests/GVFS.NativeTests.vcxproj.filters
index 4dfa38544d..ca1de7f428 100644
--- a/GVFS/GVFS.NativeTests/GVFS.NativeTests.vcxproj.filters
+++ b/GVFS/GVFS.NativeTests/GVFS.NativeTests.vcxproj.filters
@@ -1,4 +1,4 @@
-
+
@@ -160,7 +160,4 @@
source
-
-
-
\ No newline at end of file
diff --git a/GVFS/GVFS.NativeTests/packages.config b/GVFS/GVFS.NativeTests/packages.config
deleted file mode 100644
index 0dac1a4251..0000000000
--- a/GVFS/GVFS.NativeTests/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-
-
-
-
\ No newline at end of file
diff --git a/GVFS/GVFS.Payload/GVFS.Payload.csproj b/GVFS/GVFS.Payload/GVFS.Payload.csproj
index e400a2a945..eabf1e1eca 100644
--- a/GVFS/GVFS.Payload/GVFS.Payload.csproj
+++ b/GVFS/GVFS.Payload/GVFS.Payload.csproj
@@ -14,7 +14,7 @@
-
+
diff --git a/GVFS/GVFS.Payload/layout.bat b/GVFS/GVFS.Payload/layout.bat
index fbaf9ea7cb..a75bcd9795 100644
--- a/GVFS/GVFS.Payload/layout.bat
+++ b/GVFS/GVFS.Payload/layout.bat
@@ -1,5 +1,6 @@
@ECHO OFF
SETLOCAL
+SETLOCAL EnableDelayedExpansion
IF "%~1" == "" (
ECHO error: missing configuration
@@ -30,18 +31,58 @@ SET GVFSVERSION=%2
SET VCRUNTIME=%3
SET OUTPUT=%4
+IF "%~5" == "" (
+ SET ARCH=x64
+) ELSE (
+ SET ARCH=%5
+)
+IF /I "%ARCH%"=="ARM64" SET ARCH=arm64
+IF /I "%ARCH%"=="X64" SET ARCH=x64
+IF "%ARCH%"=="arm64" (
+ SET NATIVE_PLATFORM=ARM64
+) ELSE (
+ SET NATIVE_PLATFORM=x64
+)
+
SET ROOT=%~dp0..\..
SET BUILD_OUT="%ROOT%\..\out"
-SET MANAGED_OUT_FRAGMENT=bin\%CONFIGURATION%\net10.0-windows10.0.17763.0\win-x64\publish
-SET NATIVE_OUT_FRAGMENT=bin\x64\%CONFIGURATION%
+SET MANAGED_OUT_FRAGMENT=bin\%CONFIGURATION%\net10.0-windows10.0.17763.0\win-%ARCH%\publish
+SET NATIVE_OUT_FRAGMENT=bin\%NATIVE_PLATFORM%\%CONFIGURATION%
-ECHO Copying files...
+ECHO Copying files for ARCH=%ARCH%...
REM ProjFS is now a Windows Optional Feature (available since Windows 10 1809).
REM The filter driver and native library are no longer bundled from a NuGet package.
-xcopy /Y %VCRUNTIME%\lib\x64\msvcp140.dll %OUTPUT%
-xcopy /Y %VCRUNTIME%\lib\x64\msvcp140_1.dll %OUTPUT%
-xcopy /Y %VCRUNTIME%\lib\x64\msvcp140_2.dll %OUTPUT%
-xcopy /Y %VCRUNTIME%\lib\x64\vcruntime140.dll %OUTPUT%
+REM
+REM VC++ runtime DLL source:
+REM * x64 -> GVFS.VCRuntime NuGet package (lib\x64\) for parity with the historical layout.
+REM * arm64 -> VS install's redist tree, since the GVFS.VCRuntime package
+REM only ships x64. VCToolsRedistDir is set by Build.bat's
+REM vcvarsall.bat call; the matching Microsoft.VC***.CRT folder
+REM is resolved with a FOR /D wildcard so this keeps working
+REM across MSVC toolset version bumps.
+IF "%ARCH%"=="arm64" (
+ IF NOT DEFINED VCToolsRedistDir (
+ ECHO error: VCToolsRedistDir not set. ARM64 layout requires running
+ ECHO under a VS C++ developer environment ^(Build.bat calls
+ ECHO vcvarsall.bat^).
+ EXIT /B 1
+ )
+ SET VCREDIST_ARCH_DIR=
+ FOR /D %%D IN ("%VCToolsRedistDir%arm64\Microsoft.VC*.CRT") DO SET "VCREDIST_ARCH_DIR=%%D"
+ IF NOT DEFINED VCREDIST_ARCH_DIR (
+ ECHO error: could not locate Microsoft.VC*.CRT under "%VCToolsRedistDir%arm64\"
+ EXIT /B 1
+ )
+ xcopy /Y "!VCREDIST_ARCH_DIR!\msvcp140.dll" %OUTPUT%
+ xcopy /Y "!VCREDIST_ARCH_DIR!\msvcp140_1.dll" %OUTPUT%
+ xcopy /Y "!VCREDIST_ARCH_DIR!\msvcp140_2.dll" %OUTPUT%
+ xcopy /Y "!VCREDIST_ARCH_DIR!\vcruntime140.dll" %OUTPUT%
+) ELSE (
+ xcopy /Y %VCRUNTIME%\lib\%ARCH%\msvcp140.dll %OUTPUT%
+ xcopy /Y %VCRUNTIME%\lib\%ARCH%\msvcp140_1.dll %OUTPUT%
+ xcopy /Y %VCRUNTIME%\lib\%ARCH%\msvcp140_2.dll %OUTPUT%
+ xcopy /Y %VCRUNTIME%\lib\%ARCH%\vcruntime140.dll %OUTPUT%
+)
xcopy /Y /S %BUILD_OUT%\GVFS\%MANAGED_OUT_FRAGMENT%\* %OUTPUT%
xcopy /Y /S %BUILD_OUT%\GVFS.Hooks\%MANAGED_OUT_FRAGMENT%\* %OUTPUT%
xcopy /Y /S %BUILD_OUT%\GVFS.Mount\%MANAGED_OUT_FRAGMENT%\* %OUTPUT%
@@ -69,12 +110,13 @@ DEL /Q %OUTPUT%\GVFS.Virtualization.pdb 2>nul
GOTO EOF
:USAGE
-ECHO usage: %~n0%~x0 ^ ^ ^ ^
+ECHO usage: %~n0%~x0 ^ ^ ^ ^ [^]
ECHO.
ECHO configuration Build configuration (Debug, Release).
ECHO version GVFS version string.
ECHO vcruntime Path to GVFS.VCRuntime NuGet package contents.
ECHO output Output directory.
+ECHO arch Target CPU architecture: x64 or arm64 (default: x64).
ECHO.
EXIT 1
diff --git a/GVFS/GVFS.Platform.Windows/WindowsPlatform.Shared.cs b/GVFS/GVFS.Platform.Windows/WindowsPlatform.Shared.cs
index 99def6841b..59088bc88e 100644
--- a/GVFS/GVFS.Platform.Windows/WindowsPlatform.Shared.cs
+++ b/GVFS/GVFS.Platform.Windows/WindowsPlatform.Shared.cs
@@ -3,7 +3,6 @@
using System;
using System.Diagnostics;
using System.IO;
-using System.Runtime.InteropServices;
using System.Security.Principal;
namespace GVFS.Platform.Windows
@@ -15,22 +14,6 @@ public partial class WindowsPlatform
private const int StillActive = 259; /* from Win32 STILL_ACTIVE */
- private enum StdHandle
- {
- Stdin = -10,
- Stdout = -11,
- Stderr = -12
- }
-
- private enum FileType : uint
- {
- Unknown = 0x0000,
- Disk = 0x0001,
- Char = 0x0002,
- Pipe = 0x0003,
- Remote = 0x8000,
- }
-
public static bool IsElevatedImplementation()
{
using (WindowsIdentity id = WindowsIdentity.GetCurrent())
@@ -153,11 +136,6 @@ public static string GetSecureDataRootForGVFSComponentImplementation(string comp
return Path.Combine(GetSecureDataRootForGVFSImplementation(), componentName);
}
- public static bool IsConsoleOutputRedirectedToFileImplementation()
- {
- return FileType.Disk == GetFileType(GetStdHandle(StdHandle.Stdout));
- }
-
public static bool TryGetGVFSEnlistmentRootImplementation(string directory, out string enlistmentRoot, out string errorMessage)
{
enlistmentRoot = null;
@@ -177,11 +155,5 @@ public static bool TryGetGVFSEnlistmentRootImplementation(string directory, out
return true;
}
-
- [DllImport("kernel32.dll")]
- private static extern IntPtr GetStdHandle(StdHandle std);
-
- [DllImport("kernel32.dll")]
- private static extern FileType GetFileType(IntPtr hdl);
}
}
diff --git a/GVFS/GVFS.Platform.Windows/WindowsPlatform.cs b/GVFS/GVFS.Platform.Windows/WindowsPlatform.cs
index df8ccf8739..37949e6d61 100644
--- a/GVFS/GVFS.Platform.Windows/WindowsPlatform.cs
+++ b/GVFS/GVFS.Platform.Windows/WindowsPlatform.cs
@@ -153,6 +153,12 @@ public override Process StartBackgroundVFS4GProcess(ITracer tracer, string progr
processInfo.UseShellExecute = true;
processInfo.WindowStyle = ProcessWindowStyle.Hidden;
+ // Set the working directory to the program's own directory so the
+ // background process does not hold a handle on the caller's CWD.
+ // This allows callers (e.g. bootstrapping tools) to clean up or
+ // delete their own directory after launching gvfs clone/mount.
+ processInfo.WorkingDirectory = Path.GetDirectoryName(programName);
+
Process executingProcess = new Process();
executingProcess.StartInfo = processInfo;
executingProcess.Start();
@@ -331,11 +337,6 @@ public override string GetSystemInstallerLogPath()
public override Dictionary GetPhysicalDiskInfo(string path, bool sizeStatsOnly) => WindowsPhysicalDiskInfo.GetPhysicalDiskInfo(path, sizeStatsOnly);
- public override bool IsConsoleOutputRedirectedToFile()
- {
- return WindowsPlatform.IsConsoleOutputRedirectedToFileImplementation();
- }
-
public override bool IsGitStatusCacheSupported()
{
return File.Exists(Path.Combine(GVFSPlatform.Instance.GetSecureDataRootForGVFSComponent(GVFSConstants.Service.ServiceName), GVFSConstants.GitStatusCache.EnableGitStatusCacheTokenFile));
diff --git a/GVFS/GVFS.PostIndexChangedHook/GVFS.PostIndexChangedHook.vcxproj b/GVFS/GVFS.PostIndexChangedHook/GVFS.PostIndexChangedHook.vcxproj
index 3808ff0277..8e8f32a5ff 100644
--- a/GVFS/GVFS.PostIndexChangedHook/GVFS.PostIndexChangedHook.vcxproj
+++ b/GVFS/GVFS.PostIndexChangedHook/GVFS.PostIndexChangedHook.vcxproj
@@ -9,6 +9,14 @@
Release
x64
+
+ Debug
+ ARM64
+
+
+ Release
+ ARM64
+
{24D161E9-D1F0-4299-BBD3-5D940BEDD535}
@@ -19,38 +27,38 @@
GVFS.PostIndexChangedHook
-
+
Application
- true
- v143
+ true
MultiByte
+ v143
-
+
Application
- false
- v143
+ false
true
MultiByte
+ v143
-
+
-
+
-
+
true
-
+
false
-
+
Use
Level4
@@ -65,7 +73,7 @@
Console
true
- C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\x64;%(AdditionalLibraryDirectories)
+ C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\$(Platform.ToLower());%(AdditionalLibraryDirectories)
$(IntDir)\$(MSBuildProjectName).log
@@ -76,7 +84,7 @@
$(GeneratedIncludePath)
-
+
Level4
Use
@@ -95,7 +103,7 @@
true
true
true
- C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\x64;%(AdditionalLibraryDirectories)
+ C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\$(Platform.ToLower());%(AdditionalLibraryDirectories)
$(IntDir)\$(MSBuildProjectName).log
@@ -116,8 +124,8 @@
- Create
- Create
+ Create
+ Create
diff --git a/GVFS/GVFS.ReadObjectHook/GVFS.ReadObjectHook.vcxproj b/GVFS/GVFS.ReadObjectHook/GVFS.ReadObjectHook.vcxproj
index 09e9e6616e..cd6ccc65e2 100644
--- a/GVFS/GVFS.ReadObjectHook/GVFS.ReadObjectHook.vcxproj
+++ b/GVFS/GVFS.ReadObjectHook/GVFS.ReadObjectHook.vcxproj
@@ -9,6 +9,14 @@
Release
x64
+
+ Debug
+ ARM64
+
+
+ Release
+ ARM64
+
{5A6656D5-81C7-472C-9DC8-32D071CB2258}
@@ -19,38 +27,38 @@
GVFS.ReadObjectHook
-
+
Application
- true
- v143
+ true
MultiByte
+ v143
-
+
Application
- false
- v143
+ false
true
MultiByte
+ v143
-
+
-
+
-
+
true
-
+
false
-
+
Use
Level4
@@ -65,7 +73,7 @@
Console
true
- C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\x64;%(AdditionalLibraryDirectories)
+ C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\$(Platform.ToLower());%(AdditionalLibraryDirectories)
$(IntDir)\$(MSBuildProjectName).log
@@ -76,7 +84,7 @@
$(GeneratedIncludePath)
-
+
Level4
Use
@@ -95,7 +103,7 @@
true
true
true
- C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\x64;%(AdditionalLibraryDirectories)
+ C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\$(Platform.ToLower());%(AdditionalLibraryDirectories)
$(IntDir)\$(MSBuildProjectName).log
@@ -118,8 +126,8 @@
- Create
- Create
+ Create
+ Create
diff --git a/GVFS/GVFS.Service/GVFSService.Windows.cs b/GVFS/GVFS.Service/GVFSService.Windows.cs
index 3b60ba104c..62959cccf8 100644
--- a/GVFS/GVFS.Service/GVFSService.Windows.cs
+++ b/GVFS/GVFS.Service/GVFSService.Windows.cs
@@ -45,6 +45,7 @@ public void Run()
{
EventMetadata metadata = new EventMetadata();
metadata.Add("Version", ProcessHelper.GetCurrentProcessVersion());
+ metadata.Add("Architecture", ProcessHelper.GetCurrentProcessArchitecture());
this.tracer.RelatedEvent(EventLevel.Informational, $"{nameof(GVFSService)}_{nameof(this.Run)}", metadata);
// Set up deferred telemetry pipe attachment FIRST, before any
diff --git a/GVFS/GVFS.Tests/NUnitRunner.cs b/GVFS/GVFS.Tests/NUnitRunner.cs
index e0861eea9f..701aac4d4e 100644
--- a/GVFS/GVFS.Tests/NUnitRunner.cs
+++ b/GVFS/GVFS.Tests/NUnitRunner.cs
@@ -97,10 +97,16 @@ public void PrepareTestSlice(string filters, (uint, uint) testSlice)
priorityQueue.Add((i, buckets[i].Count));
}
- // Now distribute the tests into the buckets
- Regex perFixtureRegex = new Regex(
- @"^.*\.EnlistmentPerFixture\..+\.",
- // @"^.*\.",
+ // Now distribute the tests into the buckets.
+ // Tests from the same fixture class must stay in the same bucket
+ // when the fixture shares a single enlistment across tests (both
+ // EnlistmentPerFixture classes, MultiEnlistmentTests with [Order],
+ // and GitCommands fixture classes like GitCommandsTests, CheckoutTests,
+ // etc. use a shared enlistment).
+ // The regex captures "everything up to and including the class name"
+ // so that SomeClass.TestA and SomeClass.TestB share a prefix.
+ Regex fixtureRegex = new Regex(
+ @"^.*\.(?:EnlistmentPerFixture|MultiEnlistmentTests|GitCommands)\..+\.",
RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
for (uint i = 0; i < list.Length; i++)
{
@@ -112,8 +118,8 @@ public void PrepareTestSlice(string filters, (uint, uint) testSlice)
buckets[bucket.Item1].Add(test);
- // Ensure that EnlistmentPerFixture tests of the same class are all in the same bucket
- var match = perFixtureRegex.Match(test);
+ // Ensure that fixture tests of the same class are all in the same bucket
+ var match = fixtureRegex.Match(test);
if (match.Success)
{
string prefix = match.Value;
diff --git a/GVFS/GVFS.Tests/Should/EnumerableShouldExtensions.cs b/GVFS/GVFS.Tests/Should/EnumerableShouldExtensions.cs
index efe65bb0ae..c8a28fd426 100644
--- a/GVFS/GVFS.Tests/Should/EnumerableShouldExtensions.cs
+++ b/GVFS/GVFS.Tests/Should/EnumerableShouldExtensions.cs
@@ -47,8 +47,15 @@ public static T ShouldContainSingle(this IEnumerable group, Func
public static void ShouldNotContain(this IEnumerable group, Func predicate)
{
- T item = group.SingleOrDefault(predicate);
- item.ShouldEqual(default(T), "Unexpected matching entry found in {" + string.Join(",", group) + "}");
+ List matches = group.Where(predicate).ToList();
+ if (matches.Count != 0)
+ {
+ Assert.Fail("Unexpected matching {0} {1}: {2} found in {{{3}}}",
+ matches.Count,
+ matches.Count == 1 ? "entry" : "entries",
+ string.Join(",", matches),
+ string.Join(",", group));
+ }
}
public static IEnumerable ShouldNotContain(this IEnumerable group, IEnumerable unexpectedValues, Func predicate)
diff --git a/GVFS/GVFS.UnitTests/Common/Database/PlaceholderTableTests.cs b/GVFS/GVFS.UnitTests/Common/Database/PlaceholderTableTests.cs
index abf2eeaa24..2bd714ba2c 100644
--- a/GVFS/GVFS.UnitTests/Common/Database/PlaceholderTableTests.cs
+++ b/GVFS/GVFS.UnitTests/Common/Database/PlaceholderTableTests.cs
@@ -241,7 +241,7 @@ public void AddPlaceholderDataThrowsGVFSDatabaseException()
PathTypeFile,
DefaultSha,
throwException: true));
- ex.Message.ShouldEqual($"PlaceholderTable.Insert({DefaultPath}, {PlaceholderTable.PlaceholderData.PlaceholderType.File}, {DefaultSha}) Exception");
+ ex.Message.ShouldEqual($"PlaceholderTable.AddFile({DefaultPath}, File, {DefaultSha}) Exception");
ex.InnerException.Message.ShouldEqual(DefaultExceptionMessage);
}
@@ -374,7 +374,7 @@ public void AddFileThrowsGVFSDatabaseException()
PathTypeFile,
DefaultSha,
throwException: true));
- ex.Message.ShouldEqual($"PlaceholderTable.Insert({DefaultPath}, {PlaceholderTable.PlaceholderData.PlaceholderType.File}, {DefaultSha}) Exception");
+ ex.Message.ShouldEqual($"PlaceholderTable.AddFile({DefaultPath}, File, {DefaultSha}) Exception");
ex.InnerException.Message.ShouldEqual(DefaultExceptionMessage);
}
@@ -398,7 +398,7 @@ public void AddPartialFolderThrowsGVFSDatabaseException()
PathTypePartialFolder,
sha: null,
throwException: true));
- ex.Message.ShouldEqual($"PlaceholderTable.Insert({DefaultPath}, {PlaceholderTable.PlaceholderData.PlaceholderType.PartialFolder}, ) Exception");
+ ex.Message.ShouldEqual($"PlaceholderTable.AddPartialFolder({DefaultPath}, PartialFolder, null) Exception");
ex.InnerException.Message.ShouldEqual(DefaultExceptionMessage);
}
@@ -422,7 +422,7 @@ public void AddExpandedFolderThrowsGVFSDatabaseException()
PathTypeExpandedFolder,
sha: null,
throwException: true));
- ex.Message.ShouldEqual($"PlaceholderTable.Insert({DefaultPath}, {PlaceholderTable.PlaceholderData.PlaceholderType.ExpandedFolder}, ) Exception");
+ ex.Message.ShouldEqual($"PlaceholderTable.AddExpandedFolder({DefaultPath}, ExpandedFolder, null) Exception");
ex.InnerException.Message.ShouldEqual(DefaultExceptionMessage);
}
@@ -446,7 +446,7 @@ public void AddPossibleTombstoneFolderThrowsGVFSDatabaseException()
PathTypePossibleTombstoneFolder,
sha: null,
throwException: true));
- ex.Message.ShouldEqual($"PlaceholderTable.Insert({DefaultPath}, {PlaceholderTable.PlaceholderData.PlaceholderType.PossibleTombstoneFolder}, ) Exception");
+ ex.Message.ShouldEqual($"PlaceholderTable.AddPossibleTombstoneFolder({DefaultPath}, PossibleTombstoneFolder, null) Exception");
ex.InnerException.Message.ShouldEqual(DefaultExceptionMessage);
}
@@ -486,7 +486,7 @@ public void RemoveThrowsGVFSDatabaseException()
mockCommand.SetupSet(x => x.CommandText = "DELETE FROM Placeholder WHERE path = @path;").Throws(new Exception(DefaultExceptionMessage));
GVFSDatabaseException ex = Assert.Throws(() => placeholders.Remove(DefaultPath));
- ex.Message.ShouldEqual($"PlaceholderTable.Remove({DefaultPath}) Exception");
+ ex.Message.ShouldEqual($"PlaceholderTable.Remove Exception");
ex.InnerException.Message.ShouldEqual(DefaultExceptionMessage);
});
}
@@ -540,7 +540,7 @@ public void RemoveAllEntriesForFolderThrowsGVFSDatabaseException()
mockCommand.SetupSet(x => x.CommandText = "SELECT path, pathType, sha FROM Placeholder WHERE path = @path OR path LIKE @pathWithDirectorySeparator;").Throws(new Exception(DefaultExceptionMessage));
GVFSDatabaseException ex = Assert.Throws(() => placeholders.RemoveAllEntriesForFolder(DefaultPath));
- ex.Message.ShouldEqual($"PlaceholderTable.RemoveAllEntriesForFolder({DefaultPath}) Exception");
+ ex.Message.ShouldEqual($"PlaceholderTable.RemoveAllEntriesForFolder Exception");
ex.InnerException.Message.ShouldEqual(DefaultExceptionMessage);
});
}
diff --git a/GVFS/GVFS.UnitTests/Common/Database/SparseTableTests.cs b/GVFS/GVFS.UnitTests/Common/Database/SparseTableTests.cs
index ab648f0c61..9749717ddc 100644
--- a/GVFS/GVFS.UnitTests/Common/Database/SparseTableTests.cs
+++ b/GVFS/GVFS.UnitTests/Common/Database/SparseTableTests.cs
@@ -71,7 +71,7 @@ public void GetAllThrowsGVFSDatabaseException()
mockCommand.SetupSet(x => x.CommandText = GetAllCommandString);
mockReader.Setup(x => x.Read()).Throws(new Exception(DefaultExceptionMessage));
GVFSDatabaseException ex = Assert.Throws(() => sparseTable.GetAll());
- ex.Message.ShouldContain("SparseTable.GetAll Exception:");
+ ex.Message.ShouldContain("SparseTable.GetAll Exception");
ex.InnerException.Message.ShouldEqual(DefaultExceptionMessage);
});
}
@@ -187,7 +187,7 @@ private void TestSparseTableAddOrRemove(bool isAdd, string pathToPass, string ex
if (throwException)
{
GVFSDatabaseException ex = Assert.Throws(() => sparseTable.Add(pathToPass));
- ex.Message.ShouldContain($"SparseTable.Add({expectedPath}) Exception");
+ ex.Message.ShouldContain($"SparseTable.Add Exception");
ex.InnerException.Message.ShouldEqual(DefaultExceptionMessage);
}
else
@@ -201,7 +201,7 @@ private void TestSparseTableAddOrRemove(bool isAdd, string pathToPass, string ex
if (throwException)
{
GVFSDatabaseException ex = Assert.Throws(() => sparseTable.Remove(pathToPass));
- ex.Message.ShouldContain($"SparseTable.Remove({expectedPath}) Exception");
+ ex.Message.ShouldContain($"SparseTable.Remove Exception");
ex.InnerException.Message.ShouldEqual(DefaultExceptionMessage);
}
else
diff --git a/GVFS/GVFS.UnitTests/Common/Database/TableTests.cs b/GVFS/GVFS.UnitTests/Common/Database/TableTests.cs
index bc75362626..c171c63c00 100644
--- a/GVFS/GVFS.UnitTests/Common/Database/TableTests.cs
+++ b/GVFS/GVFS.UnitTests/Common/Database/TableTests.cs
@@ -78,6 +78,7 @@ protected void TestTable(Action> testCode)
{
Mock mockCommand = new Mock(MockBehavior.Strict);
mockCommand.Setup(x => x.Dispose());
+ mockCommand.SetupSet(x => x.CommandTimeout = It.IsAny());
Mock mockConnection = new Mock(MockBehavior.Strict);
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
diff --git a/GVFS/GVFS.UnitTests/Common/EventMetadataConverterTests.cs b/GVFS/GVFS.UnitTests/Common/EventMetadataConverterTests.cs
new file mode 100644
index 0000000000..a6daca208e
--- /dev/null
+++ b/GVFS/GVFS.UnitTests/Common/EventMetadataConverterTests.cs
@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+using GVFS.Common.Tracing;
+using GVFS.Tests.Should;
+using NUnit.Framework;
+
+namespace GVFS.UnitTests.Common
+{
+ [TestFixture]
+ public class EventMetadataConverterTests
+ {
+ [TestCase]
+ public void NestedEventMetadataSerializesAsObject()
+ {
+ EventMetadata inner = new EventMetadata();
+ inner.Add("ProcessName1", "git.exe");
+ inner.Add("ProcessCount1", 42);
+
+ EventMetadata outer = new EventMetadata();
+ outer.Add("FilePlaceholderCreation", inner);
+
+ string json = EventMetadataConverter.SerializeToString(outer);
+
+ json.ShouldContain("\"FilePlaceholderCreation\":{");
+ json.ShouldContain("\"ProcessName1\":\"git.exe\"");
+ json.ShouldContain("\"ProcessCount1\":42");
+ json.ShouldNotContain(false, "GVFS.Common.Tracing.EventMetadata");
+ }
+
+ [TestCase]
+ public void DictionaryStringStringSerializesAsObject()
+ {
+ Dictionary diskInfo = new Dictionary
+ {
+ ["DriveLetter"] = "D",
+ ["VolumeDriveType"] = "Fixed",
+ ["VolumeFileSystem"] = "ReFS",
+ };
+
+ EventMetadata metadata = new EventMetadata();
+ metadata.Add("PhysicalDiskInfo", diskInfo);
+
+ string json = EventMetadataConverter.SerializeToString(metadata);
+
+ json.ShouldContain("\"PhysicalDiskInfo\":{");
+ json.ShouldContain("\"DriveLetter\":\"D\"");
+ json.ShouldContain("\"VolumeDriveType\":\"Fixed\"");
+ json.ShouldContain("\"VolumeFileSystem\":\"ReFS\"");
+ json.ShouldNotContain(false, "System.Collections.Generic.Dictionary");
+ }
+
+ [TestCase]
+ public void EmptyNestedEventMetadataSerializesAsEmptyObject()
+ {
+ EventMetadata inner = new EventMetadata();
+ EventMetadata outer = new EventMetadata();
+ outer.Add("FilePlaceholderCreation", inner);
+
+ string json = EventMetadataConverter.SerializeToString(outer);
+
+ json.ShouldContain("\"FilePlaceholderCreation\":{}");
+ }
+
+ [TestCase]
+ public void PrimitiveValuesStillSerializeCorrectly()
+ {
+ EventMetadata metadata = new EventMetadata();
+ metadata.Add("StringVal", "hello");
+ metadata.Add("IntVal", 123);
+ metadata.Add("LongVal", 999999999999L);
+ metadata.Add("BoolVal", true);
+
+ string json = EventMetadataConverter.SerializeToString(metadata);
+
+ json.ShouldContain("\"StringVal\":\"hello\"");
+ json.ShouldContain("\"IntVal\":123");
+ json.ShouldContain("\"LongVal\":999999999999");
+ json.ShouldContain("\"BoolVal\":true");
+ }
+ }
+}
diff --git a/GVFS/GVFS.UnitTests/Common/ModifiedPathsDatabaseTests.cs b/GVFS/GVFS.UnitTests/Common/ModifiedPathsDatabaseTests.cs
index 0f76828309..9037592f02 100644
--- a/GVFS/GVFS.UnitTests/Common/ModifiedPathsDatabaseTests.cs
+++ b/GVFS/GVFS.UnitTests/Common/ModifiedPathsDatabaseTests.cs
@@ -135,6 +135,24 @@ public void EntryNotAddedIfParentDirectoryExists()
modifiedPathsDatabase.Contains("dir2/dir", isFolder: true).ShouldBeTrue();
}
+ [TestCase]
+ public void AddFollowedByDeleteIsRecoveredOnLoad()
+ {
+ // Simulates the on-disk state during the window between a background
+ // operation completing and PostBackgroundOperation calling
+ // WriteAllEntriesAndFlush. The append log contains both the add and
+ // delete entries; a subsequent load must replay them and end with
+ // the path NOT in the modified-paths set.
+ const string AddThenDelete = "A temp.txt\r\nD temp.txt\r\n";
+
+ ModifiedPathsDatabase modifiedPathsDatabase = CreateModifiedPathsDatabase(AddThenDelete);
+
+ // Only the auto-added .gitattributes default entry should remain.
+ modifiedPathsDatabase.Count.ShouldEqual(1);
+ modifiedPathsDatabase.Contains(DefaultEntry, isFolder: false).ShouldBeTrue();
+ modifiedPathsDatabase.Contains("temp.txt", isFolder: false).ShouldBeFalse();
+ }
+
[TestCase]
public void RemoveEntriesWithParentFolderEntry()
{
diff --git a/GVFS/GVFS.UnitTests/Mock/Common/MockPhysicalGitObjects.cs b/GVFS/GVFS.UnitTests/Mock/Common/MockPhysicalGitObjects.cs
index 7f1b46f146..39e21e6eaa 100644
--- a/GVFS/GVFS.UnitTests/Mock/Common/MockPhysicalGitObjects.cs
+++ b/GVFS/GVFS.UnitTests/Mock/Common/MockPhysicalGitObjects.cs
@@ -3,7 +3,8 @@
using GVFS.Common.Git;
using GVFS.Common.Http;
using GVFS.Common.Tracing;
-using System.Diagnostics;
+
+using System;
using System.IO;
namespace GVFS.UnitTests.Mock.Common
@@ -26,7 +27,7 @@ public override string WriteLooseObject(Stream responseStream, string sha, bool
public override string WriteTempPackFile(Stream stream)
{
- Debug.Assert(stream != null, "WriteTempPackFile should not receive a null stream");
+ ArgumentNullException.ThrowIfNull(stream);
using (stream)
using (StreamReader reader = new StreamReader(stream))
diff --git a/GVFS/GVFS.UnitTests/Mock/Common/MockPlatform.cs b/GVFS/GVFS.UnitTests/Mock/Common/MockPlatform.cs
index 41876f953b..e7dca80cc5 100644
--- a/GVFS/GVFS.UnitTests/Mock/Common/MockPlatform.cs
+++ b/GVFS/GVFS.UnitTests/Mock/Common/MockPlatform.cs
@@ -131,11 +131,6 @@ public override string GetSystemInstallerLogPath()
return "MockPath";
}
- public override bool IsConsoleOutputRedirectedToFile()
- {
- throw new NotSupportedException();
- }
-
public override bool IsElevated()
{
throw new NotSupportedException();
diff --git a/GVFS/GVFS.UnitTests/Mock/ReusableMemoryStream.cs b/GVFS/GVFS.UnitTests/Mock/ReusableMemoryStream.cs
index 5afa60627c..dfd70a943b 100644
--- a/GVFS/GVFS.UnitTests/Mock/ReusableMemoryStream.cs
+++ b/GVFS/GVFS.UnitTests/Mock/ReusableMemoryStream.cs
@@ -67,7 +67,7 @@ public string ReadAt(long position, long length)
this.Position = position;
byte[] bytes = new byte[length];
- this.Read(bytes, 0, (int)length);
+ this.ReadExactly(bytes, 0, (int)length);
this.Position = lastPosition;
diff --git a/GVFS/GVFS.UnitTests/Prefetch/BlobPrefetcherTests.cs b/GVFS/GVFS.UnitTests/Prefetch/BlobPrefetcherTests.cs
index 21f31a92b3..18bd5579fd 100644
--- a/GVFS/GVFS.UnitTests/Prefetch/BlobPrefetcherTests.cs
+++ b/GVFS/GVFS.UnitTests/Prefetch/BlobPrefetcherTests.cs
@@ -1,7 +1,11 @@
-using GVFS.Common.Prefetch;
+using GVFS.Common;
+using GVFS.Common.Prefetch;
using GVFS.Tests.Should;
+using GVFS.UnitTests.Mock;
+using GVFS.UnitTests.Mock.Common;
using GVFS.UnitTests.Mock.FileSystem;
using NUnit.Framework;
+using System.Collections.Generic;
using System.IO;
namespace GVFS.UnitTests.Prefetch
@@ -9,6 +13,8 @@ namespace GVFS.UnitTests.Prefetch
[TestFixture]
public class BlobPrefetcherTests
{
+ private const string MockCacheFileName = "mock:\\prefetch-cache.dat";
+
[TestCase]
public void AppendToNewlineSeparatedFileTests()
{
@@ -29,5 +35,207 @@ public void AppendToNewlineSeparatedFileTests()
BlobPrefetcher.AppendToNewlineSeparatedFile(fileSystem, testFileName, "expected line 2");
fileSystem.ReadAllText(testFileName).ShouldEqual("existing content\nexpected line 2\n");
}
+
+ [TestCase]
+ public void ComputeCacheKeyIsDeterministic()
+ {
+ List files = new List { "src/a.cs", "src/b.cs" };
+ List folders = new List { "src/dir1", "src/dir2" };
+
+ string key1 = BlobPrefetcher.ComputeCacheKey(files, folders, hydrate: false);
+ string key2 = BlobPrefetcher.ComputeCacheKey(files, folders, hydrate: false);
+
+ key1.ShouldEqual(key2);
+ }
+
+ [TestCase]
+ public void ComputeCacheKeyDiffersForDifferentFiles()
+ {
+ List files1 = new List { "src/a.cs" };
+ List files2 = new List { "src/b.cs" };
+ List folders = new List { "src/dir1" };
+
+ string key1 = BlobPrefetcher.ComputeCacheKey(files1, folders, hydrate: false);
+ string key2 = BlobPrefetcher.ComputeCacheKey(files2, folders, hydrate: false);
+
+ key1.ShouldNotEqual(key2);
+ }
+
+ [TestCase]
+ public void ComputeCacheKeyDiffersForDifferentFolders()
+ {
+ List files = new List { "src/a.cs" };
+ List folders1 = new List { "src/dir1" };
+ List folders2 = new List { "src/dir2" };
+
+ string key1 = BlobPrefetcher.ComputeCacheKey(files, folders1, hydrate: false);
+ string key2 = BlobPrefetcher.ComputeCacheKey(files, folders2, hydrate: false);
+
+ key1.ShouldNotEqual(key2);
+ }
+
+ [TestCase]
+ public void ComputeCacheKeyDiffersForHydrateFlag()
+ {
+ List files = new List { "src/a.cs" };
+ List folders = new List { "src/dir1" };
+
+ string key1 = BlobPrefetcher.ComputeCacheKey(files, folders, hydrate: false);
+ string key2 = BlobPrefetcher.ComputeCacheKey(files, folders, hydrate: true);
+
+ key1.ShouldNotEqual(key2);
+ }
+
+ [TestCase]
+ public void ComputeCacheKeyIsOrderIndependent()
+ {
+ List filesA = new List { "src/b.cs", "src/a.cs" };
+ List filesB = new List { "src/a.cs", "src/b.cs" };
+ List folders = new List { "src/dir1" };
+
+ string key1 = BlobPrefetcher.ComputeCacheKey(filesA, folders, hydrate: false);
+ string key2 = BlobPrefetcher.ComputeCacheKey(filesB, folders, hydrate: false);
+
+ key1.ShouldEqual(key2);
+ }
+
+ [TestCase]
+ public void ComputeCacheKeyFolderOrderIndependent()
+ {
+ List files = new List { "src/a.cs" };
+ List foldersA = new List { "src/dir2", "src/dir1" };
+ List foldersB = new List { "src/dir1", "src/dir2" };
+
+ string key1 = BlobPrefetcher.ComputeCacheKey(files, foldersA, hydrate: false);
+ string key2 = BlobPrefetcher.ComputeCacheKey(files, foldersB, hydrate: false);
+
+ key1.ShouldEqual(key2);
+ }
+
+ [TestCase]
+ public void IsNoopPrefetchReturnsFalseWhenCacheIsNull()
+ {
+ MockTracer tracer = new MockTracer();
+ List files = new List { "src/a.cs" };
+ List folders = new List { "src/dir1" };
+
+ BlobPrefetcher.IsNoopPrefetch(tracer, null, "abc123", files, folders, false).ShouldEqual(false);
+ }
+
+ [TestCase]
+ public void IsNoopPrefetchReturnsFalseWhenCacheIsEmpty()
+ {
+ MockTracer tracer = new MockTracer();
+ List files = new List { "src/a.cs" };
+ List folders = new List { "src/dir1" };
+ FileBasedDictionary cache = CreateEmptyCache();
+
+ BlobPrefetcher.IsNoopPrefetch(tracer, cache, "abc123", files, folders, false).ShouldEqual(false);
+ }
+
+ [TestCase]
+ public void IsNoopPrefetchReturnsTrueOnCacheHit()
+ {
+ MockTracer tracer = new MockTracer();
+ List files = new List { "src/a.cs" };
+ List folders = new List { "src/dir1" };
+ string commitId = "abc123";
+
+ FileBasedDictionary cache = CreateEmptyCache();
+ string cacheKey = BlobPrefetcher.ComputeCacheKey(files, folders, hydrate: false);
+ cache.SetValueAndFlush(cacheKey, commitId);
+
+ BlobPrefetcher.IsNoopPrefetch(tracer, cache, commitId, files, folders, false).ShouldEqual(true);
+ }
+
+ [TestCase]
+ public void IsNoopPrefetchReturnsFalseWhenCommitIdChanged()
+ {
+ MockTracer tracer = new MockTracer();
+ List files = new List { "src/a.cs" };
+ List folders = new List { "src/dir1" };
+
+ FileBasedDictionary cache = CreateEmptyCache();
+ string cacheKey = BlobPrefetcher.ComputeCacheKey(files, folders, hydrate: false);
+ cache.SetValueAndFlush(cacheKey, "oldcommit");
+
+ BlobPrefetcher.IsNoopPrefetch(tracer, cache, "newcommit", files, folders, false).ShouldEqual(false);
+ }
+
+ [TestCase]
+ public void IsNoopPrefetchSupportsMultipleEntries()
+ {
+ MockTracer tracer = new MockTracer();
+ List filesA = new List { "src/a.cs" };
+ List filesB = new List { "src/b.cs" };
+ List folders = new List { "src/dir1" };
+ string commitId = "abc123";
+
+ FileBasedDictionary cache = CreateEmptyCache();
+
+ string keyA = BlobPrefetcher.ComputeCacheKey(filesA, folders, hydrate: false);
+ cache.SetValueAndFlush(keyA, commitId);
+
+ string keyB = BlobPrefetcher.ComputeCacheKey(filesB, folders, hydrate: false);
+ cache.SetValueAndFlush(keyB, commitId);
+
+ // Both should hit
+ BlobPrefetcher.IsNoopPrefetch(tracer, cache, commitId, filesA, folders, false).ShouldEqual(true);
+ BlobPrefetcher.IsNoopPrefetch(tracer, cache, commitId, filesB, folders, false).ShouldEqual(true);
+
+ // A third pattern should miss
+ List filesC = new List { "src/c.cs" };
+ BlobPrefetcher.IsNoopPrefetch(tracer, cache, commitId, filesC, folders, false).ShouldEqual(false);
+ }
+
+ private static FileBasedDictionary CreateEmptyCache()
+ {
+ CacheFileSystem fs = new CacheFileSystem();
+ fs.ExpectedFiles.Add(MockCacheFileName, new ReusableMemoryStream(string.Empty));
+ fs.ExpectedOpenFileStreams.Add(MockCacheFileName + ".tmp", new ReusableMemoryStream(string.Empty));
+ fs.ExpectedOpenFileStreams.Add(MockCacheFileName, fs.ExpectedFiles[MockCacheFileName]);
+
+ FileBasedDictionary.TryCreate(
+ null,
+ MockCacheFileName,
+ fs,
+ out FileBasedDictionary cache,
+ out string error).ShouldEqual(true, error);
+
+ fs.ExpectedOpenFileStreams.Remove(MockCacheFileName);
+ return cache;
+ }
+
+ private class CacheFileSystem : ConfigurableFileSystem
+ {
+ public CacheFileSystem()
+ {
+ this.ExpectedOpenFileStreams = new Dictionary();
+ }
+
+ public Dictionary ExpectedOpenFileStreams { get; }
+
+ public override Stream OpenFileStream(string path, FileMode fileMode, FileAccess fileAccess, FileShare shareMode, FileOptions options, bool flushesToDisk)
+ {
+ this.ExpectedOpenFileStreams.TryGetValue(path, out ReusableMemoryStream stream);
+
+ if (fileMode == FileMode.Create)
+ {
+ this.ExpectedFiles[path] = new ReusableMemoryStream(string.Empty);
+ }
+
+ this.ExpectedFiles.TryGetValue(path, out stream).ShouldEqual(true, "Unexpected access of file: " + path);
+ return stream;
+ }
+
+ public override void MoveAndOverwriteFile(string sourceFileName, string destinationFilename)
+ {
+ this.ExpectedFiles.TryGetValue(sourceFileName, out ReusableMemoryStream source).ShouldEqual(true, "Source file does not exist: " + sourceFileName);
+ this.ExpectedFiles.ContainsKey(destinationFilename).ShouldEqual(true, "MoveAndOverwriteFile expects the destination file to exist: " + destinationFilename);
+
+ this.ExpectedFiles.Remove(sourceFileName);
+ this.ExpectedFiles[destinationFilename] = source;
+ }
+ }
}
}
\ No newline at end of file
diff --git a/GVFS/GVFS.UnitTests/Prefetch/DiffTreeResultTests.cs b/GVFS/GVFS.UnitTests/Prefetch/DiffTreeResultTests.cs
index 5dd1a9dad7..e5aef689db 100644
--- a/GVFS/GVFS.UnitTests/Prefetch/DiffTreeResultTests.cs
+++ b/GVFS/GVFS.UnitTests/Prefetch/DiffTreeResultTests.cs
@@ -38,6 +38,15 @@ public class DiffTreeResultTests
private static readonly string InvalidLineFromLsTree = $"040000 bad {TestSha1}\t{TestTreePath1}";
private static readonly string SymLinkLineFromLsTree = $"120000 blob {TestSha1}\t{TestTreePath1}";
+ // ls-files -s test data
+ private static readonly string BlobLineFromLsFilesStaging = $"100644 {TestSha1} 0\t{TestTreePath1}";
+ private static readonly string ExecutableBlobFromLsFilesStaging = $"100755 {TestSha1} 0\t{TestBlobPath1}";
+ private static readonly string SymLinkFromLsFilesStaging = $"120000 {TestSha1} 0\t{TestTreePath1}";
+ private static readonly string BlobWithSpacesFromLsFilesStaging = $"100644 {TestSha1} 0\t{TestBlobPath1}";
+ private static readonly string UnmergedStage1FromLsFilesStaging = $"100644 {TestSha1} 1\t{TestTreePath1}";
+ private static readonly string UnmergedStage2FromLsFilesStaging = $"100644 {Test2Sha1} 2\t{TestTreePath1}";
+ private static readonly string UnmergedStage3FromLsFilesStaging = $"100644 {TestSha1} 3\t{TestTreePath1}";
+
[TestCase]
[Category(CategoryConstants.ExceptionExpected)]
public void ParseFromDiffTreeLine_NullLine()
@@ -341,6 +350,90 @@ public void ParseFromDiffTreeLine_BlobLineWithTreePath()
this.ValidateDiffTreeResult(expected, result);
}
+ [TestCase]
+ [Category(CategoryConstants.ExceptionExpected)]
+ public void ParseFromLsFilesStagingLine_NullLine()
+ {
+ Assert.Throws(() => DiffTreeResult.ParseFromLsFilesStagingLine(null));
+ }
+
+ [TestCase]
+ [Category(CategoryConstants.ExceptionExpected)]
+ public void ParseFromLsFilesStagingLine_EmptyLine()
+ {
+ Assert.Throws(() => DiffTreeResult.ParseFromLsFilesStagingLine(string.Empty));
+ }
+
+ [TestCase]
+ public void ParseFromLsFilesStagingLine_InvalidLine()
+ {
+ DiffTreeResult.ParseFromLsFilesStagingLine("short").ShouldBeNull();
+ }
+
+ [TestCase]
+ public void ParseFromLsFilesStagingLine_BlobLine()
+ {
+ DiffTreeResult expected = new DiffTreeResult()
+ {
+ Operation = DiffTreeResult.Operations.Add,
+ SourceIsDirectory = false,
+ TargetIsDirectory = false,
+ TargetPath = TestTreePath1.Replace('/', Path.DirectorySeparatorChar),
+ SourceSha = null,
+ TargetSha = TestSha1
+ };
+
+ DiffTreeResult result = DiffTreeResult.ParseFromLsFilesStagingLine(BlobLineFromLsFilesStaging);
+ this.ValidateDiffTreeResult(expected, result);
+ }
+
+ [TestCase]
+ public void ParseFromLsFilesStagingLine_ExecutableBlob()
+ {
+ DiffTreeResult result = DiffTreeResult.ParseFromLsFilesStagingLine(ExecutableBlobFromLsFilesStaging);
+ result.ShouldNotBeNull();
+ result.Operation.ShouldEqual(DiffTreeResult.Operations.Add);
+ result.TargetMode.ShouldEqual(Convert.ToUInt16("100755", 8));
+ result.TargetSha.ShouldEqual(TestSha1);
+ result.TargetPath.ShouldEqual(TestBlobPath1.Replace('/', Path.DirectorySeparatorChar));
+ }
+
+ [TestCase]
+ public void ParseFromLsFilesStagingLine_SymLink()
+ {
+ DiffTreeResult result = DiffTreeResult.ParseFromLsFilesStagingLine(SymLinkFromLsFilesStaging);
+ result.ShouldNotBeNull();
+ result.TargetIsSymLink.ShouldBeTrue();
+ result.TargetSha.ShouldEqual(TestSha1);
+ }
+
+ [TestCase]
+ public void ParseFromLsFilesStagingLine_PathWithSpaces()
+ {
+ DiffTreeResult result = DiffTreeResult.ParseFromLsFilesStagingLine(BlobWithSpacesFromLsFilesStaging);
+ result.ShouldNotBeNull();
+ result.TargetPath.ShouldEqual(TestBlobPath1.Replace('/', Path.DirectorySeparatorChar));
+ result.TargetSha.ShouldEqual(TestSha1);
+ }
+
+ [TestCase]
+ public void ParseFromLsFilesStagingLine_UnmergedStage1_ReturnsNull()
+ {
+ DiffTreeResult.ParseFromLsFilesStagingLine(UnmergedStage1FromLsFilesStaging).ShouldBeNull();
+ }
+
+ [TestCase]
+ public void ParseFromLsFilesStagingLine_UnmergedStage2_ReturnsNull()
+ {
+ DiffTreeResult.ParseFromLsFilesStagingLine(UnmergedStage2FromLsFilesStaging).ShouldBeNull();
+ }
+
+ [TestCase]
+ public void ParseFromLsFilesStagingLine_UnmergedStage3_ReturnsNull()
+ {
+ DiffTreeResult.ParseFromLsFilesStagingLine(UnmergedStage3FromLsFilesStaging).ShouldBeNull();
+ }
+
[TestCase("040000 tree 73b881d52b607b0f3e9e620d36f556d3d233a11d\tGVFS", DiffTreeResult.TreeMarker, true)]
[TestCase("040000 tree 73b881d52b607b0f3e9e620d36f556d3d233a11d\tGVFS", DiffTreeResult.BlobMarker, false)]
[TestCase("100644 blob 44c5f5cba4b29d31c2ad06eed51ea02af76c27c0\tReadme.md", DiffTreeResult.BlobMarker, true)]
diff --git a/GVFS/GVFS.UnitTests/Prefetch/MidxReaderTests.cs b/GVFS/GVFS.UnitTests/Prefetch/MidxReaderTests.cs
new file mode 100644
index 0000000000..d3956c11ee
--- /dev/null
+++ b/GVFS/GVFS.UnitTests/Prefetch/MidxReaderTests.cs
@@ -0,0 +1,299 @@
+using GVFS.Common.Git;
+using GVFS.Tests.Should;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace GVFS.UnitTests.Prefetch
+{
+ [TestFixture]
+ public class MidxReaderTests
+ {
+ private string tempDir;
+
+ [SetUp]
+ public void SetUp()
+ {
+ this.tempDir = Path.Combine(Path.GetTempPath(), "MidxReaderTests_" + Guid.NewGuid().ToString("N").Substring(0, 8));
+ Directory.CreateDirectory(this.tempDir);
+ }
+
+ [TearDown]
+ public void TearDown()
+ {
+ if (Directory.Exists(this.tempDir))
+ {
+ Directory.Delete(this.tempDir, recursive: true);
+ }
+ }
+
+ [Test]
+ public void FindsExistingObject()
+ {
+ string[] oids = GenerateSortedOids(100);
+ string midxPath = WriteMidxFile(this.tempDir, oids, new[] { "pack-abc123" });
+
+ using (MidxReader reader = new MidxReader(midxPath))
+ {
+ reader.TotalObjects.ShouldEqual(100);
+ reader.Exists(oids[0]).ShouldBeTrue("First OID should exist");
+ reader.Exists(oids[50]).ShouldBeTrue("Middle OID should exist");
+ reader.Exists(oids[99]).ShouldBeTrue("Last OID should exist");
+ }
+ }
+
+ [Test]
+ public void ReturnsFalseForMissingObject()
+ {
+ string[] oids = GenerateSortedOids(100);
+ string midxPath = WriteMidxFile(this.tempDir, oids, new[] { "pack-abc123" });
+
+ using (MidxReader reader = new MidxReader(midxPath))
+ {
+ reader.Exists("0000000000000000000000000000000000000000").ShouldBeFalse();
+ reader.Exists("ffffffffffffffffffffffffffffffffffffffff").ShouldBeFalse();
+ reader.Exists("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef").ShouldBeFalse();
+ }
+ }
+
+ [Test]
+ public void ReturnsFalseForNullOrShortSha()
+ {
+ string[] oids = GenerateSortedOids(10);
+ string midxPath = WriteMidxFile(this.tempDir, oids, new[] { "pack-abc123" });
+
+ using (MidxReader reader = new MidxReader(midxPath))
+ {
+ reader.Exists((string)null).ShouldBeFalse();
+ reader.Exists("abc").ShouldBeFalse();
+ }
+ }
+
+ [Test]
+ public void ParsesPackNames()
+ {
+ string[] oids = GenerateSortedOids(10);
+ string[] packs = new[] { "pack-aaaa", "pack-bbbb", "prefetch-cccc" };
+ string midxPath = WriteMidxFile(this.tempDir, oids, packs);
+
+ using (MidxReader reader = new MidxReader(midxPath))
+ {
+ HashSet stems = reader.GetPackStems();
+ stems.Count.ShouldEqual(3);
+ stems.Contains("pack-aaaa").ShouldBeTrue();
+ stems.Contains("pack-bbbb").ShouldBeTrue();
+ stems.Contains("prefetch-cccc").ShouldBeTrue();
+ }
+ }
+
+ [Test]
+ public void HandlesEmptyMidx()
+ {
+ string midxPath = WriteMidxFile(this.tempDir, Array.Empty(), new[] { "pack-empty" });
+
+ using (MidxReader reader = new MidxReader(midxPath))
+ {
+ reader.TotalObjects.ShouldEqual(0);
+ reader.Exists("0000000000000000000000000000000000000000").ShouldBeFalse();
+ }
+ }
+
+ [Test]
+ public void ThrowsOnInvalidMagic()
+ {
+ string path = Path.Combine(this.tempDir, "bad-midx");
+ File.WriteAllBytes(path, new byte[] { 0, 0, 0, 0, 1, 1, 3, 0, 0, 0, 0, 1 });
+
+ Assert.Throws(() =>
+ {
+ using (MidxReader _ = new MidxReader(path)) { }
+ });
+ }
+
+ [Test]
+ public void HandlesAllFanoutBuckets()
+ {
+ // Create OIDs that span all 256 fanout buckets
+ List oids = new List();
+ for (int i = 0; i < 256; i++)
+ {
+ byte[] raw = new byte[20];
+ raw[0] = (byte)i;
+ raw[1] = 0x42;
+ oids.Add(BitConverter.ToString(raw).Replace("-", "").ToLowerInvariant());
+ }
+
+ oids.Sort(StringComparer.Ordinal);
+ string midxPath = WriteMidxFile(this.tempDir, oids.ToArray(), new[] { "pack-full" });
+
+ using (MidxReader reader = new MidxReader(midxPath))
+ {
+ reader.TotalObjects.ShouldEqual(256);
+ foreach (string oid in oids)
+ {
+ reader.Exists(oid).ShouldBeTrue($"OID {oid} should exist");
+ }
+ }
+ }
+
+ ///
+ /// Writes a synthetic MIDX v1 file.
+ /// Format: Header(12) + ChunkTOC(numChunks*12 + 12 terminator) + PNAM + OIDF + OIDL + OOFF
+ ///
+ internal static string WriteMidxFile(string dir, string[] sortedOidHexes, string[] packNames)
+ {
+ int numObjects = sortedOidHexes.Length;
+ int numPacks = packNames.Length;
+
+ // PNAM chunk: null-terminated .idx filenames concatenated
+ List pnamBytes = new List();
+ foreach (string name in packNames)
+ {
+ byte[] nameBytes = System.Text.Encoding.ASCII.GetBytes(name + ".idx\0");
+ pnamBytes.AddRange(nameBytes);
+ }
+
+ // Pad PNAM to 4-byte alignment
+ while (pnamBytes.Count % 4 != 0)
+ {
+ pnamBytes.Add(0);
+ }
+
+ // OIDF (fanout): 256 * 4 bytes
+ uint[] fanout = new uint[256];
+ foreach (string hex in sortedOidHexes)
+ {
+ int firstByte = (HexVal(hex[0]) << 4) | HexVal(hex[1]);
+ fanout[firstByte]++;
+ }
+
+ // Make cumulative
+ for (int i = 1; i < 256; i++)
+ {
+ fanout[i] += fanout[i - 1];
+ }
+
+ // OIDL: sorted 20-byte OIDs
+ byte[] oidlBytes = new byte[numObjects * 20];
+ for (int i = 0; i < numObjects; i++)
+ {
+ byte[] oid = HexToByteArray(sortedOidHexes[i]);
+ Array.Copy(oid, 0, oidlBytes, i * 20, 20);
+ }
+
+ // OOFF: dummy 8-byte entries per object (pack-id:4 + offset:4)
+ byte[] ooffBytes = new byte[numObjects * 8];
+
+ // Chunk layout: 3 chunks (PNAM, OIDF, OIDL) + OOFF for terminator boundary
+ int numChunks = 4; // PNAM, OIDF, OIDL, OOFF
+ int headerSize = 12;
+ int tocSize = (numChunks * 12) + 12; // +12 for terminator
+ long dataStart = headerSize + tocSize;
+
+ long pnamOff = dataStart;
+ long oidfOff = pnamOff + pnamBytes.Count;
+ long oidlOff = oidfOff + (256 * 4);
+ long ooffOff = oidlOff + oidlBytes.Length;
+ long endOff = ooffOff + ooffBytes.Length;
+
+ string path = Path.Combine(dir, "multi-pack-index");
+ using (FileStream fs = File.Create(path))
+ using (BinaryWriter bw = new BinaryWriter(fs))
+ {
+ // Header
+ bw.Write(new byte[] { 0x4D, 0x49, 0x44, 0x58 }); // MIDX
+ bw.Write((byte)1); // version
+ bw.Write((byte)1); // oid version (SHA-1)
+ bw.Write((byte)numChunks);
+ bw.Write((byte)0); // reserved
+ WriteBE32(bw, (uint)numPacks);
+
+ // Chunk TOC
+ WriteTocEntry(bw, 0x504E414D, pnamOff); // PNAM
+ WriteTocEntry(bw, 0x4F494446, oidfOff); // OIDF
+ WriteTocEntry(bw, 0x4F49444C, oidlOff); // OIDL
+ WriteTocEntry(bw, 0x4F4F4646, ooffOff); // OOFF
+ WriteTocEntry(bw, 0x00000000, endOff); // Terminator
+
+ // PNAM
+ bw.Write(pnamBytes.ToArray());
+
+ // OIDF (fanout)
+ for (int i = 0; i < 256; i++)
+ {
+ WriteBE32(bw, fanout[i]);
+ }
+
+ // OIDL
+ bw.Write(oidlBytes);
+
+ // OOFF
+ bw.Write(ooffBytes);
+ }
+
+ return path;
+ }
+
+ internal static string[] GenerateSortedOids(int count)
+ {
+ Random rng = new Random(42); // deterministic
+ HashSet set = new HashSet();
+ while (set.Count < count)
+ {
+ byte[] raw = new byte[20];
+ rng.NextBytes(raw);
+ set.Add(BitConverter.ToString(raw).Replace("-", "").ToLowerInvariant());
+ }
+
+ string[] result = set.ToArray();
+ Array.Sort(result, StringComparer.Ordinal);
+ return result;
+ }
+
+ private static void WriteTocEntry(BinaryWriter bw, uint chunkId, long offset)
+ {
+ WriteBE32(bw, chunkId);
+ WriteBE64(bw, offset);
+ }
+
+ private static void WriteBE32(BinaryWriter bw, uint value)
+ {
+ bw.Write((byte)(value >> 24));
+ bw.Write((byte)(value >> 16));
+ bw.Write((byte)(value >> 8));
+ bw.Write((byte)value);
+ }
+
+ private static void WriteBE64(BinaryWriter bw, long value)
+ {
+ bw.Write((byte)(value >> 56));
+ bw.Write((byte)(value >> 48));
+ bw.Write((byte)(value >> 40));
+ bw.Write((byte)(value >> 32));
+ bw.Write((byte)(value >> 24));
+ bw.Write((byte)(value >> 16));
+ bw.Write((byte)(value >> 8));
+ bw.Write((byte)value);
+ }
+
+ private static byte[] HexToByteArray(string hex)
+ {
+ byte[] result = new byte[hex.Length / 2];
+ for (int i = 0; i < result.Length; i++)
+ {
+ result[i] = (byte)((HexVal(hex[i * 2]) << 4) | HexVal(hex[(i * 2) + 1]));
+ }
+
+ return result;
+ }
+
+ private static int HexVal(char c)
+ {
+ if (c >= 'a') return c - 'a' + 10;
+ if (c >= 'A') return c - 'A' + 10;
+ return c - '0';
+ }
+ }
+}
diff --git a/GVFS/GVFS.UnitTests/Prefetch/PackIndexObjectExistenceCheckerTests.cs b/GVFS/GVFS.UnitTests/Prefetch/PackIndexObjectExistenceCheckerTests.cs
new file mode 100644
index 0000000000..78fa3a6683
--- /dev/null
+++ b/GVFS/GVFS.UnitTests/Prefetch/PackIndexObjectExistenceCheckerTests.cs
@@ -0,0 +1,216 @@
+using GVFS.Common;
+using GVFS.Common.Git;
+using GVFS.Tests.Should;
+using GVFS.UnitTests.Mock.Common;
+using NUnit.Framework;
+using System;
+using System.IO;
+using System.Linq;
+
+namespace GVFS.UnitTests.Prefetch
+{
+ [TestFixture]
+ public class PackIndexObjectExistenceCheckerTests
+ {
+ private string tempDir;
+ private string objectsRoot;
+ private string packDir;
+
+ [SetUp]
+ public void SetUp()
+ {
+ this.tempDir = Path.Combine(Path.GetTempPath(), "PackIdxCheckerTests_" + Guid.NewGuid().ToString("N").Substring(0, 8));
+ this.objectsRoot = Path.Combine(this.tempDir, "objects");
+ this.packDir = Path.Combine(this.objectsRoot, "pack");
+ Directory.CreateDirectory(this.packDir);
+ }
+
+ [TearDown]
+ public void TearDown()
+ {
+ if (Directory.Exists(this.tempDir))
+ {
+ Directory.Delete(this.tempDir, recursive: true);
+ }
+ }
+
+ [Test]
+ public void FindsObjectInMidx()
+ {
+ string[] oids = MidxReaderTests.GenerateSortedOids(100);
+ MidxReaderTests.WriteMidxFile(this.packDir, oids, new[] { "pack-abc" });
+
+ using (PackIndexObjectExistenceChecker checker = new PackIndexObjectExistenceChecker(
+ MockTracerProvider.CreateMockTracer(),
+ this.objectsRoot))
+ {
+ checker.ObjectExists(oids[0]).ShouldBeTrue();
+ checker.ObjectExists(oids[50]).ShouldBeTrue();
+ checker.ObjectExists(oids[99]).ShouldBeTrue();
+ }
+ }
+
+ [Test]
+ public void FindsObjectInSupplementalPack()
+ {
+ // Create MIDX with one set of OIDs
+ string[] midxOids = MidxReaderTests.GenerateSortedOids(50);
+ MidxReaderTests.WriteMidxFile(this.packDir, midxOids, new[] { "pack-inmidx" });
+
+ // Create a supplemental .idx NOT listed in the MIDX
+ string[] extraOids = MidxReaderTests.GenerateSortedOids(30);
+ // Use a different seed to get different OIDs
+ Random rng = new Random(999);
+ extraOids = Enumerable.Range(0, 30)
+ .Select(_ =>
+ {
+ byte[] raw = new byte[20];
+ rng.NextBytes(raw);
+ return BitConverter.ToString(raw).Replace("-", "").ToLowerInvariant();
+ })
+ .Distinct()
+ .OrderBy(x => x, StringComparer.Ordinal)
+ .ToArray();
+
+ PackIndexReaderTests.WritePackIndexV2(this.packDir, "pack-supplemental", extraOids);
+
+ using (PackIndexObjectExistenceChecker checker = new PackIndexObjectExistenceChecker(
+ MockTracerProvider.CreateMockTracer(),
+ this.objectsRoot))
+ {
+ // MIDX objects should still be found
+ checker.ObjectExists(midxOids[0]).ShouldBeTrue("MIDX object should be found");
+
+ // Supplemental pack objects should be found
+ checker.ObjectExists(extraOids[0]).ShouldBeTrue("Supplemental pack object should be found");
+ checker.ObjectExists(extraOids[extraOids.Length - 1]).ShouldBeTrue("Last supplemental object should be found");
+ }
+ }
+
+ [Test]
+ public void FindsLooseObject()
+ {
+ // No packs at all — just a loose object
+ string sha = "aabbccddee112233445566778899001122334455";
+ string prefix = sha.Substring(0, 2);
+ string suffix = sha.Substring(2);
+ string looseDir = Path.Combine(this.objectsRoot, prefix);
+ Directory.CreateDirectory(looseDir);
+ File.WriteAllBytes(Path.Combine(looseDir, suffix), new byte[] { 0x78, 0x01 }); // zlib header
+
+ using (PackIndexObjectExistenceChecker checker = new PackIndexObjectExistenceChecker(
+ MockTracerProvider.CreateMockTracer(),
+ this.objectsRoot))
+ {
+ checker.ObjectExists(sha).ShouldBeTrue("Loose object should be found");
+ checker.ObjectExists("0000000000000000000000000000000000000000").ShouldBeFalse("Non-existent loose should not be found");
+ }
+ }
+
+ [Test]
+ public void ReturnsFalseForMissingObject()
+ {
+ string[] oids = MidxReaderTests.GenerateSortedOids(50);
+ MidxReaderTests.WriteMidxFile(this.packDir, oids, new[] { "pack-abc" });
+
+ using (PackIndexObjectExistenceChecker checker = new PackIndexObjectExistenceChecker(
+ MockTracerProvider.CreateMockTracer(),
+ this.objectsRoot))
+ {
+ checker.ObjectExists("0000000000000000000000000000000000000000").ShouldBeFalse();
+ checker.ObjectExists("ffffffffffffffffffffffffffffffffffffffff").ShouldBeFalse();
+ }
+ }
+
+ [Test]
+ public void HandlesEmptyPackDir()
+ {
+ using (PackIndexObjectExistenceChecker checker = new PackIndexObjectExistenceChecker(
+ MockTracerProvider.CreateMockTracer(),
+ this.objectsRoot))
+ {
+ checker.ObjectExists("0000000000000000000000000000000000000000").ShouldBeFalse();
+ }
+ }
+
+ [Test]
+ public void HandlesMissingPackDir()
+ {
+ string noPackRoot = Path.Combine(this.tempDir, "nopack");
+ Directory.CreateDirectory(noPackRoot);
+ // No "pack" subdirectory
+
+ using (PackIndexObjectExistenceChecker checker = new PackIndexObjectExistenceChecker(
+ MockTracerProvider.CreateMockTracer(),
+ noPackRoot))
+ {
+ checker.ObjectExists("0000000000000000000000000000000000000000").ShouldBeFalse();
+ }
+ }
+
+ [Test]
+ public void DeduplicatesIdenticalRoots()
+ {
+ string[] oids = MidxReaderTests.GenerateSortedOids(10);
+ MidxReaderTests.WriteMidxFile(this.packDir, oids, new[] { "pack-dedup" });
+
+ // Pass the same root twice (simulates LocalObjectsRoot == GitObjectsRoot)
+ using (PackIndexObjectExistenceChecker checker = new PackIndexObjectExistenceChecker(
+ MockTracerProvider.CreateMockTracer(),
+ this.objectsRoot,
+ this.objectsRoot))
+ {
+ checker.ObjectExists(oids[0]).ShouldBeTrue();
+ }
+ }
+
+ [Test]
+ public void SearchesMultipleRoots()
+ {
+ // Root 1 with some objects
+ string root1 = Path.Combine(this.tempDir, "root1");
+ string packDir1 = Path.Combine(root1, "pack");
+ Directory.CreateDirectory(packDir1);
+ string[] oids1 = MidxReaderTests.GenerateSortedOids(20);
+ MidxReaderTests.WriteMidxFile(packDir1, oids1, new[] { "pack-r1" });
+
+ // Root 2 with different objects
+ string root2 = Path.Combine(this.tempDir, "root2");
+ string packDir2 = Path.Combine(root2, "pack");
+ Directory.CreateDirectory(packDir2);
+ Random rng = new Random(12345);
+ string[] oids2 = Enumerable.Range(0, 20)
+ .Select(_ =>
+ {
+ byte[] raw = new byte[20];
+ rng.NextBytes(raw);
+ return BitConverter.ToString(raw).Replace("-", "").ToLowerInvariant();
+ })
+ .Distinct()
+ .OrderBy(x => x, StringComparer.Ordinal)
+ .ToArray();
+ MidxReaderTests.WriteMidxFile(packDir2, oids2, new[] { "pack-r2" });
+
+ using (PackIndexObjectExistenceChecker checker = new PackIndexObjectExistenceChecker(
+ MockTracerProvider.CreateMockTracer(),
+ root1,
+ root2))
+ {
+ checker.ObjectExists(oids1[0]).ShouldBeTrue("Root1 object should be found");
+ checker.ObjectExists(oids2[0]).ShouldBeTrue("Root2 object should be found");
+ checker.ObjectExists("0000000000000000000000000000000000000000").ShouldBeFalse();
+ }
+ }
+ }
+
+ ///
+ /// Helper to create mock tracers for tests that need ITracer.
+ ///
+ internal static class MockTracerProvider
+ {
+ public static MockTracer CreateMockTracer()
+ {
+ return new MockTracer();
+ }
+ }
+}
diff --git a/GVFS/GVFS.UnitTests/Prefetch/PackIndexReaderTests.cs b/GVFS/GVFS.UnitTests/Prefetch/PackIndexReaderTests.cs
new file mode 100644
index 0000000000..e153d46901
--- /dev/null
+++ b/GVFS/GVFS.UnitTests/Prefetch/PackIndexReaderTests.cs
@@ -0,0 +1,171 @@
+using GVFS.Common.Git;
+using GVFS.Tests.Should;
+using NUnit.Framework;
+using System;
+using System.IO;
+using System.Linq;
+
+namespace GVFS.UnitTests.Prefetch
+{
+ [TestFixture]
+ public class PackIndexReaderTests
+ {
+ private string tempDir;
+
+ [SetUp]
+ public void SetUp()
+ {
+ this.tempDir = Path.Combine(Path.GetTempPath(), "PackIndexReaderTests_" + Guid.NewGuid().ToString("N").Substring(0, 8));
+ Directory.CreateDirectory(this.tempDir);
+ }
+
+ [TearDown]
+ public void TearDown()
+ {
+ if (Directory.Exists(this.tempDir))
+ {
+ Directory.Delete(this.tempDir, recursive: true);
+ }
+ }
+
+ [Test]
+ public void FindsExistingObject()
+ {
+ string[] oids = MidxReaderTests.GenerateSortedOids(50);
+ string idxPath = WritePackIndexV2(this.tempDir, "pack-test1", oids);
+
+ using (PackIndexReader reader = new PackIndexReader(idxPath))
+ {
+ reader.TotalObjects.ShouldEqual(50);
+ reader.Exists(oids[0]).ShouldBeTrue();
+ reader.Exists(oids[25]).ShouldBeTrue();
+ reader.Exists(oids[49]).ShouldBeTrue();
+ }
+ }
+
+ [Test]
+ public void ReturnsFalseForMissingObject()
+ {
+ string[] oids = MidxReaderTests.GenerateSortedOids(50);
+ string idxPath = WritePackIndexV2(this.tempDir, "pack-test2", oids);
+
+ using (PackIndexReader reader = new PackIndexReader(idxPath))
+ {
+ reader.Exists("0000000000000000000000000000000000000000").ShouldBeFalse();
+ reader.Exists("ffffffffffffffffffffffffffffffffffffffff").ShouldBeFalse();
+ }
+ }
+
+ [Test]
+ public void HandlesSingleObject()
+ {
+ string[] oids = MidxReaderTests.GenerateSortedOids(1);
+ string idxPath = WritePackIndexV2(this.tempDir, "pack-single", oids);
+
+ using (PackIndexReader reader = new PackIndexReader(idxPath))
+ {
+ reader.TotalObjects.ShouldEqual(1);
+ reader.Exists(oids[0]).ShouldBeTrue();
+ reader.Exists("0000000000000000000000000000000000000000").ShouldBeFalse();
+ }
+ }
+
+ [Test]
+ public void ThrowsOnInvalidMagic()
+ {
+ string path = Path.Combine(this.tempDir, "bad.idx");
+ File.WriteAllBytes(path, new byte[] { 0, 0, 0, 0, 0, 0, 0, 2 });
+
+ Assert.Throws(() =>
+ {
+ using (PackIndexReader _ = new PackIndexReader(path)) { }
+ });
+ }
+
+ ///
+ /// Writes a synthetic pack index v2 file.
+ /// Format: Magic(4) + Version(4) + Fanout(256*4) + OIDs(N*20) + CRC32(N*4) + Offsets(N*4) + PackSHA(20) + IdxSHA(20)
+ ///
+ internal static string WritePackIndexV2(string dir, string packStem, string[] sortedOidHexes)
+ {
+ int numObjects = sortedOidHexes.Length;
+
+ // Fanout
+ uint[] fanout = new uint[256];
+ foreach (string hex in sortedOidHexes)
+ {
+ int firstByte = (HexVal(hex[0]) << 4) | HexVal(hex[1]);
+ fanout[firstByte]++;
+ }
+
+ for (int i = 1; i < 256; i++)
+ {
+ fanout[i] += fanout[i - 1];
+ }
+
+ // OID table
+ byte[] oidBytes = new byte[numObjects * 20];
+ for (int i = 0; i < numObjects; i++)
+ {
+ byte[] oid = HexToByteArray(sortedOidHexes[i]);
+ Array.Copy(oid, 0, oidBytes, i * 20, 20);
+ }
+
+ string path = Path.Combine(dir, packStem + ".idx");
+ using (FileStream fs = File.Create(path))
+ using (BinaryWriter bw = new BinaryWriter(fs))
+ {
+ // Magic
+ bw.Write(new byte[] { 0xFF, 0x74, 0x4F, 0x63 });
+ // Version
+ WriteBE32(bw, 2);
+
+ // Fanout
+ for (int i = 0; i < 256; i++)
+ {
+ WriteBE32(bw, fanout[i]);
+ }
+
+ // OID table
+ bw.Write(oidBytes);
+
+ // CRC32 table (dummy)
+ bw.Write(new byte[numObjects * 4]);
+
+ // Offset table (dummy)
+ bw.Write(new byte[numObjects * 4]);
+
+ // Pack SHA + Idx SHA (dummy)
+ bw.Write(new byte[40]);
+ }
+
+ return path;
+ }
+
+ private static void WriteBE32(BinaryWriter bw, uint value)
+ {
+ bw.Write((byte)(value >> 24));
+ bw.Write((byte)(value >> 16));
+ bw.Write((byte)(value >> 8));
+ bw.Write((byte)value);
+ }
+
+ private static byte[] HexToByteArray(string hex)
+ {
+ byte[] result = new byte[hex.Length / 2];
+ for (int i = 0; i < result.Length; i++)
+ {
+ result[i] = (byte)((HexVal(hex[i * 2]) << 4) | HexVal(hex[(i * 2) + 1]));
+ }
+
+ return result;
+ }
+
+ private static int HexVal(char c)
+ {
+ if (c >= 'a') return c - 'a' + 10;
+ if (c >= 'A') return c - 'A' + 10;
+ return c - '0';
+ }
+ }
+}
diff --git a/GVFS/GVFS.UnitTests/Tracing/TelemetryDaemonEventListenerTests.cs b/GVFS/GVFS.UnitTests/Tracing/TelemetryDaemonEventListenerTests.cs
index f3024bfaa5..f1deffe98f 100644
--- a/GVFS/GVFS.UnitTests/Tracing/TelemetryDaemonEventListenerTests.cs
+++ b/GVFS/GVFS.UnitTests/Tracing/TelemetryDaemonEventListenerTests.cs
@@ -14,6 +14,7 @@ public class TelemetryDaemonEventListenerTests
public void TraceMessageDataIsCorrectFormat()
{
const string vfsVersion = "test-vfsVersion";
+ const string vfsArchitecture = "test-architecture";
const string providerName = "test-ProviderName";
const string eventName = "test-eventName";
const EventLevel level = EventLevel.Error;
@@ -26,6 +27,7 @@ public void TraceMessageDataIsCorrectFormat()
TelemetryDaemonEventListener.PipeMessage message = new TelemetryDaemonEventListener.PipeMessage
{
Version = vfsVersion,
+ Architecture = vfsArchitecture,
ProviderName = providerName,
EventName = eventName,
EventLevel = level,
@@ -44,8 +46,9 @@ public void TraceMessageDataIsCorrectFormat()
using (JsonDocument doc = JsonDocument.Parse(messageJson))
{
JsonElement root = doc.RootElement;
- root.EnumerateObject().Count().ShouldEqual(6);
+ root.EnumerateObject().Count().ShouldEqual(7);
root.GetProperty("version").GetString().ShouldEqual(vfsVersion);
+ root.GetProperty("architecture").GetString().ShouldEqual(vfsArchitecture);
root.GetProperty("providerName").GetString().ShouldEqual(providerName);
root.GetProperty("eventName").GetString().ShouldEqual(eventName);
root.GetProperty("eventLevel").GetInt32().ShouldEqual((int)level);
diff --git a/GVFS/GVFS.VirtualFileSystemHook/GVFS.VirtualFileSystemHook.vcxproj b/GVFS/GVFS.VirtualFileSystemHook/GVFS.VirtualFileSystemHook.vcxproj
index 9390120db3..026b18af42 100644
--- a/GVFS/GVFS.VirtualFileSystemHook/GVFS.VirtualFileSystemHook.vcxproj
+++ b/GVFS/GVFS.VirtualFileSystemHook/GVFS.VirtualFileSystemHook.vcxproj
@@ -9,6 +9,14 @@
Release
x64
+
+ Debug
+ ARM64
+
+
+ Release
+ ARM64
+
{2D23AB54-541F-4ABC-8DCA-08C199E97ABB}
@@ -19,38 +27,38 @@
GVFS.VirtualFileSystemHook
-
+
Application
- true
- v143
+ true
MultiByte
+ v143
-
+
Application
- false
- v143
+ false
true
MultiByte
+ v143
-
+
-
+
-
+
true
-
+
false
-
+
Use
Level4
@@ -65,7 +73,7 @@
Console
true
- C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\x64;%(AdditionalLibraryDirectories)
+ C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\$(Platform.ToLower());%(AdditionalLibraryDirectories)
$(IntDir)\$(MSBuildProjectName).log
@@ -76,7 +84,7 @@
$(GeneratedIncludePath)
-
+
Level4
Use
@@ -95,7 +103,7 @@
true
true
true
- C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\x64;%(AdditionalLibraryDirectories)
+ C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\$(Platform.ToLower());%(AdditionalLibraryDirectories)
$(IntDir)\$(MSBuildProjectName).log
@@ -116,8 +124,8 @@
- Create
- Create
+ Create
+ Create
diff --git a/GVFS/GVFS.Virtualization/BlobSize/BlobSizes.cs b/GVFS/GVFS.Virtualization/BlobSize/BlobSizes.cs
index a4d59f3160..d4eb621a0b 100644
--- a/GVFS/GVFS.Virtualization/BlobSize/BlobSizes.cs
+++ b/GVFS/GVFS.Virtualization/BlobSize/BlobSizes.cs
@@ -54,6 +54,54 @@ public virtual void Initialize()
string folderPath = Path.GetDirectoryName(this.databasePath);
this.fileSystem.CreateDirectory(folderPath);
+ try
+ {
+ this.InitializeDatabase();
+ }
+ catch (SqliteException ex) when (ex.SqliteErrorCode == SqliteErrorCodes.Corrupt || ex.SqliteErrorCode == SqliteErrorCodes.NotADatabase)
+ {
+ EventMetadata metadata = this.CreateEventMetadata(ex);
+ metadata.Add("SqliteErrorCode", ex.SqliteErrorCode);
+ this.tracer.RelatedWarning(metadata, $"{nameof(BlobSizes)}.{nameof(this.Initialize)}: database corrupt, deleting and recreating");
+
+ SqliteConnection.ClearAllPools();
+ this.DeleteDatabaseFiles();
+ this.InitializeDatabase();
+ }
+
+ this.flushDataThread = new Thread(this.FlushDbThreadMain);
+ this.flushDataThread.IsBackground = true;
+ this.flushDataThread.Start();
+ }
+
+ public virtual void Shutdown()
+ {
+ this.isStopping = true;
+ this.wakeUpFlushThread.Set();
+ this.flushDataThread.Join();
+ }
+
+ public virtual void AddSize(Sha1Id sha, long size)
+ {
+ this.queuedSizes.Enqueue(new BlobSize(sha, size));
+ }
+
+ public virtual void Flush()
+ {
+ this.wakeUpFlushThread.Set();
+ }
+
+ public void Dispose()
+ {
+ if (this.wakeUpFlushThread != null)
+ {
+ this.wakeUpFlushThread.Dispose();
+ this.wakeUpFlushThread = null;
+ }
+ }
+
+ private void InitializeDatabase()
+ {
using (SqliteConnection connection = new SqliteConnection(this.sqliteConnectionString))
{
connection.Open();
@@ -125,36 +173,13 @@ public virtual void Initialize()
createTableCommand.ExecuteNonQuery();
}
}
-
- this.flushDataThread = new Thread(this.FlushDbThreadMain);
- this.flushDataThread.IsBackground = true;
- this.flushDataThread.Start();
}
- public virtual void Shutdown()
+ private void DeleteDatabaseFiles()
{
- this.isStopping = true;
- this.wakeUpFlushThread.Set();
- this.flushDataThread.Join();
- }
-
- public virtual void AddSize(Sha1Id sha, long size)
- {
- this.queuedSizes.Enqueue(new BlobSize(sha, size));
- }
-
- public virtual void Flush()
- {
- this.wakeUpFlushThread.Set();
- }
-
- public void Dispose()
- {
- if (this.wakeUpFlushThread != null)
- {
- this.wakeUpFlushThread.Dispose();
- this.wakeUpFlushThread = null;
- }
+ this.fileSystem.TryDeleteFile(this.databasePath);
+ this.fileSystem.TryDeleteFile(this.databasePath + "-wal");
+ this.fileSystem.TryDeleteFile(this.databasePath + "-shm");
}
private void FlushDbThreadMain()
diff --git a/GVFS/GVFS.Virtualization/Projection/GitIndexProjection.GitIndexParser.cs b/GVFS/GVFS.Virtualization/Projection/GitIndexProjection.GitIndexParser.cs
index 382a05945f..4f83ff0fdc 100644
--- a/GVFS/GVFS.Virtualization/Projection/GitIndexProjection.GitIndexParser.cs
+++ b/GVFS/GVFS.Virtualization/Projection/GitIndexProjection.GitIndexParser.cs
@@ -391,7 +391,11 @@ private FileSystemTaskResult ParseIndex(
private void ReadNextPage()
{
+ // Last page may be smaller than PageSize; partial fill is safe because
+ // the parser stops after entryCount entries and never reads stale bytes.
+#pragma warning disable CA2022 // Avoid inexact read
this.indexStream.Read(this.page, 0, PageSize);
+#pragma warning restore CA2022
this.nextByteIndex = 0;
}
diff --git a/GVFS/GVFS/CommandLine/GVFSVerb.cs b/GVFS/GVFS/CommandLine/GVFSVerb.cs
index 069ac1661d..51b693578d 100644
--- a/GVFS/GVFS/CommandLine/GVFSVerb.cs
+++ b/GVFS/GVFS/CommandLine/GVFSVerb.cs
@@ -193,7 +193,23 @@ protected bool ShowStatusWhileRunning(
action,
message,
this.Output,
- showSpinner: !this.Unattended && this.Output == Console.Out && !GVFSPlatform.Instance.IsConsoleOutputRedirectedToFile(),
+ showSpinner: !this.Unattended && this.Output == Console.Out && !Console.IsOutputRedirected,
+ gvfsLogEnlistmentRoot: gvfsLogEnlistmentRoot,
+ initialDelayMs: 0);
+ }
+
+ protected bool ShowStatusWhileRunning(
+ Func action,
+ Func getMessage,
+ string message,
+ string gvfsLogEnlistmentRoot)
+ {
+ return ConsoleHelper.ShowStatusWhileRunning(
+ action,
+ getMessage,
+ message,
+ this.Output,
+ showSpinner: !this.Unattended && this.Output == Console.Out && !Console.IsOutputRedirected,
gvfsLogEnlistmentRoot: gvfsLogEnlistmentRoot,
initialDelayMs: 0);
}
@@ -487,13 +503,31 @@ protected bool TryDownloadCommit(
out string error,
bool checkLocalObjectCache = true)
{
- if (!checkLocalObjectCache || !repo.CommitAndRootTreeExists(commitId, out _))
+ if (checkLocalObjectCache && repo.CommitAndRootTreeExists(commitId, out _))
{
- if (!gitObjects.TryDownloadCommit(commitId))
+ if (repo.LooseObjectExists(commitId))
{
- error = "Could not download commit " + commitId + " from: " + Uri.EscapeDataString(objectRequestor.CacheServer.ObjectsEndpointUrl);
- return false;
+ // The commit exists as a loose object (e.g., from a prior 'git show'
+ // or 'git log' in a mounted enlistment). Loose commits do not include
+ // their reachable trees — those would need to be fetched individually.
+ // Download the commit pack which includes all reachable trees so that
+ // operations like 'git checkout -f' can succeed without the read-object
+ // hook.
}
+ else
+ {
+ // The commit exists in a pack file (prefetch pack or a previous commit
+ // pack download). Packs from the GVFS protocol include all reachable
+ // trees, so we can safely skip re-downloading.
+ error = null;
+ return true;
+ }
+ }
+
+ if (!gitObjects.TryDownloadCommit(commitId))
+ {
+ error = "Could not download commit " + commitId + " from: " + Uri.EscapeDataString(objectRequestor.CacheServer.ObjectsEndpointUrl);
+ return false;
}
error = null;
diff --git a/GVFS/GVFS/CommandLine/MountVerb.cs b/GVFS/GVFS/CommandLine/MountVerb.cs
index 37e5f1041f..5ea8c5781e 100644
--- a/GVFS/GVFS/CommandLine/MountVerb.cs
+++ b/GVFS/GVFS/CommandLine/MountVerb.cs
@@ -14,6 +14,7 @@ public class MountVerb : GVFSVerb.ForExistingEnlistment
{
private const string MountVerbName = "mount";
private Process mountProcess;
+ private volatile string currentMountProgress;
public string Verbosity { get; set; }
@@ -197,7 +198,9 @@ protected override void Execute(GVFSEnlistment enlistment)
if (!this.ShowStatusWhileRunning(
() => { return this.TryMount(tracer, enlistment, mountExecutableLocation, out errorMessage); },
- "Mounting"))
+ getMessage: () => this.currentMountProgress,
+ "Mounting",
+ enlistment.WorkingDirectoryRoot))
{
ReturnCode mountExitCode = ReturnCode.GenericError;
if (this.mountProcess != null)
@@ -277,7 +280,33 @@ private bool TryMount(ITracer tracer, GVFSEnlistment enlistment, string mountExe
tracer.RelatedInfo($"{nameof(this.TryMount)}: Waiting for repo to be mounted");
- return GVFSEnlistment.WaitUntilMounted(tracer, enlistment.NamedPipeName, enlistment.WorkingDirectoryRoot, this.Unattended, out errorMessage);
+ Process process = this.mountProcess;
+ Func snapshot = () =>
+ {
+ try
+ {
+ if (!process.HasExited)
+ {
+ return new GVFSEnlistment.MountProcessSnapshot(process.Id, hasExited: false, exitCode: 0);
+ }
+
+ return new GVFSEnlistment.MountProcessSnapshot(process.Id, hasExited: true, exitCode: process.ExitCode);
+ }
+ catch (InvalidOperationException)
+ {
+ // Process object disposed or not started — treat as exited.
+ return new GVFSEnlistment.MountProcessSnapshot(processId: 0, hasExited: true, exitCode: -1);
+ }
+ };
+
+ return GVFSEnlistment.WaitUntilMounted(
+ tracer,
+ enlistment.NamedPipeName,
+ enlistment.WorkingDirectoryRoot,
+ this.Unattended,
+ snapshot,
+ out errorMessage,
+ onProgress: progress => this.currentMountProgress = progress);
}
private bool RegisterMount(GVFSEnlistment enlistment, out string errorMessage)
diff --git a/GVFS/GVFS/CommandLine/PrefetchVerb.cs b/GVFS/GVFS/CommandLine/PrefetchVerb.cs
index 17483c34cf..ef6d3ddf94 100644
--- a/GVFS/GVFS/CommandLine/PrefetchVerb.cs
+++ b/GVFS/GVFS/CommandLine/PrefetchVerb.cs
@@ -3,11 +3,15 @@
using GVFS.Common.Git;
using GVFS.Common.Http;
using GVFS.Common.Maintenance;
+using GVFS.Common.NamedPipes;
using GVFS.Common.Prefetch;
using GVFS.Common.Tracing;
using System;
using System.Collections.Generic;
using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
namespace GVFS.CommandLine
{
@@ -172,30 +176,73 @@ protected override void Execute(GVFSEnlistment enlistment)
this.ReportErrorAndExit(tracer, "You can only specify --hydrate with --files or --folders");
}
- GitObjectsHttpRequestor objectRequestor;
- CacheServerInfo resolvedCacheServer;
- this.InitializeServerConnection(
- tracer,
- enlistment,
- cacheServerFromConfig,
- out objectRequestor,
- out resolvedCacheServer);
- this.PrefetchCommits(tracer, enlistment, objectRequestor, resolvedCacheServer);
+ // Try offload silently — if mount isn't available this returns
+ // false quickly and we fall through to the direct-auth path which
+ // has its own spinner. We don't wrap this in ShowStatusWhileRunning
+ // because a false return (mount unavailable) would print "Failed"
+ // to the console, which is misleading for an expected fallback.
+ bool offloadSucceeded = this.TryPrefetchCommitsViaMountProcess(tracer, enlistment);
+
+ if (!offloadSucceeded)
+ {
+ GitObjectsHttpRequestor objectRequestor;
+ CacheServerInfo resolvedCacheServer;
+ this.InitializeServerConnection(
+ tracer,
+ enlistment,
+ cacheServerFromConfig,
+ out objectRequestor,
+ out resolvedCacheServer);
+ this.PrefetchCommits(tracer, enlistment, objectRequestor, resolvedCacheServer);
+ }
}
else
{
string headCommitId;
List filesList;
List foldersList;
- FileBasedDictionary lastPrefetchArgs;
+ FileBasedDictionary prefetchCache;
+ int prefetchCacheSize;
- this.LoadBlobPrefetchArgs(tracer, enlistment, out headCommitId, out filesList, out foldersList, out lastPrefetchArgs);
+ this.LoadBlobPrefetchArgs(tracer, enlistment, out headCommitId, out filesList, out foldersList, out prefetchCache, out prefetchCacheSize);
- if (BlobPrefetcher.IsNoopPrefetch(tracer, lastPrefetchArgs, headCommitId, filesList, foldersList, this.HydrateFiles))
+ if (BlobPrefetcher.IsNoopPrefetch(tracer, prefetchCache, headCommitId, filesList, foldersList, this.HydrateFiles))
{
Console.WriteLine("All requested files are already available. Nothing new to prefetch.");
}
- else
+ else if (filesList.Count == 0 && foldersList.Count == 0)
+ {
+ this.ReportErrorAndExit(tracer, "Did you mean to fetch all blobs? If so, specify `--files '*'` to confirm.");
+ }
+ else if (this.HydrateFiles)
+ {
+ // For --hydrate, try offloading the download phase to the mount
+ // (without hydration), then hydrate locally in the verb process.
+ // This avoids the mount process writing to ProjFS-virtualized files
+ // (self-callback risk) while still benefiting from warm auth.
+ if (!this.TryPrefetchBlobsViaMountProcess(tracer, enlistment, filesList, foldersList, headCommitId))
+ {
+ // Mount unavailable — fall back to direct auth for download
+ GitObjectsHttpRequestor objectRequestor;
+ CacheServerInfo resolvedCacheServer;
+ this.InitializeServerConnection(
+ tracer,
+ enlistment,
+ cacheServerFromConfig,
+ out objectRequestor,
+ out resolvedCacheServer);
+ this.PrefetchBlobs(tracer, enlistment, headCommitId, filesList, foldersList, prefetchCache, prefetchCacheSize, objectRequestor, resolvedCacheServer);
+ }
+ else
+ {
+ // Mount handled download — hydrate locally, then update noop
+ // cache. Cache update is after hydration so a hydration failure
+ // doesn't suppress the retry on the next run.
+ this.HydrateMatchingFiles(tracer, enlistment, filesList, foldersList);
+ BlobPrefetcher.UpdateNoopCache(prefetchCache, prefetchCacheSize, headCommitId, filesList, foldersList, this.HydrateFiles);
+ }
+ }
+ else if (!this.TryPrefetchBlobsViaMountProcess(tracer, enlistment, filesList, foldersList, headCommitId))
{
GitObjectsHttpRequestor objectRequestor;
CacheServerInfo resolvedCacheServer;
@@ -205,7 +252,12 @@ protected override void Execute(GVFSEnlistment enlistment)
cacheServerFromConfig,
out objectRequestor,
out resolvedCacheServer);
- this.PrefetchBlobs(tracer, enlistment, headCommitId, filesList, foldersList, lastPrefetchArgs, objectRequestor, resolvedCacheServer);
+ this.PrefetchBlobs(tracer, enlistment, headCommitId, filesList, foldersList, prefetchCache, prefetchCacheSize, objectRequestor, resolvedCacheServer);
+ }
+ else
+ {
+ // Mount handled download — update noop cache so repeat runs are skipped
+ BlobPrefetcher.UpdateNoopCache(prefetchCache, prefetchCacheSize, headCommitId, filesList, foldersList, hydrate: false);
}
}
}
@@ -296,6 +348,137 @@ private void InitializeServerConnection(
objectRequestor = new GitObjectsHttpRequestor(tracer, enlistment, resolvedCacheServer, retryConfig);
}
+ ///
+ /// Attempts to offload the commit prefetch to a running mount process,
+ /// which already has warm authentication. Returns true if the mount
+ /// handled the request (success or failure); returns false if offload
+ /// is unavailable and the caller should fall back to direct auth.
+ ///
+ private bool TryPrefetchCommitsViaMountProcess(ITracer tracer, GVFSEnlistment enlistment)
+ {
+ using (NamedPipeClient pipeClient = new NamedPipeClient(enlistment.NamedPipeName))
+ {
+ if (!pipeClient.Connect())
+ {
+ tracer.RelatedInfo("TryPrefetchCommitsViaMountProcess: Mount not running, falling back to direct prefetch");
+ return false;
+ }
+
+ NamedPipeMessages.Message request = new NamedPipeMessages.Message(NamedPipeMessages.PrefetchCommits.Request, null);
+ if (!pipeClient.TrySendRequest(request))
+ {
+ tracer.RelatedWarning("TryPrefetchCommitsViaMountProcess: Failed to send request, falling back to direct prefetch");
+ return false;
+ }
+
+ NamedPipeMessages.Message response;
+ if (!pipeClient.TryReadResponse(out response))
+ {
+ tracer.RelatedWarning("TryPrefetchCommitsViaMountProcess: Failed to read response, falling back to direct prefetch");
+ return false;
+ }
+
+ switch (response.Header)
+ {
+ case NamedPipeMessages.PrefetchCommits.CompleteResult:
+ NamedPipeMessages.PrefetchCommits.Response prefetchResponse =
+ NamedPipeMessages.PrefetchCommits.Response.FromMessage(response);
+
+ if (prefetchResponse.Success)
+ {
+ tracer.RelatedInfo("TryPrefetchCommitsViaMountProcess: Mount completed prefetch successfully");
+ return true;
+ }
+
+ this.ReportErrorAndExit(tracer, "Prefetching commits and trees failed (via mount): " + prefetchResponse.Error);
+ return true;
+
+ case NamedPipeMessages.PrefetchCommits.MountNotReadyResult:
+ tracer.RelatedInfo("TryPrefetchCommitsViaMountProcess: Mount not ready, falling back to direct prefetch");
+ return false;
+
+ default:
+ // Older mount that doesn't recognize PrefetchCommits
+ tracer.RelatedInfo("TryPrefetchCommitsViaMountProcess: Unexpected response '{0}', falling back to direct prefetch", response.Header);
+ return false;
+ }
+ }
+ }
+
+ ///
+ /// Attempts to offload the blob prefetch to a running mount process,
+ /// which already has warm authentication. Returns true if the mount
+ /// handled the request (success or failure); returns false if offload
+ /// is unavailable and the caller should fall back to direct auth.
+ ///
+ private bool TryPrefetchBlobsViaMountProcess(
+ ITracer tracer,
+ GVFSEnlistment enlistment,
+ List filesList,
+ List foldersList,
+ string headCommitId)
+ {
+ using (NamedPipeClient pipeClient = new NamedPipeClient(enlistment.NamedPipeName))
+ {
+ if (!pipeClient.Connect())
+ {
+ tracer.RelatedInfo("TryPrefetchBlobsViaMountProcess: Mount not running, falling back to direct prefetch");
+ return false;
+ }
+
+ NamedPipeMessages.PrefetchBlobs.Request request = new NamedPipeMessages.PrefetchBlobs.Request
+ {
+ Files = filesList,
+ Folders = foldersList,
+ HeadCommitId = headCommitId,
+ };
+
+ if (!pipeClient.TrySendRequest(request.CreateMessage()))
+ {
+ tracer.RelatedWarning("TryPrefetchBlobsViaMountProcess: Failed to send request, falling back to direct prefetch");
+ return false;
+ }
+
+ NamedPipeMessages.Message response;
+ if (!pipeClient.TryReadResponse(out response))
+ {
+ tracer.RelatedWarning("TryPrefetchBlobsViaMountProcess: Failed to read response, falling back to direct prefetch");
+ return false;
+ }
+
+ switch (response.Header)
+ {
+ case NamedPipeMessages.PrefetchBlobs.CompleteResult:
+ NamedPipeMessages.PrefetchBlobs.Response blobResponse =
+ NamedPipeMessages.PrefetchBlobs.Response.FromMessage(response);
+
+ if (blobResponse.Success)
+ {
+ tracer.RelatedInfo("TryPrefetchBlobsViaMountProcess: Mount completed blob prefetch successfully");
+
+ Console.WriteLine();
+ Console.WriteLine("Stats:");
+ Console.WriteLine(" Matched blobs: " + blobResponse.MatchedBlobCount);
+ Console.WriteLine(" Already cached: " + (blobResponse.MatchedBlobCount - blobResponse.DownloadedBlobCount));
+ Console.WriteLine(" Downloaded: " + blobResponse.DownloadedBlobCount);
+
+ return true;
+ }
+
+ this.ReportErrorAndExit(tracer, "Prefetching blobs failed (via mount): " + blobResponse.Error);
+ return true;
+
+ case NamedPipeMessages.PrefetchBlobs.MountNotReadyResult:
+ tracer.RelatedInfo("TryPrefetchBlobsViaMountProcess: Mount not ready, falling back to direct prefetch");
+ return false;
+
+ default:
+ tracer.RelatedInfo("TryPrefetchBlobsViaMountProcess: Unexpected response '{0}', falling back to direct prefetch", response.Header);
+ return false;
+ }
+ }
+ }
+
private void PrefetchCommits(ITracer tracer, GVFSEnlistment enlistment, GitObjectsHttpRequestor objectRequestor, CacheServerInfo cacheServer)
{
bool success;
@@ -328,18 +511,38 @@ private void LoadBlobPrefetchArgs(
out string headCommitId,
out List filesList,
out List foldersList,
- out FileBasedDictionary lastPrefetchArgs)
+ out FileBasedDictionary prefetchCache,
+ out int prefetchCacheSize)
{
string error;
- if (!FileBasedDictionary.TryCreate(
- tracer,
- Path.Combine(enlistment.DotGVFSRoot, "LastBlobPrefetch.dat"),
- new PhysicalFileSystem(),
- out lastPrefetchArgs,
- out error))
+ // Read cache size from git config
+ prefetchCacheSize = BlobPrefetcher.DefaultPrefetchCacheSize;
+ GitProcess gitProcess = new GitProcess(enlistment);
+ if (gitProcess.TryGetFromConfig(BlobPrefetcher.PrefetchCacheSizeConfigKey, forceOutsideEnlistment: false, out string cacheSizeValue))
+ {
+ if (int.TryParse(cacheSizeValue, out int parsedSize))
+ {
+ prefetchCacheSize = Math.Clamp(parsedSize, 0, BlobPrefetcher.MaxPrefetchCacheSize);
+ }
+ else
+ {
+ tracer.RelatedWarning($"Invalid value '{cacheSizeValue}' for {BlobPrefetcher.PrefetchCacheSizeConfigKey}, using default {BlobPrefetcher.DefaultPrefetchCacheSize}");
+ }
+ }
+
+ prefetchCache = null;
+ if (prefetchCacheSize > 0)
{
- tracer.RelatedWarning("Unable to load last prefetch args: " + error);
+ if (!FileBasedDictionary.TryCreate(
+ tracer,
+ Path.Combine(enlistment.DotGVFSRoot, BlobPrefetcher.BlobPrefetchCacheFile),
+ new PhysicalFileSystem(),
+ out prefetchCache,
+ out error))
+ {
+ tracer.RelatedWarning("Unable to load prefetch cache: " + error);
+ }
}
filesList = new List();
@@ -355,7 +558,6 @@ private void LoadBlobPrefetchArgs(
this.ReportErrorAndExit(tracer, error);
}
- GitProcess gitProcess = new GitProcess(enlistment);
GitProcess.Result result = gitProcess.RevParse(GVFSConstants.DotGit.HeadName);
if (result.ExitCodeIsFailure)
{
@@ -371,7 +573,8 @@ private void PrefetchBlobs(
string headCommitId,
List filesList,
List foldersList,
- FileBasedDictionary lastPrefetchArgs,
+ FileBasedDictionary prefetchCache,
+ int prefetchCacheSize,
GitObjectsHttpRequestor objectRequestor,
CacheServerInfo cacheServer)
{
@@ -381,7 +584,8 @@ private void PrefetchBlobs(
objectRequestor,
filesList,
foldersList,
- lastPrefetchArgs,
+ prefetchCache,
+ prefetchCacheSize,
ChunkSize,
SearchThreadCount,
DownloadThreadCount,
@@ -487,5 +691,101 @@ private string GetCacheServerDisplay(CacheServerInfo cacheServer, string repoUrl
return "from origin (no cache server)";
}
+
+ ///
+ /// Hydrates files matching the file/folder filters by reading 1 byte from each.
+ /// Runs in the verb process (not the mount) to avoid ProjFS self-callbacks.
+ /// Blobs should already be in the object cache from a prior download phase.
+ ///
+ private void HydrateMatchingFiles(
+ ITracer tracer,
+ GVFSEnlistment enlistment,
+ List filesList,
+ List foldersList)
+ {
+ string workingDir = enlistment.WorkingDirectoryRoot;
+ List filesToHydrate = new List();
+
+ // Collect files from folder filters
+ foreach (string folder in foldersList)
+ {
+ string normalizedFolder = folder.Replace(GVFSConstants.GitPathSeparator, Path.DirectorySeparatorChar).TrimEnd(Path.DirectorySeparatorChar);
+ string fullFolderPath = Path.Combine(workingDir, normalizedFolder);
+ if (Directory.Exists(fullFolderPath))
+ {
+ filesToHydrate.AddRange(Directory.EnumerateFiles(fullFolderPath, "*", SearchOption.AllDirectories));
+ }
+ }
+
+ // Collect files from file filters (supports simple prefix wildcards like *.txt)
+ foreach (string filePattern in filesList)
+ {
+ string normalizedPattern = filePattern.Replace(GVFSConstants.GitPathSeparator, Path.DirectorySeparatorChar);
+
+ if (normalizedPattern.StartsWith("*"))
+ {
+ // Prefix wildcard — search entire working directory
+ filesToHydrate.AddRange(Directory.EnumerateFiles(workingDir, normalizedPattern, SearchOption.AllDirectories));
+ }
+ else
+ {
+ // Exact file path
+ string fullPath = Path.Combine(workingDir, normalizedPattern);
+ if (File.Exists(fullPath))
+ {
+ filesToHydrate.Add(fullPath);
+ }
+ }
+ }
+
+ if (filesToHydrate.Count == 0)
+ {
+ tracer.RelatedInfo("HydrateMatchingFiles: No files to hydrate");
+ return;
+ }
+
+ int hydratedCount = 0;
+ int failedCount = 0;
+ int maxParallelism = Math.Max(1, Environment.ProcessorCount / 2);
+
+ bool success = true;
+ Func doHydrate = () =>
+ {
+ Parallel.ForEach(
+ filesToHydrate,
+ new ParallelOptions { MaxDegreeOfParallelism = maxParallelism },
+ filePath =>
+ {
+ if (GVFSPlatform.Instance.FileSystem.HydrateFile(filePath, new byte[1]))
+ {
+ Interlocked.Increment(ref hydratedCount);
+ }
+ else
+ {
+ tracer.RelatedWarning("HydrateMatchingFiles: Failed to hydrate " + filePath);
+ Interlocked.Increment(ref failedCount);
+ }
+ });
+
+ return failedCount == 0;
+ };
+
+ if (this.Verbose)
+ {
+ success = doHydrate();
+ }
+ else
+ {
+ success = this.ShowStatusWhileRunning(doHydrate, "Hydrating files");
+ }
+
+ Console.WriteLine();
+ Console.WriteLine(" Hydrated files: " + hydratedCount);
+ if (failedCount > 0)
+ {
+ Console.WriteLine(" Failed to hydrate: " + failedCount);
+ Environment.ExitCode = 1;
+ }
+ }
}
}
diff --git a/GVFS/GVFS/CommandLine/UnmountVerb.cs b/GVFS/GVFS/CommandLine/UnmountVerb.cs
index 4804d94155..0de886a501 100644
--- a/GVFS/GVFS/CommandLine/UnmountVerb.cs
+++ b/GVFS/GVFS/CommandLine/UnmountVerb.cs
@@ -261,7 +261,7 @@ private void AcquireLock(string pipeName, string enlistmentRoot)
"gvfs unmount",
currentProcess.Id,
GVFSPlatform.Instance.IsElevated(),
- isConsoleOutputRedirectedToFile: GVFSPlatform.Instance.IsConsoleOutputRedirectedToFile(),
+ isConsoleOutputRedirectedToFile: Console.IsOutputRedirected,
checkAvailabilityOnly: false,
gvfsEnlistmentRoot: enlistmentRoot,
gitCommandSessionId: string.Empty,
diff --git a/GVFS/GitHooksLoader/GitHooksLoader.vcxproj b/GVFS/GitHooksLoader/GitHooksLoader.vcxproj
index 0c4d4fbdfc..28513e8ef3 100644
--- a/GVFS/GitHooksLoader/GitHooksLoader.vcxproj
+++ b/GVFS/GitHooksLoader/GitHooksLoader.vcxproj
@@ -9,6 +9,14 @@
Release
x64
+
+ Debug
+ ARM64
+
+
+ Release
+ ARM64
+
{798DE293-6EDA-4DC4-9395-BE7A71C563E3}
@@ -17,38 +25,38 @@
10.0
-
+
Application
- true
- v143
+ true
Unicode
+ v143
-
+
Application
- false
- v143
+ false
true
Unicode
+ v143
-
+
-
+
-
+
true
-
+
false
-
+
Use
Level4
@@ -62,7 +70,7 @@
Console
true
- C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\x64;%(AdditionalLibraryDirectories)
+ C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\$(Platform.ToLower());%(AdditionalLibraryDirectories)
$(IntDir)\$(MSBuildProjectName).log
@@ -71,7 +79,7 @@
$(GeneratedIncludePath)
-
+
Level4
Use
@@ -89,7 +97,7 @@
true
true
true
- C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\x64;%(AdditionalLibraryDirectories)
+ C:\Program Files (x86)\Windows Kits\10\Lib\10.0.16299.0\ucrt\$(Platform.ToLower());%(AdditionalLibraryDirectories)
$(IntDir)\$(MSBuildProjectName).log
@@ -106,8 +114,8 @@
- Create
- Create
+ Create
+ Create
diff --git a/scripts/Build.bat b/scripts/Build.bat
index faf6649f31..592020f594 100644
--- a/scripts/Build.bat
+++ b/scripts/Build.bat
@@ -21,6 +21,33 @@ IF "%~3"=="" (
SET VERBOSITY=%3
)
+REM Architecture: x64 (default) or arm64.
+REM Drives vcpkg triplet selection, vcxproj Platform, and dotnet RID.
+IF "%~4"=="" (
+ SET ARCH=x64
+) ELSE (
+ SET ARCH=%4
+)
+IF /I "%ARCH%"=="ARM64" SET ARCH=arm64
+IF /I "%ARCH%"=="X64" SET ARCH=x64
+IF NOT "%ARCH%"=="x64" IF NOT "%ARCH%"=="arm64" (
+ ECHO ERROR: Unknown architecture '%ARCH%'. Expected x64 or arm64.
+ EXIT /B 2
+)
+REM vcxproj Platform name (mixed case): x64 stays x64, arm64 becomes ARM64.
+IF "%ARCH%"=="arm64" (
+ SET NATIVE_PLATFORM=ARM64
+) ELSE (
+ SET NATIVE_PLATFORM=x64
+)
+ECHO INFO: Building for ARCH=%ARCH% (vcxproj Platform=%NATIVE_PLATFORM%)
+
+REM Make sure vswhere.exe is on PATH so the NativeAOT toolchain (ilc) can
+REM locate the VS install and the matching link.exe. Without this, ilc
+REM emits the literal vswhere "not recognized" stderr into the link command
+REM line and the publish step fails with a malformed link.rsp invocation.
+SET "PATH=%ProgramFiles(x86)%\Microsoft Visual Studio\Installer;%PATH%"
+
REM .NET 10 SDK ships MSBuild 18.x; VS 2022 ships MSBuild 17.x.
REM Managed (csproj) projects require MSBuild 18.x via "dotnet build".
REM Native C++ (vcxproj) projects require VS MSBuild with VC++ targets.
@@ -30,13 +57,14 @@ ECHO ^* Restoring Packages *
ECHO ^**********************
dotnet restore "%VFS_SRCDIR%\GVFS.sln" ^
/v:%VERBOSITY% ^
- /p:Configuration=%CONFIGURATION% || GOTO ERROR
+ /p:Configuration=%CONFIGURATION% ^
+ /p:VfsArch=%ARCH% || GOTO ERROR
ECHO ^*************************************
ECHO ^* Installing vcpkg native libraries *
ECHO ^*************************************
-IF EXIST "%VFS_OUTDIR%\vcpkg_installed\dynamic\x64-windows-dynamic\bin\git2.dll" (
- ECHO INFO: vcpkg native libraries already present, skipping install.
+IF EXIST "%VFS_OUTDIR%\vcpkg_installed\dynamic\%ARCH%-windows-dynamic\bin\git2.dll" (
+ ECHO INFO: vcpkg native libraries already present for %ARCH%, skipping install.
GOTO :VCPKG_DONE
)
SET VCPKG_EXEC=
@@ -66,8 +94,8 @@ EXIT /B 1
:FOUND_VCPKG
ECHO INFO: Using vcpkg at '%VCPKG_EXEC%'
-"%VCPKG_EXEC%" install --triplet x64-windows-static-aot --x-install-root="%VFS_OUTDIR%\vcpkg_installed\static" --x-manifest-root="%VFS_SRCDIR%" || GOTO ERROR
-"%VCPKG_EXEC%" install --triplet x64-windows-dynamic --x-install-root="%VFS_OUTDIR%\vcpkg_installed\dynamic" --x-manifest-root="%VFS_SRCDIR%" || GOTO ERROR
+"%VCPKG_EXEC%" install --triplet %ARCH%-windows-static-aot --x-install-root="%VFS_OUTDIR%\vcpkg_installed\static" --x-manifest-root="%VFS_SRCDIR%" || GOTO ERROR
+"%VCPKG_EXEC%" install --triplet %ARCH%-windows-dynamic --x-install-root="%VFS_OUTDIR%\vcpkg_installed\dynamic" --x-manifest-root="%VFS_SRCDIR%" || GOTO ERROR
:VCPKG_DONE
ECHO ^**************************
@@ -91,27 +119,54 @@ IF EXIST %VSWHERE_EXEC% (
)
:FOUND_MSBUILD
-IF DEFINED MSBUILD_EXEC (
- FOR %%P IN (
- "%VFS_SRCDIR%\GVFS\GitHooksLoader\GitHooksLoader.vcxproj"
- "%VFS_SRCDIR%\GVFS\GVFS.NativeTests\GVFS.NativeTests.vcxproj"
- "%VFS_SRCDIR%\GVFS\GVFS.PostIndexChangedHook\GVFS.PostIndexChangedHook.vcxproj"
- "%VFS_SRCDIR%\GVFS\GVFS.ReadObjectHook\GVFS.ReadObjectHook.vcxproj"
- "%VFS_SRCDIR%\GVFS\GVFS.VirtualFileSystemHook\GVFS.VirtualFileSystemHook.vcxproj"
- ) DO (
- ECHO Building %%~nP...
- "%MSBUILD_EXEC%" %%P ^
- /t:Build ^
- /v:%VERBOSITY% ^
- /p:Configuration=%CONFIGURATION% ^
- /p:Platform=x64 ^
- /p:SolutionDir="%VFS_SRCDIR%\\" || GOTO ERROR
- )
-) ELSE (
+IF NOT DEFINED MSBUILD_EXEC (
ECHO ERROR: Could not find VS MSBuild. Install Visual Studio with the C++ workload to build native projects.
EXIT /B 1
)
+REM Initialize the VC++ developer environment for the target architecture so
+REM MSBuild can locate the matching cl.exe / link.exe and the right INCLUDE/LIB
+REM search paths. Without this, MSBuild finds the v180 toolset's targets file
+REM but cannot locate the actual ARM64 build tool binaries.
+SET VCVARS_BAT=
+SET VSWHERE_VC="%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe"
+IF EXIST %VSWHERE_VC% (
+ FOR /F "tokens=* USEBACKQ" %%F IN (`%VSWHERE_VC% -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath`) DO (
+ IF EXIST "%%F\VC\Auxiliary\Build\vcvarsall.bat" SET "VCVARS_BAT=%%F\VC\Auxiliary\Build\vcvarsall.bat"
+ )
+)
+IF NOT DEFINED VCVARS_BAT (
+ ECHO ERROR: Could not find vcvarsall.bat. Install Visual Studio with the C++ workload.
+ EXIT /B 1
+)
+ECHO INFO: Initializing VC++ env for %ARCH% via "%VCVARS_BAT%"
+CALL "%VCVARS_BAT%" %ARCH% || GOTO ERROR
+
+FOR %%P IN (
+ "%VFS_SRCDIR%\GVFS\GitHooksLoader\GitHooksLoader.vcxproj"
+ "%VFS_SRCDIR%\GVFS\GVFS.NativeTests\GVFS.NativeTests.vcxproj"
+ "%VFS_SRCDIR%\GVFS\GVFS.PostIndexChangedHook\GVFS.PostIndexChangedHook.vcxproj"
+ "%VFS_SRCDIR%\GVFS\GVFS.ReadObjectHook\GVFS.ReadObjectHook.vcxproj"
+ "%VFS_SRCDIR%\GVFS\GVFS.VirtualFileSystemHook\GVFS.VirtualFileSystemHook.vcxproj"
+) DO (
+ ECHO Building %%~nP...
+ "%MSBUILD_EXEC%" %%P ^
+ /t:Build ^
+ /v:%VERBOSITY% ^
+ /p:Configuration=%CONFIGURATION% ^
+ /p:Platform=%NATIVE_PLATFORM% ^
+ /p:VfsArch=%ARCH% ^
+ /p:SolutionDir="%VFS_SRCDIR%\\" || GOTO ERROR
+)
+
+REM vcvarsall.bat sets Platform= in the environment. MSBuild picks that
+REM up as the default $(Platform) for csproj evaluation, which makes the
+REM managed projects add an extra "\\" segment to their bin\obj output
+REM paths. That breaks GVFS.Installers which expects the Payload at a
+REM Platform-free path. Clear Platform before the managed build so csproj
+REM defaults to "AnyCPU" (= Platform-free output paths).
+SET "Platform="
+
ECHO ^*****************************
ECHO ^* Building Managed Projects *
ECHO ^*****************************
@@ -128,7 +183,7 @@ FOR %%P IN (
"%VFS_SRCDIR%\GVFS\GVFS.PerfProfiling\GVFS.PerfProfiling.csproj"
) DO (
ECHO Publishing %%~nP...
- dotnet publish %%P --no-restore -v:%VERBOSITY% -c %CONFIGURATION% || GOTO ERROR
+ dotnet publish %%P -v:%VERBOSITY% -c %CONFIGURATION% /p:VfsArch=%ARCH% || GOTO ERROR
)
ECHO ^*******************************
@@ -141,17 +196,18 @@ FOR %%P IN (
"%VFS_SRCDIR%\GVFS\GVFS.Installers\GVFS.Installers.csproj"
) DO (
ECHO Publishing %%~nP...
- dotnet publish %%P --no-restore -v:%VERBOSITY% -c %CONFIGURATION% || GOTO ERROR
+ dotnet publish %%P -v:%VERBOSITY% -c %CONFIGURATION% /p:VfsArch=%ARCH% || GOTO ERROR
)
GOTO :EOF
:USAGE
-ECHO usage: %~n0%~x0 [^] [^] [^]
+ECHO usage: %~n0%~x0 [^] [^] [^] [^]
ECHO.
ECHO configuration Solution configuration (default: Debug).
ECHO version GVFS version (default: 0.2.173.2).
ECHO verbosity MSBuild verbosity (default: minimal).
+ECHO arch Target CPU architecture: x64 or arm64 (default: x64).
ECHO.
EXIT 1
diff --git a/scripts/CreateBuildArtifacts.bat b/scripts/CreateBuildArtifacts.bat
index d27f5a64c7..7ee2a52ca7 100644
--- a/scripts/CreateBuildArtifacts.bat
+++ b/scripts/CreateBuildArtifacts.bat
@@ -14,6 +14,14 @@ IF "%~2"=="" (
SET OUTROOT=%2
)
+IF "%~3"=="" (
+ SET ARCH=x64
+) ELSE (
+ SET ARCH=%3
+)
+IF /I "%ARCH%"=="ARM64" SET ARCH=arm64
+IF /I "%ARCH%"=="X64" SET ARCH=x64
+
IF EXIST %OUTROOT% (
rmdir /s /q %OUTROOT%
)
@@ -33,7 +41,7 @@ ECHO ^* Collecting GVFS.Installers *
ECHO ^******************************
mkdir %OUTROOT%\GVFS.Installers
xcopy /S /Y ^
- %VFS_OUTDIR%\GVFS.Installers\bin\%CONFIGURATION%\win-x64\* ^
+ %VFS_OUTDIR%\GVFS.Installers\bin\%CONFIGURATION%\win-%ARCH%\* ^
%OUTROOT%\GVFS.Installers\ || GOTO ERROR
ECHO ^************************
@@ -42,7 +50,7 @@ ECHO ^************************
ECHO Collecting FastFetch...
mkdir %OUTROOT%\FastFetch
xcopy /S /Y ^
- %VFS_OUTDIR%\FastFetch\bin\%CONFIGURATION%\net10.0-windows10.0.17763.0\win-x64\publish\* ^
+ %VFS_OUTDIR%\FastFetch\bin\%CONFIGURATION%\net10.0-windows10.0.17763.0\win-%ARCH%\publish\* ^
%OUTROOT%\FastFetch\ || GOTO ERROR
ECHO ^***********************************
@@ -50,16 +58,17 @@ ECHO ^* Collecting GVFS.FunctionalTests *
ECHO ^***********************************
mkdir %OUTROOT%\GVFS.FunctionalTests
xcopy /S /Y ^
- %VFS_OUTDIR%\GVFS.FunctionalTests\bin\%CONFIGURATION%\net10.0-windows10.0.17763.0\win-x64\publish\* ^
+ %VFS_OUTDIR%\GVFS.FunctionalTests\bin\%CONFIGURATION%\net10.0-windows10.0.17763.0\win-%ARCH%\publish\* ^
%OUTROOT%\GVFS.FunctionalTests\ || GOTO ERROR
GOTO :EOF
:USAGE
-ECHO usage: %~n0%~x0 [^] [^]
+ECHO usage: %~n0%~x0 [^] [^] [^]
ECHO.
ECHO configuration Solution configuration (default: Debug).
ECHO destination Destination directory to copy artifacts (default: %VFS_PUBLISHDIR%).
+ECHO arch Target CPU architecture: x64 or arm64 (default: x64).
ECHO.
EXIT 1
diff --git a/scripts/RunFunctionalTests-Dev.ps1 b/scripts/RunFunctionalTests-Dev.ps1
index 048afa6b2e..24692ed60c 100644
--- a/scripts/RunFunctionalTests-Dev.ps1
+++ b/scripts/RunFunctionalTests-Dev.ps1
@@ -15,6 +15,10 @@
.PARAMETER Configuration
Build configuration: Debug (default) or Release.
+.PARAMETER Arch
+ Target CPU architecture: x64 (default) or arm64. Selects which
+ publish output (win-x64 or win-arm64) to put on PATH and to run.
+
.PARAMETER ExtraArgs
Additional arguments passed through to GVFS.FunctionalTests.exe
(e.g. --test=GVFS.FunctionalTests.Tests.GVFSVerbTests.UnknownVerb)
@@ -22,11 +26,14 @@
.EXAMPLE
.\RunFunctionalTests-Dev.ps1
.\RunFunctionalTests-Dev.ps1 -Configuration Release
+ .\RunFunctionalTests-Dev.ps1 -Configuration Release -Arch arm64
.\RunFunctionalTests-Dev.ps1 -ExtraArgs "--test=GVFS.FunctionalTests.Tests.GVFSVerbTests.UnknownVerb"
.\RunFunctionalTests-Dev.ps1 Debug --test=GVFS.FunctionalTests.Tests.EnlistmentPerFixture.WorktreeTests
#>
param(
[string]$Configuration = "Debug",
+ [ValidateSet("x64","arm64")]
+ [string]$Arch = "x64",
[Parameter(ValueFromRemainingArguments)]
[string[]]$ExtraArgs
)
@@ -58,14 +65,22 @@ $env:GVFS_TEST_DATA = Join-Path $env:TEMP "GVFS-FunctionalTest-$hash.$PID"
$env:GVFS_COMMON_APPDATA_ROOT = Join-Path $env:GVFS_TEST_DATA "AppData"
$env:GVFS_SECURE_DATA_ROOT = Join-Path $env:GVFS_TEST_DATA "ProgramData"
-# Put build output gvfs.exe on PATH
-$payloadDir = Join-Path $outDir "GVFS.Payload\bin\$Configuration\net10.0-windows10.0.17763.0\win-x64\publish"
+# Put build output gvfs.exe on PATH. The Payload csproj sets
+# false
+# and layout.bat assembles binaries under bin\\win-\,
+# so there is no net\publish\ segment for this project.
+$payloadDir = Join-Path $outDir "GVFS.Payload\bin\$Configuration\win-$Arch"
+if (-not (Test-Path (Join-Path $payloadDir "GVFS.exe"))) {
+ Write-Error "Payload GVFS.exe not found at $payloadDir. Has the solution been built for $Arch / $Configuration?"
+ exit 1
+}
$env:PATH = "$payloadDir;C:\Program Files\Git\cmd;$env:PATH"
Write-Host "============================================"
Write-Host "GVFS Functional Tests - Dev Mode (no admin)"
Write-Host "============================================"
Write-Host "Configuration: $Configuration"
+Write-Host "Architecture: $Arch"
Write-Host "Build output: $outDir"
Write-Host "Test service: $env:GVFS_TEST_SERVICE_NAME"
Write-Host "Test data: $env:GVFS_TEST_DATA"
@@ -87,8 +102,9 @@ if (-not $gitPath) {
Write-Host "git location: $($gitPath.Source)"
Write-Host ""
-# Build test exe path
-$testExe = Join-Path $outDir "GVFS.FunctionalTests\bin\$Configuration\net10.0-windows10.0.17763.0\win-x64\publish\GVFS.FunctionalTests.exe"
+# Build test exe path. The FunctionalTests csproj is a regular AOT-published
+# executable, so it ends up under the standard publish layout.
+$testExe = Join-Path $outDir "GVFS.FunctionalTests\bin\$Configuration\net10.0-windows10.0.17763.0\win-$Arch\publish\GVFS.FunctionalTests.exe"
if (-not (Test-Path $testExe)) {
Write-Error "Test executable not found: $testExe`nRun Build.bat first."
exit 1
diff --git a/scripts/RunUnitTests.bat b/scripts/RunUnitTests.bat
index 669b0b17a4..dc35bdb2ad 100644
--- a/scripts/RunUnitTests.bat
+++ b/scripts/RunUnitTests.bat
@@ -2,9 +2,10 @@
CALL %~dp0\InitializeEnvironment.bat || EXIT /b 10
IF "%1"=="" (SET "CONFIGURATION=Debug") ELSE (SET "CONFIGURATION=%1")
+IF "%2"=="" (SET "ARCH=x64") ELSE (SET "ARCH=%2")
SET RESULT=0
-%VFS_OUTDIR%\GVFS.UnitTests\bin\%CONFIGURATION%\net10.0-windows10.0.17763.0\win-x64\publish\GVFS.UnitTests.exe || SET RESULT=1
+%VFS_OUTDIR%\GVFS.UnitTests\bin\%CONFIGURATION%\net10.0-windows10.0.17763.0\win-%ARCH%\publish\GVFS.UnitTests.exe || SET RESULT=1
EXIT /b %RESULT%
diff --git a/triplets/arm64-windows-dynamic.cmake b/triplets/arm64-windows-dynamic.cmake
new file mode 100644
index 0000000000..425eff4042
--- /dev/null
+++ b/triplets/arm64-windows-dynamic.cmake
@@ -0,0 +1,5 @@
+set(VCPKG_TARGET_ARCHITECTURE arm64)
+# Dynamic linkage: produces git2.dll for non-AOT projects (tests) that use
+# runtime P/Invoke. AOT projects use the static triplet instead.
+set(VCPKG_CRT_LINKAGE dynamic)
+set(VCPKG_LIBRARY_LINKAGE dynamic)
diff --git a/triplets/arm64-windows-static-aot.cmake b/triplets/arm64-windows-static-aot.cmake
new file mode 100644
index 0000000000..57e395a6d9
--- /dev/null
+++ b/triplets/arm64-windows-static-aot.cmake
@@ -0,0 +1,12 @@
+set(VCPKG_TARGET_ARCHITECTURE arm64)
+# Static linkage: libgit2 and its dependencies (pcre, zlib) are compiled into
+# the consuming binary. This eliminates "DLL missing" crashes for the native
+# git2 library.
+#
+# Licensing notes:
+# libgit2 — GPLv2 with linking exception (see COPYING in libgit2 repo), which
+# explicitly permits static linking without imposing GPL on the consumer.
+# pcre — BSD license (permissive, no static-linking restrictions).
+# zlib — zlib license (permissive, no static-linking restrictions).
+set(VCPKG_CRT_LINKAGE static)
+set(VCPKG_LIBRARY_LINKAGE static)