private static async Task DoLeakyBucketWait(AlgorithmCheckResult checkResult)
{
// Simulation leaky bucket algorithm queuing mechanism
var wait = checkResult.RuleCheckResults.Max(d => d.Wait);
if (wait > 0)
{
await Task.Delay((int)wait).ConfigureAwait(false);
}
}
/// <summary>
/// setting response header
/// </summary>
/// <param name="context"></param>
/// <param name="checkResult"></param>
/// <returns></returns>
private async Task SetHeaders(HttpContext context, AlgorithmCheckResult checkResult)
{
var headers = await BuildHttpHeaders(context, checkResult).ConfigureAwait(false);
if (headers != null && headers.Count > 0)
{
foreach (var h in headers)
{
context.Response.Headers.Append(h.Key, h.Value);
}
}
}
/// <summary>
/// rateLimit exception
/// </summary>
/// <returns></returns>
private static AsyncPolicy <AlgorithmCheckResult> PollyRateLimitAdvancedCircuitBreakerAsync(string policyKey, EnableRateLimitAttribute enableRateLimitAttribute)
{
var getResult = _getPollyObj.TryGetValue(policyKey, out AsyncPolicy <AlgorithmCheckResult> pollyObj);
if (getResult)
{
return(pollyObj);
}
int retryCount = enableRateLimitAttribute == null ? 1 : enableRateLimitAttribute.RetryCount;
double failureThreshold = enableRateLimitAttribute == null ? 0.75 : enableRateLimitAttribute.FailureThreshold;
TimeSpan samplingDuration = enableRateLimitAttribute == null?TimeSpan.FromSeconds(10) : enableRateLimitAttribute.SamplingDuration;
int minimumThroughput = enableRateLimitAttribute == null ? 100 : enableRateLimitAttribute.MinimumThroughput;
TimeSpan durationOfBreak = enableRateLimitAttribute == null?TimeSpan.FromSeconds(10) : enableRateLimitAttribute.DurationOfBreak;
var breakPolicy = Policy <AlgorithmCheckResult> .Handle <RateLimitException>().AdvancedCircuitBreakerAsync(
failureThreshold: failureThreshold,
samplingDuration: samplingDuration,
minimumThroughput: minimumThroughput,
durationOfBreak: durationOfBreak,
onBreak: (r, t) =>
{
Console.WriteLine("onbreak");
},
onReset: () =>
{
Console.WriteLine("onReset");
},
onHalfOpen: () =>
{
Console.WriteLine("onHalfOpen");
}
);
var retry = Policy <AlgorithmCheckResult> .Handle <RateLimitException>().WaitAndRetryAsync(retryCount, i => TimeSpan.FromMilliseconds(100 * i));
var message = new AlgorithmCheckResult(new List <RuleCheckResult>()
{
new RuleCheckResult()
{
IsLimit = true
}
})
{
};
var fallback = Policy <AlgorithmCheckResult> .Handle <BrokenCircuitException>().FallbackAsync(message);
var fallbackBreak = Policy.WrapAsync(fallback, retry, breakPolicy).WithPolicyKey(policyKey);
_getPollyObj.TryAdd(policyKey, fallbackBreak);
return(fallbackBreak);
}
private async Task DoOnAfterUntriggeredDoNext(HttpContext context, AlgorithmCheckResult checkResult)
{
if (_interceptor != null)
{
if (_interceptor.OnAfterUntriggeredDoNextAsync != null)
{
await _interceptor.OnAfterUntriggeredDoNextAsync(context, checkResult).ConfigureAwait(false);
}
else if (_interceptor.OnAfterUntriggeredDoNext != null)
{
_interceptor.OnAfterUntriggeredDoNext(context, checkResult);
}
}
}
private async Task <string> BuildHttpContent(HttpContext context, AlgorithmCheckResult checkResult)
{
string content = null;
if (_error.BuildHttpContentAsync != null)
{
content = await _error.BuildHttpContentAsync(context, checkResult).ConfigureAwait(false);
}
else if (_error.BuildHttpContent != null)
{
content = _error.BuildHttpContent(context, checkResult);
}
return(content);
}
/// <summary>
/// setting rateLimit response content
/// </summary>
/// <param name="context"></param>
/// <param name="checkResult"></param>
/// <returns></returns>
private async Task ReponseWithTooManyRequests(HttpContext context, AlgorithmCheckResult checkResult)
{
string content = await BuildHttpContent(context, checkResult).ConfigureAwait(false);
if (!string.IsNullOrWhiteSpace(content))
{
var bodyContent = Encoding.UTF8.GetBytes(content);
context.Response.ContentType = "application/json;charset=utf-8";
await context.Response.Body.WriteAsync(bodyContent, 0, bodyContent.Length).ConfigureAwait(false);
}
else
{
await context.Response.WriteAsync(string.Empty).ConfigureAwait(false);
}
}
private async Task <Dictionary <string, StringValues> > BuildHttpHeaders(HttpContext context, AlgorithmCheckResult checkResult)
{
Dictionary <string, StringValues> headers = null;
if (_error.BuildHttpHeadersAsync != null)
{
headers = await _error.BuildHttpHeadersAsync(context, checkResult).ConfigureAwait(false);
}
else if (_error.BuildHttpHeaders != null)
{
headers = _error.BuildHttpHeaders(context, checkResult);
}
return(headers);
}