Merge features/octorun-initial-setup into releases/0.30

Author: shana

src/GitHub.Api/Application/ApplicationManagerBase.cs

@@ -54,48 +54,53 @@ public void Run(bool firstRun)
         {
             Logger.Trace("Run - CurrentDirectory {0}", NPath.CurrentDirectory);
 
-            isBusy = true;
+            var initEnvironmentTask = new ActionTask<NPath>(CancellationToken,
+                    (_, path) => InitializeEnvironment(path))
+                { Affinity = TaskAffinity.UI };
 
-            var gitExecutablePath = SystemSettings.Get(Constants.GitInstallPathKey)?.ToNPath();
-            if (gitExecutablePath.HasValue && gitExecutablePath.Value.FileExists()) // we have a git path
-            {
-                Logger.Trace("Using git install path from settings: {0}", gitExecutablePath);
-                InitializeEnvironment(gitExecutablePath.Value);
-            }
-            else // we need to go find git
-            {
-                Logger.Trace("No git path found in settings");
+            isBusy = true;
 
-                var initEnvironmentTask = new ActionTask<NPath>(CancellationToken,
-                    (b, path) => InitializeEnvironment(path)) { Affinity = TaskAffinity.UI };
-                var findExecTask = new FindExecTask("git", CancellationToken)
-                    .FinallyInUI((b, ex, path) =>
+            var octorunInstaller = new OctorunInstaller(Environment, TaskManager);
+            var setupTask = octorunInstaller
+                .SetupOctorunIfNeeded()
+                .Then((s, octorunPath) =>
                     {
-                        if (b && path.IsInitialized)
-                        {
-                            //Logger.Trace("FindExecTask Success: {0}", path);
-                            InitializeEnvironment(path);
-                        }
-                        else
-                        {
-                            //Logger.Warning("FindExecTask Failure");
-                            Logger.Error("Git not found");
-                        }
+                        Environment.OctorunScriptPath = octorunPath;
                     });
 
-                var gitInstaller = new GitInstaller(Environment, CancellationToken);
+            var initializeGitTask = new FuncTask<NPath>(CancellationToken, () =>
+                {
+                    var gitExecutablePath = SystemSettings.Get(Constants.GitInstallPathKey)?.ToNPath();
+                    if (gitExecutablePath.HasValue && gitExecutablePath.Value.FileExists()) // we have a git path
+                    {
+                        Logger.Trace("Using git install path from settings: {0}", gitExecutablePath);
+                        return gitExecutablePath.Value;
+                    }
+                    return NPath.Default;
+                });
 
-                // if successful, continue with environment initialization, otherwise try to find an existing git installation
-                var setupTask = gitInstaller.SetupGitIfNeeded();
-                setupTask.Progress(progressReporter.UpdateProgress);
-                setupTask.OnEnd += (thisTask, result, success, exception) =>
+            initializeGitTask.OnEnd += (t, path, _, __) =>
                 {
-                    if (success && result.IsInitialized)
-                        thisTask.Then(initEnvironmentTask);
-                    else
-                        thisTask.Then(findExecTask);
+                    if (path.IsInitialized)
+                        return;
+
+                    Logger.Trace("No git path found in settings");
+
+                    var gitInstaller = new GitInstaller(Environment, CancellationToken);
+
+                    // if successful, continue with environment initialization, otherwise try to find an existing git installation
+                    var task = gitInstaller.SetupGitIfNeeded();
+                    task.Progress(progressReporter.UpdateProgress);
+                    task.OnEnd += (thisTask, result, success, exception) =>
+                    {
+                        thisTask.Then(initEnvironmentTask, taskIsTopOfChain: true);
+                    };
+
+                    // append installer task to top chain
+                    t.Then(task, taskIsTopOfChain: true);
                 };
-            }
+
+            setupTask.Then(initializeGitTask).Start();
         }
 
         public ITask InitializeRepository()
@@ -195,13 +200,20 @@ protected void SetupMetrics(string unityVersion, bool firstRun)
         /// <param name="octorunScriptPath"></param>
         private void InitializeEnvironment(NPath gitExecutablePath)
         {
+            SetupMetrics();
+
+            if (!gitExecutablePath.IsInitialized)
+            {
+                isBusy = false;
+                return;
+            }
+
             Environment.GitExecutablePath = gitExecutablePath;
             Environment.User.Initialize(GitClient);
 
             var afterGitSetup = new ActionTask(CancellationToken, RestartRepository)
                 .ThenInUI(InitializeUI);
 
-            SetupMetrics();
             ITask task = afterGitSetup;
             if (Environment.IsWindows)
             {

src/GitHub.Api/Installer/GitInstaller.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Threading;
-using System.Threading.Tasks;
 using GitHub.Logging;
 
 namespace GitHub.Unity
@@ -14,6 +13,7 @@ class GitInstaller
         private readonly GitInstallDetails installDetails;
         private readonly IZipHelper sharpZipLibHelper;
 
+        GitInstallationState installationState;
         ITask<NPath> installationTask;
 
         public GitInstaller(IEnvironment environment, CancellationToken cancellationToken,
@@ -35,35 +35,35 @@ public ITask<NPath> SetupGitIfNeeded()
             installationTask.OnEnd += (thisTask, result, success, exception) => thisTask.UpdateProgress(100, 100);
 
             if (!environment.IsWindows)
-                return installationTask;
+            {
+                return new FindExecTask("git", cancellationToken)
+                    .Then(installationTask, taskIsTopOfChain: true);
+            }
 
-            var startTask = new FuncTask<GitInstallationState>(cancellationToken, () =>
+            var startTask = new FuncTask<NPath>(cancellationToken, () =>
                 {
-                    var state = VerifyGitInstallation();
-                    if (!state.GitIsValid && !state.GitLfsIsValid)
-                        state = GrabZipFromResources(state);
+                    installationState = VerifyGitInstallation();
+                    if (!installationState.GitIsValid && !installationState.GitLfsIsValid)
+                        installationState = GrabZipFromResources(installationState);
                     else
                         Logger.Trace("SetupGitIfNeeded: Skipped");
-                    return state;
+                    return installDetails.GitExecutablePath;
                 })
                 { Name = "Git Installation - Extract" };
 
 
-            startTask.OnEnd += (thisTask, state, success, exception) =>
+            startTask.OnEnd += (thisTask, path, success, exception) =>
             {
-                if (!state.GitIsValid && !state.GitLfsIsValid)
+                if (!installationState.GitIsValid && !installationState.GitLfsIsValid)
                 {
-                    if (!state.GitZipExists || !state.GitLfsZipExists)
-                        thisTask = thisTask.Then(CreateDownloadTask(state));
-                    thisTask = thisTask.Then(ExtractPortableGit(state));
+                    if (!installationState.GitZipExists || !installationState.GitLfsZipExists)
+                        thisTask = thisTask.Then(CreateDownloadTask(installationState));
+                    thisTask = thisTask.Then(ExtractPortableGit(installationState));
                 }
                 thisTask.Then(installationTask);
             };
 
-            // we want to start the startTask and not the installationTask because the latter only gets
-            // appended to the task chain when startTask ends, so calling Start() on it wouldn't work
-            startTask.Start();
-            return installationTask;
+            return startTask;
         }
 
         private GitInstallationState VerifyGitInstallation()
@@ -123,7 +123,7 @@ private GitInstallationState GrabZipFromResources(GitInstallationState state)
             return state;
         }
 
-        private ITask<GitInstallationState> CreateDownloadTask(GitInstallationState state)
+        private ITask<NPath> CreateDownloadTask(GitInstallationState state)
         {
             var downloader = new Downloader();
             downloader.QueueDownload(installDetails.GitZipUrl, installDetails.GitZipMd5Url, installDetails.ZipPath);
@@ -133,11 +133,11 @@ private ITask<GitInstallationState> CreateDownloadTask(GitInstallationState stat
                 state.GitZipExists = installDetails.GitZipPath.FileExists();
                 state.GitLfsZipExists = installDetails.GitLfsZipPath.FileExists();
                 installationTask.UpdateProgress(40, 100);
-                return state;
+                return installDetails.ZipPath;
             });
         }
 
-        private FuncTask<GitInstallationState> ExtractPortableGit(GitInstallationState state)
+        private FuncTask<NPath> ExtractPortableGit(GitInstallationState state)
         {
             ITask<NPath> task = null;
             var tempZipExtractPath = NPath.CreateTempDirectory("git_zip_extract_zip_paths");
@@ -187,10 +187,10 @@ private FuncTask<GitInstallationState> ExtractPortableGit(GitInstallationState s
                 task = task?.Then(unzipTask) ?? unzipTask;
             }
 
-            return task.Finally(new FuncTask<GitInstallationState>(cancellationToken, (success) =>
+            return task.Finally(new FuncTask<NPath>(cancellationToken, (success) =>
             {
                 tempZipExtractPath.DeleteIfExists();
-                return state;
+                return installDetails.GitInstallationPath;
             }));
         }
 

src/GitHub.Api/Installer/IZipHelper.cs

@@ -6,6 +6,6 @@ namespace GitHub.Unity
     interface IZipHelper
     {
         bool Extract(string archive, string outFolder, CancellationToken cancellationToken,
-            Func<long, long, bool> onProgress = null);
+            Func<long, long, bool> onProgress);
     }
 }