public void Run(bool firstRun) { Logger.Trace("Run - CurrentDirectory {0}", NPath.CurrentDirectory); 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"); var initEnvironmentTask = new ActionTask <NPath>(CancellationToken, (_, path) => InitializeEnvironment(path)) { Affinity = TaskAffinity.UI }; var findExecTask = new FindExecTask("git", CancellationToken) .FinallyInUI((b, ex, path) => { if (b && path.IsInitialized) { Logger.Trace("FindExecTask Success: {0}", path); InitializeEnvironment(path); } else { Logger.Warning("FindExecTask Failure"); Logger.Error("Git not found"); } }); var installDetails = new GitInstallDetails(Environment.UserCachePath, true); var gitInstaller = new GitInstaller(Environment, CancellationToken, installDetails); // if successful, continue with environment initialization, otherwise try to find an existing git installation gitInstaller.SetupGitIfNeeded(initEnvironmentTask, findExecTask); } }
/// <summary> /// Initialize environment after finding where git is. This needs to run on the main thread /// </summary> /// <param name="gitExecutablePath"></param> /// <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); ITask task = afterGitSetup; if (Environment.IsWindows) { var credHelperTask = GitClient.GetConfig("credential.helper", GitConfigSource.Global); credHelperTask.OnEnd += (thisTask, credentialHelper, success, exception) => { if (!success || string.IsNullOrEmpty(credentialHelper)) { Logger.Warning("No Windows CredentialHelper found: Setting to wincred"); thisTask .Then(GitClient.SetConfig("credential.helper", "wincred", GitConfigSource.Global)) .Then(afterGitSetup); } else { thisTask.Then(afterGitSetup); } }; task = credHelperTask; } task.Start(); }
public void SetupGitIfNeeded(ActionTask <NPath> onSuccess, ITask onFailure) { Logger.Trace("SetupGitIfNeeded"); if (!environment.IsWindows) { onFailure.Start(); return; } new ActionTask(cancellationToken, () => { if (IsGitExtracted()) { Logger.Trace("SetupGitIfNeeded: Skipped"); onSuccess.PreviousResult = installDetails.GitExecutablePath; onSuccess.Start(); } else { ExtractPortableGit(onSuccess, onFailure); } }).Start(); }
/// <summary> /// Initialize environment after finding where git is. This needs to run on the main thread /// </summary> /// <param name="gitExecutablePath"></param> /// <param name="octorunScriptPath"></param> private void InitializeEnvironment(NPath gitExecutablePath, NPath octorunScriptPath) { var afterGitSetup = new ActionTask(CancellationToken, RestartRepository) .ThenInUI(InitializeUI); Environment.GitExecutablePath = gitExecutablePath; Environment.OctorunScriptPath = octorunScriptPath; Environment.User.Initialize(GitClient); SetupMetrics(); if (Environment.IsWindows) { GitClient .GetConfig("credential.helper", GitConfigSource.Global) .Then((b, credentialHelper) => { if (!string.IsNullOrEmpty(credentialHelper)) { Logger.Trace("Windows CredentialHelper: {0}", credentialHelper); afterGitSetup.Start(); } else { Logger.Warning("No Windows CredentialHelper found: Setting to wincred"); GitClient.SetConfig("credential.helper", "wincred", GitConfigSource.Global) .Then(afterGitSetup) .Start(); } }) .Start(); } else { afterGitSetup.Start(); } }
static void Main(string[] args) { var taskManager = new TaskManager(); var syncContext = new ThreadSynchronizationContext(taskManager.Token); taskManager.UIScheduler = new SynchronizationContextTaskScheduler(syncContext); var env = new DefaultEnvironment(); var processManager = new ProcessManager(env, new ProcessEnvironment(env), taskManager.Token); ConsoleKey key; while ((key = Console.ReadKey().Key) != ConsoleKey.Escape) { if (key == ConsoleKey.Enter) { { //var task = new GitConfigListTask(GitConfigSource.NonSpecified, cts.Token).Configure(processManager); //var other = new FuncTask<List<KeyValuePair<string, string>>, bool>(cts.Token, d => //{ // Console.WriteLine("Results! {0}", d.Count); // Thread.Sleep(1000); // return true; //}, task); //other.Name = "Other"; //other.Affinity = TaskAffinity.Concurrent; //other.OnStart += tt => Console.WriteLine(String.Format("Executing id:{0} thread:{1}", tt.Task.Id, Thread.CurrentThread.ManagedThreadId)); //other.OnEnd += tt => Console.WriteLine(String.Format("Finished id:{0} thread:{1}", tt.Task.Id, Thread.CurrentThread.ManagedThreadId)); //var final = new FuncTask<bool, bool>(cts.Token, d => d, other); //final.Name = "Final"; //final.Affinity = TaskAffinity.UI; //final.OnStart += tt => Console.WriteLine(String.Format("Executing id:{0} thread:{1}", tt.Task.Id, Thread.CurrentThread.ManagedThreadId)); //final.OnEnd += tt => Console.WriteLine(String.Format("Finished id:{0} thread:{1}", tt.Task.Id, Thread.CurrentThread.ManagedThreadId)); //taskManager.Schedule(task, other, final); } { //var task = new GitConfigListTask(GitConfigSource.NonSpecified, cts.Token) // .ConfigureGitProcess(processManager) // .Schedule(taskManager); //task // .ContinueWithUI((success, result) => Console.WriteLine("{0} Result? {1} {2}", Thread.CurrentThread.ManagedThreadId, success, // success ? String.Join(";", result.Take(10).Select(x => x.Key + "=" + x.Value).ToArray()) : "error", false)); } { //var task = new GitConfigGetTask("user.name", GitConfigSource.NonSpecified, cts.Token) // .ConfigureGitProcess(processManager) // .Schedule(taskManager); //task // .ContinueWithUI((success, result) => // { // Console.WriteLine("{0} Result? {1} {2}", Thread.CurrentThread.ManagedThreadId, success, result); // return 1; // }, true); } { //var task = new GitConfigGetTask("user.name", GitConfigSource.NonSpecified, cts.Token).ConfigureGitProcess(processManager); //var other = new GitConfigListTask(GitConfigSource.Global, cts.Token).ConfigureGitProcess(processManager); //var another = new ActionTask(cts.Token, () => Console.WriteLine("And we are done")); //task.Then(other).Then(another); //task.Schedule(taskManager); //other.Schedule(taskManager); //another.Schedule(taskManager); } { for (int i = 0; i < 5; i++) { var first = new GitConfigGetTask("user.name", GitConfigSource.NonSpecified, taskManager.Token) { Affinity = TaskAffinity.Concurrent }.Configure(processManager); var second = new GitConfigListTask(GitConfigSource.Global, taskManager.Token) { Affinity = TaskAffinity.Concurrent }.Configure(processManager); var third = new ActionTask(taskManager.Token, _ => Console.WriteLine("And we are done")) { Affinity = TaskAffinity.UI }; second.Then(third); taskManager.Schedule(first, second); } } } } taskManager.Stop(); Console.WriteLine("Done"); Console.Read(); }
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 static ITask Then <T>(this ITask task, ActionTask <T> nextTask, T valueForNextTask, TaskRunOptions runOptions = TaskRunOptions.OnSuccess) { Guard.ArgumentNotNull(nextTask, nameof(nextTask)); nextTask.PreviousResult = valueForNextTask; return(task.Then(nextTask, runOptions)); }