Adding functionality to fire cache invalidated events on first run

Author: StanleyGoldman

src/GitHub.Api/Git/Repository.cs

@@ -58,11 +58,6 @@ public void Initialize(IRepositoryManager initRepositoryManager)
             repositoryManager.OnRemoteBranchAdded += RepositoryManager_OnRemoteBranchAdded;
             repositoryManager.OnRemoteBranchRemoved += RepositoryManager_OnRemoteBranchRemoved;
             repositoryManager.OnGitUserLoaded += user => User = user;
-
-            UpdateGitStatus();
-            UpdateGitLog();
-
-            new ActionTask(CancellationToken.None, UpdateLocks) { Affinity = TaskAffinity.UI }.Start();
         }
 
         public ITask SetupRemote(string remote, string remoteUrl)
@@ -318,6 +313,9 @@ private void CacheContainer_OnCacheInvalidated(CacheType cacheType)
                 case CacheType.GitUserCache:
                     break;
 
+                case CacheType.RepositoryInfoCache:
+                    break;
+
                 default:
                     throw new ArgumentOutOfRangeException(nameof(cacheType), cacheType, null);
             }

src/UnityExtension/Assets/Editor/GitHub.Unity/ApplicationCache.cs

@@ -10,25 +10,46 @@ namespace GitHub.Unity
 {
     sealed class ApplicationCache : ScriptObjectSingleton<ApplicationCache>
     {
-        [NonSerialized] private bool? val;
         [SerializeField] private bool firstRun = true;
+        [SerializeField] public string firstRunAtString;
+        [NonSerialized] private bool? firstRunValue;
+        [NonSerialized] public DateTimeOffset? firstRunAtValue;
 
         public bool FirstRun
         {
             get
             {
-                if (!val.HasValue)
+                if (!firstRunValue.HasValue)
                 {
-                    val = firstRun;
+                    firstRunValue = firstRun;
                 }
 
                 if (firstRun)
                 {
                     firstRun = false;
+                    FirstRunAt = DateTimeOffset.Now;
                     Save(true);
                 }
 
-                return val.Value;
+                return firstRunValue.Value;
+            }
+        }
+
+        public DateTimeOffset FirstRunAt
+        {
+            get
+            {
+                if (!firstRunAtValue.HasValue)
+                {
+                    firstRunAtValue = DateTimeOffset.Parse(firstRunAtString);
+                }
+
+                return firstRunAtValue.Value;
+            }
+            private set
+            {
+                firstRunAtString = value.ToString();
+                firstRunAtValue = null;
             }
         }
     }
@@ -89,23 +110,35 @@ public IEnvironment Environment
 
     abstract class ManagedCacheBase<T> : ScriptObjectSingleton<T> where T : ScriptableObject, IManagedCache
     {
-        private static readonly TimeSpan DataTimeout = TimeSpan.MaxValue;
+        private static readonly TimeSpan DataTimeout = TimeSpan.FromMinutes(1);
 
         [NonSerialized] private DateTimeOffset? lastUpdatedAtValue;
-
         [NonSerialized] private DateTimeOffset? lastVerifiedAtValue;
+        [NonSerialized] private DateTimeOffset? firstInitializedAtValue;
+        [NonSerialized] private readonly bool invalidOnFirstRun;
 
         public event Action CacheInvalidated;
         public event Action<DateTimeOffset> CacheUpdated;
 
-        protected ManagedCacheBase()
+        protected ManagedCacheBase(bool invalidOnFirstRun)
         {
+            this.invalidOnFirstRun = invalidOnFirstRun;
             Logger = Logging.GetLogger(GetType());
         }
 
         public void ValidateData()
         {
-            if (DateTimeOffset.Now - LastUpdatedAt > DataTimeout)
+            if (ApplicationCache.Instance.FirstRunAt > FirstInitializedAt)
+            {
+                FirstInitializedAt = DateTimeOffset.Now;
+                Save(true);
+
+                if (invalidOnFirstRun)
+                {
+                    InvalidateData();
+                }
+            }
+            else if (DateTimeOffset.Now - LastUpdatedAt > DataTimeout)
             {
                 InvalidateData();
             }
@@ -141,6 +174,7 @@ protected void SaveData(DateTimeOffset now, bool isUpdated)
 
         public abstract string LastUpdatedAtString { get; protected set; }
         public abstract string LastVerifiedAtString { get; protected set; }
+        public abstract string FirstInitializedAtString { get; protected set; }
 
         public DateTimeOffset LastUpdatedAt
         {
@@ -178,6 +212,24 @@ public DateTimeOffset LastVerifiedAt
             }
         }
 
+        public DateTimeOffset FirstInitializedAt
+        {
+            get
+            {
+                if (!firstInitializedAtValue.HasValue)
+                {
+                    firstInitializedAtValue = DateTimeOffset.Parse(FirstInitializedAtString);
+                }
+
+                return firstInitializedAtValue.Value;
+            }
+            set
+            {
+                FirstInitializedAtString = value.ToString();
+                firstInitializedAtValue = null;
+            }
+        }
+
         protected ILogging Logger { get; private set; }
     }
 
@@ -417,9 +469,13 @@ sealed class RepositoryInfoCache : ManagedCacheBase<RepositoryInfoCache>, IRepos
     {
         [SerializeField] private string lastUpdatedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private string lastVerifiedAtString = DateTimeOffset.MinValue.ToString();
+        [SerializeField] private string firstInitializedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private GitRemote gitRemote;
         [SerializeField] private GitBranch gitBranch;
 
+        public RepositoryInfoCache() : base(false)
+        { }
+
         public GitRemote? CurrentGitRemote
         {
             get
@@ -479,6 +535,12 @@ public override string LastVerifiedAtString
             get { return lastVerifiedAtString; }
             protected set { lastVerifiedAtString = value; }
         }
+
+        public override string FirstInitializedAtString
+        {
+            get { return firstInitializedAtString; }
+            protected set { firstInitializedAtString = value; }
+        }
     }
 
     [Location("cache/branches.yaml", LocationAttribute.Location.LibraryFolder)]
@@ -489,6 +551,7 @@ sealed class BranchCache : ManagedCacheBase<BranchCache>, IBranchCache
 
         [SerializeField] private string lastUpdatedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private string lastVerifiedAtString = DateTimeOffset.MinValue.ToString();
+        [SerializeField] private string firstInitializedAtString = DateTimeOffset.MinValue.ToString();
 
         [SerializeField] private ConfigBranch gitConfigBranch;
         [SerializeField] private ConfigRemote gitConfigRemote;
@@ -501,6 +564,9 @@ sealed class BranchCache : ManagedCacheBase<BranchCache>, IBranchCache
         [SerializeField] private RemoteConfigBranchDictionary remoteConfigBranches = new RemoteConfigBranchDictionary();
         [SerializeField] private ConfigRemoteDictionary configRemotes = new ConfigRemoteDictionary();
 
+        public BranchCache() : base(false)
+        { }
+
         public ConfigRemote? CurrentConfigRemote
         {
             get
@@ -740,32 +806,24 @@ public override string LastVerifiedAtString
             get { return lastVerifiedAtString; }
             protected set { lastVerifiedAtString = value; }
         }
+
+        public override string FirstInitializedAtString
+        {
+            get { return firstInitializedAtString; }
+            protected set { firstInitializedAtString = value; }
+        }
     }
 
     [Location("cache/gitlog.yaml", LocationAttribute.Location.LibraryFolder)]
     sealed class GitLogCache : ManagedCacheBase<GitLogCache>, IGitLogCache
     {
         [SerializeField] private string lastUpdatedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private string lastVerifiedAtString = DateTimeOffset.MinValue.ToString();
+        [SerializeField] private string firstInitializedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private List<GitLogEntry> log = new List<GitLogEntry>();
 
-        public void UpdateData(List<GitLogEntry> logUpdate)
-        {
-            var now = DateTimeOffset.Now;
-            var isUpdated = false;
-
-            Logger.Trace("Processing Update: {0}", now);
-
-            var logIsNull = log == null;
-            var updateIsNull = logUpdate == null;
-            if (logIsNull != updateIsNull || !logIsNull && !log.SequenceEqual(logUpdate))
-            {
-                log = logUpdate;
-                isUpdated = true;
-            }
-
-            SaveData(now, isUpdated);
-        }
+        public GitLogCache() : base(true)
+        { }
 
         public List<GitLogEntry> Log
         {
@@ -802,30 +860,24 @@ public override string LastVerifiedAtString
             get { return lastVerifiedAtString; }
             protected set { lastVerifiedAtString = value; }
         }
+
+        public override string FirstInitializedAtString
+        {
+            get { return firstInitializedAtString; }
+            protected set { firstInitializedAtString = value; }
+        }
     }
 
     [Location("cache/gitstatus.yaml", LocationAttribute.Location.LibraryFolder)]
     sealed class GitStatusCache : ManagedCacheBase<GitStatusCache>, IGitStatusCache
     {
         [SerializeField] private string lastUpdatedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private string lastVerifiedAtString = DateTimeOffset.MinValue.ToString();
+        [SerializeField] private string firstInitializedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private GitStatus status;
 
-        public void UpdateData(GitStatus statusUpdate)
-        {
-            var now = DateTimeOffset.Now;
-            var isUpdated = false;
-
-            Logger.Trace("Processing Update: {0}", now);
-
-            if (!status.Equals(statusUpdate))
-            {
-                status = statusUpdate;
-                isUpdated = true;
-            }
-
-            SaveData(now, isUpdated);
-        }
+        public GitStatusCache() : base(true)
+        { }
 
         public GitStatus GitStatus
         {
@@ -862,15 +914,25 @@ public override string LastVerifiedAtString
             get { return lastVerifiedAtString; }
             protected set { lastVerifiedAtString = value; }
         }
+
+        public override string FirstInitializedAtString
+        {
+            get { return firstInitializedAtString; }
+            protected set { firstInitializedAtString = value; }
+        }
     }
 
     [Location("cache/gitlocks.yaml", LocationAttribute.Location.LibraryFolder)]
     sealed class GitLocksCache : ManagedCacheBase<GitLocksCache>, IGitLocksCache
     {
         [SerializeField] private string lastUpdatedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private string lastVerifiedAtString = DateTimeOffset.MinValue.ToString();
+        [SerializeField] private string firstInitializedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private List<GitLock> gitLocks = new List<GitLock>();
 
+        public GitLocksCache() : base(true)
+        { }
+
         public List<GitLock> GitLocks
         {
             get
@@ -906,30 +968,24 @@ public override string LastVerifiedAtString
             get { return lastVerifiedAtString; }
             protected set { lastVerifiedAtString = value; }
         }
+
+        public override string FirstInitializedAtString
+        {
+            get { return firstInitializedAtString; }
+            protected set { firstInitializedAtString = value; }
+        }
     }
 
     [Location("cache/gituser.yaml", LocationAttribute.Location.LibraryFolder)]
     sealed class GitUserCache : ManagedCacheBase<GitUserCache>, IGitUserCache
     {
         [SerializeField] private string lastUpdatedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private string lastVerifiedAtString = DateTimeOffset.MinValue.ToString();
+        [SerializeField] private string firstInitializedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private User user;
 
-        public void UpdateData(User userUpdate)
-        {
-            var now = DateTimeOffset.Now;
-            var isUpdated = false;
-
-            Logger.Trace("Processing Update: {0}", now);
-
-            if (user != userUpdate)
-            {
-                user = userUpdate;
-                isUpdated = true;
-            }
-
-            SaveData(now, isUpdated);
-        }
+        public GitUserCache() : base(true)
+        { }
 
         public User User
         {
@@ -938,6 +994,21 @@ public User User
                 ValidateData();
                 return user;
             }
+            set
+            {
+                var now = DateTimeOffset.Now;
+                var isUpdated = false;
+
+                Logger.Trace("Updating: {0} user:{1}", now, value);
+
+                if (!user.Equals(value))
+                {
+                    user = value;
+                    isUpdated = true;
+                }
+
+                SaveData(now, isUpdated);
+            }
         }
 
         public override string LastUpdatedAtString
@@ -951,5 +1022,11 @@ public override string LastVerifiedAtString
             get { return lastVerifiedAtString; }
             protected set { lastVerifiedAtString = value; }
         }
+
+        public override string FirstInitializedAtString
+        {
+            get { return firstInitializedAtString; }
+            protected set { firstInitializedAtString = value; }
+        }
     }
 }