Merge pull request microsoft#1916 from tyrielv/tyrielv/dev-func-tests

functional tests: add dev mode for running without admin

Author: tyrielv

GVFS/GVFS.FunctionalTests/GVFSTestConfig.cs

@@ -16,6 +16,8 @@ public static class GVFSTestConfig
 
         public static bool ReplaceInboxProjFS { get; set; }
 
+        public static bool IsDevMode { get; set; }
+
         public static string PathToGVFS
         {
             get

GVFS/GVFS.FunctionalTests/Program.cs

@@ -1,3 +1,4 @@
+using GVFS.Common;
 using GVFS.FunctionalTests.Properties;
 using GVFS.FunctionalTests.Tools;
 using GVFS.PlatformLoader;
@@ -15,10 +16,17 @@ public static void Main(string[] args)
         {
             Properties.Settings.Default.Initialize();
             GVFSPlatformLoader.Initialize();
+
+            GVFSTestConfig.IsDevMode = Environment.GetEnvironmentVariable("GVFS_FUNCTIONAL_TEST_DEV_MODE") == "1";
+
             Console.WriteLine("Settings.Default.CurrentDirectory: {0}", Settings.Default.CurrentDirectory);
             Console.WriteLine("Settings.Default.PathToGit: {0}", Settings.Default.PathToGit);
             Console.WriteLine("Settings.Default.PathToGVFS: {0}", Settings.Default.PathToGVFS);
             Console.WriteLine("Settings.Default.PathToGVFSService: {0}", Settings.Default.PathToGVFSService);
+            if (GVFSTestConfig.IsDevMode)
+            {
+                Console.WriteLine("*** Dev mode enabled (GVFS_FUNCTIONAL_TEST_DEV_MODE=1) ***");
+            }
 
             NUnitRunner runner = new NUnitRunner(args);
             runner.AddGlobalSetupIfNeeded("GVFS.FunctionalTests.GlobalSetup");
@@ -140,11 +148,8 @@ private static void RunBeforeAnyTests()
 
             GVFSServiceProcess.InstallService();
 
-            string serviceProgramDataDir = Path.Combine(
-                Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles, Environment.SpecialFolderOption.Create),
-                "GVFS",
-                "ProgramData",
-                "GVFS.Service");
+            string serviceProgramDataDir = GVFSPlatform.Instance.GetSecureDataRootForGVFSComponent(
+                GVFSConstants.Service.ServiceName);
 
             string statusCacheVersionTokenPath = Path.Combine(
                 serviceProgramDataDir, "EnableGitStatusCacheToken.dat");

GVFS/GVFS.FunctionalTests/Settings.cs

@@ -45,16 +45,30 @@ public static void Initialize()
                 Commitish = @"FunctionalTests/20201014";
 
                 EnlistmentRoot = @"C:\Repos\GVFSFunctionalTests\enlistment";
-                PathToGVFS = @"C:\Program Files\VFS for Git\GVFS.exe";
-                PathToGit = @"C:\Program Files\Git\cmd\git.exe";
-                PathToBash = @"C:\Program Files\Git\bin\bash.exe";
 
                 ControlGitRepoRoot = @"C:\Repos\GVFSFunctionalTests\ControlRepo";
                 FastFetchBaseRoot = @"C:\Repos\GVFSFunctionalTests\FastFetch";
                 FastFetchRoot = Path.Combine(FastFetchBaseRoot, "test");
                 FastFetchControl = Path.Combine(FastFetchBaseRoot, "control");
-                PathToGVFSService = @"C:\Program Files\VFS for Git\GVFS.Service.exe";
                 BinaryFileNameExtension = ".exe";
+
+                string devModeOutDir = Environment.GetEnvironmentVariable("GVFS_DEV_OUT_DIR");
+                if (!string.IsNullOrEmpty(devModeOutDir))
+                {
+                    string configuration = Environment.GetEnvironmentVariable("GVFS_DEV_CONFIGURATION") ?? "Debug";
+                    string payloadDir = Path.Combine(devModeOutDir, "GVFS.Payload", "bin", configuration, "win-x64");
+
+                    PathToGVFS = Path.Combine(payloadDir, "gvfs.exe");
+                    PathToGVFSService = Path.Combine(payloadDir, "GVFS.Service.exe");
+                }
+                else
+                {
+                    PathToGVFS = @"C:\Program Files\VFS for Git\GVFS.exe";
+                    PathToGVFSService = @"C:\Program Files\VFS for Git\GVFS.Service.exe";
+                }
+
+                PathToGit = @"C:\Program Files\Git\cmd\git.exe";
+                PathToBash = @"C:\Program Files\Git\bin\bash.exe";
             }
         }
     }

GVFS/GVFS.FunctionalTests/Tools/GVFSServiceProcess.cs

@@ -12,6 +12,7 @@ namespace GVFS.FunctionalTests.Tools
     public static class GVFSServiceProcess
     {
         private static readonly string ServiceNameArgument = "--servicename=" + TestServiceName;
+        private static Process consoleServiceProcess;
 
         public static string TestServiceName
         {
@@ -22,10 +23,145 @@ public static string TestServiceName
         }
 
         public static void InstallService()
+        {
+            if (GVFSTestConfig.IsDevMode)
+            {
+                StartServiceAsConsoleProcess();
+            }
+            else
+            {
+                InstallWindowsService();
+            }
+        }
+
+        public static void UninstallService()
+        {
+            if (GVFSTestConfig.IsDevMode)
+            {
+                StopConsoleServiceProcess();
+                CleanupServiceData();
+            }
+            else
+            {
+                UninstallWindowsService();
+            }
+        }
+
+        public static void StartService()
+        {
+            if (GVFSTestConfig.IsDevMode)
+            {
+                StartServiceAsConsoleProcess();
+            }
+            else
+            {
+                StartWindowsService();
+            }
+        }
+
+        public static void StopService()
+        {
+            if (GVFSTestConfig.IsDevMode)
+            {
+                StopConsoleServiceProcess();
+            }
+            else
+            {
+                StopWindowsService();
+            }
+        }
+
+        private static void StartServiceAsConsoleProcess()
+        {
+            StopConsoleServiceProcess();
+
+            string pathToService = GetPathToService();
+            Console.WriteLine("Starting test service in console mode: " + pathToService);
+
+            ProcessStartInfo startInfo = new ProcessStartInfo(pathToService);
+            startInfo.Arguments = $"--console {ServiceNameArgument}";
+            startInfo.UseShellExecute = false;
+            startInfo.CreateNoWindow = true;
+            startInfo.RedirectStandardOutput = true;
+            startInfo.RedirectStandardError = true;
+
+            consoleServiceProcess = Process.Start(startInfo);
+            consoleServiceProcess.ShouldNotBeNull("Failed to start test service process");
+
+            // Consume output asynchronously to prevent buffer deadlock
+            consoleServiceProcess.BeginOutputReadLine();
+            consoleServiceProcess.BeginErrorReadLine();
+
+            // Wait for the service to start listening on its named pipe
+            string pipeName = TestServiceName + ".pipe";
+            int retries = 50;
+            while (retries-- > 0)
+            {
+                if (consoleServiceProcess.HasExited)
+                {
+                    throw new InvalidOperationException(
+                        $"Test service process exited with code {consoleServiceProcess.ExitCode} before becoming ready");
+                }
+
+                if (File.Exists(@"\\.\pipe\" + pipeName))
+                {
+                    Console.WriteLine("Test service is ready (pipe: " + pipeName + ")");
+                    return;
+                }
+
+                Thread.Sleep(200);
+            }
+
+            throw new System.TimeoutException("Timed out waiting for test service pipe: " + pipeName);
+        }
+
+        private static void StopConsoleServiceProcess()
+        {
+            if (consoleServiceProcess != null && !consoleServiceProcess.HasExited)
+            {
+                try
+                {
+                    Console.WriteLine("Stopping test service console process (PID: " + consoleServiceProcess.Id + ")");
+                    consoleServiceProcess.Kill();
+                    consoleServiceProcess.WaitForExit(5000);
+                }
+                catch (InvalidOperationException)
+                {
+                    // Process already exited
+                }
+
+                consoleServiceProcess = null;
+            }
+        }
+
+        private static void CleanupServiceData()
+        {
+            string commonAppDataRoot = Environment.GetEnvironmentVariable("GVFS_COMMON_APPDATA_ROOT");
+            string serviceData;
+            if (!string.IsNullOrEmpty(commonAppDataRoot))
+            {
+                serviceData = Path.Combine(commonAppDataRoot, TestServiceName);
+            }
+            else
+            {
+                serviceData = Path.Combine(
+                    Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
+                    "GVFS",
+                    TestServiceName);
+            }
+
+            DirectoryInfo serviceDataDir = new DirectoryInfo(serviceData);
+            if (serviceDataDir.Exists)
+            {
+                serviceDataDir.Delete(true);
+            }
+        }
+
+        private static void InstallWindowsService()
         {
             Console.WriteLine("Installing " + TestServiceName);
 
-            UninstallService();
+            UninstallWindowsService();
 
             // Wait for delete to complete. If the services control panel is open, this will never complete.
             while (RunScCommand("query", TestServiceName).ExitCode == 0)
@@ -47,12 +183,12 @@ public static void InstallService()
             ProcessResult result = RunScCommand("create", createServiceArguments);
             result.ExitCode.ShouldEqual(0, "Failure while running sc create " + createServiceArguments + "\r\n" + result.Output);
 
-            StartService();
+            StartWindowsService();
         }
 
-        public static void UninstallService()
+        private static void UninstallWindowsService()
         {
-            StopService();
+            StopWindowsService();
 
             RunScCommand("delete", TestServiceName);
 
@@ -65,7 +201,7 @@ public static void UninstallService()
             }
         }
 
-        public static void StartService()
+        private static void StartWindowsService()
         {
             ServiceController testService = ServiceController.GetServices().SingleOrDefault(service => service.ServiceName == TestServiceName);
             testService.ShouldNotBeNull($"{TestServiceName} does not exist as a service");
@@ -78,7 +214,7 @@ public static void StartService()
             }
         }
 
-        public static void StopService()
+        private static void StopWindowsService()
         {
             try
             {

GVFS/GVFS.Platform.Windows/ProjFSFilter.cs

@@ -38,6 +38,7 @@ public class ProjFSFilter : IKernelDriver
 
         private const uint OkResult = 0;
         private const uint NameCollisionErrorResult = 0x801F0012;
+        private const uint AccessDeniedResult = 0x80070005;
 
         private enum ProjFSInboxStatus
         {
@@ -460,10 +461,35 @@ public bool TryPrepareFolderForCallbacks(string folderPath, out string error, ou
         public bool IsReady(JsonTracer tracer, string enlistmentRoot, TextWriter output, out string error)
         {
             error = string.Empty;
-            return
-                IsServiceRunning(tracer) &&
-                IsNativeLibInstalled(tracer, new PhysicalFileSystem()) &&
-                TryAttach(enlistmentRoot, out error);
+            if (!IsServiceRunning(tracer))
+            {
+                error = "ProjFS (prjflt) service is not running";
+                return false;
+            }
+
+            if (!IsNativeLibInstalled(tracer, new PhysicalFileSystem()))
+            {
+                error = "ProjFS native library is not installed";
+                return false;
+            }
+
+            if (!TryAttach(enlistmentRoot, out error))
+            {
+                // FilterAttach requires SE_LOAD_DRIVER_PRIVILEGE (admin). When running
+                // non-elevated on a machine where ProjFS is already set up, the filter
+                // is already attached to the volume and the only failure is ACCESS_DENIED.
+                // Allow the mount to proceed in that specific case.
+                if (error.Contains(AccessDeniedResult.ToString()))
+                {
+                    tracer.RelatedInfo($"IsReady: TryAttach returned ACCESS_DENIED, but ProjFS service is running. Proceeding.");
+                    error = string.Empty;
+                    return true;
+                }
+
+                return false;
+            }
+
+            return true;
         }
 
         public bool RegisterForOfflineIO()

GVFS/GVFS.Platform.Windows/WindowsPlatform.Shared.cs

@@ -77,6 +77,12 @@ public static string GetNamedPipeNameImplementation(string enlistmentRoot)
 
         public static string GetSecureDataRootForGVFSImplementation()
         {
+            string envOverride = Environment.GetEnvironmentVariable("GVFS_SECURE_DATA_ROOT");
+            if (!string.IsNullOrEmpty(envOverride))
+            {
+                return envOverride;
+            }
+
             return Path.Combine(
                 Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles, Environment.SpecialFolderOption.Create),
                  "GVFS",
@@ -85,6 +91,12 @@ public static string GetSecureDataRootForGVFSImplementation()
 
         public static string GetCommonAppDataRootForGVFSImplementation()
         {
+            string envOverride = Environment.GetEnvironmentVariable("GVFS_COMMON_APPDATA_ROOT");
+            if (!string.IsNullOrEmpty(envOverride))
+            {
+                return envOverride;
+            }
+
             return Path.Combine(
                 Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData, Environment.SpecialFolderOption.Create),
                 "GVFS");

GVFS/GVFS.Service/GVFSService.Windows.cs

@@ -152,6 +152,53 @@ protected override void OnSessionChange(SessionChangeDescription changeDescripti
             }
         }
 
+        public void RunInConsoleMode(string[] args)
+        {
+            if (this.serviceThread != null)
+            {
+                throw new InvalidOperationException("Cannot start service twice in a row.");
+            }
+
+            string serviceName = args.FirstOrDefault(arg => arg.StartsWith(ServiceNameArgPrefix));
+            if (serviceName != null)
+            {
+                this.serviceName = serviceName.Substring(ServiceNameArgPrefix.Length);
+            }
+
+            string serviceLogsDirectoryPath = GVFSPlatform.Instance.GetLogsDirectoryForGVFSComponent(this.serviceName);
+
+            Directory.CreateDirectory(serviceLogsDirectoryPath);
+            this.tracer.AddLogFileEventListener(
+                GVFSEnlistment.GetNewGVFSLogFileName(serviceLogsDirectoryPath, GVFSConstants.LogFileTypes.Service),
+                EventLevel.Verbose,
+                Keywords.Any);
+
+            try
+            {
+                this.serviceDataLocation = GVFSPlatform.Instance.GetSecureDataRootForGVFSComponent(this.serviceName);
+                Directory.CreateDirectory(this.serviceDataLocation);
+                Directory.CreateDirectory(Path.GetDirectoryName(this.serviceDataLocation));
+
+                this.serviceStopped = new ManualResetEvent(false);
+
+                Console.WriteLine($"GVFS.Service running in console mode as '{this.serviceName}'");
+                Console.WriteLine("Press Ctrl+C to stop.");
+
+                Console.CancelKeyPress += (sender, e) =>
+                {
+                    e.Cancel = true;
+                    this.StopRunning();
+                };
+
+                this.Run();
+            }
+            catch (Exception e)
+            {
+                this.tracer.RelatedError($"Console mode failed: {e}");
+                throw;
+            }
+        }
+
         protected override void OnStart(string[] args)
         {
             if (this.serviceThread != null)