private static int GetThrottleCount(IRateLimitingCacheProvider rateLimiter,
RateLimitPolicy policy,
int totalNumberOfCalls,
int sleepTimeInMilliSeconds)
{
int throttleCount = 0;
for (var i = 1; i <= totalNumberOfCalls; i++)
{
if (rateLimiter.LimitRequestAsync(policy.RequestKey, policy.HttpMethod,
"TestRateLimiting.com", policy.RouteTemplate, policy.AllowedCallRates).Result.Throttled)
{
throttleCount++;
}
Thread.Sleep(sleepTimeInMilliSeconds);
}
return(throttleCount);
}
public async Task LimitRequestAsync(
RateLimitingRequest rateLimitingRequest,
Func <IList <AllowedConsumptionRate> > getCustomAttributes, string host,
Func <RateLimitingRequest, RateLimitPolicy, RateLimitingResult, Task> onPostLimitFuncAsync = null,
Func <RateLimitingRequest, Task <RateLimitPolicy> > getPolicyFuncAsync = null,
bool revert = false)
{
if (_policyProvider == null && getPolicyFuncAsync == null)
{
throw new ArgumentNullException("There are no valid policy providers");
}
var getPolicyAsync = getPolicyFuncAsync ?? _policyProvider.GetPolicyAsync;
var rateLimitingPolicy = await getPolicyAsync(rateLimitingRequest).ConfigureAwait(false);
if (rateLimitingPolicy == null)
{
if (onPostLimitFuncAsync != null)
{
await onPostLimitFuncAsync.Invoke(rateLimitingRequest, rateLimitingPolicy, new RateLimitingResult(ResultState.NotApplicable)).ConfigureAwait(false);
}
return;
}
var allowedCallRates = rateLimitingPolicy.AllowedCallRates;
var routeTemplate = rateLimitingPolicy.RouteTemplate;
var httpMethod = rateLimitingPolicy.HttpMethod;
var policyName = rateLimitingPolicy.Name;
if (rateLimitingPolicy.AllowAttributeOverride)
{
var attributeRates = getCustomAttributes?.Invoke();
if (attributeRates != null && attributeRates.Any())
{
allowedCallRates = attributeRates;
routeTemplate = rateLimitingRequest.RouteTemplate;
httpMethod = rateLimitingRequest.Method;
policyName = $"AttributeOn_{routeTemplate}";
}
}
if (allowedCallRates == null || !Enumerable.Any <AllowedConsumptionRate>(allowedCallRates))
{
if (onPostLimitFuncAsync != null)
{
await onPostLimitFuncAsync.Invoke(rateLimitingRequest, rateLimitingPolicy, new RateLimitingResult(ResultState.NotApplicable)).ConfigureAwait(false);
}
return;
}
var rateLimitingResult = await _rateLimitingCacheProvider.LimitRequestAsync(rateLimitingPolicy.RequestKey, httpMethod,
host, routeTemplate, allowedCallRates,
revert? -rateLimitingPolicy.CostPerCall : rateLimitingPolicy.CostPerCall).ConfigureAwait(false);
if (onPostLimitFuncAsync != null)
{
await onPostLimitFuncAsync.Invoke(rateLimitingRequest, rateLimitingPolicy, rateLimitingResult).ConfigureAwait(false);
}
}
