public static async IAsyncEnumerable <string> GetAllKeysAsync(this ICacheClientAsync cache)
{
await foreach (var key in cache.GetKeysByPatternAsync("*"))
{
yield return(key);
}
}
public static async IAsyncEnumerable <string> GetKeysStartingWithAsync(this ICacheClientAsync cache, string prefix)
{
await foreach (var key in cache.GetKeysByPatternAsync(prefix + "*"))
{
yield return(key);
}
}
public static async Task <T> GetOrCreateSessionAsync <T>(ICacheClientAsync cache = null, IRequest httpReq = null, IResponse httpRes = null, CancellationToken token = default)
{
if (httpReq == null)
{
httpReq = HostContext.GetCurrentRequest();
}
var iSession = await httpReq.GetSessionAsync(reload : false, token).ConfigAwait();
if (iSession is T variable)
{
return(variable);
}
var sessionId = httpReq.GetSessionId();
var sessionKey = GetSessionKey(sessionId);
if (sessionKey != null)
{
var session = await(cache ?? httpReq.GetCacheClientAsync()).GetAsync <T>(sessionKey, token).ConfigAwait();
if (!Equals(session, default(T)))
{
return((T)HostContext.AppHost.OnSessionFilter(httpReq, (IAuthSession)session, sessionId));
}
}
return((T)CreateNewSession(httpReq, sessionId));
}
/// <summary>
/// Removes items from the cache based on the specified regular expression pattern
/// </summary>
/// <param name="cacheClient">Cache client</param>
/// <param name="regex">Regular expression pattern to search cache keys</param>
public static Task RemoveByRegexAsync(this ICacheClientAsync cacheClient, string regex)
{
if (!(cacheClient is IRemoveByPatternAsync canRemoveByPattern))
{
throw new NotImplementedException("IRemoveByPattern is not implemented by: " + cacheClient.GetType().FullName);
}
return(canRemoveByPattern.RemoveByRegexAsync(regex));
}
public async Task OnBeforeEachTest()
{
if (cacheClient is object)
{
await cacheClient.DisposeAsync();
}
cacheClient = new RedisClient(TestConfig.SingleHost);
await cacheClient.FlushAllAsync();
}
/// <summary>
/// Removes items from cache that have keys matching the specified wildcard pattern
/// </summary>
/// <param name="cacheClient">Cache client</param>
/// <param name="pattern">The wildcard, where "*" means any sequence of characters and "?" means any single character.</param>
/// <param name="token"></param>
public static Task RemoveByPatternAsync(this ICacheClientAsync cacheClient, string pattern, CancellationToken token = default)
{
if (!(cacheClient is IRemoveByPatternAsync canRemoveByPattern))
{
throw new NotImplementedException(
"IRemoveByPattern is not implemented on: " + cacheClient.GetType().FullName);
}
return(canRemoveByPattern.RemoveByPatternAsync(pattern, token));
}
public static async Task CacheSetAsync <T>(this ICacheClientAsync cache, string key, T value, TimeSpan?expiresIn, CancellationToken token = default)
{
if (expiresIn.HasValue)
{
await cache.SetAsync(key, value, expiresIn.Value, token).ConfigAwait();
}
else
{
await cache.SetAsync(key, value, token).ConfigAwait();
}
}
public static async Task SetAsync <T>(this ICacheClientAsync cache, string cacheKey, T value, TimeSpan?expireCacheIn, CancellationToken token = default)
{
if (expireCacheIn.HasValue)
{
await cache.SetAsync(cacheKey, value, expireCacheIn.Value, token);
}
else
{
await cache.SetAsync(cacheKey, value, token);
}
}
public static async Task <T> GetOrCreateAsync <T>(this ICacheClientAsync cache,
string key, TimeSpan expiresIn, Func <Task <T> > createFn)
{
var value = await cache.GetAsync <T>(key);
if (Equals(value, default(T)))
{
value = await createFn().ConfigAwait();
await cache.SetAsync(key, value, expiresIn);
}
return(value);
}
/// <summary>
/// Returning the most optimized result based on the MimeType and CompressionType from the IRequest.
/// <param name="expireCacheIn">How long to cache for, null is no expiration</param>
/// </summary>
public static async Task <object> ToOptimizedResultUsingCacheAsync <T>(
this IRequest req, ICacheClientAsync cacheClient, string cacheKey,
TimeSpan?expireCacheIn, Func <T> factoryFn, CancellationToken token = default)
{
var cacheResult = await cacheClient.ResolveFromCacheAsync(cacheKey, req, token).ConfigAwait();
if (cacheResult != null)
{
return(cacheResult);
}
cacheResult = await cacheClient.CacheAsync(cacheKey, factoryFn(), req, expireCacheIn, token).ConfigAwait();
return(cacheResult);
}
public static async Task <ValidCache> HasValidCacheAsync(this ICacheClientAsync cache, IRequest req, string cacheKey, DateTime?checkLastModified,
CancellationToken token = default)
{
if (!HostContext.GetPlugin <HttpCacheFeature>().ShouldAddLastModifiedToOptimizedResults())
{
return(ValidCache.NotValid);
}
var ticks = await cache.GetAsync <long>(DateCacheKey(cacheKey), token).ConfigAwait();
if (ticks > 0)
{
if (checkLastModified == null)
{
return(ValidCache.NotValid);
}
var lastModified = new DateTime(ticks, DateTimeKind.Utc);
return(new ValidCache(checkLastModified.Value <= lastModified, lastModified));
}
return(ValidCache.NotValid);
}
public static async Task <IAuthSession> GetUntypedSessionAsync(this ICacheClientAsync cache,
IRequest httpReq = null, IResponse httpRes = null, CancellationToken token = default)
{
var sessionKey = GetSessionKey(httpReq);
if (sessionKey != null)
{
var userSession = await cache.GetAsync <IAuthSession>(sessionKey, token);
if (!Equals(userSession, default(AuthUserSession)))
{
return(userSession);
}
}
if (sessionKey == null)
{
SessionFeature.CreateSessionIds(httpReq, httpRes);
}
var unAuthorizedSession = (IAuthSession)typeof(AuthUserSession).CreateInstance();
return(unAuthorizedSession);
}
public CacheClientWithPrefixAsync(ICacheClientAsync cache, string prefix)
{
this.prefix = prefix;
this.cache = cache;
}
/// <summary> /// Returns underlying wrapped sync ICacheClient or ICacheClient API if cache implements it /// </summary> public static ICacheClient AsSync(this ICacheClientAsync cache) => cache is CacheClientAsyncWrapper wrapper
/// <summary>
/// Decorates the ICacheClient (and its siblings) prefixing every key with the given prefix
///
/// Useful for multi-tenant environments
/// </summary>
public static ICacheClientAsync WithPrefix(this ICacheClientAsync cache, string prefix)
{
return(new CacheClientWithPrefixAsync(cache, prefix));
}
public static async Task<bool> HandleValidCache(this IRequest req, CacheInfo cacheInfo, CancellationToken token=default)
{
if (cacheInfo == null)
return false;
ICacheClient cache;
ICacheClientAsync cacheAsync = null; // only non-null if native ICacheClientAsync exists
if (cacheInfo.LocalCache)
cache = HostContext.AppHost.GetMemoryCacheClient(req);
else
HostContext.AppHost.TryGetNativeCacheClient(req, out cache, out cacheAsync);
var cacheControl = HostContext.GetPlugin<HttpCacheFeature>().BuildCacheControlHeader(cacheInfo);
var res = req.Response;
DateTime? lastModified = null;
var doHttpCaching = cacheInfo.MaxAge != null || cacheInfo.CacheControl != CacheControl.None;
if (doHttpCaching)
{
lastModified = cacheAsync != null
? await cacheAsync.GetAsync<DateTime?>(cacheInfo.LastModifiedKey(), token).ConfigAwait()
: cache.Get<DateTime?>(cacheInfo.LastModifiedKey());
if (req.HasValidCache(lastModified))
{
if (cacheControl != null)
res.AddHeader(HttpHeaders.CacheControl, cacheControl);
res.EndNotModified();
return true;
}
}
var encoding = !cacheInfo.NoCompression
? req.GetCompressionType()
: null;
var useCacheKey = encoding != null
? cacheInfo.CacheKey + "." + encoding
: cacheInfo.CacheKey;
var responseBytes = cacheAsync != null
? await cacheAsync.GetAsync<byte[]>(useCacheKey, token).ConfigAwait()
: cache.Get<byte[]>(useCacheKey);
if (responseBytes != null)
{
if (encoding != null)
res.AddHeader(HttpHeaders.ContentEncoding, encoding);
if (cacheInfo.VaryByUser)
res.AddHeader(HttpHeaders.Vary, "Cookie");
if (cacheControl != null)
res.AddHeader(HttpHeaders.CacheControl, cacheControl);
if (!doHttpCaching)
{
lastModified = cacheAsync != null ?
await cacheAsync.GetAsync<DateTime?>(cacheInfo.LastModifiedKey(), token).ConfigAwait() :
cache.Get<DateTime?>(cacheInfo.LastModifiedKey());
}
if (lastModified != null)
res.AddHeader(HttpHeaders.LastModified, lastModified.Value.ToUniversalTime().ToString("r"));
await res.WriteBytesToResponse(responseBytes, req.ResponseContentType, token).ConfigAwait();
return true;
}
return false;
}
protected CacheClientTestsAsyncBase()
{
Cache = CreateClient();
}
public SessionCacheClientAsync(ICacheClientAsync cacheClient, string sessionId)
{
this.cacheClient = cacheClient;
this.prefixNs = "sess:" + sessionId + ":";
}
public async Task OnOneTimeSetUp()
{
cache = (ICacheClientAsync)CreateCacheClient();
}
public static async Task <object> ResolveFromCacheAsync(this ICacheClientAsync cache, string cacheKey, IRequest req,
CancellationToken token = default)
{
var checkModifiedSince = GetIfModifiedSince(req);
if (!req.ResponseContentType.IsBinary())
{
string modifiers = null;
if (req.ResponseContentType == MimeTypes.Json)
{
string jsonp = req.GetJsonpCallback();
if (jsonp != null)
{
modifiers = ".jsonp," + jsonp.SafeVarName();
}
}
var cacheKeySerialized = GetCacheKeyForSerialized(cacheKey, req.ResponseContentType, modifiers);
var compressionType = req.GetCompressionType();
bool doCompression = compressionType != null;
if (doCompression)
{
var cacheKeySerializedZip = GetCacheKeyForCompressed(cacheKeySerialized, compressionType);
var validCache = await cache.HasValidCacheAsync(req, cacheKeySerializedZip, checkModifiedSince, token).ConfigAwait();
if (validCache.IsValid)
{
return(HttpResult.NotModified());
}
DateTime?lastModified = validCache.LastModified;
if (req.Response.GetHeader(HttpHeaders.CacheControl) != null)
{
lastModified = null;
}
var compressedResult = await cache.GetAsync <byte[]>(cacheKeySerializedZip, token).ConfigAwait();
if (compressedResult != null)
{
return(new CompressedResult(
compressedResult,
compressionType,
req.ResponseContentType)
{
LastModified = lastModified,
});
}
}
else
{
if ((await cache.HasValidCacheAsync(req, cacheKeySerialized, checkModifiedSince, token).ConfigAwait()).IsValid)
{
return(HttpResult.NotModified());
}
var serializedResult = await cache.GetAsync <string>(cacheKeySerialized, token).ConfigAwait();
if (serializedResult != null)
{
return(serializedResult);
}
}
}
else
{
var cacheKeySerialized = GetCacheKeyForSerialized(cacheKey, req.ResponseContentType, modifiers: null);
if ((await cache.HasValidCacheAsync(req, cacheKeySerialized, checkModifiedSince, token).ConfigAwait()).IsValid)
{
return(HttpResult.NotModified());
}
var serializedResult = await cache.GetAsync <byte[]>(cacheKeySerialized, token).ConfigAwait();
if (serializedResult != null)
{
return(serializedResult);
}
}
return(null);
}
public SessionFactory(ICacheClient cacheClient, ICacheClientAsync cacheClientAsync)
{
this.cacheClient = cacheClient;
this.cacheClientAsync = cacheClientAsync ?? cacheClient.AsAsync();
}
public CachedUserSessionManagerAsync(ICacheClientAsync cacheClient)
{
this.cacheClient = cacheClient;
}
public static Task ClearSessionAsync(this ICacheClientAsync cache, IRequest httpReq = null, CancellationToken token = default)
{
return(cache.RemoveAsync(GetSessionKey(httpReq), token));
}
public static IAsyncEnumerable <string> GetKeysByPatternAsync(this ICacheClientAsync cache, string pattern)
{
return(cache.GetKeysByPatternAsync(pattern));
}
public static async Task <TimeSpan?> GetSessionTimeToLiveAsync(this ICacheClientAsync cache, string sessionId, CancellationToken token = default)
{
var sessionKey = SessionFeature.GetSessionKey(sessionId);
return(await cache.GetTimeToLiveAsync(sessionKey, token).ConfigAwait());
}
public static Task <TUserSession> SessionAsAsync <TUserSession>(this ICacheClientAsync cache,
IRequest httpReq = null, IResponse httpRes = null, CancellationToken token = default)
{
return(SessionFeature.GetOrCreateSessionAsync <TUserSession>(cache, httpReq, httpRes, token));
}
public static async Task ClearCachesAsync(this ICacheClientAsync cache, string[] cacheKeys, CancellationToken token = default)
{
var allCacheKeys = GetAllContentCacheKeys(cacheKeys);
await cache.RemoveAllAsync(allCacheKeys, token);
}
public static async Task <object> CacheAsync(this ICacheClientAsync cache,
string cacheKey,
object responseDto,
IRequest req,
TimeSpan?expireCacheIn = null,
CancellationToken token = default)
{
req.Response.Dto = responseDto;
await cache.SetAsync(cacheKey, responseDto, expireCacheIn, token).ConfigAwait();
if (!req.ResponseContentType.IsBinary())
{
string serializedDto = SerializeToString(req, responseDto);
string modifiers = null;
if (req.ResponseContentType.MatchesContentType(MimeTypes.Json))
{
var jsonp = req.GetJsonpCallback();
if (jsonp != null)
{
modifiers = ".jsonp," + jsonp.SafeVarName();
serializedDto = jsonp + "(" + serializedDto + ")";
//Add a default expire timespan for jsonp requests,
//because they aren't cleared when calling ClearCaches()
if (expireCacheIn == null)
{
expireCacheIn = HostContext.Config.DefaultJsonpCacheExpiration;
}
}
}
var cacheKeySerialized = GetCacheKeyForSerialized(cacheKey, req.ResponseContentType, modifiers);
await cache.SetAsync(cacheKeySerialized, serializedDto, expireCacheIn, token).ConfigAwait();
var compressionType = req.GetCompressionType();
bool doCompression = compressionType != null;
if (doCompression)
{
var lastModified = HostContext.GetPlugin <HttpCacheFeature>().ShouldAddLastModifiedToOptimizedResults() &&
string.IsNullOrEmpty(req.Response.GetHeader(HttpHeaders.CacheControl))
? DateTime.UtcNow
: (DateTime?)null;
var cacheKeySerializedZip = GetCacheKeyForCompressed(cacheKeySerialized, compressionType);
byte[] compressedSerializedDto = serializedDto.Compress(compressionType);
await cache.SetAsync(cacheKeySerializedZip, compressedSerializedDto, expireCacheIn, token).ConfigAwait();
if (lastModified != null)
{
await cache.SetAsync(DateCacheKey(cacheKeySerializedZip), lastModified.Value.Ticks, expireCacheIn, token).ConfigAwait();
}
return(compressedSerializedDto != null
? new CompressedResult(compressedSerializedDto, compressionType, req.ResponseContentType)
{
Status = req.Response.StatusCode,
LastModified = lastModified,
}
: null);
}
return(serializedDto);
}
else
{
string modifiers = null;
byte[] serializedDto = HostContext.ContentTypes.SerializeToBytes(req, responseDto);
var cacheKeySerialized = GetCacheKeyForSerialized(cacheKey, req.ResponseContentType, modifiers);
await cache.SetAsync(cacheKeySerialized, serializedDto, expireCacheIn, token).ConfigAwait();
return(serializedDto);
}
}
public CachedUserSessionManagerAsync GetCacheManager(ICacheClientAsync cacheClient)
{
return(new CachedUserSessionManagerAsync(cacheClient));
}
/// <summary>
/// Returning the most optimized result based on the MimeType and CompressionType from the IRequest.
/// </summary>
public static Task <object> ToOptimizedResultUsingCacheAsync <T>(
this IRequest req, ICacheClientAsync cacheClient, string cacheKey, Func <T> factoryFn, CancellationToken token = default)
{
return(req.ToOptimizedResultUsingCacheAsync(cacheClient, cacheKey, null, factoryFn, token));
}