internal static bool IsCachedEntityExpiresInTheFuture(HTTPRequest request)
{
if (!IsSupported)
{
return(false);
}
CheckSetup();
HTTPCacheFileInfo info = null;
rwLock.EnterReadLock();
try
{
if (!library.TryGetValue(request.CurrentUri, out info))
{
return(false);
}
}
finally
{
rwLock.ExitReadLock();
}
return(info.WillExpireInTheFuture());
}
internal static HTTPCacheFileInfo Store(Uri uri, HTTPMethods method, HTTPResponse response)
{
if (response == null || response.Data == null || response.Data.Length == 0)
{
return(null);
}
HTTPCacheFileInfo hTTPCacheFileInfo = null;
Dictionary <Uri, HTTPCacheFileInfo> obj = HTTPCacheService.Library;
lock (obj)
{
if (!HTTPCacheService.Library.TryGetValue(uri, out hTTPCacheFileInfo))
{
HTTPCacheService.Library.Add(uri, hTTPCacheFileInfo = new HTTPCacheFileInfo(uri));
}
try
{
hTTPCacheFileInfo.Store(response);
}
catch
{
HTTPCacheService.DeleteEntity(uri, true);
throw;
}
}
return(hTTPCacheFileInfo);
}
internal static HTTPResponse GetFullResponse(HTTPRequest request)
{
if (!IsSupported)
{
return(null);
}
CheckSetup();
HTTPCacheFileInfo info = null;
rwLock.EnterReadLock();
try
{
if (!library.TryGetValue(request.CurrentUri, out info))
{
return(null);
}
}
finally
{
rwLock.ExitReadLock();
}
return(info.ReadResponseTo(request));
}
internal static bool IsCachedEntityExpiresInTheFuture(HTTPRequest request)
{
if (!IsSupported || request.DisableCache)
{
return(false);
}
CheckSetup();
HTTPCacheFileInfo info = null;
rwLock.EnterReadLock();
try
{
if (!library.TryGetValue(request.CurrentUri, out info))
{
return(false);
}
}
finally
{
rwLock.ExitReadLock();
}
return(info.WillExpireInTheFuture(request.State == HTTPRequestStates.ConnectionTimedOut ||
request.State == HTTPRequestStates.TimedOut ||
request.State == HTTPRequestStates.Error ||
(request.State == HTTPRequestStates.Finished && request.Response != null && request.Response.StatusCode >= 500)));
}
internal static System.IO.Stream PrepareStreamed(Uri uri, HTTPResponse response)
{
if (!IsSupported)
{
return(null);
}
HTTPCacheFileInfo info;
lock (Library)
{
if (!Library.TryGetValue(uri, out info))
{
Library.Add(uri, info = new HTTPCacheFileInfo(uri));
UsedIndexes.Add(info.MappedNameIDX, info);
}
try
{
return(info.GetSaveStream(response));
}
catch
{
// If something happens while we write out the response, than we will delete it because it might be in an invalid state.
DeleteEntity(uri);
throw;
}
}
}
internal static Stream PrepareStreamed(Uri uri, HTTPResponse response)
{
lock (Library)
{
if (!Library.TryGetValue(uri, out HTTPCacheFileInfo value))
{
Library.Add(uri, value = new HTTPCacheFileInfo(uri));
}
try
{
return(value.GetSaveStream(response));
IL_003e:
Stream result;
return(result);
}
catch (Exception ex)
{
DeleteEntity(uri);
throw ex;
IL_004c:
Stream result;
return(result);
}
}
}
/// <summary>
/// Utility function to set the cache control headers according to the spec.: http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.3.4
/// </summary>
/// <param name="request"></param>
internal static void SetHeaders(HTTPRequest request)
{
if (!IsSupported)
{
return;
}
CheckSetup();
request.RemoveHeader("If-None-Match");
request.RemoveHeader("If-Modified-Since");
HTTPCacheFileInfo info = null;
rwLock.EnterReadLock();
try
{
if (!library.TryGetValue(request.CurrentUri, out info))
{
return;
}
}
finally
{
rwLock.ExitReadLock();
}
info.SetUpRevalidationHeaders(request);
}
internal static HTTPCacheFileInfo Store(Uri uri, HTTPMethods method, HTTPResponse response)
{
if (response == null || response.Data == null || response.Data.Length == 0)
{
return(null);
}
HTTPCacheFileInfo info = null;
lock (Library)
{
if (!Library.TryGetValue(uri, out info))
{
Library.Add(uri, info = new HTTPCacheFileInfo(uri));
}
try
{
info.Store(response);
}
catch
{
// If something happens while we write out the response, than we will delete it becouse it might be in an invalid state.
DeleteEntity(uri);
throw;
}
}
return(info);
}
internal static HTTPCacheFileInfo GetEntity(Uri uri)
{
if (!IsSupported)
{
return(null);
}
HTTPCacheFileInfo info = null;
lock (Library)
Library.TryGetValue(uri, out info);
return(info);
}
internal static void SetBodyLength(Uri uri, int bodyLength)
{
lock (Library)
{
if (Library.TryGetValue(uri, out HTTPCacheFileInfo value))
{
value.BodyLength = bodyLength;
}
else
{
Library.Add(uri, value = new HTTPCacheFileInfo(uri, DateTime.UtcNow, bodyLength));
}
}
}
internal static HTTPCacheFileInfo Store(HTTPRequest request, HTTPMethods method, HTTPResponse response)
{
if (response == null || response.Data == null || response.Data.Length == 0)
{
return(null);
}
if (!IsSupported)
{
return(null);
}
Uri cacheUri;
if (request.CacheUriBuilder != null)
{
cacheUri = request.CacheUriBuilder.BuildCacheUri(request.CurrentUri);
}
else
{
cacheUri = request.CurrentUri;
}
HTTPCacheFileInfo info = null;
lock (Library)
{
if (!Library.TryGetValue(cacheUri, out info))
{
Library.Add(cacheUri, info = new HTTPCacheFileInfo(cacheUri));
UsedIndexes.Add(info.MappedNameIDX, info);
}
try
{
info.Store(response);
}
catch
{
// If something happens while we write out the response, than we will delete it becouse it might be in an invalid state.
DeleteEntity(cacheUri);
throw;
}
}
return(info);
}
internal static HTTPCacheFileInfo Store(Uri uri, HTTPMethods method, HTTPResponse response)
{
if (response == null || response.Data == null || response.Data.Length == 0)
{
return(null);
}
if (!IsSupported)
{
return(null);
}
CheckSetup();
HTTPCacheFileInfo info = null;
rwLock.EnterWriteLock();
try
{
if (!library.TryGetValue(uri, out info))
{
library.Add(uri, info = new HTTPCacheFileInfo(uri));
UsedIndexes.Add(info.MappedNameIDX, info);
}
}
finally
{
rwLock.ExitWriteLock();
}
try
{
info.Store(response);
if (HTTPManager.Logger.Level == Logger.Loglevels.All)
{
HTTPManager.Logger.Verbose("HTTPCacheService", string.Format("{0} - Saved to cache", uri.ToString()));
}
}
catch
{
// If something happens while we write out the response, than we will delete it because it might be in an invalid state.
DeleteEntity(uri);
throw;
}
return(info);
}
internal static void SetBodyLength(Uri uri, int bodyLength)
{
lock (Library)
{
HTTPCacheFileInfo fileInfo;
if (Library.TryGetValue(uri, out fileInfo))
{
fileInfo.BodyLength = bodyLength;
}
else
{
Library.Add(uri, fileInfo = new HTTPCacheFileInfo(uri, DateTime.UtcNow, bodyLength));
}
}
}
internal static void SetBodyLength(Uri uri, int bodyLength)
{
Dictionary <Uri, HTTPCacheFileInfo> obj = HTTPCacheService.Library;
lock (obj)
{
HTTPCacheFileInfo hTTPCacheFileInfo;
if (HTTPCacheService.Library.TryGetValue(uri, out hTTPCacheFileInfo))
{
hTTPCacheFileInfo.BodyLength = bodyLength;
}
else
{
HTTPCacheService.Library.Add(uri, hTTPCacheFileInfo = new HTTPCacheFileInfo(uri, DateTime.UtcNow, bodyLength));
}
}
}
static int get_CacheFileInfo(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
BestHTTP.HTTPResponse obj = (BestHTTP.HTTPResponse)o;
BestHTTP.Caching.HTTPCacheFileInfo ret = obj.CacheFileInfo;
ToLua.PushObject(L, ret);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o, "attempt to index CacheFileInfo on a nil value"));
}
}
internal static void SetUpCachingValues(Uri uri, HTTPResponse response)
{
if (!IsSupported)
{
return;
}
CheckSetup();
rwLock.EnterWriteLock();
try
{
HTTPCacheFileInfo info = null;
if (!library.TryGetValue(uri, out info))
{
library.Add(uri, info = new HTTPCacheFileInfo(uri));
UsedIndexes.Add(info.MappedNameIDX, info);
}
try
{
info.SetUpCachingValues(response);
if (HTTPManager.Logger.Level == Logger.Loglevels.All)
{
HTTPManager.Logger.Verbose("HTTPCacheService", string.Format("{0} - SetUpCachingValues done!", uri.ToString()));
}
}
catch
{
// If something happens while we write out the response, than we will delete it because it might be in an invalid state.
DeleteEntityImpl(uri);
throw;
}
}
finally
{
rwLock.ExitWriteLock();
}
}
internal static void Store(Uri uri, HTTPMethods method, HTTPResponse response)
{
if (response != null && response.Data != null && response.Data.Length != 0)
{
lock (Library)
{
if (!Library.TryGetValue(uri, out HTTPCacheFileInfo value))
{
Library.Add(uri, value = new HTTPCacheFileInfo(uri));
}
try
{
value.Store(response);
}
catch (Exception ex)
{
DeleteEntity(uri);
throw ex;
IL_0065 :;
}
}
}
}
internal static HTTPCacheFileInfo GetEntity(Uri uri)
{
if (!IsSupported)
{
return(null);
}
CheckSetup();
HTTPCacheFileInfo info = null;
rwLock.EnterReadLock();
try
{
library.TryGetValue(uri, out info);
}
finally
{
rwLock.ExitReadLock();
}
return(info);
}
internal static Stream PrepareStreamed(Uri uri, HTTPResponse response)
{
Dictionary <Uri, HTTPCacheFileInfo> obj = HTTPCacheService.Library;
Stream saveStream;
lock (obj)
{
HTTPCacheFileInfo hTTPCacheFileInfo;
if (!HTTPCacheService.Library.TryGetValue(uri, out hTTPCacheFileInfo))
{
HTTPCacheService.Library.Add(uri, hTTPCacheFileInfo = new HTTPCacheFileInfo(uri));
}
try
{
saveStream = hTTPCacheFileInfo.GetSaveStream(response);
}
catch
{
HTTPCacheService.DeleteEntity(uri, true);
throw;
}
}
return(saveStream);
}
internal static void SetBodyLength(Uri uri, int bodyLength)
{
if (!IsSupported)
{
return;
}
CheckSetup();
rwLock.EnterUpgradeableReadLock();
try
{
HTTPCacheFileInfo fileInfo;
if (library.TryGetValue(uri, out fileInfo))
{
fileInfo.BodyLength = bodyLength;
}
else
{
rwLock.EnterWriteLock();
try
{
library.Add(uri, fileInfo = new HTTPCacheFileInfo(uri, DateTime.UtcNow, bodyLength));
UsedIndexes.Add(fileInfo.MappedNameIDX, fileInfo);
}
finally
{
rwLock.ExitWriteLock();
}
}
}
finally
{
rwLock.ExitUpgradeableReadLock();
}
}
public static void BeginMaintainence(HTTPCacheMaintananceParams maintananceParam)
{
if (maintananceParam == null)
{
throw new ArgumentNullException("maintananceParams == null");
}
if (HTTPCacheService.InMaintainenceThread)
{
return;
}
HTTPCacheService.InMaintainenceThread = true;
HTTPCacheService.SetupCacheFolder();
new Thread(delegate(object param)
{
try
{
Dictionary <Uri, HTTPCacheFileInfo> obj = HTTPCacheService.Library;
lock (obj)
{
DateTime t = DateTime.UtcNow - maintananceParam.DeleteOlder;
List <Uri> list = new List <Uri>();
foreach (KeyValuePair <Uri, HTTPCacheFileInfo> current in HTTPCacheService.Library)
{
if (current.Value.LastAccess < t && HTTPCacheService.DeleteEntity(current.Key, false))
{
list.Add(current.Key);
}
}
for (int i = 0; i < list.Count; i++)
{
HTTPCacheService.Library.Remove(list[i]);
}
list.Clear();
ulong num = HTTPCacheService.GetCacheSize();
if (num > maintananceParam.MaxCacheSize)
{
List <HTTPCacheFileInfo> list2 = new List <HTTPCacheFileInfo>(HTTPCacheService.library.Count);
foreach (KeyValuePair <Uri, HTTPCacheFileInfo> current2 in HTTPCacheService.library)
{
list2.Add(current2.Value);
}
list2.Sort();
int num2 = 0;
while (num >= maintananceParam.MaxCacheSize && num2 < list2.Count)
{
try
{
HTTPCacheFileInfo hTTPCacheFileInfo = list2[num2];
ulong num3 = (ulong)((long)hTTPCacheFileInfo.BodyLength);
HTTPCacheService.DeleteEntity(hTTPCacheFileInfo.Uri, true);
num -= num3;
}
catch
{
}
finally
{
num2++;
}
}
}
}
}
finally
{
HTTPCacheService.SaveLibrary();
HTTPCacheService.InMaintainenceThread = false;
}
}).Start();
}
private static void LoadLibrary()
{
// Already loaded?
if (library != null)
{
return;
}
if (!IsSupported)
{
return;
}
int version = 1;
rwLock.EnterWriteLock();
library = new Dictionary <Uri, HTTPCacheFileInfo>(new UriComparer());
try
{
using (var fs = HTTPManager.IOService.CreateFileStream(LibraryPath, FileStreamModes.Open))
using (var br = new System.IO.BinaryReader(fs))
{
version = br.ReadInt32();
if (version > 1)
{
NextNameIDX = br.ReadUInt64();
}
int statCount = br.ReadInt32();
for (int i = 0; i < statCount; ++i)
{
Uri uri = new Uri(br.ReadString());
var entity = new HTTPCacheFileInfo(uri, br, version);
if (entity.IsExists())
{
library.Add(uri, entity);
if (version > 1)
{
UsedIndexes.Add(entity.MappedNameIDX, entity);
}
}
}
}
}
catch
{ }
finally
{
rwLock.ExitWriteLock();
}
if (version == 1)
{
BeginClear();
}
else
{
DeleteUnusedFiles();
}
}
public static void BeginMaintainence(HTTPCacheMaintananceParams maintananceParams)
{
if (maintananceParams == null)
{
throw new ArgumentNullException("maintananceParams == null");
}
if (!InMaintainenceThread)
{
InMaintainenceThread = true;
SetupCacheFolder();
ThreadPool.QueueUserWorkItem(delegate(object maintananceParam)
{
HTTPCacheMaintananceParams hTTPCacheMaintananceParams = maintananceParam as HTTPCacheMaintananceParams;
try
{
lock (Library)
{
DateTime t = DateTime.UtcNow - hTTPCacheMaintananceParams.DeleteOlder;
foreach (KeyValuePair <Uri, HTTPCacheFileInfo> item in Library)
{
if (item.Value.LastAccess < t)
{
DeleteEntity(item.Key);
}
}
ulong num = GetCacheSize();
if (num > hTTPCacheMaintananceParams.MaxCacheSize)
{
List <HTTPCacheFileInfo> list = new List <HTTPCacheFileInfo>(library.Count);
foreach (KeyValuePair <Uri, HTTPCacheFileInfo> item2 in library)
{
list.Add(item2.Value);
}
list.Sort();
int num2 = 0;
while (num >= hTTPCacheMaintananceParams.MaxCacheSize && num2 < list.Count)
{
try
{
HTTPCacheFileInfo hTTPCacheFileInfo = list[num2];
ulong num3 = (ulong)hTTPCacheFileInfo.BodyLength;
DeleteEntity(hTTPCacheFileInfo.Uri);
num -= num3;
}
catch
{
}
finally
{
num2++;
}
}
}
}
}
finally
{
SaveLibrary();
InMaintainenceThread = false;
}
}, maintananceParams);
}
}
