示例#1
0
        public void Configure(ProcessStartInfo psi, NPath workingDirectory, bool dontSetupGit = false)
        {
            psi.WorkingDirectory             = workingDirectory;
            psi.EnvironmentVariables["HOME"] = NPath.HomeDirectory;
            psi.EnvironmentVariables["TMP"]  = psi.EnvironmentVariables["TEMP"] = NPath.SystemTemp;

            var path = Environment.Path;

            psi.EnvironmentVariables["GHU_WORKINGDIR"] = workingDirectory;
            var pathEnvVarKey = Environment.GetEnvironmentVariableKey("PATH");

            if (dontSetupGit)
            {
                psi.EnvironmentVariables["GHU_FULLPATH"] = path;
                psi.EnvironmentVariables[pathEnvVarKey]  = path;
                return;
            }

            Guard.ArgumentNotNull(psi, "psi");

            var    pathEntries = new List <string>();
            string separator   = Environment.IsWindows ? ";" : ":";

            NPath         libexecPath    = NPath.Default;
            List <string> gitPathEntries = new List <string>();

            if (Environment.GitInstallPath.IsInitialized)
            {
                var gitPathRoot      = Environment.GitExecutablePath.Resolve().Parent.Parent;
                var gitExecutableDir = Environment.GitExecutablePath.Parent; // original path to git (might be different from install path if it's a symlink)

                var baseExecPath = gitPathRoot;
                var binPath      = baseExecPath;
                if (Environment.IsWindows)
                {
                    if (baseExecPath.DirectoryExists("mingw32"))
                    {
                        baseExecPath = baseExecPath.Combine("mingw32");
                    }
                    else
                    {
                        baseExecPath = baseExecPath.Combine("mingw64");
                    }
                    binPath = baseExecPath.Combine("bin");
                }

                libexecPath = baseExecPath.Combine("libexec", "git-core");
                if (!libexecPath.DirectoryExists())
                {
                    libexecPath = NPath.Default;
                }

                if (Environment.IsWindows)
                {
                    gitPathEntries.AddRange(new[] { gitPathRoot.Combine("cmd").ToString(), gitPathRoot.Combine("usr", "bin") });
                }
                else
                {
                    gitPathEntries.Add(gitExecutableDir.ToString());
                }

                if (libexecPath.IsInitialized)
                {
                    gitPathEntries.Add(libexecPath);
                }
                gitPathEntries.Add(binPath);

                // we can only set this env var if there is a libexec/git-core. git will bypass internally bundled tools if this env var
                // is set, which will break Apple's system git on certain tools (like osx-credentialmanager)
                if (libexecPath.IsInitialized)
                {
                    psi.EnvironmentVariables["GIT_EXEC_PATH"] = libexecPath.ToString();
                }
            }

            if (Environment.GitLfsInstallPath.IsInitialized && libexecPath != Environment.GitLfsInstallPath)
            {
                pathEntries.Add(Environment.GitLfsInstallPath);
            }
            if (gitPathEntries.Count > 0)
            {
                pathEntries.AddRange(gitPathEntries);
            }

            pathEntries.Add("END");

            path = string.Join(separator, pathEntries.ToArray()) + separator + path;

            psi.EnvironmentVariables["GHU_FULLPATH"] = path;
            psi.EnvironmentVariables[pathEnvVarKey]  = path;

            //TODO: Remove with Git LFS Locking becomes standard
            psi.EnvironmentVariables["GITLFSLOCKSENABLED"] = "1";

            if (Environment.IsWindows)
            {
                psi.EnvironmentVariables["PLINK_PROTOCOL"] = "ssh";
                psi.EnvironmentVariables["TERM"]           = "msys";
            }

            var httpProxy = Environment.GetEnvironmentVariable("HTTP_PROXY");

            if (!string.IsNullOrEmpty(httpProxy))
            {
                psi.EnvironmentVariables["HTTP_PROXY"] = httpProxy;
            }

            var httpsProxy = Environment.GetEnvironmentVariable("HTTPS_PROXY");

            if (!string.IsNullOrEmpty(httpsProxy))
            {
                psi.EnvironmentVariables["HTTPS_PROXY"] = httpsProxy;
            }
            psi.EnvironmentVariables["DISPLAY"] = "0";
        }
示例#2
0
 public ITask RequestLock(NPath file) => repositoryManager.LockFile(file);
示例#3
0
 public ITask ReleaseLock(NPath file, bool force) => repositoryManager.UnlockFile(file, force);
示例#4
0
 public GitInstaller(IEnvironment environment, IZipHelper sharpZipLibHelper, CancellationToken cancellationToken,
                     GitInstallDetails installDetails, NPath gitArchiveFilePath, NPath gitLfsArchivePath)
 {
     this.environment        = environment;
     this.sharpZipLibHelper  = sharpZipLibHelper;
     this.cancellationToken  = cancellationToken;
     this.installDetails     = installDetails;
     this.gitArchiveFilePath = gitArchiveFilePath;
     this.gitLfsArchivePath  = gitLfsArchivePath;
 }
示例#5
0
 public NPath GetGitLfsExecutablePath(NPath gitInstallRoot)
 {
     return(onWindows
         ? gitInstallRoot.Combine("mingw32", "libexec", "git-core", GitLfsExecutable)
         : gitInstallRoot.Combine("libexec", "git-core", GitLfsExecutable));
 }
 public SimpleProcessTask(CancellationToken token, NPath fullPathToExecutable, string arguments)
     : base(token, new SimpleOutputProcessor())
 {
     this.fullPathToExecutable = fullPathToExecutable;
     this.arguments            = arguments;
 }
示例#7
0
 public GitInstaller(IEnvironment environment, CancellationToken cancellationToken,
                     GitInstallDetails installDetails, NPath gitArchiveFilePath, NPath gitLfsArchivePath)
     : this(
         environment, ZipHelper.Instance, cancellationToken, installDetails, gitArchiveFilePath,
         gitLfsArchivePath)
 {
 }
 public static T Configure <T>(this T task, IProcessManager processManager, string executable, string arguments,
                               NPath workingDirectory = null, bool withInput = false)
     where T : IProcess
 {
     return(processManager.Configure(task, executable, arguments, workingDirectory, withInput));
 }
示例#9
0
        public static RepositoryManager CreateInstance(IPlatform platform, ITaskManager taskManager, IGitClient gitClient,
                                                       IProcessManager processManager, IFileSystem fileSystem, NPath repositoryRoot)
        {
            var    repositoryPathConfiguration = new RepositoryPathConfiguration(repositoryRoot);
            string filePath  = repositoryPathConfiguration.DotGitConfig;
            var    gitConfig = new GitConfig(filePath);

            var repositoryWatcher = new RepositoryWatcher(platform, repositoryPathConfiguration, taskManager.Token);

            return(new RepositoryManager(gitConfig, repositoryWatcher,
                                         gitClient, processManager, fileSystem,
                                         taskManager.Token, repositoryPathConfiguration));
        }
示例#10
0
 public void Initialize(string unityVersion, NPath extensionInstallPath, NPath unityApplicationPath, NPath unityApplicationContentsPath, NPath assetsPath)
 {
     ExtensionInstallPath     = extensionInstallPath;
     UnityApplication         = unityApplicationPath;
     UnityApplicationContents = unityApplicationContentsPath;
     UnityAssetsPath          = assetsPath;
     UnityProjectPath         = assetsPath.Parent;
     UnityVersion             = unityVersion;
     User = new User(CacheContainer);
 }
示例#11
0
 public bool ValidateGitInstall(NPath path)
 {
     return(path.FileExists());
 }
示例#12
0
        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, "Initialized");
                }
                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();
        }