Fix premature cache disposal

Now that we're not creating a million copies of the same cache every
time something wants something for the cache, `ModelService` can't just
willy-nilly dispose of the `hostCache` object when it feels like it,
because that cache object is in itself cached in the factory and will be
reused by other services, if needed.

The factory is the one responsible for keeping the lifetime of its
cached objects (and yes, now it should probably not be called a factory
anymore, it should be a service but oh well), and so now it needs to be
disposable and take care of things.

Author: shana

src/GitHub.App/Factories/HostCacheFactory.cs

@@ -39,5 +39,23 @@ public IBlobCache Create(HostAddress hostAddress)
 
         IOperatingSystem OperatingSystem { get { return operatingSystem.Value; } }
         IBlobCacheFactory BlobCacheFactory { get { return blobCacheFactory.Value; } }
+
+        bool disposed;
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (disposed) return;
+                disposed = true;
+                if (blobCacheFactory.IsValueCreated)
+                    blobCacheFactory.Value.Dispose();
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
     }
 }

src/GitHub.App/Factories/IBlobCacheFactory.cs

@@ -1,8 +1,9 @@
 using Akavache;
+using System;
 
 namespace GitHub.Factories
 {
-    public interface IBlobCacheFactory
+    public interface IBlobCacheFactory : IDisposable
     {
         IBlobCache CreateBlobCache(string path);
     }

src/GitHub.App/Factories/IHostCacheFactory.cs

@@ -1,9 +1,10 @@
 using Akavache;
 using GitHub.Primitives;
+using System;
 
 namespace GitHub.Factories
 {
-    public interface IHostCacheFactory
+    public interface IHostCacheFactory : IDisposable
     {
         IBlobCache Create(HostAddress hostAddress);
     }

src/GitHub.App/Factories/RepositoryHostFactory.cs

@@ -51,6 +51,7 @@ protected virtual void Dispose(bool disposing)
 
                 loginCache.Dispose();
                 avatarProvider.Dispose();
+                hostCacheFactory.Dispose();
                 disposed = true;
             }
         }

src/GitHub.App/Factories/SqlitePersistentBlobCacheFactory.cs

@@ -4,13 +4,15 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
+using System.Reactive.Disposables;
 
 namespace GitHub.Factories
 {
     [Export(typeof(IBlobCacheFactory))]
     [PartCreationPolicy(CreationPolicy.Shared)]
     public class SqlitePersistentBlobCacheFactory : IBlobCacheFactory
     {
+        readonly CompositeDisposable disposables = new CompositeDisposable();
         static readonly Logger log = LogManager.GetCurrentClassLogger();
         Dictionary<string, IBlobCache> cache = new Dictionary<string, IBlobCache>();
 
@@ -24,6 +26,7 @@ public IBlobCache CreateBlobCache(string path)
             {
                 var c = new SQLitePersistentBlobCache(path);
                 cache.Add(path, c);
+                disposables.Add(c);
                 return c;
             }
             catch(Exception ex)
@@ -32,5 +35,23 @@ public IBlobCache CreateBlobCache(string path)
                 return new InMemoryBlobCache();
             }
         }
+
+        bool disposed;
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (disposed) return;
+                disposed = true;
+                disposables.Dispose();
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
     }
 }

src/GitHub.App/Services/ModelService.cs

@@ -277,15 +277,6 @@ protected virtual void Dispose(bool disposing)
             if (disposing)
             {
                 if (disposed) return;
-
-                try
-                {
-                    hostCache.Dispose();
-                }
-                catch (Exception e)
-                {
-                    log.Warn("Exception occured while disposing host cache", e);
-                }
                 disposed = true;
             }
         }