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);
}
