private async Task OnMessageAsync(InvalidateCache message)
{
if (!String.IsNullOrEmpty(message.CacheId) && String.Equals(_cacheId, message.CacheId))
{
return;
}
_logger.Trace("Invalidating local cache from remote: id={0} keys={1}", message.CacheId, String.Join(",", message.Keys ?? new string[] { }));
Interlocked.Increment(ref _invalidateCacheCalls);
if (message.FlushAll)
{
await _localCache.RemoveAllAsync().AnyContext();
_logger.Trace("Fushed local cache");
}
else if (message.Keys != null && message.Keys.Length > 0)
{
foreach (var pattern in message.Keys.Where(k => k.EndsWith("*")))
{
await _localCache.RemoveByPrefixAsync(pattern.Substring(0, pattern.Length - 1)).AnyContext();
}
await _localCache.RemoveAllAsync(message.Keys.Where(k => !k.EndsWith("*"))).AnyContext();
_logger.Trace("Removed keys from local cache");
}
else
{
_logger.Warn("Unknown invalidate cache message");
}
}
public void Initialize()
{
OnBeforeDatabaseAccess();
if (Initializing == null)
{
return;
}
if (InvalidateCache != null)
{
foreach (var ic in InvalidateCache.GetInvocationListTyped())
{
using (HeavyProfiler.Log("InvalidateCache", () => ic.Method.DeclaringType !.ToString()))
ic();
}
}
using (ExecutionMode.Global())
foreach (var init in Initializing.GetInvocationListTyped())
{
using (HeavyProfiler.Log("Initialize", () => init.Method.DeclaringType !.ToString()))
init();
}
Initializing = null;
}
private Task OnRemoteCacheItemExpiredAsync(InvalidateCache message)
{
if (!String.IsNullOrEmpty(message.CacheId) && String.Equals(_cacheId, message.CacheId))
{
return(Task.CompletedTask);
}
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("Invalidating local cache from remote: id={CacheId} expired={Expired} keys={Keys}", message.CacheId, message.Expired, String.Join(",", message.Keys ?? new string[] { }));
}
Interlocked.Increment(ref _invalidateCacheCalls);
if (message.FlushAll)
{
_logger.LogTrace("Flushed local cache");
return(_localCache.RemoveAllAsync());
}
if (message.Keys != null && message.Keys.Length > 0)
{
var tasks = new List <Task>(message.Keys.Length);
var keysToRemove = new List <string>(message.Keys.Length);
foreach (string key in message.Keys)
{
if (message.Expired)
{
tasks.Add(_localCache.RemoveExpiredKeyAsync(key, false));
}
else if (key.EndsWith("*"))
{
tasks.Add(_localCache.RemoveByPrefixAsync(key.Substring(0, key.Length - 1)));
}
else
{
keysToRemove.Add(key);
}
}
if (keysToRemove.Count > 0)
{
tasks.Add(_localCache.RemoveAllAsync(keysToRemove));
}
return(Task.WhenAll(tasks));
}
_logger.LogWarning("Unknown invalidate cache message");
return(Task.CompletedTask);
}
private async Task OnRemoteCacheItemExpiredAsync(InvalidateCache message)
{
if (!String.IsNullOrEmpty(message.CacheId) && String.Equals(_cacheId, message.CacheId))
{
return;
}
_logger.Trace(() => String.Format("Invalidating local cache from remote: id={0} expired={1} keys={2}", message.CacheId, message.Expired, String.Join(",", message.Keys ?? new string[] { })));
Interlocked.Increment(ref _invalidateCacheCalls);
if (message.FlushAll)
{
await _localCache.RemoveAllAsync().AnyContext();
_logger.Trace("Fushed local cache");
}
else if (message.Keys != null && message.Keys.Length > 0)
{
var keysToRemove = new List <string>(message.Keys.Length);
foreach (string key in message.Keys)
{
if (message.Expired)
{
await _localCache.RemoveExpiredKeyAsync(key, false).AnyContext();
}
else if (key.EndsWith("*"))
{
await _localCache.RemoveByPrefixAsync(key.Substring(0, key.Length - 1)).AnyContext();
}
else
{
keysToRemove.Add(key);
}
}
int results = await _localCache.RemoveAllAsync(keysToRemove).AnyContext();
_logger.Trace("Removed {0} keys from local cache", results);
}
else
{
_logger.Warn("Unknown invalidate cache message");
}
}
private void OnMessage(InvalidateCache message)
{
if (!String.IsNullOrEmpty(message.CacheId) && String.Equals(_cacheId, message.CacheId))
{
return;
}
if (message.FlushAll)
{
_localCache.FlushAll();
}
else if (message.Keys != null && message.Keys.Length > 0)
{
_localCache.RemoveAll(message.Keys);
}
else
{
Debug.Assert(false, "Unknown invalidate cache message");
}
}
private void OnMessage(InvalidateCache message)
{
if (!String.IsNullOrEmpty(message.CacheId) && String.Equals(_cacheId, message.CacheId))
{
return;
}
Log.Trace().Message("Invalidating local cache from remote: id={0} keys={1}", message.CacheId, String.Join(",", message.Keys ?? new string[] { })).Write();
Interlocked.Increment(ref _invalidateCacheCalls);
if (message.FlushAll)
{
_localCache.FlushAll();
}
else if (message.Keys != null && message.Keys.Length > 0)
{
_localCache.RemoveAll(message.Keys);
}
else
{
Log.Warn().Message("Unknown invalidate cache message").Write();
}
}
