RFC: Enhance automount to wait for volume to be available

GVFS/GVFS.Common/FileSystem/IPlatformFileSystem.cs

@@ -8,5 +8,42 @@ public interface IPlatformFileSystem
         void CreateHardLink(string newLinkFileName, string existingFileName);
         bool TryGetNormalizedPath(string path, out string normalizedPath, out string errorMessage);
         void ChangeMode(string path, int mode);
+
+        /// <summary>
+        /// Check if a path exists as a subpath of the specified directory.
+        /// </summary>
+        /// <param name="directoryPath">Directory path.</param>
+        /// <param name="path">Path to query.</param>
+        /// <returns>True if <see cref="path"/> exists as a subpath of <see cref="directoryPath"/>, false otherwise.</returns>
+        bool IsPathUnderDirectory(string directoryPath, string path);
+
+        /// <summary>
+        /// Get the path to the volume root that the given path.
+        /// </summary>
+        /// <param name="path">File path to find the volume for.</param>
+        /// <returns>Path to the root of the volume.</returns>
+        string GetVolumeRoot(string path);
+
+        /// <summary>
+        /// Check if the volume for the given path is available and ready for use.
+        /// </summary>
+        /// <param name="path">Path to any directory or file on a volume.</param>
+        /// <remarks>
+        /// A volume might be unavailable for multiple reasons, including:
+        /// <para/>
+        ///  - the volume resides on a removable device which is not present
+        /// <para/>
+        ///  - the volume is not mounted in the operating system
+        /// <para/>
+        ///  - the volume is encrypted or locked
+        /// </remarks>
+        /// <returns>True if the volume is available, false otherwise.</returns>
+        bool IsVolumeAvailable(string path);
+
+        /// <summary>
+        /// Create an <see cref="IVolumeStateWatcher"/> which monitors for changes to the state of volumes on the system.
+        /// </summary>
+        /// <returns>Volume watcher</returns>
+        IVolumeStateWatcher CreateVolumeStateWatcher();
     }
 }

GVFS/GVFS.Common/FileSystem/IVolumeStateWatcher.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace GVFS.Common.FileSystem
+{
+    /// <summary>
+    /// Monitors the system for changes to the state of any disk volume, notifying subscribers when a change occurs.
+    /// </summary>
+    public interface IVolumeStateWatcher : IDisposable
+    {
+        /// <summary>
+        /// Raised when the state of a volume has changed, such as becoming available.
+        /// </summary>
+        event EventHandler<VolumeStateChangedEventArgs> VolumeStateChanged;
+
+        /// <summary>
+        /// Start watching for changes to the states of volumes on the system.
+        /// </summary>
+        void Start();
+
+        /// <summary>
+        /// Stop watching for changes to the states of volumes on the system.
+        /// </summary>
+        void Stop();
+    }
+}

GVFS/GVFS.Common/FileSystem/VolumeStateChangedEventArgs.cs

@@ -0,0 +1,36 @@
+using System;
+
+namespace GVFS.Common.FileSystem
+{
+    public enum VolumeStateChangeType
+    {
+        /// <summary>
+        /// The volume is now available and ready to use.
+        /// </summary>
+        VolumeAvailable,
+
+        /// <summary>
+        /// The volume is no longer available.
+        /// </summary>
+        VolumeUnavailable,
+    }
+
+    public class VolumeStateChangedEventArgs : EventArgs
+    {
+        public VolumeStateChangedEventArgs(string volumePath, VolumeStateChangeType changeType)
+        {
+            this.VolumePath = volumePath;
+            this.ChangeType = changeType;
+        }
+
+        /// <summary>
+        /// Path to the root of the volume that has changed.
+        /// </summary>
+        public string VolumePath { get; }
+
+        /// <summary>
+        /// Type of change.
+        /// </summary>
+        public VolumeStateChangeType ChangeType { get; }
+    }
+}

GVFS/GVFS.Common/NamedPipes/NamedPipeMessages.cs

@@ -300,6 +300,8 @@ public class Response : BaseResponse<GetActiveRepoListRequest>
             {
                 public List<string> RepoList { get; set; }
 
+                public List<string> InvalidRepoList { get; set; }
+
                 public static Response FromMessage(Message message)
                 {
                     return JsonConvert.DeserializeObject<Response>(message.Body);

GVFS/GVFS.Common/NativeMethods.cs

@@ -164,6 +164,13 @@ public static DateTime GetLastRebootTime()
             return DateTime.Now - uptime;
         }
 
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool GetVolumePathName(
+            string volumeName,
+            StringBuilder volumePathName,
+            uint bufferLength);
+
         [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
         private static extern bool MoveFileEx(
             string existingFileName,

GVFS/GVFS.Platform.Mac/MacFileSystem.cs

@@ -1,5 +1,6 @@
-using GVFS.Common;
+using GVFS.Common;
 using GVFS.Common.FileSystem;
+using System;
 using System.IO;
 using System.Runtime.InteropServices;
 
@@ -33,6 +34,32 @@ public void ChangeMode(string path, int mode)
            Chmod(path, mode);
         }
 
+        public bool IsPathUnderDirectory(string directoryPath, string path)
+        {
+            // TODO(Mac): Check if the user has set HFS+/APFS to case sensitive
+            // TODO(Mac): Normalize paths
+            // Note: this may be called with paths or volumes which do not exist/are not mounted
+            return path.StartsWith(directoryPath, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public string GetVolumeRoot(string path)
+        {
+            // TODO(Mac): Query the volume mount points and check if the path is under any of those
+            // For now just assume everything is under the system root.
+            return "/";
+        }
+
+        public bool IsVolumeAvailable(string path)
+        {
+            // TODO(Mac): Perform any additional checks for locked or encrypted volumes
+            return Directory.Exists(path) || File.Exists(path);
+        }
+
+        public IVolumeStateWatcher CreateVolumeStateWatcher()
+        {
+            return new MacVolumeStateWatcher();
+        }
+
         public bool TryGetNormalizedPath(string path, out string normalizedPath, out string errorMessage)
         {
             return MacFileSystem.TryGetNormalizedPathImplementation(path, out normalizedPath, out errorMessage);

GVFS/GVFS.Platform.Mac/MacVolumeStateWatcher.cs

@@ -0,0 +1,27 @@
+using System;
+using GVFS.Common.FileSystem;
+
+namespace GVFS.Platform.Mac
+{
+    public class MacVolumeStateWatcher : IVolumeStateWatcher
+    {
+        public event EventHandler<VolumeStateChangedEventArgs> VolumeStateChanged;
+
+        public void Start()
+        {
+        }
+
+        public void Stop()
+        {
+        }
+
+        public void Dispose()
+        {
+        }
+
+        protected void RaiseVolumeStateChanged(string volumePath, VolumeStateChangeType changeType)
+        {
+            this.VolumeStateChanged?.Invoke(this, new VolumeStateChangedEventArgs(volumePath, changeType));
+        }
+    }
+}

GVFS/GVFS.Platform.Windows/BitLockerHelpers.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Linq;
+using System.Management;
+
+namespace GVFS.Platform.Windows
+{
+    internal static class BitLockerHelpers
+    {
+        public const string VolumeEncryptionNamespace = @"root\cimv2\security\MicrosoftVolumeEncryption";
+
+        public static bool TryGetVolumeLockStatus(string driveName, out bool isLocked)
+        {
+            string queryString = $"SELECT * FROM Win32_EncryptableVolume WHERE DriveLetter = '{driveName}'";
+
+            using (var searcher = new ManagementObjectSearcher(VolumeEncryptionNamespace, queryString))
+            {
+                ManagementObjectCollection results = searcher.Get();
+                ManagementObject mo = results.OfType<ManagementObject>().FirstOrDefault();
+                if (mo != null)
+                {
+                    // Check the protection status
+                    // ProtectionStatus == 0 means the drive is not protected by BitLocker and therefore cannot be locked
+                    if (mo.Properties["ProtectionStatus"].Value is uint protectedInt && protectedInt == 0)
+                    {
+                        isLocked = false;
+                        return true;
+                    }
+
+                    // Check the lock status
+                    // Lock status is not a property and must be retrieved by the GetLockStatus method
+                    var args = new object[1];
+                    if (TryInvokeMethod(mo, "GetLockStatus", args) && args[0] is uint lockedInt)
+                    {
+                        // Unlocked
+                        if (lockedInt == 0)
+                        {
+                            isLocked = false;
+                            return true;
+                        }
+
+                        // Locked
+                        if (lockedInt == 1)
+                        {
+                            isLocked = true;
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            isLocked = false;
+            return false;
+        }
+
+        private static bool TryInvokeMethod(ManagementObject mo, string methodName, object[] args)
+        {
+            try
+            {
+                return mo.InvokeMethod(methodName, args) is uint result && result == 0;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+    }
+}

GVFS/GVFS.Platform.Windows/GVFS.Platform.Windows.csproj

@@ -72,6 +72,7 @@
     <Compile Include="$(BuildOutputDir)\CommonAssemblyVersion.cs">
       <Link>CommonAssemblyVersion.cs</Link>
     </Compile>
+    <Compile Include="BitLockerHelpers.cs" />
     <Compile Include="DiskLayoutUpgrades\DiskLayout10to11Upgrade_NewOperationType.cs" />
     <Compile Include="DiskLayoutUpgrades\DiskLayout11to12Upgrade_SharedLocalCache.cs" />
     <Compile Include="DiskLayoutUpgrades\DiskLayout12to13Upgrade_FolderPlaceholder.cs" />
@@ -101,6 +102,7 @@
     <Compile Include="WindowsPlatform.cs" />
     <Compile Include="WindowsPlatform.Shared.cs" />
     <Compile Include="WindowsFileSystem.cs" />
+    <Compile Include="WindowsVolumeStateWatcher.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config">

GVFS/GVFS.Platform.Windows/ProjFSFilter.cs

@@ -53,7 +53,7 @@ public static bool TryAttach(ITracer tracer, string enlistmentRoot, out string e
             try
             {
                 StringBuilder volumePathName = new StringBuilder(GVFSConstants.MaxPath);
-                if (!NativeMethods.GetVolumePathName(enlistmentRoot, volumePathName, GVFSConstants.MaxPath))
+                if (!Common.NativeMethods.GetVolumePathName(enlistmentRoot, volumePathName, GVFSConstants.MaxPath))
                 {
                     errorMessage = "Could not get volume path name";
                     tracer.RelatedError($"{nameof(TryAttach)}:{errorMessage}");
@@ -626,13 +626,6 @@ public static extern uint FilterAttach(
                 string instanceName,
                 uint createdInstanceNameLength = 0,
                 string createdInstanceName = null);
-
-            [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
-            [return: MarshalAs(UnmanagedType.Bool)]
-            public static extern bool GetVolumePathName(
-                string volumeName,
-                StringBuilder volumePathName,
-                uint bufferLength);
         }
     }
 }

GVFS/GVFS.Platform.Windows/WindowsFileSystem.cs

@@ -1,4 +1,6 @@
-using GVFS.Common;
+using System;
+using System.Text;
+using GVFS.Common;
 using GVFS.Common.FileSystem;
 
 namespace GVFS.Platform.Windows
@@ -29,6 +31,39 @@ public void ChangeMode(string path, int mode)
         {
         }
 
+        public bool IsPathUnderDirectory(string directoryPath, string path)
+        {
+            // TODO: Normalize paths
+            // We can't use the existing TryGetNormalizedPathImplementation method
+            // because it relies on actual calls to the disk to check if directories exist.
+            // This may be called with paths or volumes which do not actually exist.
+            return path.StartsWith(directoryPath, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public string GetVolumeRoot(string path)
+        {
+            var volumePathName = new StringBuilder(GVFSConstants.MaxPath);
+            if (NativeMethods.GetVolumePathName(path, volumePathName, GVFSConstants.MaxPath))
+            {
+                return volumePathName.ToString();
+            }
+
+            return null;
+        }
+
+        public bool IsVolumeAvailable(string path)
+        {
+            // No paths 'exist' on locked BitLocker volumes so it is sufficent to just
+            // check if the directory/file exists using the framework APIs.
+            return System.IO.Directory.Exists(path) || System.IO.File.Exists(path);
+        }
+
+        public IVolumeStateWatcher CreateVolumeStateWatcher()
+        {
+            // TODO: Extract the polling interval to a configuration value?
+            return new WindowsVolumeStateWatcher(TimeSpan.FromSeconds(15));
+        }
+
         public bool TryGetNormalizedPath(string path, out string normalizedPath, out string errorMessage)
         {
             return WindowsFileSystem.TryGetNormalizedPathImplementation(path, out normalizedPath, out errorMessage);