Merge branch 'enhancements/async-git-setup' into enhancements/window-loading-view

Author: StanleyGoldman

src/GitHub.Api/Extensions/FileSystemExtensions.cs

@@ -37,7 +37,7 @@ public static string CalculateFileMD5(this IFileSystem fileSystem, string file)
             return BitConverter.ToString(computeHash).Replace("-", string.Empty).ToLower();
         }
 
-        public static string CalculateFolderMD5(this IFileSystem fileSystem, string path)
+        public static string CalculateFolderMD5(this IFileSystem fileSystem, string path, bool includeContents = true)
         {
             //https://stackoverflow.com/questions/3625658/creating-hash-for-folder
 
@@ -56,9 +56,12 @@ public static string CalculateFolderMD5(this IFileSystem fileSystem, string path
                     var pathBytes = Encoding.UTF8.GetBytes(relativeFilePath);
                     md5.TransformBlock(pathBytes, 0, pathBytes.Length, pathBytes, 0);
 
-                    // hash contents
-                    var contentBytes = File.ReadAllBytes(filePath);
-                    md5.TransformBlock(contentBytes, 0, contentBytes.Length, contentBytes, 0);
+                    if (includeContents)
+                    {
+                        // hash contents
+                        var contentBytes = File.ReadAllBytes(filePath);
+                        md5.TransformBlock(contentBytes, 0, contentBytes.Length, contentBytes, 0);
+                    }
                 }
 
                 //Handles empty filePaths case

src/GitHub.Api/Installer/PortableGitInstallTask.cs

@@ -12,13 +12,17 @@ class PortableGitInstallDetails
         public NPath GitLfsExecPath { get; }
 
         public const string ExtractedMD5 = "65fd0575d3b47d8207b9e19d02faca4f";
+        public const string FileListMD5 = "a152a216b2e76f6c127053251187a278";
 
-        private const string ExpectedVersion = "f02737a78695063deace08e96d5042710d3e32db";
+        private const string PackageVersion = "f02737a78695063deace08e96d5042710d3e32db";
         private const string PackageName = "PortableGit";
-        private const string PackageNameWithVersion = PackageName + "_" + ExpectedVersion;
+        private const string PackageNameWithVersion = PackageName + "_" + PackageVersion;
+
+        private readonly bool onWindows;
 
         public PortableGitInstallDetails(NPath targetInstallPath, bool onWindows)
         {
+            this.onWindows = onWindows;
             var gitInstallPath = targetInstallPath.Combine(ApplicationInfo.ApplicationName, PackageNameWithVersion);
             GitInstallPath = gitInstallPath;
 
@@ -28,16 +32,23 @@ public PortableGitInstallDetails(NPath targetInstallPath, bool onWindows)
                 GitLfsExec += "git-lfs.exe";
 
                 GitExecPath = gitInstallPath.Combine("cmd", GitExec);
-                GitLfsExecPath = gitInstallPath.Combine("mingw32", "libexec", "git-core", GitLfsExec);
             }
             else
             {
                 GitExec = "git";
                 GitLfsExec = "git-lfs";
 
                 GitExecPath = gitInstallPath.Combine("bin", GitExec);
-                GitLfsExecPath = gitInstallPath.Combine("libexec", "git-core", GitLfsExec);
             }
+
+            GitLfsExecPath = GetGitLfsExecPath(gitInstallPath);
+        }
+
+        public NPath GetGitLfsExecPath(NPath gitInstallRoot)
+        {
+            return onWindows
+                ? gitInstallRoot.Combine("mingw32", "libexec", "git-core", GitLfsExec)
+                : gitInstallRoot.Combine("libexec", "git-core", GitLfsExec);
         }
     }
 
@@ -64,20 +75,74 @@ protected override NPath RunWithReturn(bool success)
                 return installDetails.GitExecPath;
             }
 
-            var installGit = InstallGit();
-            if (installGit)
+            Token.ThrowIfCancellationRequested();
+
+            installDetails.GitInstallPath.DeleteIfExists();
+            installDetails.GitInstallPath.EnsureParentDirectoryExists();
+
+            Token.ThrowIfCancellationRequested();
+
+            var extractTarget = NPath.CreateTempDirectory("git_install_task");
+            var installGit = InstallGit(extractTarget);
+            if (!installGit)
+            {
+                Logger.Warning("Failed PortableGitInstallTask");
+                return null;
+            }
+
+            Token.ThrowIfCancellationRequested();
+
+            var installGitLfs = InstallGitLfs(extractTarget);
+            if (!installGitLfs)
+            {
+                Logger.Warning("Failed PortableGitInstallTask");
+                return null;
+            }
+
+            Token.ThrowIfCancellationRequested();
+
+            var extractedMD5 = environment.FileSystem.CalculateFolderMD5(extractTarget);
+            if (!extractedMD5.Equals(PortableGitInstallDetails.ExtractedMD5, StringComparison.InvariantCultureIgnoreCase))
             {
-                var installGitLfs = InstallGitLfs();
-                if (installGitLfs)
-                {
-                    Logger.Trace("Completed PortableGitInstallTask");
-                    return installDetails.GitExecPath;
-                }
+                Logger.Warning("MD5 {0} does not match expected {1}", extractedMD5, PortableGitInstallDetails.ExtractedMD5);
+                Logger.Warning("Failed PortableGitInstallTask");
+                return null;
             }
 
-            Logger.Warning("Unsuccessful PortableGitInstallTask");
+            var moveSuccessful = MoveExtractTarget(extractTarget);
+            if (!moveSuccessful)
+            {
+                Logger.Warning("Failed PortableGitInstallTask");
+                return null;
+            }
 
-            return null;
+            Logger.Trace("Completed PortableGitInstallTask");
+            return installDetails.GitExecPath;
+        }
+
+        private bool MoveExtractTarget(NPath extractTarget)
+        {
+            try
+            {
+                Logger.Trace("Moving tempDirectory:\"{0}\" to extractTarget:\"{1}\"", extractTarget,
+                    installDetails.GitInstallPath);
+
+                extractTarget.Move(installDetails.GitInstallPath);
+
+                Logger.Trace("Deleting extractTarget:\"{0}\"", extractTarget);
+                extractTarget.DeleteIfExists();
+
+                Logger.Trace("Completed PortableGitInstallTask");
+            }
+            catch (Exception ex)
+            {
+                Logger.Warning(ex, "Error Moving tempDirectory:\"{0}\" to extractTarget:\"{1}\"", extractTarget,
+                    installDetails.GitInstallPath);
+
+                return false;
+            }
+
+            return true;
         }
 
         private bool IsPortableGitExtracted()
@@ -88,22 +153,22 @@ private bool IsPortableGitExtracted()
                 return false;
             }
 
-            var installMD5 = environment.FileSystem.CalculateFolderMD5(installDetails.GitInstallPath);
-            if (!installMD5.Equals(PortableGitInstallDetails.ExtractedMD5, StringComparison.InvariantCultureIgnoreCase))
+            var fileListMD5 = environment.FileSystem.CalculateFolderMD5(installDetails.GitInstallPath, false);
+            if (!fileListMD5.Equals(PortableGitInstallDetails.FileListMD5, StringComparison.InvariantCultureIgnoreCase))
             {
-                Logger.Trace("MD5 {0} does not match expected {1}", installMD5, PortableGitInstallDetails.ExtractedMD5);
+                Logger.Trace("MD5 {0} does not match expected {1}", fileListMD5, PortableGitInstallDetails.FileListMD5);
                 return false;
             }
 
             Logger.Trace("Git Present");
             return true;
         }
 
-        private bool InstallGit()
+        private bool InstallGit(NPath targetPath)
         {
             Logger.Trace("InstallGit");
 
-            var tempPath = NPath.GetTempFilename();
+            var tempPath = NPath.CreateTempDirectory("git_zip_path");
             var gitArchivePath = AssemblyResources.ToFile(ResourceType.Platform, "git.zip", tempPath, environment);
 
             if (!environment.FileSystem.FileExists(gitArchivePath))
@@ -115,54 +180,31 @@ private bool InstallGit()
 
             Token.ThrowIfCancellationRequested();
 
-            var tempDirectory = NPath.CreateTempDirectory("git_install_task");
-
             try
             {
-                Logger.Trace("Extracting gitArchivePath:\"{0}\" tempDirectory:\"{1}\"",
-                    gitArchivePath, tempDirectory);
+                Logger.Trace("Extracting gitArchivePath:\"{0}\" targetPath:\"{1}\"",
+                    gitArchivePath, targetPath);
 
-                ZipHelper.ExtractZipFile(gitArchivePath, tempDirectory, Token);
+                ZipHelper.ExtractZipFile(gitArchivePath, targetPath, Token);
             }
             catch (Exception ex)
             {
                 Logger.Warning(ex, "Error Extracting gitArchivePath:\"{0}\" tempDirectory:\"{1}\"", 
-                    gitArchivePath, tempDirectory);
+                    gitArchivePath, targetPath);
 
                 return false;
             }
 
-            Token.ThrowIfCancellationRequested();
-
-            try
-            {
-                installDetails.GitInstallPath.DeleteIfExists();
-                installDetails.GitInstallPath.EnsureParentDirectoryExists();
-
-                Logger.Trace("Moving tempDirectory:\"{0}\" to gitInstallPath:\"{1}\"",
-                    tempDirectory, installDetails.GitInstallPath);
-
-                tempDirectory.Move(installDetails.GitInstallPath);
-            }
-            catch (Exception ex)
-            {
-                Logger.Warning(ex, "Error Moving tempDirectory:\"{0}\" to gitInstallPath:\"{1}\"", 
-                    tempDirectory, installDetails.GitInstallPath);
-
-                return false;
-            }
-
-            Logger.Trace("Deleting tempDirectory:\"{0}\"", tempDirectory);
-            tempDirectory.DeleteIfExists();
+            tempPath.DeleteIfExists();
 
             return true;
         }
 
-        private bool InstallGitLfs()
+        private bool InstallGitLfs(NPath targetPath)
         {
             Logger.Trace("InstallGitLfs");
 
-            var tempPath = NPath.GetTempFilename();
+            var tempPath = NPath.CreateTempDirectory("git_lfs_zip_path");
             var gitLfsArchivePath = AssemblyResources.ToFile(ResourceType.Platform, "git-lfs.zip", tempPath, environment);
 
             if (!environment.FileSystem.FileExists(gitLfsArchivePath))
@@ -173,7 +215,7 @@ private bool InstallGitLfs()
 
             Token.ThrowIfCancellationRequested();
 
-            var tempDirectory = NPath.CreateTempDirectory("git_install_task");
+            var tempDirectory = NPath.CreateTempDirectory("git_lfs_extract_path");
 
             try
             {
@@ -182,22 +224,23 @@ private bool InstallGitLfs()
             }
             catch (Exception ex)
             {
-                Logger.Warning($"Error Extracting gitLfsArchivePath:\"{gitLfsArchivePath}\" tempDirectory:\"{tempDirectory}\"", ex);
+                Logger.Warning(ex, $"Error Extracting gitLfsArchivePath:\"{gitLfsArchivePath}\" tempDirectory:\"{tempDirectory}\"");
                 return false;
             }
 
             Token.ThrowIfCancellationRequested();
 
             var tempDirectoryGitLfsExec = tempDirectory.Combine(installDetails.GitLfsExec);
 
+            var targetLfsExecPath = installDetails.GetGitLfsExecPath(targetPath);
             try
             {
-                Logger.Trace("Moving tempDirectoryGitLfsExec:\"{0}\" to gitLfsExecFullPath:\"{1}\"", tempDirectoryGitLfsExec, installDetails.GitLfsExecPath);
-                tempDirectoryGitLfsExec.Move(installDetails.GitLfsExecPath);
+                Logger.Trace("Moving tempDirectoryGitLfsExec:\"{0}\" to targetLfsExecPath:\"{1}\"", tempDirectoryGitLfsExec, targetLfsExecPath);
+                tempDirectoryGitLfsExec.Move(targetLfsExecPath);
             }
             catch (Exception ex)
             {
-                Logger.Warning($"Error Moving tempDirectoryGitLfsExec:\"{tempDirectoryGitLfsExec}\" to gitLfsExecFullPath:\"{installDetails.GitLfsExecPath}\"", ex);
+                Logger.Warning(ex, $"Error Moving tempDirectoryGitLfsExec:\"{tempDirectoryGitLfsExec}\" to targetLfsExecPath:\"{targetLfsExecPath}\"");
                 return false;
             }
 

src/tests/IntegrationTests/Installer/PortableGitInstallTaskTests.cs

@@ -24,8 +24,8 @@ public void GitInstallTest()
 
             gitInstallTask.Start().Wait();
 
-            var calculateFolderMd5 = Environment.FileSystem.CalculateFolderMD5(gitInstallDetails.GitInstallPath);
-            calculateFolderMd5.Should().Be(PortableGitInstallDetails.ExtractedMD5);
+            Environment.FileSystem.CalculateFolderMD5(gitInstallDetails.GitInstallPath).Should().Be(PortableGitInstallDetails.ExtractedMD5);
+            Environment.FileSystem.CalculateFolderMD5(gitInstallDetails.GitInstallPath, false).Should().Be(PortableGitInstallDetails.FileListMD5);
 
             new PortableGitInstallTask(CancellationToken.None, Environment, gitInstallDetails)
                 .Then(new PortableGitInstallTask(CancellationToken.None, Environment, gitInstallDetails))