public static IObjectCache GetCache(CacheType cacheType, CacheIdentifiers cacheIdentifiers)
{
switch (cacheType)
{
case CacheType.InMemoryObjectCache:
IObjectCache inMemoryObjectCache;
if (!ObjectCaches.TryGetValue(cacheType.ToString() + cacheIdentifiers, out inMemoryObjectCache))
{
inMemoryObjectCache = new InMemoryObjectCache(cacheIdentifiers);
ObjectCaches.Add(cacheType.ToString() + cacheIdentifiers, inMemoryObjectCache);
return(inMemoryObjectCache);
}
return(inMemoryObjectCache);
case CacheType.RedisObjectCache:
break;
case CacheType.AzureRedisObjectCache:
break;
default:
return(null);
}
return(null);
}
public static IThumbnailCache GetCache(CacheType t)
{
logger.Info("Creating instance of {cacheType}", t.ToString());
switch (t)
{
case CacheType.FolderImages:
return(ThumbnailCacheInFolder.Instance);
default:
throw new NotImplementedException($"Thumbnail Cache for {t.ToString()} is not implemented.");
}
}
public void SaveContent(string url, CacheType type, string content)
{
try
{
ConvertToHash(ref url);
string dir = Path.Combine(cache, type.ToString()) + Path.DirectorySeparatorChar;
// precrete dir
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
string file = dir + url + ".txt";
using (StreamWriter writer = new StreamWriter(file, false, Encoding.UTF8))
{
writer.Write(content);
}
}
catch (Exception ex)
{
Debug.WriteLine("SaveContent: " + ex);
}
}
public string GetContent(string url, CacheType type, TimeSpan stayInCache)
{
string ret = null;
try
{
ConvertToHash(ref url);
string dir = Path.Combine(cache, type.ToString()) + Path.DirectorySeparatorChar;
string file = dir + url + ".txt";
if (File.Exists(file))
{
var writeTime = File.GetLastWriteTime(file);
if (DateTime.Now - writeTime < stayInCache)
{
using (StreamReader r = new StreamReader(file, Encoding.UTF8))
{
ret = r.ReadToEnd();
}
}
else
{
File.Delete(file);
}
}
}
catch (Exception ex)
{
ret = null;
Debug.WriteLine("GetContent: " + ex);
}
return(ret);
}
public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next)
{
if (CacheLocation == CacheLocation.Client)
{
await next.Invoke();
return;
}
var req = context.HttpContext.Request;
var resp = context.HttpContext.Response;
_cacheKey = $"{req.Path}{ req.QueryString}";
//get cached results
var cachedResult = await CacheService.Get <string>(_cacheKey);
var contentType = await
CacheService.Get <string>($"{_cacheKey}{ContentType}");
var eTag = await CacheService.Get <string>($"{_cacheKey}_{HeaderNames.ETag}");
//if we don't have cached output than return and execute the method
//data will be store in the the cache later in the method OnResultExecuted
if (cachedResult == null || string.IsNullOrEmpty(contentType) || string.IsNullOrEmpty(eTag))
{
await next.Invoke();
return;
}
SetCacheHeaderForClientSideCaching(context.HttpContext.Response, eTag); //refresh cache lifetime on client side
//we have to check the eTag, if the value is the same (which means that client already have the current version)
if (req.Headers[HeaderNames.IfNoneMatch].Count != 0 && req.Headers[HeaderNames.IfNoneMatch] == context.HttpContext.Response.Headers[HeaderNames.ETag])
{
context.Result = new EmptyResult();
context.HttpContext.Response.StatusCode = StatusCodes.Status304NotModified; // this will blank response
SetCacheHeaderForClientSideCaching(context.HttpContext.Response, eTag); //refresh cache lifetime on client side
return;
}
context.Result = new ContentResult();
resp.ContentType = contentType;
resp.StatusCode = StatusCodes.Status200OK;//We add to cache only results with StatusCodes.Status200OK
var responseStream = resp.Body;
responseStream.Position = 0;
if (responseStream.Length <= cachedResult.Length)
{
responseStream.SetLength(cachedResult.Length);
}
using (var writer = new StreamWriter(responseStream, Encoding.UTF8, 4096, true))
{
Debug.WriteLine("from cache");
writer.Write(cachedResult);
writer.Flush();
responseStream.Flush();
}
context.HttpContext.Response.Headers.Add("CachingMechanism", CacheType.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static Object GetItem(CacheType type)
{
switch (type)
{
case CacheType.TopCatalog:
if (QJVRMSCache.Get(type.ToString()) == null)
{
QJVRMSCache.Insert(type.ToString(), Catalog.GetTopCatalog());
}
break;
case CacheType.AllCatalog:
if (QJVRMSCache.Get(type.ToString()) == null)
{
QJVRMSCache.Insert(type.ToString(), Catalog.GetAllCatalog());
}
break;
case CacheType.Feature:
break;
case CacheType.ResouceType:
if (QJVRMSCache.Get(type.ToString()) == null)
{
QJVRMSCache.Insert(type.ToString(), ResourceTypeManager.GetTypeList());
}
break;
default:
break;
}
return(QJVRMSCache.Get(type.ToString()));
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static Object GetItem(CacheType type)
{
switch (type)
{
case CacheType.TopCatalog:
if (QJVRMSCache.Get(type.ToString()) == null)
{
QJVRMSCache.Insert(type.ToString(), Catalog.GetTopCatalog());
}
break;
case CacheType.AllCatalog:
if (QJVRMSCache.Get(type.ToString()) == null)
{
QJVRMSCache.Insert(type.ToString(), Catalog.GetAllCatalog());
}
break;
case CacheType.Feature:
break;
case CacheType.ResouceType:
if (QJVRMSCache.Get(type.ToString()) == null)
{
QJVRMSCache.Insert(type.ToString(), ResourceTypeManager.GetTypeList());
}
break;
default:
break;
}
return QJVRMSCache.Get(type.ToString());
}
public static async void Invalidate(CacheType cacheType)
{
var file = await _tempFolder.GetFileAsync(cacheType.ToString());
if (file != null)
{
await file.DeleteAsync();
}
}
public string GetContent(string urlEnd, CacheType type, TimeSpan stayInCache)
{
string ret = null;
try
{
Stuff.RemoveInvalidPathSymbols(ref urlEnd);
string dir = Path.Combine(cache, type.ToString()) + Path.DirectorySeparatorChar;
string file = dir + urlEnd;
switch (type)
{
case CacheType.GeocoderCache:
file += ".geo";
break;
case CacheType.PlacemarkCache:
file += ".plc";
break;
case CacheType.RouteCache:
file += ".dragdir";
break;
case CacheType.UrlCache:
file += ".url";
break;
default:
file += ".txt";
break;
}
if (File.Exists(file))
{
var writeTime = File.GetLastWriteTime(file);
if (DateTime.Now - writeTime < stayInCache)
{
using (StreamReader r = new StreamReader(file, Encoding.UTF8))
{
ret = r.ReadToEnd();
}
}
}
}
catch (Exception ex)
{
ret = null;
Debug.WriteLine("GetContent: " + ex);
}
return(ret);
}
public async static Task Save(CacheType cacheType, object data)
{
var file = await _tempFolder.CreateFileAsync(cacheType.ToString(), CreationCollisionOption.ReplaceExisting);
var cache = new CacheItem();
cache.CreatedDate = DateTime.Now;
cache.JsonData = JsonSerializerHelper.Serialize(data);
var json = JsonSerializerHelper.Serialize(cache);
await FileIO.WriteTextAsync(file, json);
}
public void SaveContent(string urlEnd, CacheType type, string content)
{
try
{
Stuff.RemoveInvalidPathSymbols(ref urlEnd);
string dir = Path.Combine(cache, type.ToString()) + Path.DirectorySeparatorChar;
// precrete dir
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
string file = dir + urlEnd;
switch (type)
{
case CacheType.GeocoderCache:
file += ".geo";
break;
case CacheType.PlacemarkCache:
file += ".plc";
break;
case CacheType.RouteCache:
file += ".dragdir";
break;
case CacheType.UrlCache:
file += ".url";
break;
case CacheType.DirectionsCache:
file += ".dir";
break;
default:
file += ".txt";
break;
}
using (StreamWriter writer = new StreamWriter(file, false, Encoding.UTF8))
{
writer.Write(content);
}
}
catch (Exception ex)
{
Debug.WriteLine("SaveContent: " + ex);
}
}
/// <summary>
/// Hash key used by the cache system
/// </summary>
/// <returns>the key's hash</returns>
public string KeyHash()
{
string typeName = ObjectType.Name;
//Normalize interfaces versus classnames
if (ObjectType.IsInterface)
{
typeName = typeName.Substring(1);
}
return(string.Format("{0}_{1}_{2}", CacheType.ToString(), typeName, BirthMark.ToString()));
}
/// <summary>
/// 获取配置
/// </summary>
/// <param name="cacheType"><see cref="CacheType"/>枚举</param>
/// <returns></returns>
public static ItemConfig GetConfig(CacheType cacheType)
{
var name = cacheType.ToString();
if (Configs.ContainsKey(name))
{
return(Configs[name]);
}
return(new ItemConfig {
Level = 0, Minutes = 1
});
}
private void CacheHasBeenInvalidated(CacheType cacheType)
{
if (repositoryManager == null)
{
if (!cacheInvalidationRequests.Contains(cacheType))
{
cacheInvalidationRequests.Add(cacheType);
}
return;
}
Logger.Trace($"CacheInvalidated {cacheType.ToString()}");
switch (cacheType)
{
case CacheType.Branches:
repositoryManager?.UpdateBranches();
break;
case CacheType.GitLog:
repositoryManager?.UpdateGitLog();
break;
case CacheType.GitAheadBehind:
repositoryManager?.UpdateGitAheadBehindStatus();
break;
case CacheType.GitLocks:
if (CurrentRemote != null)
{
repositoryManager?.UpdateLocks();
}
break;
case CacheType.GitUser:
// user handles its own invalidation event
break;
case CacheType.RepositoryInfo:
repositoryManager?.UpdateRepositoryInfo();
break;
case CacheType.GitStatus:
repositoryManager?.UpdateGitStatus();
break;
default:
throw new ArgumentOutOfRangeException(nameof(cacheType), cacheType, null);
}
}
public static async void Invalidate(CacheType cacheType)
{
try
{
var file = await _tempFolder.GetFileAsync(cacheType.ToString());
if (file != null)
{
await file.DeleteAsync();
}
}
catch (FileNotFoundException)
{
}
}
public async static Task <CacheItem> Load <T>(CacheType cacheType)
{
var file = await _tempFolder.CreateFileAsync(cacheType.ToString(), CreationCollisionOption.OpenIfExists);
var fileContent = await FileIO.ReadTextAsync(file);
if (string.IsNullOrEmpty(fileContent))
{
return(null);
}
CacheItem cache = JsonSerializerHelper.Deserialize <CacheItem>(fileContent);
cache.Data = JsonSerializerHelper.Deserialize <T>(cache.JsonData);
return(cache);
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
var cacheSettings = context.HttpContext.RequestServices.GetRequiredService <RedisCacheSettings>();
var logger = context.HttpContext.RequestServices.GetRequiredService <ILogger <CachedAttribute> >();
if (!cacheSettings.Enabled)
{
await next();
return;
}
var key = _getCacheKey(_itemType, _cacheType.ToString().ToLower(), context.HttpContext.Request);
var cache = context.HttpContext.RequestServices.GetRequiredService <IResponseCacheService>();
var cachedResponse = string.Empty;
try {
cachedResponse = await cache.GetCacheResponseAsync(key);
} catch (RedisConnectionException) {
await next();
return;
}
if (!string.IsNullOrEmpty(cachedResponse))
{
logger.LogDebug($"Cache hit: {key}");
var contentResult = new ContentResult {
ContentType = _contentType,
StatusCode = 200,
Content = cachedResponse
};
context.Result = contentResult;
return;
}
logger.LogDebug($"Cache miss: {key}");
var executedContext = await next();
if (executedContext.Result is ContentResult result)
{
await cache.CacheResponseAsync(key, result.Content, TimeSpan.FromSeconds(_ttl));
}
}
private string JoinKey(string cacheId, CacheType cacheType)
{
string cacheKeyPrefix;
switch (cacheType)
{
case CacheType.User:
cacheKeyPrefix = HttpContext.Current.Session.SessionID;
break;
case CacheType.Application:
cacheKeyPrefix = cacheType.ToString();
break;
default:
throw new ArgumentOutOfRangeException("cacheType");
}
return(cacheKeyPrefix + "." + cacheId);
}
private void ExecuteRestoreCacheDataJob()
{
var jobName = CacheType.ToString() + "RestoreCacheDataJob";
var jobGroup = "RestoreCacheDataGroup";
var job = JobBuilder.Create <RestoreCacheDataJob>()
.WithIdentity(jobName, jobGroup)
.UsingJobData("CacheType", (int)CacheType)
.Build();
var triggerName = CacheType.ToString() + "RestoreCacheDataTrigger";
var trigger = TriggerBuilder.Create()
.WithIdentity(triggerName, jobGroup)
.StartNow()
.Build();
var jobManager = Container.Resolve <IJobManager>();
jobManager.ScheduleJob(job, trigger);
}
private ICache <int, int> GetCache(CacheType cacheType, int capacity)
{
switch (cacheType)
{
case CacheType.LRU_ThreadSafe:
return(CacheBuilder.LRU_ThreadSafe <int, int>(capacity));
case CacheType.LRU_Non_ThreadSafe:
return(CacheBuilder.LRU_NonThreadSafe <int, int>(capacity));
case CacheType.MRU_ThreadSafe:
return(CacheBuilder.MRU_ThreadSafe <int, int>(capacity));
case CacheType.MRU_Non_ThreadSafe:
return(CacheBuilder.MRU_NonThreadSafe <int, int>(capacity));
default:
throw new NotSupportedException(cacheType.ToString());
}
}
/// <summary>
/// Hash key used by the cache system
/// </summary>
/// <returns>the key's hash</returns>
public string KeyHash()
{
//Not using type name right now, birthmarks are unique globally anyways
return(string.Format("{0}_{1}", CacheType.ToString(), BirthMark));
}
private string GetCacheKey(HttpRequest req) =>
_includeUrl
? $"{_cacheType}-{req.Path}"
: _cacheType.ToString();
public override string ToString()
{
return(type.ToString() + ":" + id.ToString());
}
public static IEnumerable <string> GetCacheEntries(CacheType cacheType)
{
var cacheDictionary = GetCacheDictionary();
var cacheItems = new List <string>();
var filteredCacheItems = cacheDictionary.Where(x => x.Key.ToString().Contains(cacheType.ToString())).ToList();
foreach (var item in filteredCacheItems[0].Value)
{
cacheItems.Add(item);
}
cacheItems.Sort();
return(cacheItems);
}
public string GetCacheKey(CacheType type) =>
$"podcast|{this.AppUser.Slug}|{this.Slug}|{type.ToString()}";
public static string GetCacheKey(CacheType cacheType, string key)
{
return("{0}_{1}".FormatTo(cacheType.ToString(), key));
}
private ICache<int, int> GetCache(CacheType cacheType, int capacity)
{
switch (cacheType)
{
case CacheType.LRU_ThreadSafe:
return CacheBuilder.LRU_ThreadSafe<int, int>(capacity);
case CacheType.LRU_Non_ThreadSafe:
return CacheBuilder.LRU_NonThreadSafe<int, int>(capacity);
case CacheType.MRU_ThreadSafe:
return CacheBuilder.MRU_ThreadSafe<int, int>(capacity);
case CacheType.MRU_Non_ThreadSafe:
return CacheBuilder.MRU_NonThreadSafe<int, int>(capacity);
default:
throw new NotSupportedException(cacheType.ToString());
}
}
