public void Run(bool firstRun) { Logger.Trace("Run - CurrentDirectory {0}", NPath.CurrentDirectory); var octorunScriptPath = Environment.UserCachePath.Combine("octorun", "src", "bin", "app.js"); Logger.Trace("Using octorunScriptPath: {0}", octorunScriptPath); 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, octorunScriptPath); } else // we need to go find git { Logger.Trace("No git path found in settings"); var initEnvironmentTask = new ActionTask <NPath>(CancellationToken, (_, path) => InitializeEnvironment(path, octorunScriptPath)) { 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, octorunScriptPath); } 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); } }
public void Run(bool firstRun) { Logger.Trace("Run - CurrentDirectory {0}", NPath.CurrentDirectory); var gitExecutablePath = SystemSettings.Get(Constants.GitInstallPathKey)?.ToNPath(); if (gitExecutablePath != null && gitExecutablePath.FileExists()) // we have a git path { Logger.Trace("Using git install path from settings: {0}", gitExecutablePath); InitializeEnvironment(gitExecutablePath); } else // we need to go find git { Logger.Trace("No git path found in settings"); var initEnvironmentTask = new ActionTask <NPath>(CancellationToken, (b, path) => InitializeEnvironment(path)) { Affinity = TaskAffinity.UI }; var findExecTask = new FindExecTask("git", CancellationToken) .FinallyInUI((b, ex, path) => { if (b && path != null) { Logger.Trace("FindExecTask Success: {0}", path); InitializeEnvironment(gitExecutablePath); } else { Logger.Warning("FindExecTask Failure"); Logger.Error("Git not found"); } }); var applicationDataPath = Environment.GetSpecialFolder(System.Environment.SpecialFolder.LocalApplicationData).ToNPath(); var installDetails = new GitInstallDetails(applicationDataPath, 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); } }
private async Task <NPath> DetermineGitExecutablePath(ProgressReport progress = null) { var gitExecutablePath = SystemSettings.Get(Constants.GitInstallPathKey)?.ToNPath(); if (gitExecutablePath != null && gitExecutablePath.FileExists()) { Logger.Trace("Using git install path from settings"); return(gitExecutablePath); } var gitInstaller = new GitInstaller(Environment, CancellationToken); var setupDone = await gitInstaller.SetupIfNeeded(progress?.Percentage, progress?.Remaining); if (setupDone) { Logger.Trace("Setup performed using new path"); return(gitInstaller.GitExecutablePath); } Logger.Trace("Finding git install path"); return(await GitClient.FindGitInstallation().SafeAwait()); }
public void Run() { isBusy = true; progress.UpdateProgress(0, 100, "Initializing..."); if (firstRun) { UsageTracker.IncrementNumberOfStartups(); } var thread = new Thread(() => { GitInstallationState state = new GitInstallationState(); try { if (Environment.IsMac) { var getEnvPath = new SimpleProcessTask(TaskManager.Token, "bash".ToNPath(), "-c \"/usr/libexec/path_helper\"") .Configure(ProcessManager, dontSetupGit: true) .Catch(e => true); // make sure this doesn't throw if the task fails var path = getEnvPath.RunSynchronously(); if (getEnvPath.Successful) { Logger.Trace("Existing Environment Path Original:{0} Updated:{1}", Environment.Path, path); Environment.Path = path?.Split(new[] { "\"" }, StringSplitOptions.None)[1]; } } progress.UpdateProgress(20, 100, "Setting up octorun..."); Environment.OctorunScriptPath = new OctorunInstaller(Environment, TaskManager) .SetupOctorunIfNeeded(); progress.UpdateProgress(50, 100, "Setting up git..."); state = Environment.GitInstallationState; if (!state.GitIsValid && !state.GitLfsIsValid && FirstRun) { // importing old settings NPath gitExecutablePath = Environment.SystemSettings.Get(Constants.GitInstallPathKey, NPath.Default); if (gitExecutablePath.IsInitialized) { Environment.SystemSettings.Unset(Constants.GitInstallPathKey); state.GitExecutablePath = gitExecutablePath; state.GitInstallationPath = gitExecutablePath.Parent.Parent; Environment.GitInstallationState = state; } } var installer = new GitInstaller(Environment, ProcessManager, TaskManager.Token); installer.Progress.OnProgress += progressReporter.UpdateProgress; if (state.GitIsValid && state.GitLfsIsValid) { if (firstRun) { installer.ValidateGitVersion(state); if (state.GitIsValid) { installer.ValidateGitLfsVersion(state); } } } if (!state.GitIsValid || !state.GitLfsIsValid) { state = installer.SetupGitIfNeeded(); } SetupGit(state); progress.UpdateProgress(80, 100, "Initializing repository..."); if (state.GitIsValid && state.GitLfsIsValid) { RestartRepository(); } progress.UpdateProgress(100, 100, "Initialization failed"); } catch (Exception ex) { Logger.Error(ex, "A problem ocurred setting up Git"); progress.UpdateProgress(90, 100, "Initialization failed"); } new ActionTask <bool>(TaskManager.Token, (s, gitIsValid) => { InitializationComplete(); if (gitIsValid) { InitializeUI(); } }, () => state.GitIsValid && state.GitLfsIsValid) { Affinity = TaskAffinity.UI } .Start(); }); thread.Start(); }
public override void OnGUI() { // Install path GUILayout.Label(GitInstallTitle, EditorStyles.boldLabel); EditorGUI.BeginDisabledGroup(IsBusy || Parent.IsBusy); { GUILayout.BeginVertical(); { GUILayout.BeginHorizontal(); { EditorGUI.BeginChangeCheck(); { gitPath = EditorGUILayout.TextField(PathToGit, gitPath); gitPath = gitPath != null?gitPath.Trim() : gitPath; if (GUILayout.Button(BrowseButton, EditorStyles.miniButton, GUILayout.Width(Styles.BrowseButtonWidth))) { GUI.FocusControl(null); var newPath = EditorUtility.OpenFilePanel(GitInstallBrowseTitle, !String.IsNullOrEmpty(gitPath) ? gitPath.ToNPath().Parent : "", Environment.ExecutableExtension.TrimStart('.')); if (!string.IsNullOrEmpty(newPath)) { gitPath = newPath.ToNPath().ToString(); } } } if (EditorGUI.EndChangeCheck()) { changingManually = ViewHasChanges; } } GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); { EditorGUI.BeginChangeCheck(); { gitLfsPath = EditorGUILayout.TextField(PathToGitLfs, gitLfsPath); gitLfsPath = gitLfsPath != null?gitLfsPath.Trim() : gitLfsPath; if (GUILayout.Button(BrowseButton, EditorStyles.miniButton, GUILayout.Width(Styles.BrowseButtonWidth))) { GUI.FocusControl(null); var newPath = EditorUtility.OpenFilePanel(GitInstallBrowseTitle, !String.IsNullOrEmpty(gitLfsPath) ? gitLfsPath.ToNPath().Parent : "", Environment.ExecutableExtension.TrimStart('.')); if (!string.IsNullOrEmpty(newPath)) { gitLfsPath = newPath.ToNPath().ToString(); } } } if (EditorGUI.EndChangeCheck()) { changingManually = ViewHasChanges; errorMessage = ""; } } GUILayout.EndHorizontal(); } GUILayout.EndVertical(); GUILayout.Space(EditorGUIUtility.standardVerticalSpacing); GUILayout.BeginHorizontal(); { EditorGUI.BeginDisabledGroup(!changingManually && !resetToBundled && !resetToSystem); { if (GUILayout.Button(GitPathSaveButton, GUILayout.ExpandWidth(false))) { GUI.FocusControl(null); isBusy = true; ValidateAndSetGitInstallPath(); } } EditorGUI.EndDisabledGroup(); // disable the button if the paths are already pointing to the bundled git // both on windows, only lfs on mac EditorGUI.BeginDisabledGroup( (!Environment.IsWindows || gitPath == installDetails.GitExecutablePath) && gitLfsPath == installDetails.GitLfsExecutablePath); { if (GUILayout.Button(SetToBundledGitButton, GUILayout.ExpandWidth(false))) { GUI.FocusControl(null); if (Environment.IsWindows) { gitPath = installDetails.GitExecutablePath; } gitLfsPath = installDetails.GitLfsExecutablePath; resetToBundled = ViewHasChanges; resetToSystem = false; changingManually = false; errorMessage = ""; } } EditorGUI.EndDisabledGroup(); //Find button - for attempting to locate a new install if (GUILayout.Button(FindSystemGitButton, GUILayout.ExpandWidth(false))) { GUI.FocusControl(null); isBusy = true; new FuncTask <GitInstaller.GitInstallationState>(TaskManager.Token, () => { var gitInstaller = new GitInstaller(Environment, Manager.ProcessManager, TaskManager.Token); return(gitInstaller.FindSystemGit(new GitInstaller.GitInstallationState())); }) { Message = "Locating git..." } .FinallyInUI((success, ex, state) => { if (success) { if (state.GitIsValid) { gitPath = state.GitExecutablePath; } if (state.GitLfsIsValid) { gitLfsPath = state.GitLfsExecutablePath; } } else { Logger.Error(ex); } isBusy = false; resetToBundled = false; resetToSystem = ViewHasChanges; changingManually = false; errorMessage = ""; Redraw(); }) .Start(); } } GUILayout.EndHorizontal(); if (!String.IsNullOrEmpty(errorMessage)) { GUILayout.BeginHorizontal(); { GUILayout.Label(errorMessage, Styles.ErrorLabel); } GUILayout.EndHorizontal(); } } EditorGUI.EndDisabledGroup(); }
private void ValidateAndSetGitInstallPath() { if (resetToBundled) { new FuncTask <GitInstaller.GitInstallationState>(TaskManager.Token, () => { var gitInstaller = new GitInstaller(Environment, Manager.ProcessManager, TaskManager.Token); var state = new GitInstaller.GitInstallationState(); state = gitInstaller.SetDefaultPaths(state); // on non-windows we only bundle git-lfs if (!Environment.IsWindows) { state.GitExecutablePath = installationState.GitExecutablePath; state.GitInstallationPath = installationState.GitInstallationPath; } state = gitInstaller.SetupGitIfNeeded(state); if (state.GitIsValid && state.GitLfsIsValid) { Manager.SetupGit(state); Manager.RestartRepository(); } return(state); }) { Message = "Setting up git... " } .FinallyInUI((success, exception, state) => { if (!success) { Logger.Error(exception, ErrorInstallingInternalGit); errorMessage = ErrorValidatingGitPath; } else { refresh = true; } isBusy = false; resetToBundled = false; resetToSystem = false; changingManually = false; Redraw(); }).Start(); } else { var newState = new GitInstaller.GitInstallationState(); newState.GitExecutablePath = gitPath.ToNPath(); newState.GitLfsExecutablePath = gitLfsPath.ToNPath(); var installer = new GitInstaller(Environment, Manager.ProcessManager, TaskManager.Token); installer.Progress.OnProgress += UpdateProgress; new FuncTask <GitInstaller.GitInstallationState>(TaskManager.Token, () => { return(installer.SetupGitIfNeeded(newState)); }) .Then((success, state) => { if (state.GitIsValid && state.GitLfsIsValid) { Manager.SetupGit(state); Manager.RestartRepository(); } return(state); }) .FinallyInUI((success, ex, state) => { installer.Progress.OnProgress -= UpdateProgress; if (!success) { Logger.Error(ex, ErrorValidatingGitPath); return; } if (!state.GitIsValid || !state.GitLfsIsValid) { var errorMessageStringBuilder = new StringBuilder(); Logger.Warning( "Software versions do not meet minimums Git:{0} (Minimum:{1}) GitLfs:{2} (Minimum:{3})", state.GitVersion, Constants.MinimumGitVersion, state.GitLfsVersion, Constants.MinimumGitLfsVersion); if (state.GitVersion == TheVersion.Default) { errorMessageStringBuilder.Append(ErrorGitNotFoundMessage); } else if (state.GitLfsVersion == TheVersion.Default) { errorMessageStringBuilder.Append(ErrorGitLfsNotFoundMessage); } else { if (state.GitVersion < Constants.MinimumGitVersion) { errorMessageStringBuilder.AppendFormat(ErrorMinimumGitVersionMessageFormat, state.GitVersion, Constants.MinimumGitVersion); } if (state.GitLfsVersion < Constants.MinimumGitLfsVersion) { if (errorMessageStringBuilder.Length > 0) { errorMessageStringBuilder.Append(Environment.NewLine); } errorMessageStringBuilder.AppendFormat(ErrorMinimumGitLfsVersionMessageFormat, state.GitLfsVersion, Constants.MinimumGitLfsVersion); } } errorMessage = errorMessageStringBuilder.ToString(); } else { Logger.Trace("Software versions meet minimums Git:{0} GitLfs:{1}", state.GitVersion, state.GitLfsVersion); refresh = true; } isBusy = false; resetToBundled = false; resetToSystem = false; changingManually = false; Redraw(); }).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(); }
private void ValidateAndSetGitInstallPath(string value) { value = value.Trim(); if (value == portableGitPath) { Logger.Trace("Attempting to restore portable Git Path:{0}", value); var gitInstaller = new GitInstaller(Environment, EntryPoint.ApplicationManager.ProcessManager, EntryPoint.ApplicationManager.TaskManager); gitInstaller.SetupGitIfNeeded() .FinallyInUI((success, exception, installationState) => { Logger.Trace("Setup Git Using the installer:{0}", success); if (!success) { Logger.Error(exception, ErrorInstallingInternalGit); gitVersionErrorMessage = ErrorValidatingGitPath; } else { Manager.SystemSettings.Unset(Constants.GitInstallPathKey); Environment.GitExecutablePath = installationState.GitExecutablePath; Environment.GitLfsExecutablePath = installationState.GitLfsExecutablePath; Environment.IsCustomGitExecutable = false; gitExecHasChanged = true; } isBusy = false; }).Start(); } else { //Logger.Trace("Validating Git Path:{0}", value); gitVersionErrorMessage = null; GitClient.ValidateGitInstall(value.ToNPath(), true) .ThenInUI((success, result) => { if (!success) { Logger.Trace(ErrorValidatingGitPath); gitVersionErrorMessage = ErrorValidatingGitPath; } else if (!result.IsValid) { Logger.Warning( "Software versions do not meet minimums Git:{0} (Minimum:{1}) GitLfs:{2} (Minimum:{3})", result.GitVersion, Constants.MinimumGitVersion, result.GitLfsVersion, Constants.MinimumGitLfsVersion); var errorMessageStringBuilder = new StringBuilder(); if (result.GitVersion == null) { errorMessageStringBuilder.Append(ErrorGitNotFoundMessage); } else if (result.GitLfsVersion == null) { errorMessageStringBuilder.Append(ErrorGitLfsNotFoundMessage); } else { if (result.GitVersion < Constants.MinimumGitVersion) { errorMessageStringBuilder.AppendFormat(ErrorMinimumGitVersionMessageFormat, result.GitVersion, Constants.MinimumGitVersion); } if (result.GitLfsVersion < Constants.MinimumGitLfsVersion) { if (errorMessageStringBuilder.Length > 0) { errorMessageStringBuilder.Append(Environment.NewLine); } errorMessageStringBuilder.AppendFormat(ErrorMinimumGitLfsVersionMessageFormat, result.GitLfsVersion, Constants.MinimumGitLfsVersion); } } gitVersionErrorMessage = errorMessageStringBuilder.ToString(); } else { Logger.Trace("Software versions meet minimums Git:{0} GitLfs:{1}", result.GitVersion, result.GitLfsVersion); Manager.SystemSettings.Set(Constants.GitInstallPathKey, value); Environment.GitExecutablePath = value.ToNPath(); Environment.IsCustomGitExecutable = true; gitExecHasChanged = true; } isBusy = false; }).Start(); } }