public ITask <NPath> SetupOctorunIfNeeded() { //Logger.Trace("SetupOctorunIfNeeded"); var task = new FuncTask <NPath>(taskManager.Token, () => { var isOctorunExtracted = IsOctorunExtracted(); Logger.Trace("isOctorunExtracted: {0}", isOctorunExtracted); if (isOctorunExtracted) { return(installDetails.ExecutablePath); } GrabZipFromResources(); return(NPath.Default); }); task.OnEnd += (t, path, _, __) => { if (!path.IsInitialized) { var tempZipExtractPath = NPath.CreateTempDirectory("octorun_extract_archive_path"); var unzipTask = new UnzipTask(taskManager.Token, installDetails.ZipFile, tempZipExtractPath, sharpZipLibHelper, fileSystem) .Then((success, extractPath) => MoveOctorun(extractPath.Combine("octorun"))); t.Then(unzipTask); } }; return(task); }
public ITask <ValidateGitInstallResult> ValidateGitInstall(NPath path, bool isCustomGit) { Version gitVersion = null; Version gitLfsVersion = null; var endTask = new FuncTask <ValidateGitInstallResult>(cancellationToken, () => new ValidateGitInstallResult( gitVersion?.CompareTo(Constants.MinimumGitVersion) >= 0 && gitLfsVersion?.CompareTo(Constants.MinimumGitLfsVersion) >= 0, gitVersion, gitLfsVersion)); if (path.FileExists()) { var gitLfsVersionTask = new GitLfsVersionTask(cancellationToken) .Configure(processManager, path, dontSetupGit: isCustomGit); gitLfsVersionTask.OnEnd += (t, v, _, __) => gitLfsVersion = v; var gitVersionTask = new GitVersionTask(cancellationToken) .Configure(processManager, path, dontSetupGit: isCustomGit); gitVersionTask.OnEnd += (t, v, _, __) => gitVersion = v; gitVersionTask .Then(gitLfsVersionTask) .Finally(endTask); } return(endTask); }
public static ITask <T> Then <T>(this ITask task, Task <T> continuation, TaskAffinity affinity = TaskAffinity.Concurrent, bool always = false) { var cont = new FuncTask <T>(continuation) { Affinity = affinity, Name = $"ThenAsync<{typeof(T)}>" }; return(task.Then(cont, always)); }
public static ITask <T> Then <T>(this ITask task, Task <T> continuation, TaskAffinity affinity = TaskAffinity.Concurrent, TaskRunOptions runOptions = TaskRunOptions.OnSuccess) { var cont = new FuncTask <T>(continuation) { Affinity = affinity, Name = $"ThenAsync<{typeof(T)}>" }; return(task.Then(cont, runOptions)); }
public void Run(bool firstRun) { Logger.Trace("Run - CurrentDirectory {0}", NPath.CurrentDirectory); var initEnvironmentTask = new ActionTask <NPath>(CancellationToken, (_, path) => InitializeEnvironment(path)) { Affinity = TaskAffinity.UI }; isBusy = true; var octorunInstaller = new OctorunInstaller(Environment, TaskManager); var setupTask = octorunInstaller .SetupOctorunIfNeeded() .Then((s, octorunPath) => { Environment.OctorunScriptPath = octorunPath; }); 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); }); initializeGitTask.OnEnd += (t, path, _, __) => { if (path.IsInitialized) { 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); }; // append installer task to top chain t.Then(task, taskIsTopOfChain: true); }; setupTask.Then(initializeGitTask).Start(); }
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); } else { setExistingEnvironmentPath = new FuncTask <string>(CancellationToken, () => null); } 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 setupOctorun = new OctorunInstaller(Environment, TaskManager).SetupOctorunIfNeeded(); var setOctorunEnvironment = new ActionTask <NPath>(CancellationToken, (s, octorunPath) => Environment.OctorunScriptPath = 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 { Logger.Trace("Using git install path from settings: {0}", gitExecutablePath); return(gitExecutablePath.Value); } return(NPath.Default); }); getGitFromSettings.OnEnd += (t, path, _, __) => { if (path.IsInitialized) { var state = new GitInstaller.GitInstallationState { GitExecutablePath = path, GitIsValid = true }; endTask.PreviousResult = state; endTask.Start(); return; } Logger.Trace("Using portable git"); var setupGit = new GitInstaller(Environment, ProcessManager, TaskManager).SetupGitIfNeeded(); t.Then(setupGit); setupGit.Finally((s, state) => { endTask.PreviousResult = state; endTask.Start(); }); setupGit.Progress(progressReporter.UpdateProgress); // append installer task to top chain }; var setupChain = setExistingEnvironmentPath.Then(setupOctorun); setupChain.OnEnd += (t, path, _, __) => { t.GetEndOfChain().Then(setOctorunEnvironment).Then(getGitFromSettings); }; setupChain.Start(); }
public Task <DownloadData> QueueDownload(UriString url, UriString md5Url, NPath targetDirectory) { var destinationFile = targetDirectory.Combine(url.Filename); var destinationMd5 = targetDirectory.Combine(md5Url.Filename); var result = new DownloadData(url, destinationFile); Action <ITask <NPath>, NPath, bool, Exception> verifyDownload = (t, res, success, ex) => { var count = Interlocked.Increment(ref finishedTaskCount); isSuccessful &= success; if (!success) { exception = ex; } if (count == queuedTasks.Count) { if (!isSuccessful) { DownloadFailed(result, exception); } else { if (!Utils.VerifyFileIntegrity(destinationFile, destinationMd5)) { destinationMd5.Delete(); destinationFile.Delete(); DownloadFailed(result, new DownloadException($"Verification of {url} failed")); } else { DownloadComplete(result); } } } }; var md5Exists = destinationMd5.FileExists(); var fileExists = destinationFile.FileExists(); if (!md5Exists) { destinationMd5.DeleteIfExists(); var md5Download = new DownloadTask(cancellationToken, fs, md5Url, targetDirectory) .Catch(e => DownloadFailed(result, e)); md5Download.OnEnd += verifyDownload; queuedTasks.Add(md5Download); } if (!fileExists) { var fileDownload = new DownloadTask(cancellationToken, fs, url, targetDirectory) .Catch(e => DownloadFailed(result, e)); fileDownload.OnStart += _ => DownloadStart?.Invoke(result); fileDownload.OnEnd += verifyDownload; queuedTasks.Add(fileDownload); } if (fileExists && md5Exists) { var verification = new FuncTask <NPath>(cancellationToken, () => destinationFile); verification.OnEnd += verifyDownload; queuedTasks.Add(verification); } return(aggregateDownloads.Task); }
public ITask <NPath> SetupGitIfNeeded() { //Logger.Trace("SetupGitIfNeeded"); installationTask = new FuncTask <NPath, NPath>(cancellationToken, (success, path) => { return(path); }) { Name = "Git Installation - Complete" }; installationTask.OnStart += thisTask => thisTask.UpdateProgress(0, 100); installationTask.OnEnd += (thisTask, result, success, exception) => thisTask.UpdateProgress(100, 100); ITask <NPath> startTask = null; if (!environment.IsWindows) { startTask = new FindExecTask("git", cancellationToken) .Configure(processManager); // we should doublecheck that system git is usable here installationState = new GitInstallationState { GitIsValid = true, GitLfsIsValid = true }; } else { startTask = new FuncTask <NPath>(cancellationToken, () => { installationState = VerifyGitInstallation(); if (!installationState.GitIsValid && !installationState.GitLfsIsValid) { installationState = GrabZipFromResources(installationState); } else { Logger.Trace("SetupGitIfNeeded: Skipped"); } return(installDetails.GitExecutablePath); }) { Name = "Git Installation - Extract" }; } startTask.OnEnd += (thisTask, path, success, exception) => { if (!installationState.GitIsValid && !installationState.GitLfsIsValid) { if (!installationState.GitZipExists || !installationState.GitLfsZipExists) { thisTask = thisTask.Then(CreateDownloadTask(installationState)); } thisTask = thisTask.Then(ExtractPortableGit(installationState)); } thisTask.Then(installationTask); }; return(startTask); }
public ITask <GitInstallationState> SetupGitIfNeeded() { //Logger.Trace("SetupGitIfNeeded"); GitInstallationState installationState = new GitInstallationState(); installationTask = new FuncTask <GitInstallationState, GitInstallationState>(cancellationToken, (success, path) => path) { Name = "Git Installation - Complete" }; installationTask.OnStart += thisTask => thisTask.UpdateProgress(0, 100); installationTask.OnEnd += (thisTask, result, success, exception) => thisTask.UpdateProgress(100, 100); ITask <GitInstallationState> startTask = null; if (!environment.IsWindows) { var findTask = new FindExecTask("git", cancellationToken) .Configure(processManager, dontSetupGit: true) .Catch(e => true); findTask.OnEnd += (thisTask, path, success, exception) => { // we should doublecheck that system git is usable here installationState.GitIsValid = success; if (success) { installationState.GitExecutablePath = path; installationState.GitInstallationPath = path.Resolve().Parent.Parent; } }; findTask.Then(new FindExecTask("git-lfs", cancellationToken) .Configure(processManager, dontSetupGit: true)) .Catch(e => true); findTask.OnEnd += (thisTask, path, success, exception) => { installationState.GitLfsIsValid = success; if (success) { // we should doublecheck that system git is usable here installationState.GitLfsExecutablePath = path; installationState.GitLfsInstallationPath = path.Resolve().Parent.Parent; } }; startTask = findTask.Then(s => installationState); } else { startTask = new FuncTask <GitInstallationState>(cancellationToken, () => { return(VerifyPortableGitInstallation()); }) { Name = "Git Installation - Verify" }; } startTask = startTask.Then(new FuncTask <GitInstallationState, GitInstallationState>(cancellationToken, (success, installState) => { if (installState.GitIsValid && installState.GitLfsIsValid) { return(installState); } installState = VerifyZipFiles(installState); installState = GrabZipFromResourcesIfNeeded(installState); return(installState); }) { Name = "Git Installation - Validate" } ); startTask.OnEnd += (thisTask, installState, success, exception) => { if (installState.GitIsValid && installState.GitLfsIsValid) { Logger.Trace("Skipping git installation"); thisTask.Then(installationTask); return; } var downloadZipTask = DownloadZipsIfNeeded(installState); downloadZipTask.OnEnd += ExtractPortableGit; thisTask.Then(downloadZipTask); }; return(startTask); }
private void ExtractPortableGit(ITask <GitInstallationState> thisTask, GitInstallationState state, bool s, Exception exception) { ITask <NPath> task = null; var tempZipExtractPath = NPath.CreateTempDirectory("git_zip_extract_zip_paths"); if (state.GitZipExists && !state.GitIsValid) { var gitExtractPath = tempZipExtractPath.Combine("git").CreateDirectory(); var unzipTask = new UnzipTask(cancellationToken, installDetails.GitZipPath, gitExtractPath, sharpZipLibHelper, environment.FileSystem) .Catch(e => true); unzipTask.Progress(p => installationTask.UpdateProgress(40 + (long)(20 * p.Percentage), 100, unzipTask.Name)); unzipTask = unzipTask.Then((success, path) => { var target = installDetails.GitInstallationPath; if (success) { var source = path; target.DeleteIfExists(); target.EnsureParentDirectoryExists(); Logger.Trace($"Moving '{source}' to '{target}'"); source.Move(target); state.GitInstallationPath = installDetails.GitInstallationPath; state.GitExecutablePath = installDetails.GitExecutablePath; state.GitIsValid = success; } return(target); }); task = unzipTask; } if (state.GitLfsZipExists && !state.GitLfsIsValid) { var gitLfsExtractPath = tempZipExtractPath.Combine("git-lfs").CreateDirectory(); var unzipTask = new UnzipTask(cancellationToken, installDetails.GitLfsZipPath, gitLfsExtractPath, sharpZipLibHelper, environment.FileSystem) .Catch(e => true); unzipTask.Progress(p => installationTask.UpdateProgress(60 + (long)(20 * p.Percentage), 100, unzipTask.Name)); unzipTask = unzipTask.Then((success, path) => { var target = installDetails.GetGitLfsExecutablePath(state.GitInstallationPath); if (success) { var source = path.Combine(installDetails.GitLfsExecutable); target.DeleteIfExists(); target.EnsureParentDirectoryExists(); Logger.Trace($"Moving '{source}' to '{target}'"); source.Move(target); state.GitLfsInstallationPath = state.GitInstallationPath; state.GitLfsExecutablePath = target; state.GitLfsIsValid = success; } return(target); }); task = task?.Then(unzipTask) ?? unzipTask; } var endTask = new FuncTask <GitInstallationState>(cancellationToken, (success) => { tempZipExtractPath.DeleteIfExists(); return(state); }); if (task != null) { endTask = task.Then(endTask); } thisTask .Then(endTask) .Then(installationTask); }