Making sure lfs and git merge configs are set up for everyone

Fixes #732

If the project isn't initialized by the extension on the local machine,
the lfs hooks and mergecmd configurations won't be set properly. These
things are as important as the credential helper configuration steps,
so do them at startup.

To make play mode switches faster, cache the git installation state in
the settings and only run the installers once a day, and validate the
existing git/lfs versions once at Unity startup (if we know where they
are from the cached settings)

Author: shana

src/GitHub.Api/Application/ApplicationManagerBase.cs

@@ -3,6 +3,7 @@
 using System.Threading.Tasks;
 using System.Collections.Generic;
 using GitHub.Logging;
+using static GitHub.Unity.GitInstaller;
 
 namespace GitHub.Unity
 {
@@ -13,6 +14,9 @@ abstract class ApplicationManagerBase : IApplicationManager
         private RepositoryManager repositoryManager;
         private Progress progressReporter;
         protected bool isBusy;
+        protected bool firstRun;
+        protected Guid instanceId;
+
         public event Action<IProgress> OnProgress
         {
             add { progressReporter.OnProgress += value; }
@@ -41,94 +45,168 @@ protected void Initialize()
             GitClient = new GitClient(Environment, ProcessManager, TaskManager.Token);
         }
 
-        public void Run(bool firstRun)
+        public void Run()
         {
             isBusy = true;
 
             var thread = new Thread(obj =>
             {
                 CancellationToken token = (CancellationToken)obj;
-                var endTask = new ActionTask<GitInstaller.GitInstallationState>(token, (_, s) => InitializeEnvironment(s)) { Affinity = TaskAffinity.UI };
-                string path = null;
+                SetupMetrics(Environment.UnityVersion, firstRun, instanceId);
 
                 if (Environment.IsMac)
                 {
                     var getEnvPath = new SimpleProcessTask(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
-                    path = getEnvPath.RunWithReturn(true);
+                    var path = getEnvPath.RunWithReturn(true);
                     if (getEnvPath.Successful)
                     {
                         Logger.Trace("Existing Environment Path Original:{0} Updated:{1}", Environment.Path, path);
                         Environment.Path = path?.Split(new[] { "\"" }, StringSplitOptions.None)[1];
                     }
                 }
 
-                Environment.OctorunScriptPath = new OctorunInstaller(Environment, TaskManager).SetupOctorunIfNeeded();
+                GitInstallationState state = new GitInstallationState();
+                var runInstallers = firstRun;
+
+                if (!runInstallers)
+                {
+                    state = SystemSettings.Get<GitInstallationState>(Constants.GitInstallationState) ?? state;
+                    var now = DateTimeOffset.Now;
+                    runInstallers = now.Date != state.GitLastCheckTime.Date || (!(state.GitIsValid && state.GitLfsIsValid));
+                }
+
+                if (runInstallers)
+                {
+                    Environment.OctorunScriptPath = new OctorunInstaller(Environment, TaskManager)
+                        .SetupOctorunIfNeeded();
+
+                    state = new GitInstaller(Environment, ProcessManager, TaskManager, SystemSettings)
+                        { Progress = progressReporter }
+                        .SetupGitIfNeeded();
+                }
+
+                SetupGit(state);
 
-                var state = new GitInstaller(Environment, ProcessManager, TaskManager, SystemSettings)
-                    { Progress = progressReporter }
-                    .SetupGitIfNeeded();
-                endTask.PreviousResult = state;
-                endTask.Start();
+                if (state.GitIsValid && state.GitLfsIsValid)
+                {
+                    RestartRepository();
+                }
+
+                new ActionTask<bool>(token, (s, gitIsValid) =>
+                    {
+                        InitializationComplete();
+                        if (gitIsValid)
+                        {
+                            InitializeUI();
+                        }
+                    },
+                    () => state.GitIsValid && state.GitLfsIsValid)
+                    { Affinity = TaskAffinity.UI }
+                .Start();
             });
             thread.Start(CancellationToken);
         }
 
-        public ITask InitializeRepository()
+        private void SetupGit(GitInstaller.GitInstallationState state)
         {
-            var targetPath = NPath.CurrentDirectory;
-
-            var unityYamlMergeExec = Environment.UnityApplicationContents.Combine("Tools", "UnityYAMLMerge" + Environment.ExecutableExtension);
-
-            var yamlMergeCommand = Environment.IsWindows
-                ? $@"'{unityYamlMergeExec}' merge -p ""$BASE"" ""$REMOTE"" ""$LOCAL"" ""$MERGED"""
-                : $@"'{unityYamlMergeExec}' merge -p '$BASE' '$REMOTE' '$LOCAL' '$MERGED'";
-
-            var gitignore = targetPath.Combine(".gitignore");
-            var gitAttrs = targetPath.Combine(".gitattributes");
-            var assetsGitignore = targetPath.Combine("Assets", ".gitignore");
-
-            var filesForInitialCommit = new List<string> { gitignore, gitAttrs, assetsGitignore };
-
-            var task =
-                GitClient.Init()
-                .Then(GitClient.SetConfig("merge.unityyamlmerge.cmd", yamlMergeCommand, GitConfigSource.Local))
-                .Then(GitClient.SetConfig("merge.unityyamlmerge.trustExitCode", "false", GitConfigSource.Local))
-                .Then(GitClient.LfsInstall())
-                .ThenInUI(SetProjectToTextSerialization)
-                .Then(new ActionTask(CancellationToken, _ => {
-                    AssemblyResources.ToFile(ResourceType.Generic, ".gitignore", targetPath, Environment);
-                    AssemblyResources.ToFile(ResourceType.Generic, ".gitattributes", targetPath, Environment);
-
-                    assetsGitignore.CreateFile();
-                }))
-                .Then(GitClient.Add(filesForInitialCommit))
-                .Then(GitClient.Commit("Initial commit", null))
-                .Then(_ =>
-                {
-                    Environment.InitializeRepository();
-                    RestartRepository();
-                })
-                .ThenInUI(() =>
+            if (!(state.GitIsValid && state.GitLfsIsValid))
+                return;
+
+            Environment.GitExecutablePath = state.GitExecutablePath;
+            Environment.GitLfsExecutablePath = state.GitLfsExecutablePath;
+            Environment.IsCustomGitExecutable = state.IsCustomGitPath;
+            Environment.User.Initialize(GitClient);
+
+            if (firstRun)
+            {
+                var unityYamlMergeExec = Environment.UnityApplicationContents.Combine("Tools", "UnityYAMLMerge" + Environment.ExecutableExtension);
+
+                var yamlMergeCommand = Environment.IsWindows
+                    ? $@"'{unityYamlMergeExec}' merge -p ""$BASE"" ""$REMOTE"" ""$LOCAL"" ""$MERGED"""
+                    : $@"'{unityYamlMergeExec}' merge -p '$BASE' '$REMOTE' '$LOCAL' '$MERGED'";
+
+                GitClient.SetConfig("merge.unityyamlmerge.cmd", yamlMergeCommand, GitConfigSource.Local)
+                    .Catch(e =>
+                    {
+                        Logger.Error(e, "Error setting merge.unityyamlmerge.cmd");
+                        return true;
+                    })
+                    .RunWithReturn(true);
+                GitClient.SetConfig("merge.unityyamlmerge.trustExitCode", "false", GitConfigSource.Local)
+                    .Catch(e =>
+                    {
+                        Logger.Error(e, "Error setting merge.unityyamlmerge.trustExitCode");
+                        return true;
+                    })
+                    .RunWithReturn(true);
+
+                GitClient.LfsInstall().RunWithReturn(true);
+
+                if (Environment.IsWindows)
                 {
-                    TaskManager.Run(UsageTracker.IncrementProjectsInitialized);
-                    InitializeUI();
-                });
-            return task;
+                    var credentialHelper = GitClient.GetConfig("credential.helper", GitConfigSource.Global)
+                        .Catch(e =>
+                        {
+                            Logger.Error(e, "Error getting the credential helper");
+                            return true;
+                        }).RunWithReturn(true);
+
+                    if (string.IsNullOrEmpty(credentialHelper))
+                    {
+                        Logger.Warning("No Windows CredentialHelper found: Setting to wincred");
+                        GitClient.SetConfig("credential.helper", "wincred", GitConfigSource.Global)
+                            .Catch(e =>
+                            {
+                                Logger.Error(e, "Error setting the credential helper");
+                                return true;
+                            })
+                            .RunWithReturn(true);
+                    }
+                }
+            }
         }
 
-        public void RestartRepository()
+        public void InitializeRepository()
         {
-            if (Environment.RepositoryPath.IsInitialized)
+            var thread = new Thread(obj =>
             {
-                repositoryManager = Unity.RepositoryManager.CreateInstance(Platform, TaskManager, GitClient, Environment.FileSystem, Environment.RepositoryPath);
-                repositoryManager.Initialize();
-                Environment.Repository.Initialize(repositoryManager, TaskManager);
-                repositoryManager.Start();
-                Environment.Repository.Start();
-                Logger.Trace($"Got a repository? {(Environment.Repository != null ? Environment.Repository.LocalPath : "null")}");
-            }
+                CancellationToken token = (CancellationToken)obj;
+                var targetPath = NPath.CurrentDirectory;
+
+                var gitignore = targetPath.Combine(".gitignore");
+                var gitAttrs = targetPath.Combine(".gitattributes");
+                var assetsGitignore = targetPath.Combine("Assets", ".gitignore");
+
+                var filesForInitialCommit = new List<string> { gitignore, gitAttrs, assetsGitignore };
+
+                GitClient.Init().RunWithReturn(true);
+                GitClient.LfsInstall().RunWithReturn(true);
+                AssemblyResources.ToFile(ResourceType.Generic, ".gitignore", targetPath, Environment);
+                AssemblyResources.ToFile(ResourceType.Generic, ".gitattributes", targetPath, Environment);
+                assetsGitignore.CreateFile();
+                GitClient.Add(filesForInitialCommit).RunWithReturn(true);
+                GitClient.Commit("Initial commit", null).RunWithReturn(true);
+                Environment.InitializeRepository();
+                RestartRepository();
+                UsageTracker.IncrementProjectsInitialized();
+                TaskManager.RunInUI(InitializeUI);
+            });
+            thread.Start(CancellationToken);
+        }
+
+        public void RestartRepository()
+        {
+            if (!Environment.RepositoryPath.IsInitialized)
+                return;
+
+            repositoryManager = Unity.RepositoryManager.CreateInstance(Platform, TaskManager, GitClient, Environment.FileSystem, Environment.RepositoryPath);
+            repositoryManager.Initialize();
+            Environment.Repository.Initialize(repositoryManager, TaskManager);
+            repositoryManager.Start();
+            Environment.Repository.Start();
+            Logger.Trace($"Got a repository? {(Environment.Repository != null ? Environment.Repository.LocalPath : "null")}");
         }
 
         protected void SetupMetrics(string unityVersion, bool firstRun, Guid instanceId)
@@ -156,62 +234,12 @@ protected void SetupMetrics(string unityVersion, bool firstRun, Guid instanceId)
 
             if (firstRun)
             {
-                TaskManager.Run(UsageTracker.IncrementNumberOfStartups);
+                UsageTracker.IncrementNumberOfStartups();
             }
 #endif
         }
-        protected abstract void SetupMetrics();
         protected abstract void InitializeUI();
-        protected abstract void SetProjectToTextSerialization();
-
-        /// <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(GitInstaller.GitInstallationState installationState)
-        {
-            isBusy = false;
-            SetupMetrics();
-
-            if (!installationState.GitIsValid)
-            {
-                return;
-            }
-
-            var gitInstallDetails = new GitInstaller.GitInstallDetails(Environment.UserCachePath, Environment.IsWindows);
-            var isCustomGitExec = installationState.GitExecutablePath != gitInstallDetails.GitExecutablePath;
-
-            Environment.GitExecutablePath = installationState.GitExecutablePath;
-            Environment.GitLfsExecutablePath = installationState.GitLfsExecutablePath;
-
-            Environment.IsCustomGitExecutable = isCustomGitExec;
-            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();
-        }
-
+        protected abstract void InitializationComplete();
 
         private bool disposed = false;
         protected virtual void Dispose(bool disposing)

src/GitHub.Api/Application/IApplicationManager.cs

@@ -18,9 +18,9 @@ public interface IApplicationManager : IDisposable
         IGitClient GitClient { get; }
         IUsageTracker UsageTracker { get; }
         bool IsBusy { get; }
-        void Run(bool firstRun);
+        void Run();
         void RestartRepository();
-        ITask InitializeRepository();
+        void InitializeRepository();
         event Action<IProgress> OnProgress;
     }
 }

src/GitHub.Api/Git/GitClient.cs

@@ -10,8 +10,8 @@ namespace GitHub.Unity
     public interface IGitClient
     {
         ITask<ValidateGitInstallResult> ValidateGitInstall(NPath path, bool isCustomGit);
-        ITask Init(IOutputProcessor<string> processor = null);
-        ITask LfsInstall(IOutputProcessor<string> processor = null);
+        ITask<string> Init(IOutputProcessor<string> processor = null);
+        ITask<string> LfsInstall(IOutputProcessor<string> processor = null);
         ITask<GitAheadBehindStatus> AheadBehindStatus(string gitRef, string otherRef, IOutputProcessor<GitAheadBehindStatus> processor = null);
         ITask<GitStatus> Status(IOutputProcessor<GitStatus> processor = null);
         ITask<string> GetConfig(string key, GitConfigSource configSource, IOutputProcessor<string> processor = null);
@@ -85,13 +85,13 @@ public ITask<ValidateGitInstallResult> ValidateGitInstall(NPath path, bool isCus
             return endTask;
         }
 
-        public ITask Init(IOutputProcessor<string> processor = null)
+        public ITask<string> Init(IOutputProcessor<string> processor = null)
         {
             return new GitInitTask(cancellationToken, processor)
                 .Configure(processManager);
         }
 
-        public ITask LfsInstall(IOutputProcessor<string> processor = null)
+        public ITask<string> LfsInstall(IOutputProcessor<string> processor = null)
         {
             return new GitLfsInstallTask(cancellationToken, processor)
                 .Configure(processManager);

src/GitHub.Api/Helpers/Constants.cs

@@ -19,6 +19,7 @@ static class Constants
             @"yyyy-MM-dd\THH\:mm\:sszzz",
         };
         public const string SkipVersionKey = "SkipVersion";
+        public const string GitInstallationState = "GitInstallationState";
 
         public static readonly Version MinimumGitVersion = new Version(2, 11, 0);
         public static readonly Version MinimumGitLfsVersion = new Version(2, 4, 0);