public Task <RateLimitPolicy> GetPolicyAsync(RateLimitingRequest rateLimitingRequest)
{
return(Task.FromResult(new RateLimitPolicy("test_oganization_01", new List <AllowedConsumptionRate>()
{
new AllowedConsumptionRate(200, RateLimitUnit.PerHour)
})));
}
public Task <RateLimitPolicy> GetPolicyAsync(RateLimitingRequest rateLimitingRequest)
{
var userId = "test_user_01";
if (_index > 200 && _index <= 400)
{
userId = "test_user_02";
}
else if (_index > 400 && _index <= 600)
{
userId = "test_user_03";
}
_index++;
if (_index > 600)
{
_index = 1;
}
return(Task.FromResult(new RateLimitPolicy(userId, new List <AllowedConsumptionRate>()
{
new AllowedConsumptionRate(100, RateLimitUnit.PerHour)
})));
}
public override async Task OnAuthorizationAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
{
var context = actionContext;
var request = new RateLimitingRequest(
GetRouteTemplate(context),
context.Request.RequestUri.AbsolutePath,
context.Request.Method.Method,
(header) => context.Request.Headers.GetValues(header).ToArray(),
context.RequestContext.Principal as ClaimsPrincipal,
await context.Request.Content.ReadAsStreamAsync().ConfigureAwait(false));
await _rateLimiter.LimitRequestAsync(
request,
() => RateLimitingFilter.GetCustomAttributes(context),
context.Request.Headers.Host,
onPostLimitFuncAsync : async(rateLimitingRequest, policy, rateLimitingResult) =>
{
context.Request.Properties.Add($"RateLimitingResult_{_filterId}", rateLimitingResult);
var clientDecision = OnPostLimit != null ? await OnPostLimit.Invoke(rateLimitingRequest, policy, rateLimitingResult, actionContext).ConfigureAwait(false) : Decision.OK;
var reverted = await RevertIfRequired(rateLimitingResult, context, request, policy, clientDecision).ConfigureAwait(false);
if (reverted)
{
await base.OnAuthorizationAsync(context, cancellationToken).ConfigureAwait(false);
return;
}
if (rateLimitingResult.State == ResultState.Success)
{
if (PostOperationDecisionFuncAsync != null)
{
context.Request.Properties.Add($"PostActionFilterFuncAsync_{_filterId}",
new Func <HttpActionExecutedContext, Task>(async(httpActionExecutedContext) =>
{
var decision =
await PostOperationDecisionFuncAsync.Invoke(rateLimitingRequest, policy, rateLimitingResult, httpActionExecutedContext).ConfigureAwait(false);
await RevertIfRequired(rateLimitingResult, context, request, policy, decision).ConfigureAwait(false);
}));
}
await base.OnAuthorizationAsync(context, cancellationToken).ConfigureAwait(false);
}
else if ((rateLimitingResult.State == ResultState.Throttled || rateLimitingResult.State == ResultState.ThrottledButCompensationFailed) &&
!SimulationMode)
{
await TooManyRequests(context, rateLimitingResult, policy.Name).ConfigureAwait(false);
}
},
getPolicyFuncAsync : GetPolicyFuncAsync != null?new Func <RateLimitingRequest, Task <RateLimitPolicy> >(async(rlr) =>
{
return(await GetPolicyFuncAsync.Invoke(rlr, actionContext).ConfigureAwait(false));
}) : null
).ConfigureAwait(false);
}
private async Task <bool> RevertIfRequired(RateLimitingResult rateLimitingResult, HttpActionContext context,
RateLimitingRequest request, RateLimitPolicy policy, Decision decision)
{
if (decision == Decision.REVERTSUCCESSCOST && rateLimitingResult.State == ResultState.Success)
{
await _rateLimiter.LimitRequestAsync(request,
() => RateLimitingFilter.GetCustomAttributes(context),
context.Request.Headers.Host,
getPolicyFuncAsync : _ => Task.FromResult(policy),
onPostLimitFuncAsync : async(rateLimitingRequest, postPolicy, rateLimitingRevertResult) =>
{
if (rateLimitingRevertResult.State == ResultState.Success)
{
context.Request.Properties[$"RateLimitingResult_{_filterId}"] = rateLimitingRevertResult;
}
if (OnPostLimitRevert != null)
{
await OnPostLimitRevert.Invoke(request, postPolicy, rateLimitingRevertResult, context).ConfigureAwait(false);
}
},
revert : true).ConfigureAwait(false);
return(await Task.FromResult(true));
}
return(await Task.FromResult(false));
}
public Task <RateLimitPolicy> GetPolicyAsync(RateLimitingRequest rateLimitingRequest, HttpActionContext actionContext)
{
//return Task.FromResult<RateLimitPolicy>(null);
var clientId = rateLimitingRequest.ClaimsPrincipal?.Claims.FirstOrDefault(c => c.Type == "client_id");
var operationClass = CallClassification.RouteTemplateToClassMap[rateLimitingRequest.RouteTemplate];
if (actionContext != null)
{
var operationId = actionContext.ActionDescriptor.GetCustomAttributes <OperationInfo>(true).ToList();
if (operationId.Count != 0)
{
operationClass = CallClassification.RouteTemplateToClassMap[operationId[0].Id];
}
}
//if (string.IsNullOrWhiteSpace(clientId?.Value)) return null;
//if (operationClass == "F")
//{
// return Task.FromResult(new RateLimitPolicy("Test_Client_01::ClassF",
// new List<AllowedConsumptionRate>()
// {
// new AllowedConsumptionRate(100, RateLimitUnit.PerMinute)
// }, name: "QuotaFree_SafetyPolicy"));
//}
var cost = CallClassification.CostPerClass[operationClass];
return(Task.FromResult(new RateLimitPolicy("Test_Client_01",
new List <AllowedConsumptionRate>()
{
//new AllowedConsumptionRate(20,
// new LimitPeriod(120),100)
new AllowedConsumptionRate(2, RateLimitUnit.PerMinute)
}, name: "Quota_Billed")
{
CostPerCall = cost
}));
}
private static void SetupPolicyManager(RateLimitingPolicyManager policyManager,
RateLimitingRequest rateLimtingRequest,
IList <string> whiteListedRequestKeys = null, IList <string> whiteListedPaths = null)
{
var allowedCallRates = new List <AllowedConsumptionRate>()
{
new AllowedConsumptionRate(5, RateLimitUnit.PerMinute)
};
policyManager.AddRequestKeysToWhiteList(whiteListedRequestKeys ?? new List <string>());
policyManager.AddPathsToWhiteList(whiteListedPaths ?? new List <string>());
policyManager.AddEndpointPolicy(new RateLimitPolicy("testclient_01", "/api/values",
"GET", allowedCallRates, name: "RequestKey_Route_Method_MatchingPolicy_FromManager"));
policyManager.AddEndpointPolicy(new RateLimitPolicy("testclient_01", "/api/values/{id}",
"*", allowedCallRates, name: "RequestKey_Route_AllMethods_MatchingPolicy_FromManager"));
policyManager.AddEndpointPolicy(new RateLimitPolicy("testclient_01", "*",
"GET", allowedCallRates, name: "RequestKey_AllRoutes_Method_MatchingPolicy_FromManager"));
policyManager.AddEndpointPolicy(new RateLimitPolicy("testclient_01", "*",
"*", allowedCallRates, name: "RequestKey_AllRoutes_AllMethods_MatchingPolicy_FromManager"));
policyManager.AddEndpointPolicy(new RateLimitPolicy("*", "/api/values",
"GET", allowedCallRates, name: "AllRequestKeys_Route_Method_MatchingPolicy_FromManager"));
policyManager.AddEndpointPolicy(new RateLimitPolicy("*", "/api/values",
"*", allowedCallRates, name: "AllRequestKeys_Route_AllMethods_MatchingPolicy_FromManager"));
policyManager.AddEndpointPolicy(new RateLimitPolicy("*", "*",
"GET", allowedCallRates, name: "AllRequestKeys_AllRoutes_Method_MatchingPolicy_FromManager"));
policyManager.AddEndpointPolicy(new RateLimitPolicy("*", "*",
"*", allowedCallRates, name: "AllRequestKeys_AllRoutes_AllMethods_MatchingPolicy_FromManager"));
}
private static async Task ArangeActAndAssert(string routeTemplate, string method, string requestKey,
string expectedPolicyNameToApply, IList <AllowedConsumptionRate> allowedCallRates = null, bool allowAttributeOverride = false,
bool returnNullPolicy = false, IList <string> whiteListedRequestKeys = null, IList <string> whiteListedPaths = null,
bool isWhiteListedPathTest = false)
{
var rateLimtingRequest = new RateLimitingRequest(routeTemplate,
routeTemplate, method, s => new string[] { "s_value" }, null, null);
var policyProviderMock = new Mock <IRateLimitingPolicyProvider>();
if (!isWhiteListedPathTest)
{
policyProviderMock.Setup(provider => provider.GetPolicyAsync(rateLimtingRequest))
.ReturnsAsync(returnNullPolicy
? null
: new RateLimitPolicy(requestKey, allowedCallRates, allowAttributeOverride,
name: "CustomProviderPolicy"));
}
var policyManager = new RateLimitingPolicyManager(policyProviderMock.Object);
SetupPolicyManager(policyManager, rateLimtingRequest, whiteListedRequestKeys, whiteListedPaths);
var policyToApply = await policyManager.GetPolicyAsync(rateLimtingRequest);
policyProviderMock.VerifyAll();
if (expectedPolicyNameToApply == null)
{
Assert.Null(policyToApply);
}
else
{
Assert.Equal(expectedPolicyNameToApply, policyToApply.Name);
}
}
public Task <RateLimitPolicy> GetPolicyAsync(RateLimitingRequest rateLimitingRequest)
{
return(Task.FromResult(new RateLimitPolicy("test_client")));
}
public Task <RateLimitPolicy> GetPolicyAsync(RateLimitingRequest rateLimitingRequest)
{
return(GetPolicyAsync(rateLimitingRequest, null));
}
public Task <RateLimitPolicy> GetPolicyAsync(RateLimitingRequest rateLimitingRequest)
{
return(Task.FromResult(new RateLimitPolicy(_requestKey)));
}
