Service: add versioned install layout support to Configuration and PendingUpgradeHandler

Add CurrentVersionPath to Configuration that resolves a Current\ junction
under the install root, falling back to the flat layout when no junction
exists. GVFSLocation is now computed dynamically so junction re-targeting
takes effect without restarting the service.

Update PendingUpgradeHandler.GetInstalledMountProcesses to recognize mount
processes from any Versions\ subdirectory, not just the flat install root.

These changes are backward-compatible: on existing flat installs,
CurrentVersionPath falls back to AssemblyPath and all behavior is identical.

This is groundwork for a versioned install layout (Plan 002) where each
version lives in its own directory and a Current junction points to the
active version, enabling non-disruptive upgrades.

Assisted-by: Claude Opus 4.6
Signed-off-by: Tyrie Vella <tyrielv@gmail.com>

Author: tyrielv

GVFS/GVFS.Service/Configuration.cs

@@ -1,16 +1,25 @@
 using GVFS.Common;
+using System;
 using System.IO;
 
 namespace GVFS.Service
 {
     public class Configuration
     {
+        /// <summary>
+        /// Subdirectory name for the junction that points to the active version.
+        /// When a versioned install layout is present, <c>{app}\Current</c> is a
+        /// junction pointing to <c>{app}\Versions\{version}</c>.
+        /// </summary>
+        public const string CurrentVersionDirName = "Current";
+
+        private static readonly Lazy<string> assemblyPath =
+            new Lazy<string>(ProcessHelper.GetCurrentProcessLocation);
+
         private static Configuration instance = new Configuration();
-        private static string assemblyPath = null;
 
         private Configuration()
         {
-            this.GVFSLocation = Path.Combine(AssemblyPath, GVFSPlatform.Instance.Constants.GVFSExecutableName);
         }
 
         public static Configuration Instance
@@ -21,19 +30,39 @@ public static Configuration Instance
             }
         }
 
-        public static string AssemblyPath
+        /// <summary>
+        /// The directory containing <c>GVFS.Service.exe</c> (the install root).
+        /// </summary>
+        public static string AssemblyPath => assemblyPath.Value;
+
+        /// <summary>
+        /// The directory containing the current version's binaries.
+        /// With versioned layout this resolves through the <c>Current</c> junction
+        /// (e.g. <c>{app}\Current</c> → <c>{app}\Versions\1.0.X</c>).
+        /// Falls back to <see cref="AssemblyPath"/> when no <c>Current</c>
+        /// junction exists (flat/legacy layout).
+        /// Evaluated on each access so that junction re-targeting is picked up
+        /// without restarting the service.
+        /// </summary>
+        public static string CurrentVersionPath
         {
             get
             {
-                if (assemblyPath == null)
+                string currentDir = Path.Combine(AssemblyPath, CurrentVersionDirName);
+                if (Directory.Exists(currentDir))
                 {
-                    assemblyPath = ProcessHelper.GetCurrentProcessLocation();
+                    return currentDir;
                 }
 
-                return assemblyPath;
+                // Legacy flat layout — binaries are siblings of the service.
+                return AssemblyPath;
             }
         }
 
-        public string GVFSLocation { get; private set; }
+        /// <summary>
+        /// Full path to the current version's <c>GVFS.exe</c>. Resolved
+        /// dynamically so that junction re-targeting takes effect immediately.
+        /// </summary>
+        public string GVFSLocation => Path.Combine(CurrentVersionPath, GVFSPlatform.Instance.Constants.GVFSExecutableName);
     }
 }

GVFS/GVFS.Service/PendingUpgradeHandler.cs

@@ -82,16 +82,15 @@ public static bool IsPending()
 
         /// <summary>
         /// Returns GVFS.Mount processes whose executable is in the install
-        /// directory. Processes from dev builds or other installs are excluded
-        /// so they don't block upgrades of the system install. If a process's
-        /// path cannot be read (access denied, 32/64-bit mismatch), it is
-        /// included conservatively.
+        /// directory (or any versioned subdirectory). Processes from dev builds
+        /// or other installs are excluded so they don't block upgrades of the
+        /// system install. If a process's path cannot be read (access denied,
+        /// 32/64-bit mismatch), it is included conservatively.
         /// Caller must dispose the returned Process objects.
         /// </summary>
         public static List<Process> GetInstalledMountProcesses(ITracer tracer)
         {
             string installDir = Configuration.AssemblyPath;
-            string expectedPath = Path.Combine(installDir, MountExeName);
             Process[] allMountProcesses = Process.GetProcessesByName(MountProcessName);
             List<Process> installed = new List<Process>();
 
@@ -101,8 +100,7 @@ public static List<Process> GetInstalledMountProcesses(ITracer tracer)
                 try
                 {
                     string processPath = process.MainModule?.FileName;
-                    if (processPath != null &&
-                        !PathComparer.Equals(processPath, expectedPath))
+                    if (processPath != null && !IsInstalledMountPath(installDir, processPath))
                     {
                         include = false;
                         tracer.RelatedInfo(
@@ -326,6 +324,26 @@ private static bool IsMarkerFile(string relativePath)
                    string.Equals(relativePath, Phase1CompleteMarkerFileName, StringComparison.OrdinalIgnoreCase);
         }
 
+        /// <summary>
+        /// Returns true if the given GVFS.Mount.exe path is under the install
+        /// directory — either in the flat layout (<c>{app}\GVFS.Mount.exe</c>)
+        /// or in a versioned subdirectory (<c>{app}\Versions\*\GVFS.Mount.exe</c>
+        /// or <c>{app}\Current\GVFS.Mount.exe</c>).
+        /// </summary>
+        private static bool IsInstalledMountPath(string installDir, string processPath)
+        {
+            // Verify filename is actually GVFS.Mount.exe (not some other exe
+            // under the install dir).
+            if (!PathComparer.Equals(Path.GetFileName(processPath), MountExeName))
+            {
+                return false;
+            }
+
+            // Verify the exe lives under the install directory.
+            string normalizedInstallDir = installDir.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar;
+            return processPath.StartsWith(normalizedInstallDir, StringComparison.OrdinalIgnoreCase);
+        }
+
         /// <summary>
         /// Moves a file, retrying once after killing any process that has the
         /// source file locked (e.g. a GVFS process that started mid-upgrade).