public void SetNotFound(string url, bool aggressivelyCached)
{
var flag = aggressivelyCached ? ItemFlags.AggressivelyCached : ItemFlags.None;
var httpCacheItem = new HttpCacheItem
{
ChangeVector = "404 Response",
Ptr = null,
Size = 0,
Allocation = null,
Cache = this,
Generation = Generation,
Flags = ItemFlags.NotFound | flag
};
HttpCacheItem old = null;
_items.AddOrUpdate(url, httpCacheItem, (s, oldItem) =>
{
old = oldItem;
return(httpCacheItem);
});
//We need to check if the cache is been disposed after the item was added otherwise we will run into another race condition
//where it started been disposed right after we checked it and before we managed to insert the new cache item.
if (_disposing)
{
//We might have double release here but we have a protection for that.
httpCacheItem.ReleaseRef();
}
old?.ReleaseRef();
}
public unsafe void Set(string url, long etag, BlittableJsonReaderObject result)
{
var mem = _unmanagedBuffersPool.Allocate(result.Size);
result.CopyTo((byte *)mem.Address);
if (Interlocked.Add(ref _totalSize, result.Size) > _maxSize)
{
if (_cleanupTask == null)
{
var cleanup = new Task(FreeSpace);
if (Interlocked.CompareExchange(ref _cleanupTask, cleanup, null) == null)
{
cleanup.ContinueWith(_ => Interlocked.Exchange(ref _cleanupTask, null));
cleanup.Start();
}
}
}
var httpCacheItem = new HttpCacheItem
{
Usages = 1,
Etag = etag,
Ptr = (byte *)mem.Address,
Size = result.Size,
Allocation = mem,
LastServerUpdate = SystemTime.UtcNow,
Cache = this,
};
_items.AddOrUpdate(url, httpCacheItem, (s, oldItem) =>
{
oldItem.Release();
return(httpCacheItem);
});
}
public unsafe void Set(string url, string changeVector, BlittableJsonReaderObject result)
{
var mem = _unmanagedBuffersPool.Allocate(result.Size);
result.CopyTo(mem.Address);
if (Interlocked.Add(ref _totalSize, result.Size) > _maxSize && _isFreeSpaceRunning.Raise())
{
Task.Run(() => FreeSpace());
}
var httpCacheItem = new HttpCacheItem
{
Usages = 1,
ChangeVector = changeVector,
Ptr = mem.Address,
Size = result.Size,
Allocation = mem,
LastServerUpdate = SystemTime.UtcNow,
Cache = this,
Generation = Generation
};
_items.AddOrUpdate(url, httpCacheItem, (s, oldItem) =>
{
oldItem.Release();
return(httpCacheItem);
});
}
public void Dispose()
{
if (Item != null)
{
Item.Release();
Item = null;
}
}
/// <summary>如果符合缓存条件，则设置缓存</summary>
/// <param name="entity"></param>
/// <param name="e"></param>
/// <returns></returns>
protected virtual Boolean SetCache(HttpHeader entity, ReceivedEventArgs e)
{
// 既然是新响应，那么需要首先重置缓存项
cacheItem = null;
var request = Request;
var response = entity;
if (request == null || response == null)
{
return(false);
}
var pxy = Host as HttpProxy;
var cache = pxy.Cache;
if (request.Method.EqualIgnoreCase("GET"))
{
if (response.StatusCode == 304)
{
response.Headers["HttpProxyCache"] = "304";
cacheItem = cache.Add(request, response);
return(true);
}
var url = request.RawUrl;
if (!String.IsNullOrEmpty(url) && url[url.Length - 1] != '/' && cacheSuffix.Contains(Path.GetExtension(url)))
{
response.Headers["HttpProxyCache"] = Path.GetExtension(url);
cacheItem = cache.Add(request, response);
return(true);
}
var contentType = response.ContentType;
if (!String.IsNullOrEmpty(contentType))
{
var p = contentType.IndexOf(";");
if (p < 0 || cacheContentType.Contains(contentType.Substring(0, p)))
{
response.Headers["HttpProxyCache"] = contentType;
cacheItem = cache.Add(request, response);
return(true);
}
}
}
return(false);
}
public void SetNotFound(string url)
{
var httpCacheItem = new HttpCacheItem
{
Usages = 1,
ChangeVector = "404 Response",
Ptr = null,
Size = 0,
Allocation = null,
LastServerUpdate = SystemTime.UtcNow,
Cache = this,
Generation = Generation
};
_items.AddOrUpdate(url, httpCacheItem, (s, oldItem) =>
{
oldItem.Release();
return(httpCacheItem);
});
}
public unsafe void Set(string url, string changeVector, BlittableJsonReaderObject result)
{
#if DEBUG
result.BlittableValidation();
#endif
var mem = _unmanagedBuffersPool.Allocate(result.Size);
result.CopyTo(mem.Address);
if (Interlocked.Add(ref _totalSize, result.Size) > _maxSize)
{
if (_isFreeSpaceRunning == false)
{
Task.Run(FreeSpace);
}
}
var httpCacheItem = new HttpCacheItem
{
ChangeVector = changeVector,
Ptr = mem.Address,
Size = result.Size,
Allocation = mem,
Cache = this,
Generation = Generation
};
HttpCacheItem old = null;
_items.AddOrUpdate(url, httpCacheItem, (s, oldItem) =>
{
old = oldItem;
return(httpCacheItem);
});
//We need to check if the cache is been disposed after the item was added otherwise we will run into another race condition
//where it started been disposed right after we checked it and before we managed to insert the new cache item.
if (_disposing)
{
//We might have double release here but we have a protection for that.
httpCacheItem.ReleaseRef();
}
old?.ReleaseRef();
}
public ReleaseCacheItem(HttpCacheItem item)
{
Item = item;
_cacheGeneration = item.Cache.Generation;
}
public ReleaseCacheItem(HttpCacheItem item)
{
Item = item;
}
