// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IPolicyRegistry <string> policyRegistry, IAsyncCacheProvider memoryCache)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
Func <Context, HttpResponseMessage, Ttl> ttlFilter = (context, result) =>
new Ttl(result.IsSuccessStatusCode ? TimeSpan.FromSeconds(30) : TimeSpan.Zero);
AsyncCachePolicy <HttpResponseMessage> policy =
Policy.CacheAsync(memoryCache.AsyncFor <HttpResponseMessage>(),
new ResultTtl <HttpResponseMessage>(ttlFilter));
policyRegistry.Add("cache", policy);
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public ProjectsController(IHttpClientFactory clientFactory, IPolicyRegistry <string> policyRegistry)
{
this.clientFactory = clientFactory;
this.policyRegistry = policyRegistry;
//this.cachePolicy = policyRegistry.Get<AsyncCachePolicy<HttpResponseMessage>>(PolicyNames.CachePolicy);
this.cachePolicy = policyRegistry.Get <AsyncCachePolicy <HttpResponseMessage> >(PolicyNames.CacheOnlyOkPolicy);
}
public JsonPlaceholderClient(HttpClient httpClient, IReadOnlyPolicyRegistry <string> policyRegistry)
{
_httpClient = httpClient;
// Resolve the caching policy to be used with this client
_cachePolicy = policyRegistry.Get <AsyncCachePolicy <string> >("jsonPlaceHolderClientCachePolicy");
}
public AuthenticationApiClientCachingDecorator(IAuthenticationApiClient inner)
{
_inner = inner;
_accessTokenResponseCachePolicy = Policy.CacheAsync(
_memoryCacheProvider.AsyncFor <AccessTokenResponse>(),
new ResultTtl <AccessTokenResponse>(r => new Ttl(_expiresIn(r), false)));
_userInfoCachePolicy = Policy.CacheAsync(
_memoryCacheProvider.AsyncFor <UserInfo>(),
new ContextualTtl());
}
public static void GetPolicyRegistry(IAsyncCacheProvider cacheProvider,
IPolicyRegistry <string> registry)
{
registry.Add("thriceTriplingRetryPolicy", Policy.HandleResult <HttpResponseMessage>(r => !r.IsSuccessStatusCode)
.Or <TimeoutRejectedException>()
.WaitAndRetryAsync(thriceTriplingTimeSpans));
registry.Add("loginResponseRetryPolicy", Policy.HandleResult <LoginResponse>(lr => lr.LoginStatus != _successfulLoginStatus)
.Or <TimeoutRejectedException>()
.WaitAndRetryAsync(thriceTriplingTimeSpans));
registry.Add("thirtySecondTimeoutPolicy", Policy.TimeoutAsync(TimeSpan.FromSeconds(30)));
AsyncCachePolicy <LoginResponse> cachePolicy = Policy.CacheAsync <LoginResponse>(cacheProvider, _timeToLive);
registry.Add("oneMinuteLoginCachePolicy", cachePolicy);
}
internal AccessTokenService(string clientId, string clientSecret, IHttpRequestSender requestSender)
{
_clientId = clientId;
_clientSecret = clientSecret;
_requestSender = requestSender;
_cache = new MemoryCache(new MemoryCacheOptions());
_cachePolicy = Policy.CacheAsync(
new MemoryCacheProvider(_cache).AsyncFor <AccessToken>(),
new ResultTtl <AccessToken>(t => new Ttl(t.LifeTime - TimeSpan.FromHours(1))),
onCacheError: (ctx, _, ex) =>
{
Logger.ErrorException($"Could not retrieve access token: '{ex.Message}'", ex);
});
}
public static AsyncPolicyWrap <HttpResponseMessage> GetRequestPolicy(IMemoryCache memoryCache = null, int cacheSeconds = 0, int additionalRetries = 0, int requestTimeoutSeconds = 100)
{
AsyncCachePolicy cache = null;
if (memoryCache != null)
{
var memoryCacheProvider = new MemoryCacheProvider(memoryCache);
cache = Policy.CacheAsync(memoryCacheProvider, TimeSpan.FromSeconds(cacheSeconds));
}
int[] httpStatusCodesWorthRetrying =
{
StatusCodes.Status408RequestTimeout,
StatusCodes.Status429TooManyRequests,
//StatusCodes.Status500InternalServerError,
StatusCodes.Status502BadGateway,
StatusCodes.Status503ServiceUnavailable,
StatusCodes.Status504GatewayTimeout
};
var waitAndRetryPolicy = Policy
.Handle <HttpRequestException>() //HttpClient Timeout or CancellationToken
.Or <TimeoutRejectedException>()
.OrResult <HttpResponseMessage>(r => httpStatusCodesWorthRetrying.Contains((int)r.StatusCode))
.WaitAndRetryAsync(additionalRetries,
retryAttempt => TimeSpan.FromSeconds(1));
//https://github.com/App-vNext/Polly/wiki/Timeout
var requestTimeout = Policy.TimeoutAsync(TimeSpan.FromSeconds(requestTimeoutSeconds));
//https://github.com/App-vNext/Polly/wiki/PolicyWrap
AsyncPolicyWrap <HttpResponseMessage> policyWrap = null;
if (cache != null)
{
policyWrap = cache.WrapAsync(waitAndRetryPolicy).WrapAsync(requestTimeout);
}
else
{
policyWrap = waitAndRetryPolicy.WrapAsync(requestTimeout);
}
return(policyWrap);
}
public NewCombinedFeedSource(IEnumerable <IAmACommunityMember> tamarins)
{
EnsureHttpClient();
Tamarins = tamarins;
if (retryPolicy == null)
{
// cache in memory for an hour
var memoryCache = new MemoryCache(new MemoryCacheOptions());
var memoryCacheProvider = new MemoryCacheProvider(memoryCache);
cachePolicy = Policy.CacheAsync(memoryCacheProvider, TimeSpan.FromHours(1), OnCacheError);
// retry policy with max 2 retries, delay by x*x^1.2 where x is retry attempt
// this will ensure we don't retry too quickly
retryPolicy = Policy.Handle <FeedReadFailedException>()
.WaitAndRetryAsync(2, retry => TimeSpan.FromSeconds(retry * Math.Pow(1.2, retry)));
}
}
public void Configure(
IApplicationBuilder p_App,
IWebHostEnvironment p_Env,
IAsyncCacheProvider p_CacheProvider,
IPolicyRegistry <string> p_Registry)
{
AsyncCachePolicy <HttpResponseMessage> v_Policy =
Policy.CacheAsync <HttpResponseMessage>(
p_CacheProvider,
TimeSpan.FromSeconds(30)
);
p_Registry.Add("CachingPolicy", v_Policy);
Services = p_App.ApplicationServices;
if (p_Env.IsDevelopment())
{
p_App.UseDeveloperExceptionPage();
}
else
{
p_App.UseExceptionHandler("/Home/Error");
p_App.UseHsts();
}
p_App.UseHttpsRedirection();
p_App.UseStaticFiles();
p_App.UseRouting();
p_App.UseAuthorization();
p_App.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
}
private AsyncPolicy <ClassToCache> SetupAsyncCachePolicy(bool isPolicyEnabled, ClassToCache valueToReturnFromClassToCache)
{
this.cacheProvider.Invocations.Clear();
this.agingStrategy.Invocations.Clear();
this.cacheProvider.Setup(provider => provider.GetAsync <ClassToCache>(It.IsAny <string>(), It.IsAny <Context>()))
.ReturnsAsync(valueToReturnFromClassToCache);
this.cacheProvider.Setup(provider => provider.SetAsync <ClassToCache>(It.IsAny <string>(), It.IsAny <ClassToCache>(), It.IsAny <TimeSpan>(), It.IsAny <Context>()))
.Returns(Task.CompletedTask);
this.agingStrategy.Setup(agingStrategy => agingStrategy.GetGraceRelativeToNow(It.IsAny <ClassToCache>(), It.IsAny <Context>()))
.Returns(TimeSpan.FromDays(1));
this.agingStrategy.Setup(agingStrategy => agingStrategy.GetExpirationRelativeToNow(It.IsAny <ClassToCache>(), It.IsAny <Context>()))
.Returns(TimeSpan.FromDays(5));
var asyncCachePolicy = AsyncCachePolicy <ClassToCache>
.CreateBuilder(isPolicyEnabled, this.agingStrategy.Object, this.cacheProvider.Object, this.loggingProvider.Object)
.FallbackToCacheWhenThrows <TimeoutException>()
.OrFallbackToCacheWhenReturns(returnedValue => returnedValue.Property.Equals(this.errorBackendValue.Property))
.Build();
return(asyncCachePolicy);
}
public async Task <T> GetCachedDataAsync <T>(Func <CancellationToken, Task <T> > dataGetter, string key, CancellationToken cancellationToken, CoordinatedResetCacheTime resetCacheTime = CoordinatedResetCacheTime.OnHour)
{
TimeSpan timeToReset;
switch (resetCacheTime)
{
case CoordinatedResetCacheTime.OnHour:
timeToReset = GetLengthOfTimeUntilNextHour();
break;
case CoordinatedResetCacheTime.OnMinute:
timeToReset = GetLengthOfTimeUntilNextMinute();
break;
}
AsyncCachePolicy cachePolicy = Policy.CacheAsync(_pollyMemoryCacheProvider.MemoryCacheProvider, timeToReset);
Context context = new Context($"{nameof(CoordinatedResetCache)}_{key}");
// collapser policy used to prevent concurrent calls retrieving the same data twice
T result = await _collapserPolicy.WrapAsync(cachePolicy).ExecuteAsync(_ => dataGetter.Invoke(cancellationToken), context);
return(result);
}
