public override Task <CacheVM> RemoveCacheStartsWith(CacheVM request, ServerCallContext context)
{
var result = GenerateResultObject(request);
if (request.Source == this.Id)
{
return(Task.FromResult(result));
}
if (!String.IsNullOrWhiteSpace(request.Key))
{
lock (lockObj)
{
foreach (var item in cache.ToList())
{
if (item.Key.StartsWith(request.Key))
{
cache.Remove(item.Key);
}
}
}
Task.Run(() => AllocateMemory());
Task.Run(() => nodeSynconizer.DeleteFromNodesStartsWith(request, request.Source));
persister.DeleteCacheBulk(request.Key);
}
return(Task.FromResult(result));
}
public CacheVM TryToGetFromPersistent(string key)
{
CacheVM cachedFileItem = null;
try
{
var cachedFile = Path.Combine(this.CacheFolder, key + ".txt");
if (File.Exists(cachedFile))
{
cachedFileItem = JsonConvert.DeserializeObject <CacheVM>(File.ReadAllText(cachedFile, Encoding.UTF8));
if (cachedFileItem != null)
{
if (cachedFileItem.ExpiresAt.ToDateTime() < DateTime.UtcNow)
{
lock (lockObj)
{
File.Delete(cachedFile);
}
}
else
{
//AddToMemoryCache(cachedFileItem);
}
}
}
}
finally
{
}
return(cachedFileItem);
}
public override Task <CacheVM> GetCache(CacheVM request, ServerCallContext context)
{
if (!String.IsNullOrWhiteSpace(request.Key))
{
CacheVM cachedContent = null;
cache.TryGetValue(request.Key, out cachedContent);
if (cachedContent != null && cachedContent.ExpiresAt.ToDateTime() < DateTime.UtcNow)
{
lock (lockObj)
{
cache.Remove(cachedContent.Key);
}
Task.Run(() => AllocateMemory());
}
//for persistent mode
if (cachedContent == null)
{
cachedContent = persister.TryToGetFromPersistent(request.Key);
if (cachedContent != null)
{
AddToMemoryCache(cachedContent);
}
}
return(Task.FromResult(cachedContent));
}
return(Task.FromResult(new CacheVM {
Succeed = false
}));
}
public override Task <CacheVM> SetCache(CacheVM request, ServerCallContext context)
{
var result = GenerateResultObject(request);
try
{
if (request.Source != null && request.Source == this.Id)
{
return(Task.FromResult(result));
}
if (request != null && !String.IsNullOrWhiteSpace(request.Key))
{
AddToMemoryCache(request);
Task.Run(() => persister.AddToPersistentCache(request));
Task.Run(() => nodeSynconizer.AddToNodes(request, request.Source));
Task.Run(() => AllocateMemory());
}
}
catch (Exception)
{
result.Succeed = false;
return(Task.FromResult(result));
}
return(Task.FromResult(result));
}
private static CacheVM GenerateResultObject(CacheVM request)
{
return(new CacheVM
{
ExpiresAt = request.ExpiresAt,
Key = request.Key,
Succeed = true
});
}
public void DeleteFromAllNodes(CacheVM cacheSource, string fromNode)
{
if (fromNode == null)
{
foreach (var node in this.nodes)
{
node.ClearAllCache(currentNodeId);
}
}
}
public void DeleteFromNodesStartsWith(CacheVM cacheToRemove, string fromNode)
{
if (fromNode == null)
{
foreach (var node in this.nodes)
{
node.RemoveKeyStartsWith(cacheToRemove.Key, fromNode);
}
}
}
public void AddToNodes(CacheVM cacheForTheSet, string fromNode)
{
if (fromNode == null)//check if it sub request for infinite loop
{
foreach (var node in this.nodes.Where(c => c.Id != this.currentNodeId))
{
node.Set <string>(cacheForTheSet.Key, cacheForTheSet.Value, cacheForTheSet.ExpiresAt.ToDateTime(), fromNode: currentNodeId);
}
}
}
public void DeleteFromNodes(CacheVM cacheToRemove, string fromNode)
{
if (fromNode == null)//check if it sub request for infinite loop
{
foreach (var node in this.nodes)
{
node.Remove(cacheToRemove.Key, currentNodeId);
}
}
}
public override Task <AllItemsReponse> GetAll(CacheVM request, ServerCallContext context)
{
var result = new AllItemsReponse();
foreach (var item in cache)
{
result.Items.Add(item.Value);
}
return(Task.FromResult(result));
}
public override Task <KeyResponse> GetKeys(CacheVM request, ServerCallContext context)
{
var result = new KeyResponse();
foreach (var item in cache)
{
result.Keys.Add(item.Key);
}
return(Task.FromResult(result));
}
public void AddToPersistentCache(CacheVM item)
{
try
{
lock (lockObj)
{
File.WriteAllText(Path.Combine(this.CacheFolder, item.Key + ".txt"), JsonConvert.SerializeObject(item), Encoding.UTF8);
}
}
finally
{
}
}
private void AddToMemoryCache(CacheVM cacheForTheSet)
{
lock (lockObj)
{
if (cache.ContainsKey(cacheForTheSet.Key))
{
cache.Remove(cacheForTheSet.Key);
}
;
cache.Add(cacheForTheSet.Key, cacheForTheSet);
}
}
public override Task <CacheVM> RemoveCache(CacheVM request, ServerCallContext context)
{
var result = GenerateResultObject(request);
if (request.Source == this.Id)
{
return(Task.FromResult(result));
}
if (request != null && !String.IsNullOrWhiteSpace(request.Key))
{
cache.Remove(request.Key);
persister.DeleteCache(request.Key);
nodeSynconizer.DeleteFromNodes(request, request.Source);
}
return(Task.FromResult(result));
}
public override Task <CacheVM> RemoveAllCache(CacheVM request, ServerCallContext context)
{
var result = GenerateResultObject(request);
if (request.Source == this.Id)
{
return(Task.FromResult(result));
}
lock (lockObj)
{
cache = new Dictionary <string, CacheVM>();
}
Task.Run(() => GC.Collect());
persister.DeleteCacheBulk();
Task.Run(() => nodeSynconizer.DeleteFromAllNodes(request, request.Source));
return(Task.FromResult(result));
}
public override Task <CacheVM> Flush(CacheVM request, ServerCallContext context)
{
return(RemoveAllCache(request, context));
}
