Merge branch 'enhancements/async-git-setup' into enhancements/git-setup-download

# Conflicts:
#	src/GitHub.Api/Installer/GitInstaller.cs
#	src/tests/IntegrationTests/BasePlatformIntegrationTest.cs
#	src/tests/IntegrationTests/Download/DownloadTaskTests.cs

Author: StanleyGoldman

src/GitHub.Api/Application/ApplicationManagerBase.cs

@@ -39,8 +39,7 @@ protected void Initialize()
             Logging.TracingEnabled = UserSettings.Get(Constants.TraceLoggingKey, false);
             ProcessManager = new ProcessManager(Environment, Platform.GitEnvironment, CancellationToken);
             Platform.Initialize(ProcessManager, TaskManager);
-            ITaskManager taskManager = TaskManager;
-            GitClient = new GitClient(Environment, ProcessManager, taskManager.Token);
+            GitClient = new GitClient(Environment, ProcessManager, TaskManager.Token);
             SetupMetrics();
         }
 
@@ -51,6 +50,7 @@ public void Run(bool firstRun)
             var afterGitSetup = new ActionTask(CancellationToken, RestartRepository)
                 .ThenInUI(InitializeUI);
 
+            //GitClient.GetConfig cannot be called until there is a git path set so it is wrapped in an ActionTask
             var windowsCredentialSetup = new ActionTask(CancellationToken, () => {
                 GitClient.GetConfig("credential.helper", GitConfigSource.Global).Then((b, credentialHelper) => {
                     if (!string.IsNullOrEmpty(credentialHelper))
@@ -68,13 +68,10 @@ public void Run(bool firstRun)
                 }).Start();
             });
 
-            var afterPathDetermined = new ActionTask<NPath>(CancellationToken, (b1, path) => {
-
+            var afterPathDetermined = new ActionTask<NPath>(CancellationToken, (b, path) => {
                 Logger.Trace("Setting Environment git path: {0}", path);
                 Environment.GitExecutablePath = path;
-
             }).ThenInUI(() => {
-
                 Environment.User.Initialize(GitClient);
 
                 if (Environment.IsWindows)
@@ -87,20 +84,35 @@ public void Run(bool firstRun)
                 }
             });
 
+            var findExecTask = new FindExecTask("git", CancellationToken)
+                .Finally((b, ex, path) => {
+                    if (b && path != null)
+                    {
+                        Logger.Trace("FindExecTask Success: {0}", path);
+
+                        new FuncTask<NPath>(CancellationToken, () => path)
+                            .Then(afterPathDetermined)
+                            .Start();
+                    }
+                    else
+                    {
+                        Logger.Warning("FindExecTask Failure");
+                        Logger.Error("Git not found");
+                    }
+                });
+
             var applicationDataPath = Environment.GetSpecialFolder(System.Environment.SpecialFolder.LocalApplicationData).ToNPath();
             var installDetails = new GitInstallDetails(applicationDataPath, true);
 
             var gitInstaller = new GitInstaller(Environment, CancellationToken, installDetails);
-            gitInstaller.SetupGitIfNeeded(new ActionTask<NPath>(CancellationToken, (b, s) => {
-
-                Logger.Trace("Success: {0}", s);
-
-                new FuncTask<NPath>(CancellationToken, () => s)
+            gitInstaller.SetupGitIfNeeded(new ActionTask<NPath>(CancellationToken, (b, path) => {
+                Logger.Trace("GitInstaller Success: {0}", path);
+                new FuncTask<NPath>(CancellationToken, () => path)
                     .Then(afterPathDetermined)
                     .Start();
-
             }), new ActionTask(CancellationToken, () => {
-                Logger.Trace("Failure");
+                Logger.Warning("GitInstaller Failure");
+                findExecTask.Start();
             }) );
         }
 

src/GitHub.Api/Installer/GitInstaller.cs

@@ -11,7 +11,12 @@ class GitInstallDetails
         public string GitLfsExec { get; }
         public NPath GitLfsExecPath { get; }
 
-        public const string ExtractedMD5 = "65fd0575d3b47d8207b9e19d02faca4f";
+        public const string GitExtractedMD5 = "e6cfc0c294a2312042f27f893dfc9c0a";
+        public const string GitLfsExtractedMD5 = "ae968b69fbf42dff72311040d24a";
+
+        public const string WindowsGitLfsExecutableMD5 = "177bb14d0c08f665a24f0d5516c3b080";
+        public const string MacGitLfsExecutableMD5 = "f81a1a065a26a4123193e8fd96c561ad";
+
         public const string FileListMD5 = "a152a216b2e76f6c127053251187a278";
 
         private const string PackageVersion = "f02737a78695063deace08e96d5042710d3e32db";
@@ -81,6 +86,7 @@ public void SetupGitIfNeeded(ActionTask<NPath> onSuccess, ITask onFailure)
             if (!environment.IsWindows)
             {
                 onFailure.Start();
+                return;
             }
 
             new FuncTask<bool>(cancellationToken, IsGitExtracted)
@@ -128,24 +134,17 @@ public void SetupGitIfNeeded(ActionTask<NPath> onSuccess, ITask onFailure)
                                 downloadGitLfsTask.ValidationHash = s;
                             })
                             .Then(downloadGitLfsTask)
-                            .Then(new UnzipTask(cancellationToken, gitArchivePath, gitExtractPath, sharpZipLibHelper))
-                            .Then(new UnzipTask(cancellationToken, gitLfsArchivePath, gitLfsExtractPath, sharpZipLibHelper))
+                            .Then(new UnzipTask(cancellationToken, gitArchivePath, gitExtractPath, sharpZipLibHelper, environment.FileSystem, GitInstallDetails.GitExtractedMD5))
+                            .Then(new UnzipTask(cancellationToken, gitLfsArchivePath, gitLfsExtractPath, sharpZipLibHelper, environment.FileSystem, GitInstallDetails.GitLfsExtractedMD5))
                             .Then(() => {
                                 var targetGitLfsExecPath = installDetails.GetGitLfsExecPath(gitExtractPath);
                                 var extractGitLfsExePath = gitLfsExtractPath.Combine(installDetails.GitLfsExec);
                                 extractGitLfsExePath.Move(targetGitLfsExecPath);
 
-                                var extractedMD5 = environment.FileSystem.CalculateFolderMD5(gitExtractPath);
-                                if (!extractedMD5.Equals(GitInstallDetails.ExtractedMD5, StringComparison.InvariantCultureIgnoreCase))
-                                {
-                                    Logger.Warning("MD5 {0} does not match expected {1}", extractedMD5, GitInstallDetails.ExtractedMD5);
-                                    Logger.Warning("Failed PortableGitInstallTask");
-                                    throw new Exception();
-                                }
-
                                 Logger.Trace("Moving tempDirectory:\"{0}\" to extractTarget:\"{1}\"", gitExtractPath,
                                     installDetails.GitInstallPath);
 
+                                installDetails.GitInstallPath.EnsureParentDirectoryExists();
                                 gitExtractPath.Move(installDetails.GitInstallPath);
 
                                 Logger.Trace("Deleting tempZipPath:\"{0}\"", tempZipPath);
@@ -187,6 +186,14 @@ private bool IsGitExtracted()
                 return false;
             }
 
+            var calculateMd5 = environment.FileSystem.CalculateFileMD5(installDetails.GitLfsExecPath);
+            var md5 = environment.IsWindows ? GitInstallDetails.WindowsGitLfsExecutableMD5 : GitInstallDetails.MacGitLfsExecutableMD5;
+            if (md5.Equals(calculateMd5, StringComparison.InvariantCultureIgnoreCase))
+            {
+                Logger.Trace("{0} has MD5 {1} Excepted {2}", installDetails.GitLfsExecPath, calculateMd5, md5);
+                return false;
+            }
+
             Logger.Trace("Git Present");
             return true;
         }

src/GitHub.Api/Installer/UnzipTask.cs

@@ -7,24 +7,27 @@ namespace GitHub.Unity
     class UnzipTask: TaskBase
     {
         private readonly string archiveFilePath;
-        private readonly string extractedPath;
+        private readonly NPath extractedPath;
         private readonly IZipHelper zipHelper;
+        private readonly IFileSystem fileSystem;
+        private readonly string expectedMD5;
         private readonly IProgress<float> zipFileProgress;
         private readonly IProgress<long> estimatedDurationProgress;
 
-        public UnzipTask(CancellationToken token, string archiveFilePath, string extractedPath,
-            IProgress<float> zipFileProgress = null, IProgress<long> estimatedDurationProgress = null) :
-            this(token, archiveFilePath, extractedPath, ZipHelper.Instance, zipFileProgress, estimatedDurationProgress)
+        public UnzipTask(CancellationToken token, string archiveFilePath, NPath extractedPath, IFileSystem fileSystem, string expectedMD5 = null, IProgress<float> zipFileProgress = null, IProgress<long> estimatedDurationProgress = null) :
+            this(token, archiveFilePath, extractedPath, ZipHelper.Instance, fileSystem, expectedMD5, zipFileProgress, estimatedDurationProgress)
         {
 
         }
 
-        public UnzipTask(CancellationToken token, string archiveFilePath, string extractedPath, IZipHelper zipHelper, IProgress<float> zipFileProgress = null, IProgress<long> estimatedDurationProgress = null)
+        public UnzipTask(CancellationToken token, string archiveFilePath, NPath extractedPath, IZipHelper zipHelper, IFileSystem fileSystem, string expectedMD5 = null, IProgress<float> zipFileProgress = null, IProgress<long> estimatedDurationProgress = null)
             : base(token)
         {
             this.archiveFilePath = archiveFilePath;
             this.extractedPath = extractedPath;
             this.zipHelper = zipHelper;
+            this.fileSystem = fileSystem;
+            this.expectedMD5 = expectedMD5;
             this.zipFileProgress = zipFileProgress;
             this.estimatedDurationProgress = estimatedDurationProgress;
         }
@@ -33,16 +36,43 @@ protected override void Run(bool success)
         {
             base.Run(success);
 
-            UnzipArchive();
-        }
-
-        private void UnzipArchive()
-        {
             Logger.Trace("Unzip File: {0} to Path: {1}", archiveFilePath, extractedPath);
 
-            zipHelper.Extract(archiveFilePath, extractedPath, Token, zipFileProgress, estimatedDurationProgress);
+            try
+            {
+                zipHelper.Extract(archiveFilePath, extractedPath, Token, zipFileProgress, estimatedDurationProgress);
+            }
+            catch (Exception ex)
+            {
+                var message = "Error Unzipping file";
+
+                Logger.Error(ex, message);
+                throw new UnzipTaskException(message);
+            }
+
+            if (expectedMD5 != null)
+            {
+                var calculatedMD5 = fileSystem.CalculateFolderMD5(extractedPath);
+                if (!calculatedMD5.Equals(expectedMD5, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    extractedPath.DeleteIfExists();
+
+                    var message = $"Extracted MD5: {calculatedMD5} Does not match expected: {expectedMD5}";
+                    Logger.Error(message);
+
+                    throw new UnzipTaskException(message);
+                }
+            }
 
             Logger.Trace("Completed Unzip");
         }
     }
+
+    public class UnzipTaskException : Exception {
+        public UnzipTaskException(string message) : base(message)
+        { }
+
+        public UnzipTaskException(string message, Exception innerException) : base(message, innerException)
+        { }
+    }
 }

src/tests/IntegrationTests/BasePlatformIntegrationTest.cs

@@ -1,8 +1,10 @@
+using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using GitHub.Unity;
 using NSubstitute;
+using Octokit;
 
 namespace IntegrationTests
 {
@@ -29,19 +31,43 @@ protected void InitializePlatform(NPath repoPath, NPath environmentPath, bool en
 
             if (setupGit)
             {
+                var autoResetEvent = new AutoResetEvent(false);
+
                 var applicationDataPath = Environment.GetSpecialFolder(System.Environment.SpecialFolder.LocalApplicationData).ToNPath();
                 var installDetails = new GitInstallDetails(applicationDataPath, true);
 
                 var zipArchivesPath = TestBasePath.Combine("ZipArchives").CreateDirectory();
                 var gitArchivePath = AssemblyResources.ToFile(ResourceType.Platform, "git.zip", zipArchivesPath, Environment);
                 var gitLfsArchivePath = AssemblyResources.ToFile(ResourceType.Platform, "git-lfs.zip", zipArchivesPath, Environment);
 
-                //var gitInstallTask = new PortableGitInstallTask(CancellationToken.None, Environment, gitArchivePath, gitLfsArchivePath, installDetails);
+                var gitInstaller = new GitInstaller(Environment, CancellationToken.None, installDetails);
+
+                NPath result = null;
+                Exception ex = null;
+
+                gitInstaller.SetupGitIfNeeded(new ActionTask<NPath>(CancellationToken.None, (b, path) => {
+                        result = path;
+                        autoResetEvent.Set();
+                    }),
+                    new ActionTask(CancellationToken.None, (b, exception) => {
+                        ex = exception;
+                        autoResetEvent.Set();
+                    }));
+
+                autoResetEvent.WaitOne();
+
+                if (result == null)
+                {
+                    if (ex != null)
+                    {
+                        throw ex;
+                    }
 
-                //var installPath = gitInstallTask.Start().Result;
-                //Environment.GitExecutablePath = installPath;
+                    throw new Exception("Did not install git");
+                }
 
-                //GitClient = new GitClient(Environment, ProcessManager, TaskManager.Token);
+                Environment.GitExecutablePath = result;
+                GitClient = new GitClient(Environment, ProcessManager, TaskManager.Token);
             }
         }
     }

src/tests/IntegrationTests/Download/DownloadTaskTests.cs

@@ -32,7 +32,7 @@ public async Task TestDownloadTask()
             Logger.Trace("File size {0} bytes", downloadPathBytes.Length);
 
             var md5Sum = fileSystem.CalculateFileMD5(downloadPath);
-            md5Sum.Should().Be(TestDownloadMD5.ToUpperInvariant());
+            md5Sum.Should().Be(TestDownloadMD5);
 
             var random = new Random();
             var takeCount = random.Next(downloadPathBytes.Length);
@@ -49,7 +49,7 @@ public async Task TestDownloadTask()
             Logger.Trace("File size {0} Bytes", downloadHalfPathBytes.Length);
 
             md5Sum = fileSystem.CalculateFileMD5(downloadPath);
-            md5Sum.Should().Be(TestDownloadMD5.ToUpperInvariant());
+            md5Sum.Should().Be(TestDownloadMD5);
         }
 
         [Test]

src/tests/IntegrationTests/SetUpFixture.cs

@@ -14,7 +14,7 @@ public void Setup()
 
             Logging.LogAdapter = new MultipleLogAdapter(
                 new FileLogAdapter($"..\\{DateTime.UtcNow.ToString("yyyyMMddHHmmss")}-integration-tests.log")
-                //, new ConsoleLogAdapter()
+                , new ConsoleLogAdapter()
             );
         }
     }

src/tests/IntegrationTests/UnzipTaskTests.cs

@@ -1,5 +1,7 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
+using FluentAssertions;
 using GitHub.Unity;
 using Microsoft.Win32.SafeHandles;
 using NSubstitute;
@@ -12,7 +14,7 @@ namespace IntegrationTests
     class UnzipTaskTests : BaseTaskManagerTest
     {
         [Test]
-        public void UnzipTest()
+        public void TaskSucceeds()
         {
             InitializeTaskManager();
 
@@ -22,14 +24,11 @@ public void UnzipTest()
             var destinationPath = TestBasePath.Combine("git_zip").CreateDirectory();
             var archiveFilePath = AssemblyResources.ToFile(ResourceType.Platform, "git.zip", destinationPath, Environment);
 
-            Logger.Trace("ArchiveFilePath: {0}", archiveFilePath);
-            Logger.Trace("TestBasePath: {0}", TestBasePath);
-
             var extractedPath = TestBasePath.Combine("git_zip_extracted").CreateDirectory();
 
             var zipProgress = 0;
             Logger.Trace("Pct Complete {0}%", zipProgress);
-            var unzipTask = new UnzipTask(CancellationToken.None, archiveFilePath, extractedPath, 
+            var unzipTask = new UnzipTask(CancellationToken.None, archiveFilePath, extractedPath, Environment.FileSystem, GitInstallDetails.GitExtractedMD5, 
                 new Progress<float>(zipFileProgress => {
                     var zipFileProgressInteger = (int) (zipFileProgress * 100);
                     if (zipProgress != zipFileProgressInteger)
@@ -40,6 +39,39 @@ public void UnzipTest()
                 }));
 
             unzipTask.Start().Wait();
+
+            extractedPath.DirectoryExists().Should().BeTrue();
+        }
+
+        [Test]
+        public void TaskFailsWhenMD5Incorect()
+        {
+            InitializeTaskManager();
+
+            var cacheContainer = Substitute.For<ICacheContainer>();
+            Environment = new IntegrationTestEnvironment(cacheContainer, TestBasePath, SolutionDirectory);
+
+            var destinationPath = TestBasePath.Combine("git_zip").CreateDirectory();
+            var archiveFilePath = AssemblyResources.ToFile(ResourceType.Platform, "git.zip", destinationPath, Environment);
+
+            var extractedPath = TestBasePath.Combine("git_zip_extracted").CreateDirectory();
+
+
+            var failed = false;
+            Exception exception = null;
+
+            var unzipTask = new UnzipTask(CancellationToken.None, archiveFilePath, extractedPath, Environment.FileSystem, "AABBCCDD")
+                .Finally((b, ex) => {
+                    failed = true;
+                    exception = ex;
+                });
+
+            unzipTask.Start().Wait();
+
+            extractedPath.DirectoryExists().Should().BeFalse();
+            failed.Should().BeTrue();
+            exception.Should().NotBeNull();
+            exception.Should().BeOfType<UnzipTaskException>();
         }
     }
 }