// Create the endpoint-specific PartitionedRateLimiter
private PartitionedRateLimiter <HttpContext> CreateEndpointLimiter()
{
// If we have a policy for this endpoint, use its partitioner. Else use a NoLimiter.
return(PartitionedRateLimiter.Create <HttpContext, DefaultKeyType>(context =>
{
DefaultRateLimiterPolicy?policy;
var enableRateLimitingAttribute = context.GetEndpoint()?.Metadata.GetMetadata <EnableRateLimitingAttribute>();
if (enableRateLimitingAttribute is null)
{
return RateLimitPartition.GetNoLimiter <DefaultKeyType>(_defaultPolicyKey);
}
policy = enableRateLimitingAttribute.Policy;
if (policy is not null)
{
return policy.GetPartition(context);
}
var name = enableRateLimitingAttribute.PolicyName;
if (name is not null)
{
if (_policyMap.TryGetValue(name, out policy))
{
return policy.GetPartition(context);
}
else
{
throw new InvalidOperationException($"This endpoint requires a rate limiting policy with name {name}, but no such policy exists.");
}
}
// Should be impossible for both name & policy to be null, but throw in that scenario just in case.
else
{
throw new InvalidOperationException("This endpoint requested a rate limiting policy with a null name.");
}
}, new DefaultKeyTypeEqualityComparer()));
}
public void AddPolicy_Generic_ThrowsOnDuplicateName()
{
var options = new RateLimiterOptions();
options.AddPolicy <string>("myKey", context => RateLimitPartition.GetNoLimiter <string>("myKey"));
Assert.Throws <ArgumentException>(() => options.AddPolicy <string, TestRateLimiterPolicy>("myKey"));
}
public async Task NoLimiter_GetStatistics()
{
var partition = RateLimitPartition.GetNoLimiter(1);
var limiter = partition.Factory(1);
var stats = limiter.GetStatistics();
Assert.NotSame(stats, limiter.GetStatistics());
Assert.Equal(long.MaxValue, stats.CurrentAvailablePermits);
Assert.Equal(0, stats.CurrentQueuedCount);
Assert.Equal(0, stats.TotalFailedLeases);
Assert.Equal(0, stats.TotalSuccessfulLeases);
var leaseCount = 0;
for (var i = 0; i < 134; i++)
{
var lease = limiter.AttemptAcquire(i);
Assert.True(lease.IsAcquired);
++leaseCount;
}
stats = limiter.GetStatistics();
Assert.Equal(long.MaxValue, stats.CurrentAvailablePermits);
Assert.Equal(0, stats.CurrentQueuedCount);
Assert.Equal(0, stats.TotalFailedLeases);
Assert.Equal(leaseCount, stats.TotalSuccessfulLeases);
for (var i = 0; i < 165; i++)
{
var wait = limiter.AcquireAsync(int.MaxValue);
Assert.True(wait.IsCompletedSuccessfully);
var lease = await wait;
Assert.True(lease.IsAcquired);
++leaseCount;
}
stats = limiter.GetStatistics();
Assert.Equal(long.MaxValue, stats.CurrentAvailablePermits);
Assert.Equal(0, stats.CurrentQueuedCount);
Assert.Equal(0, stats.TotalFailedLeases);
Assert.Equal(leaseCount, stats.TotalSuccessfulLeases);
}
public async Task Create_NoLimiter()
{
var partition = RateLimitPartition.GetNoLimiter(1);
var limiter = partition.Factory(1);
// How do we test an internal implementation of a limiter that doesn't limit? Just try some stuff that normal limiters would probably block on and see if it works.
var available = limiter.GetAvailablePermits();
var lease = limiter.Acquire(int.MaxValue);
Assert.True(lease.IsAcquired);
Assert.Equal(available, limiter.GetAvailablePermits());
lease = limiter.Acquire(int.MaxValue);
Assert.True(lease.IsAcquired);
var wait = limiter.WaitAndAcquireAsync(int.MaxValue);
Assert.True(wait.IsCompletedSuccessfully);
lease = await wait;
Assert.True(lease.IsAcquired);
lease.Dispose();
}
public void AddPolicy_ThrowsOnNullPolicyName()
{
var options = new RateLimiterOptions();
Assert.Throws <ArgumentNullException>(() => options.AddPolicy <string>(null, context => RateLimitPartition.GetNoLimiter <string>("myKey")));
}