Fix running the installation tasks on start

Author: shana

src/GitHub.Api/Application/ApplicationManagerBase.cs

@@ -52,82 +52,78 @@ protected void Initialize()
         public void Run(bool firstRun)
         {
             Logger.Trace("Run - CurrentDirectory {0}", NPath.CurrentDirectory);
+            isBusy = true;
+
+            var endTask = new ActionTask<GitInstaller.GitInstallationState>(CancellationToken,
+                    (_, state) => InitializeEnvironment(state))
+                { Affinity = TaskAffinity.UI };
 
             ITask<string> setExistingEnvironmentPath;
             if (Environment.IsMac)
             {
                 setExistingEnvironmentPath = new SimpleProcessTask(CancellationToken, "bash".ToNPath(), "-c \"/usr/libexec/path_helper\"")
                            .Configure(ProcessManager, dontSetupGit: true)
                            .Catch(e => true) // make sure this doesn't throw if the task fails
-                           .Then((success, path) => success ? path.Split(new[] { "\"" }, StringSplitOptions.None)[1] : null);
+                           .Then((success, path) => success ? path?.Split(new[] { "\"" }, StringSplitOptions.None)[1] : null);
             }
             else
             {
                 setExistingEnvironmentPath = new FuncTask<string>(CancellationToken, () => null);
             }
 
-            setExistingEnvironmentPath.OnEnd += (t, path, success, ex) => {
+            setExistingEnvironmentPath.OnEnd += (t, path, success, ex) =>
+            {
                 if (path != null)
                 {
                     Logger.Trace("Existing Environment Path Original:{0} Updated:{1}", Environment.Path, path);
                     Environment.Path = path;
                 }
             };
 
-            var initEnvironmentTask = new ActionTask<GitInstaller.GitInstallationState>(CancellationToken,
-                    (_, state) => InitializeEnvironment(state))
-                { Affinity = TaskAffinity.UI };
-
-            isBusy = true;
+            var setupOctorun = new OctorunInstaller(Environment, TaskManager).SetupOctorunIfNeeded();
+            var setOctorunEnvironment = new ActionTask<NPath>(CancellationToken,
+                (s, octorunPath) => Environment.OctorunScriptPath = octorunPath);
 
-            var octorunInstaller = new OctorunInstaller(Environment, TaskManager);
-            var setupTask = setExistingEnvironmentPath.Then(octorunInstaller.SetupOctorunIfNeeded());
-
-            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;
-                });
-            var setOctorunEnvironmentTask = new ActionTask<NPath>(CancellationToken, (s, octorunPath) =>
+            var getGitFromSettings = new FuncTask<NPath>(CancellationToken, () =>
+            {
+                var gitExecutablePath = SystemSettings.Get(Constants.GitInstallPathKey)?.ToNPath();
+                if (gitExecutablePath.HasValue && gitExecutablePath.Value.FileExists()) // we have a git path
                 {
-                    Environment.OctorunScriptPath = octorunPath;
-                });
+                    Logger.Trace("Using git install path from settings: {0}", gitExecutablePath);
+                    return gitExecutablePath.Value;
+                }
+                return NPath.Default;
+            });
 
-            setupTask.OnEnd += (t, path, _, __) =>
+            getGitFromSettings.OnEnd += (t, path, _, __) =>
+            {
+                if (path.IsInitialized)
                 {
-                    t.GetEndOfChain().Then(setOctorunEnvironmentTask).Then(initializeGitTask);
-                };
+                    var state = new GitInstaller.GitInstallationState { GitExecutablePath = path };
+                    endTask.PreviousResult = state;
+                    endTask.Start();
+                    return;
+                }
+                Logger.Trace("Using portable git");
 
-            initializeGitTask.OnEnd += (t, path, _, __) =>
+                var setupGit = new GitInstaller(Environment, ProcessManager, TaskManager).SetupGitIfNeeded();
+                setupGit.Finally((s, state) =>
                 {
-                    if (path.IsInitialized)
-                    {
-                        t.GetEndOfChain()
-                            .Then(initEnvironmentTask, taskIsTopOfChain: true);
-                        return;
-                    }
-                    Logger.Trace("Using portable git");
-
-                    var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager);
-
-                    var task = gitInstaller.SetupGitIfNeeded();
-                    task.Progress(progressReporter.UpdateProgress);
-                    task.OnEnd += (thisTask, result, success, exception) =>
-                    {
-                        thisTask.GetEndOfChain()
-                            .Then(initEnvironmentTask, taskIsTopOfChain: true);
-                    };
+                    endTask.PreviousResult = state;
+                    endTask.Start();
+                });
+                setupGit.Progress(progressReporter.UpdateProgress);
+                // append installer task to top chain
+                t.Then(setupGit);
+            };
 
-                    // append installer task to top chain
-                    t.Then(task, taskIsTopOfChain: true);
-                };
+            var setupChain = setExistingEnvironmentPath.Then(setupOctorun);
+            setupChain.OnEnd += (t, path, _, __) =>
+            {
+                t.GetEndOfChain().Then(setOctorunEnvironment).Then(getGitFromSettings);
+            };
 
-            setupTask.Start();
+            setupChain.Start();
         }
 
         public ITask InitializeRepository()