public void TestIsEnabled()
{
IDiskStorage storage = CreateDiskStorage(TESTCACHE_CURRENT_VERSION);
DiskStorageCache cache = CreateDiskCache(storage, false);
Assert.IsTrue(cache.IsEnabled);
}
public void TestVersioning()
{
// Define data that will be written to cache
ICacheKey key = new SimpleCacheKey("version_test");
byte[] value = new byte[32];
value[0] = 118; // 'v'
// Set up cache with version == 1
IDiskStorage storage1 = CreateDiskStorage(TESTCACHE_CURRENT_VERSION);
DiskStorageCache cache1 = CreateDiskCache(storage1, false);
// Write test data to cache 1
cache1.Insert(key, WriterCallbacks.From(value));
// Get cached file
IBinaryResource resource1 = GetResource(storage1, key);
Assert.IsNotNull(resource1);
// Set up cache with version == 2
IDiskStorage storageSupplier2 = CreateDiskStorage(TESTCACHE_NEXT_VERSION);
DiskStorageCache cache2 = CreateDiskCache(storageSupplier2, false);
// Write test data to cache 2
cache2.Insert(key, WriterCallbacks.From(value));
// Get cached file
IBinaryResource resource2 = GetResource(storageSupplier2, key);
Assert.IsNotNull(resource2);
// Make sure filenames of the two file are different
Assert.IsFalse(resource2.Equals(resource1));
}
public void Initialize()
{
_clock = MockSystemClock.Get();
_clock.SetDateTime(DateTime.Now);
NoOpDiskTrimmableRegistry.Instance.ResetCounter();
_diskTrimmableRegistry = NoOpDiskTrimmableRegistry.Instance;
_cacheEventListener = new DuplicatingCacheEventListener();
// We know the directory will be this
_cacheDirectory = new DirectoryInfo(
Path.Combine(ApplicationData.Current.LocalCacheFolder.Path, CACHE_TYPE));
_cacheDirectory.Create();
if (!_cacheDirectory.Exists)
{
throw new Exception(
string.Format(
"Cannot create cache dir: {0}: directory {1}",
ApplicationData.Current.LocalCacheFolder.Path,
_cacheDirectory.Exists ? "already exists" : "does not exist"));
}
_storage = CreateDiskStorage(TESTCACHE_VERSION_START_OF_VERSIONING);
_cache = CreateDiskCache(_storage, false);
Assert.IsTrue(((NoOpDiskTrimmableRegistry)_diskTrimmableRegistry).RegisterDiskTrimmableCount == 1);
}
/// <summary>
/// Builds the <see cref="DiskStorageCache"/>.
/// </summary>
public static DiskStorageCache BuildDiskStorageCache(
DiskCacheConfig diskCacheConfig,
IDiskStorage diskStorage)
{
Params parameters = new Params(
diskCacheConfig.MinimumSizeLimit,
diskCacheConfig.LowDiskSpaceSizeLimit,
diskCacheConfig.DefaultSizeLimit);
return(new DiskStorageCache(
diskStorage,
diskCacheConfig.EntryEvictionComparatorSupplier,
parameters,
diskCacheConfig.CacheEventListener,
diskCacheConfig.CacheErrorLogger,
diskCacheConfig.DiskTrimmableRegistry,
diskCacheConfig.IndexPopulateAtStartupEnabled));
}
private DiskStorageCache CreateDiskCache(
IDiskStorage diskStorage,
bool indexPopulateAtStartupEnabled)
{
Params diskStorageCacheParams = new Params(
0,
FILE_CACHE_MAX_SIZE_LOW_LIMIT,
FILE_CACHE_MAX_SIZE_HIGH_LIMIT);
return(new DiskStorageCache(
diskStorage,
new DefaultEntryEvictionComparatorSupplier(),
diskStorageCacheParams,
_cacheEventListener,
NoOpCacheErrorLogger.Instance,
_diskTrimmableRegistry,
indexPopulateAtStartupEnabled,
_clock));
}
public void TestGet_InternalCacheDir()
{
DirectoryInfo cacheDir = new DirectoryInfo(ApplicationData.Current.LocalCacheFolder.Path);
DynamicDefaultDiskStorage storage = CreateInternalCacheDirStorage();
// Initial state
Assert.IsNull(storage._currentState.DiskStorageDelegate);
// After first initialization
IDiskStorage diskStorageDelegate = storage.Get();
Assert.AreEqual(diskStorageDelegate, storage._currentState.DiskStorageDelegate);
Assert.IsTrue(diskStorageDelegate.GetType() == typeof(DefaultDiskStorage));
DirectoryInfo baseDir = new DirectoryInfo(Path.Combine(cacheDir.FullName, _baseDirectoryName));
Assert.IsTrue(baseDir.Exists);
Assert.IsTrue(GetStorageSubdirectory(baseDir, 1).Exists);
// no change => should get back the same storage instance
IDiskStorage storage2 = storage.Get();
Assert.AreEqual(diskStorageDelegate, storage2);
// Root directory has been moved (proxy for delete). So we should get back a different instance
DirectoryInfo baseDirOrig = new DirectoryInfo(baseDir.FullName);
Assert.IsTrue(baseDirOrig.RenameTo(new DirectoryInfo(
Path.Combine(cacheDir.FullName, "dummydir"))));
IDiskStorage storage3 = storage.Get();
Assert.AreNotEqual(diskStorageDelegate, storage3);
Assert.IsTrue(storage3.GetType() == typeof(DefaultDiskStorage));
baseDir.Refresh();
Assert.IsTrue(baseDir.Exists);
Assert.IsTrue(GetStorageSubdirectory(baseDir, 1).Exists);
}
internal State(FileSystemInfo rootDirectory, IDiskStorage diskStorageDelegate)
{
DiskStorageDelegate = diskStorageDelegate;
RootDirectory = rootDirectory;
}
/// <summary>
/// Creates a new <see cref="DiskStorageCache"/> from
/// the given <see cref="DiskCacheConfig"/>.
///
/// @deprecated use
/// <see cref="DiskStorageCacheFactory.BuildDiskStorageCache"/>.
/// </summary>
public static DiskStorageCache BuildDiskStorageCache(
DiskCacheConfig diskCacheConfig,
IDiskStorage diskStorage)
{
return(DiskStorageCacheFactory.BuildDiskStorageCache(diskCacheConfig, diskStorage));
}
private IBinaryResource GetResource(IDiskStorage storage, ICacheKey key)
{
return(storage.GetResource(CacheKeyUtil.GetFirstResourceId(key), key));
}
/// <summary>
/// Instantiates the <see cref="DiskStorageCache"/>.
/// </summary>
public DiskStorageCache(
IDiskStorage diskStorage,
IEntryEvictionComparatorSupplier entryEvictionComparatorSupplier,
Params parameters,
ICacheEventListener cacheEventListener,
ICacheErrorLogger cacheErrorLogger,
IDiskTrimmableRegistry diskTrimmableRegistry,
bool indexPopulateAtStartupEnabled,
Clock clock = null)
{
_lowDiskSpaceCacheSizeLimit = parameters.LowDiskSpaceCacheSizeLimit;
_defaultCacheSizeLimit = parameters.DefaultCacheSizeLimit;
_cacheSizeLimit = parameters.DefaultCacheSizeLimit;
_statFsHelper = StatFsHelper.Instance;
_storage = diskStorage;
_entryEvictionComparatorSupplier = entryEvictionComparatorSupplier;
_cacheSizeLastUpdateTime = default(DateTime);
_cacheEventListener = cacheEventListener;
_cacheSizeLimitMinimum = parameters.CacheSizeLimitMinimum;
_cacheErrorLogger = cacheErrorLogger;
_cacheStats = new CacheStats();
if (diskTrimmableRegistry != null)
{
diskTrimmableRegistry.RegisterDiskTrimmable(this);
}
_clock = clock ?? SystemClock.Get();
_indexPopulateAtStartupEnabled = indexPopulateAtStartupEnabled;
_resourceIndex = new HashSet <string>();
if (_indexPopulateAtStartupEnabled)
{
Task.Run(() =>
{
try
{
lock (_lock)
{
MaybeUpdateFileCacheSize();
}
}
finally
{
_countdownEvent.Signal();
}
});
}
else
{
_countdownEvent.Reset(0);
}
}
