public List <SVR_AniDB_File> GetByInternalVersion(int version)
{
using (CacheLock.ReaderLock())
{
return(IsCached ? InternalVersions.GetMultiple(version) : Table.Where(a => a.InternalVersion == version).ToList());
}
}
public void Remove(IEnumerable <T> data)
{
CacheLock.Write(Lock, () => {
primaryCache.Remove(data);
secondaryCaches.Remove(data);
});
}
private void AddKeysToNoDataCache <TU>(IEnumerable <TU> keys, ReaderWriterLockSlim @lock)
{
var filteredKeys = keys.ToList();
filteredKeys.RemoveAll(k => noDataCache.Contains(k));
CacheLock.Write(@lock, () => noDataCache.Update(filteredKeys));
}
protected override void ExitLock()
{
if (CacheLock.IsReadLockHeld)
{
CacheLock.ExitReadLock();
}
}
public object GetCacheItem(string cacheName, string key,
params object[] args)
{
TkDebug.AssertArgumentNullOrEmpty(cacheName, "cacheName", this);
TkDebug.AssertArgumentNullOrEmpty(key, "key", this);
ICache cache = GetCache(cacheName);
BaseCacheItemCreator creator = PlugInFactoryManager.CreateInstance <BaseCacheItemCreator>(
CacheItemCreatorPlugInFactory.REG_NAME, cacheName);
TkDebug.AssertNotNull(creator, $"{cacheName}不存在", this);
if (cache == null)
{
ICacheCreator cacheCreator = creator.CacheCreator;
if (cacheCreator == null)
{
cacheCreator = creator.SupportDistributed ? DefaultDistributedCreator : DefaultCreator;
}
cache = cacheCreator.CreateCache(cacheName);
CacheLock.WriteLockAction(() =>
{
if (!fCaches.ContainsKey(cacheName))
{
fCaches.Add(cacheName, cache);
return(true);
}
return(false);
});
}
return(cache.GetItem(creator.TransformCacheKey(key), creator, args));
}
private static async Task <T> GetAsync <T>(this ObjectCache cache, string key, Func <Task <T> > acquireAsync, Action <string, object> set)
{
string cacheKey = CacheKeyGenerator.GenerateCacheKey <T>(key);
if (cache.IsSet(cacheKey))
{
var acquiredValue = cache.Get(cacheKey);
if (acquiredValue is NullObject)
{
return(default(T));
}
return((T)acquiredValue);
}
using (await CacheLock.LockAsync(cacheKey))
{
if (cache.IsSet(cacheKey))
{
return((T)cache.Get(cacheKey));
}
var acquiredValue = await acquireAsync();
if (acquiredValue != null)
{
set(cacheKey, acquiredValue);
}
else
{
set(cacheKey, NullObject.Instance);
}
return(acquiredValue);
}
}
public AniDB_Tag GetByTagID(int id)
{
using (CacheLock.ReaderLock())
{
return(IsCached ? Tags.GetOne(id) : Table.FirstOrDefault(a => a.TagID == id));
}
}
public void EscalateLock()
{
if (!CacheLock.TryEnterWriteLock(_timeOut))
{
ThrowTimeoutException("escalated write");
}
}
internal override void RegenerateDb(IProgress <RegenerateProgress> progress)
{
List <AniDB_Episode> episodes;
using (CacheLock.ReaderLock())
{
episodes = IsCached ? Cache.Values.Where(episode => episode.EnglishName.Contains('`') || episode.RomajiName.Contains('`')).ToList() : Table.Where((episode => episode.EnglishName.Contains('`') || episode.RomajiName.Contains('`'))).ToList();
}
using (IAtomic <List <AniDB_Episode>, object> update = BeginAtomicBatchUpdate(episodes))
{
RegenerateProgress regen = new RegenerateProgress();
regen.Title = "Fixing Episode Titles";
regen.Step = 0;
regen.Total = update.Updatable.Count;
foreach (AniDB_Episode episode in update.Updatable)
{
episode.EnglishName = episode.EnglishName.Replace('`', '\'');
episode.RomajiName = episode.RomajiName.Replace('`', '\'');
regen.Step++;
progress.Report(regen);
}
update.Commit();
regen.Step = regen.Total;
progress.Report(regen);
}
}
private ICache GetCache(string cacheName)
{
ICache cache;
cache = CacheLock.ReadLockAction(() => ObjectUtil.TryGetValue(fCaches, cacheName));
return(cache);
}
public List <AniDB_Vote> GetByEntity(int entID)
{
using (CacheLock.ReaderLock())
{
return(IsCached ? EntityIDs.GetMultiple(entID)?.ToList() : Table.Where(a => a.EntityID == entID).ToList());
}
}
public SVR_AniDB_File GetByMD5(string hash)
{
using (CacheLock.ReaderLock())
{
return(IsCached ? MD5s.GetOne(hash) : Table.FirstOrDefault(a => a.MD5 == hash));
}
}
public List <SVR_AniDB_File> GetByAnimeID(int animeID)
{
using (CacheLock.ReaderLock())
{
return(IsCached ? Animes.GetMultiple(animeID) : Table.Where(a => a.AnimeID == animeID).ToList());
}
}
public List <SVR_AniDB_File> GetByResolution(string res)
{
using (CacheLock.ReaderLock())
{
return(IsCached ? Resolutions.GetMultiple(res) : Table.Where(a => a.File_VideoResolution == res).ToList());
}
}
public SVR_AniDB_File GetByFileID(int fileID)
{
using (CacheLock.ReaderLock())
{
return(IsCached ? FileIds.GetOne(fileID) : Table.FirstOrDefault(a => a.FileID == fileID));
}
}
public SVR_AniDB_File GetByHashAndFileSize(string hash, long fsize)
{
using (CacheLock.ReaderLock())
{
return(IsCached ? Hashes.GetMultiple(hash).FirstOrDefault(a => a.FileSize == fsize) : Table.FirstOrDefault(a => a.Hash == hash && a.FileSize == fsize));
}
}
protected override void ExitLock()
{
if (CacheLock.IsWriteLockHeld)
{
CacheLock.ExitWriteLock();
}
}
private void UpdateCache(IEnumerable <T> data)
{
CacheLock.Write(Lock, () => {
primaryCache.Update(data);
secondaryCaches.Update(data);
});
}
/*
public override void SaveOLD(SVR_AniDB_Anime obj)
{
lock (globalDBLock)
{
lock (obj)
{
if (obj.AniDB_AnimeID == 0)
{
obj.Contract = null;
base.Save(obj);
}
using (var session = DatabaseFactory.SessionFactory.OpenSession())
{
obj.UpdateContractDetailed(session.Wrap());
}
// populate the database
base.Save(obj);
}
}
}
*/
public SVR_AniDB_Anime GetByAnimeID(int id)
{
using (CacheLock.ReaderLock())
{
if (IsCached)
return Animes.GetOne(id);
return Table.FirstOrDefault(a => a.AnimeID == id);
}
}
public void Dispose()
{
CacheLock.Dispose();
foreach (var item in fCaches.Values)
{
item.DisposeObject();
}
fCaches.Clear();
}
public RepositoryCacheUpgradeableLock(Guid repositoryId, ReaderWriterLockSlim cacheLock, int timeOut)
: base(repositoryId, cacheLock)
{
if (!CacheLock.TryEnterUpgradeableReadLock(timeOut))
{
ThrowTimeoutException("upgradeable read");
}
_timeOut = timeOut;
}
private void InitializeCache(IEnumerable <T> data)
{
CacheLock.Write(Lock, () => {
primaryCache.Initialize(data);
secondaryCaches.Initialize(data);
cacheStorageStrategy.Save("Primary", primaryCache);
cacheStorageStrategy.Save("Secondary", secondaryCaches);
});
}
/// <summary>
/// Clear all cached values
/// </summary>
public void Clear()
{
CacheLock.EnterWriteLock();
try {
Cache.Clear();
} finally {
CacheLock.ExitWriteLock();
}
}
/// <summary>
/// Count all cached values
/// </summary>
/// <returns></returns>
public int Count()
{
CacheLock.EnterReadLock();
try {
return(Cache.Count);
} finally {
CacheLock.ExitReadLock();
}
}
public void LockTest()
{
var userCount = 1 * 1000;
var storageMaxCount = userCount;
var cache = new TestCacheUserStorage(storageMaxCount);
cache.BeginUnloadCount = int.MaxValue;
cache.StopUnloadCount = int.MaxValue;
cache.CreateUsers(userCount);
var users = cache.GetAllUsers();
var request = new CacheRequest()
{
ObjectId = users.First().Id
};
CacheLock lockObj = null;
// чтение потом запись
var readObj1 = cache.Read(request);
lockObj = ((TestCacheUserWriteObject)readObj1).Response.Lock;
Assert.False(lockObj.IsEntered());
using (var writeObj = cache.Write(request))
{
Assert.True(lockObj.IsEntered());
}
Assert.False(lockObj.IsEntered());
// запись потом чтение
using (var writeObj1 = cache.Write(request))
{
Assert.True(lockObj.IsEntered());
var readObj2 = cache.Read(request);
Assert.True(lockObj.IsEntered());
Assert.True(lockObj.IsEntered());
}
Assert.False(lockObj.IsEntered());
// чтение потом чтение
using (var writeObj1 = cache.Write(request))
{
Assert.True(lockObj.IsEntered());
Assert.Equal(1, lockObj.Count);
using (var writeObj2 = cache.Write(request))
{
Assert.True(lockObj.IsEntered());
Assert.Equal(2, lockObj.Count);
Assert.True(ReferenceEquals(writeObj1, writeObj2));
}
Assert.True(lockObj.IsEntered());
Assert.Equal(1, lockObj.Count);
}
Assert.False(lockObj.IsEntered());
Assert.Equal(0, lockObj.Count);
}
private void CheckCacheLock(CacheLock original, CacheLock copy)
{
Assert.That(copy.Version, Is.EqualTo(original.Version));
Assert.That(copy.Version, Is.TypeOf(original.Version.GetType()));
Assert.That(copy.Id, Is.EqualTo(original.Id));
Assert.That(copy.Multiplicity, Is.EqualTo(original.Multiplicity));
Assert.That(copy.Timeout, Is.EqualTo(original.Timeout));
Assert.That(copy.UnlockTimestamp, Is.EqualTo(original.UnlockTimestamp));
Assert.That(copy.WasLockedConcurrently, Is.EqualTo(original.WasLockedConcurrently));
}
/// <summary>
/// Remove cached value
/// </summary>
/// <param name="key">Cache key</param>
public void Remove(TKey key)
{
RevokeExpires();
CacheLock.EnterWriteLock();
try {
Cache.Remove(key);
} finally {
CacheLock.ExitWriteLock();
}
}
public AniDB_Episode GetByEpisodeID(int id)
{
using (CacheLock.ReaderLock())
{
if (IsCached)
{
return(EpisodesIds.GetOne(id));
}
return(Table.FirstOrDefault(a => a.EpisodeID == id));
}
}
public List <AniDB_Episode> GetByAnimeIDAndEpisodeTypeNumber(int animeid, EpisodeType epType, int epnumber)
{
using (CacheLock.ReaderLock())
{
if (IsCached)
{
return(Animes.GetMultiple(animeid).Where(a => a.EpisodeNumber == epnumber && a.GetEpisodeTypeEnum() == epType).ToList());
}
return(Table.Where(a => a.AnimeID == animeid && a.EpisodeNumber == epnumber && a.EpisodeType == (int)epType).ToList());
}
}
public List <AniDB_Episode> GetByAnimeID(int id)
{
using (CacheLock.ReaderLock())
{
if (IsCached)
{
return(Animes.GetMultiple(id));
}
return(Table.Where(a => a.AnimeID == id).ToList());
}
}
