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