React to rate limiting API changes

JamesNK · JamesNK · commit ff550a248e3e · 2022-07-13T22:09:24.000+08:00
diff --git a/src/Middleware/ConcurrencyLimiter/src/QueuePolicies/BasePolicy.cs b/src/Middleware/ConcurrencyLimiter/src/QueuePolicies/BasePolicy.cs
@@ -47,7 +47,7 @@ public ValueTask<bool> TryEnterAsync()
             return ValueTask.FromResult(true);
         }
 
-        var task = _limiter.WaitAsync();
+        var task = _limiter.WaitAndAcquireAsync();
         if (task.IsCompletedSuccessfully)
         {
             lease = task.Result;
diff --git a/src/Middleware/RateLimiting/samples/RateLimitingSample/Program.cs b/src/Middleware/RateLimiting/samples/RateLimitingSample/Program.cs
@@ -30,7 +30,8 @@
 // The global limiter will be a concurrency limiter with a max permit count of 10 and a queue depth of 5.
 options.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(context =>
         {
-            return RateLimitPartition.CreateConcurrencyLimiter<string>("globalLimiter", key => new ConcurrencyLimiterOptions(10, QueueProcessingOrder.NewestFirst, 5));
+
+            return RateLimitPartition.GetConcurrencyLimiter<string>("globalLimiter", key => new ConcurrencyLimiterOptions(10, QueueProcessingOrder.NewestFirst, 5));
         });
 app.UseRateLimiter(options);
 
diff --git a/src/Middleware/RateLimiting/samples/RateLimitingSample/SampleRateLimiterPolicy.cs b/src/Middleware/RateLimiting/samples/RateLimitingSample/SampleRateLimiterPolicy.cs
@@ -25,6 +25,6 @@ public SampleRateLimiterPolicy(ILogger<SampleRateLimiterPolicy> logger)
     // Use a sliding window limiter allowing 1 request every 10 seconds
     public RateLimitPartition<string> GetPartition(HttpContext httpContext)
     {
-        return RateLimitPartition.CreateSlidingWindowLimiter<string>(string.Empty, key => new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 1, TimeSpan.FromSeconds(5), 1));
+        return RateLimitPartition.GetSlidingWindowLimiter<string>(string.Empty, key => new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 1, TimeSpan.FromSeconds(5), 1));
     }
 }
diff --git a/src/Middleware/RateLimiting/src/RateLimiterOptionsExtensions.cs b/src/Middleware/RateLimiting/src/RateLimiterOptionsExtensions.cs
@@ -22,7 +22,7 @@ public static RateLimiterOptions AddTokenBucketLimiter(this RateLimiterOptions o
         var key = new PolicyNameKey() { PolicyName = policyName };
         return options.AddPolicy(policyName, context =>
         {
-            return RateLimitPartition.CreateTokenBucketLimiter(key,
+            return RateLimitPartition.GetTokenBucketLimiter(key,
                 _ => tokenBucketRateLimiterOptions);
         });
     }
@@ -39,7 +39,7 @@ public static RateLimiterOptions AddFixedWindowLimiter(this RateLimiterOptions o
         var key = new PolicyNameKey() { PolicyName = policyName };
         return options.AddPolicy(policyName, context =>
         {
-            return RateLimitPartition.CreateFixedWindowLimiter(key,
+            return RateLimitPartition.GetFixedWindowLimiter(key,
                 _ => fixedWindowRateLimiterOptions);
         });
     }
@@ -56,7 +56,7 @@ public static RateLimiterOptions AddSlidingWindowLimiter(this RateLimiterOptions
         var key = new PolicyNameKey() { PolicyName = policyName };
         return options.AddPolicy(policyName, context =>
         {
-            return RateLimitPartition.CreateSlidingWindowLimiter(key,
+            return RateLimitPartition.GetSlidingWindowLimiter(key,
                 _ => slidingWindowRateLimiterOptions);
         });
     }
@@ -73,7 +73,7 @@ public static RateLimiterOptions AddConcurrencyLimiter(this RateLimiterOptions o
         var key = new PolicyNameKey() { PolicyName = policyName };
         return options.AddPolicy(policyName, context =>
         {
-            return RateLimitPartition.CreateConcurrencyLimiter(key,
+            return RateLimitPartition.GetConcurrencyLimiter(key,
                 _ => concurrencyLimiterOptions);
         });
     }
@@ -89,7 +89,7 @@ public static RateLimiterOptions AddNoLimiter(this RateLimiterOptions options, s
         var key = new PolicyNameKey() { PolicyName = policyName };
         return options.AddPolicy(policyName, context =>
         {
-            return RateLimitPartition.CreateNoLimiter(key);
+            return RateLimitPartition.GetNoLimiter(key);
         });
     }
 }
diff --git a/src/Middleware/RateLimiting/src/RateLimitingMiddleware.cs b/src/Middleware/RateLimiting/src/RateLimitingMiddleware.cs
@@ -142,13 +142,13 @@ private async ValueTask<LeaseContext> CombinedWaitAsync(HttpContext context, Can
         {
             if (_globalLimiter is not null)
             {
-                globalLease = await _globalLimiter.WaitAsync(context, cancellationToken: cancellationToken);
+                globalLease = await _globalLimiter.WaitAndAcquireAsync(context, cancellationToken: cancellationToken);
                 if (!globalLease.IsAcquired)
                 {
                     return new LeaseContext() { GlobalRejected = true, Lease = globalLease };
                 }
             }
-            endpointLease = await _endpointLimiter.WaitAsync(context, cancellationToken: cancellationToken);
+            endpointLease = await _endpointLimiter.WaitAndAcquireAsync(context, cancellationToken: cancellationToken);
             if (!endpointLease.IsAcquired)
             {
                 globalLease?.Dispose();
@@ -183,7 +183,7 @@ private PartitionedRateLimiter<HttpContext> CreateEndpointLimiter()
                     throw new InvalidOperationException($"This endpoint requires a rate limiting policy with name {name}, but no such policy exists.");
                 }
             }
-            return RateLimitPartition.CreateNoLimiter<DefaultKeyType>(_defaultPolicyKey);
+            return RateLimitPartition.GetNoLimiter<DefaultKeyType>(_defaultPolicyKey);
         }, new DefaultKeyTypeEqualityComparer());
     }
 
diff --git a/src/Middleware/RateLimiting/test/RateLimitingMiddlewareTests.cs b/src/Middleware/RateLimiting/test/RateLimitingMiddlewareTests.cs
@@ -160,7 +160,7 @@ public async Task EndpointLimiter_Rejects()
         var name = "myEndpoint";
         options.Value.AddPolicy<string>(name, (context =>
         {
-            return RateLimitPartition.Create<string>("myLimiter", (key =>
+            return RateLimitPartition.Get<string>("myLimiter", (key =>
             {
                 return new TestRateLimiter(false);
             }));
diff --git a/src/Middleware/RateLimiting/test/RateLimitingOptionsTests.cs b/src/Middleware/RateLimiting/test/RateLimitingOptionsTests.cs
@@ -13,7 +13,7 @@ public class RateLimitingOptionsTests
     public void AddPolicy_ThrowsOnNullPolicyName()
     {
         var options = new RateLimiterOptions();
-        Assert.Throws<ArgumentNullException>(() => options.AddPolicy<string>(null, context => RateLimitPartition.CreateNoLimiter<string>("myKey")));
+        Assert.Throws<ArgumentNullException>(() => options.AddPolicy<string>(null, context => RateLimitPartition.GetNoLimiter<string>("myKey")));
     }
 
     [Fact]
@@ -34,15 +34,15 @@ public void AddPolicy_ThrowsOnNullPolicy()
     public void AddPolicy_ThrowsOnDuplicateName()
     {
         var options = new RateLimiterOptions();
-        options.AddPolicy<string>("myKey", context => RateLimitPartition.CreateNoLimiter<string>("myKey"));
-        Assert.Throws<ArgumentException>(() => options.AddPolicy<string>("myKey", context => RateLimitPartition.CreateNoLimiter<string>("yourKey")));
+        options.AddPolicy<string>("myKey", context => RateLimitPartition.GetNoLimiter<string>("myKey"));
+        Assert.Throws<ArgumentException>(() => options.AddPolicy<string>("myKey", context => RateLimitPartition.GetNoLimiter<string>("yourKey")));
     }
 
     [Fact]
     public void AddPolicy_Generic_ThrowsOnDuplicateName()
     {
         var options = new RateLimiterOptions();
-        options.AddPolicy<string>("myKey", context => RateLimitPartition.CreateNoLimiter<string>("myKey"));
+        options.AddPolicy<string>("myKey", context => RateLimitPartition.GetNoLimiter<string>("myKey"));
         Assert.Throws<ArgumentException>(() => options.AddPolicy<string, TestRateLimiterPolicy>("myKey"));
     }
 }
diff --git a/src/Middleware/RateLimiting/test/TestPartitionedRateLimiter.cs b/src/Middleware/RateLimiting/test/TestPartitionedRateLimiter.cs
@@ -57,7 +57,7 @@ protected override RateLimitLease AcquireCore(TResource resourceID, int permitCo
         return new TestRateLimitLease(true, leases);
     }
 
-    protected override async ValueTask<RateLimitLease> WaitAsyncCore(TResource resourceID, int permitCount, CancellationToken cancellationToken)
+    protected override async ValueTask<RateLimitLease> WaitAndAcquireAsyncCore(TResource resourceID, int permitCount, CancellationToken cancellationToken)
     {
         if (permitCount != 1)
         {
@@ -66,7 +66,7 @@ protected override async ValueTask<RateLimitLease> WaitAsyncCore(TResource resou
         var leases = new List<RateLimitLease>();
         foreach (var limiter in limiters)
         {
-            leases.Add(await limiter.WaitAsync());
+            leases.Add(await limiter.WaitAndAcquireAsync());
         }
         foreach (var lease in leases)
         {
diff --git a/src/Middleware/RateLimiting/test/TestRateLimiter.cs b/src/Middleware/RateLimiting/test/TestRateLimiter.cs
@@ -4,6 +4,7 @@
 using System.Threading.RateLimiting;
 
 namespace Microsoft.AspNetCore.RateLimiting;
+
 internal class TestRateLimiter : RateLimiter
 {
     private readonly bool _alwaysAccept;
@@ -25,7 +26,7 @@ protected override RateLimitLease AcquireCore(int permitCount)
         return new TestRateLimitLease(_alwaysAccept, null);
     }
 
-    protected override ValueTask<RateLimitLease> WaitAsyncCore(int permitCount, CancellationToken cancellationToken)
+    protected override ValueTask<RateLimitLease> WaitAndAcquireAsyncCore(int permitCount, CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
         return new ValueTask<RateLimitLease>(new TestRateLimitLease(_alwaysAccept, null));
diff --git a/src/Middleware/RateLimiting/test/TestRateLimiterPolicy.cs b/src/Middleware/RateLimiting/test/TestRateLimiterPolicy.cs
@@ -27,7 +27,7 @@ public TestRateLimiterPolicy(string key, int statusCode, bool alwaysAccept)
 
     public RateLimitPartition<string> GetPartition(HttpContext httpContext)
     {
-        return RateLimitPartition.Create<string>(_key, (key =>
+        return RateLimitPartition.Get<string>(_key, (key =>
         {
             return new TestRateLimiter(_alwaysAccept);
         }));

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public ValueTask<bool> TryEnterAsync()`
`47`	`47`	`return ValueTask.FromResult(true);`
`48`	`48`	`}`
`49`	`49`
`50`		`- var task = _limiter.WaitAsync();`
	`50`	`+ var task = _limiter.WaitAndAcquireAsync();`
`51`	`51`	`if (task.IsCompletedSuccessfully)`
`52`	`52`	`{`
`53`	`53`	`lease = task.Result;`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,8 @@`
`30`	`30`	`// The global limiter will be a concurrency limiter with a max permit count of 10 and a queue depth of 5.`
`31`	`31`	`options.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(context =>`
`32`	`32`	`{`
`33`		`- return RateLimitPartition.CreateConcurrencyLimiter<string>("globalLimiter", key => new ConcurrencyLimiterOptions(10, QueueProcessingOrder.NewestFirst, 5));`
	`33`	`+`
	`34`	`+ return RateLimitPartition.GetConcurrencyLimiter<string>("globalLimiter", key => new ConcurrencyLimiterOptions(10, QueueProcessingOrder.NewestFirst, 5));`
`34`	`35`	`});`
`35`	`36`	`app.UseRateLimiter(options);`
`36`	`37`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,6 @@ public SampleRateLimiterPolicy(ILogger<SampleRateLimiterPolicy> logger)`
`25`	`25`	`// Use a sliding window limiter allowing 1 request every 10 seconds`
`26`	`26`	`public RateLimitPartition<string> GetPartition(HttpContext httpContext)`
`27`	`27`	`{`
`28`		`- return RateLimitPartition.CreateSlidingWindowLimiter<string>(string.Empty, key => new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 1, TimeSpan.FromSeconds(5), 1));`
	`28`	`+ return RateLimitPartition.GetSlidingWindowLimiter<string>(string.Empty, key => new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 1, TimeSpan.FromSeconds(5), 1));`
`29`	`29`	`}`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public static RateLimiterOptions AddTokenBucketLimiter(this RateLimiterOptions o`
`22`	`22`	`var key = new PolicyNameKey() { PolicyName = policyName };`
`23`	`23`	`return options.AddPolicy(policyName, context =>`
`24`	`24`	`{`
`25`		`- return RateLimitPartition.CreateTokenBucketLimiter(key,`
	`25`	`+ return RateLimitPartition.GetTokenBucketLimiter(key,`
`26`	`26`	`_ => tokenBucketRateLimiterOptions);`
`27`	`27`	`});`
`28`	`28`	`}`
`@@ -39,7 +39,7 @@ public static RateLimiterOptions AddFixedWindowLimiter(this RateLimiterOptions o`
`39`	`39`	`var key = new PolicyNameKey() { PolicyName = policyName };`
`40`	`40`	`return options.AddPolicy(policyName, context =>`
`41`	`41`	`{`
`42`		`- return RateLimitPartition.CreateFixedWindowLimiter(key,`
	`42`	`+ return RateLimitPartition.GetFixedWindowLimiter(key,`
`43`	`43`	`_ => fixedWindowRateLimiterOptions);`
`44`	`44`	`});`
`45`	`45`	`}`
`@@ -56,7 +56,7 @@ public static RateLimiterOptions AddSlidingWindowLimiter(this RateLimiterOptions`
`56`	`56`	`var key = new PolicyNameKey() { PolicyName = policyName };`
`57`	`57`	`return options.AddPolicy(policyName, context =>`
`58`	`58`	`{`
`59`		`- return RateLimitPartition.CreateSlidingWindowLimiter(key,`
	`59`	`+ return RateLimitPartition.GetSlidingWindowLimiter(key,`
`60`	`60`	`_ => slidingWindowRateLimiterOptions);`
`61`	`61`	`});`
`62`	`62`	`}`
`@@ -73,7 +73,7 @@ public static RateLimiterOptions AddConcurrencyLimiter(this RateLimiterOptions o`
`73`	`73`	`var key = new PolicyNameKey() { PolicyName = policyName };`
`74`	`74`	`return options.AddPolicy(policyName, context =>`
`75`	`75`	`{`
`76`		`- return RateLimitPartition.CreateConcurrencyLimiter(key,`
	`76`	`+ return RateLimitPartition.GetConcurrencyLimiter(key,`
`77`	`77`	`_ => concurrencyLimiterOptions);`
`78`	`78`	`});`
`79`	`79`	`}`
`@@ -89,7 +89,7 @@ public static RateLimiterOptions AddNoLimiter(this RateLimiterOptions options, s`
`89`	`89`	`var key = new PolicyNameKey() { PolicyName = policyName };`
`90`	`90`	`return options.AddPolicy(policyName, context =>`
`91`	`91`	`{`
`92`		`- return RateLimitPartition.CreateNoLimiter(key);`
	`92`	`+ return RateLimitPartition.GetNoLimiter(key);`
`93`	`93`	`});`
`94`	`94`	`}`
`95`	`95`	`}`
Original file line number	Diff line number	Diff line change
`@@ -142,13 +142,13 @@ private async ValueTask<LeaseContext> CombinedWaitAsync(HttpContext context, Can`
`142`	`142`	`{`
`143`	`143`	`if (_globalLimiter is not null)`
`144`	`144`	`{`
`145`		`- globalLease = await _globalLimiter.WaitAsync(context, cancellationToken: cancellationToken);`
	`145`	`+ globalLease = await _globalLimiter.WaitAndAcquireAsync(context, cancellationToken: cancellationToken);`
`146`	`146`	`if (!globalLease.IsAcquired)`
`147`	`147`	`{`
`148`	`148`	`return new LeaseContext() { GlobalRejected = true, Lease = globalLease };`
`149`	`149`	`}`
`150`	`150`	`}`
`151`		`- endpointLease = await _endpointLimiter.WaitAsync(context, cancellationToken: cancellationToken);`
	`151`	`+ endpointLease = await _endpointLimiter.WaitAndAcquireAsync(context, cancellationToken: cancellationToken);`
`152`	`152`	`if (!endpointLease.IsAcquired)`
`153`	`153`	`{`
`154`	`154`	`globalLease?.Dispose();`
`@@ -183,7 +183,7 @@ private PartitionedRateLimiter<HttpContext> CreateEndpointLimiter()`
`183`	`183`	`throw new InvalidOperationException($"This endpoint requires a rate limiting policy with name {name}, but no such policy exists.");`
`184`	`184`	`}`
`185`	`185`	`}`
`186`		`- return RateLimitPartition.CreateNoLimiter<DefaultKeyType>(_defaultPolicyKey);`
	`186`	`+ return RateLimitPartition.GetNoLimiter<DefaultKeyType>(_defaultPolicyKey);`
`187`	`187`	`}, new DefaultKeyTypeEqualityComparer());`
`188`	`188`	`}`
`189`	`189`
Original file line number	Diff line number	Diff line change
`@@ -160,7 +160,7 @@ public async Task EndpointLimiter_Rejects()`
`160`	`160`	`var name = "myEndpoint";`
`161`	`161`	`options.Value.AddPolicy<string>(name, (context =>`
`162`	`162`	`{`
`163`		`- return RateLimitPartition.Create<string>("myLimiter", (key =>`
	`163`	`+ return RateLimitPartition.Get<string>("myLimiter", (key =>`
`164`	`164`	`{`
`165`	`165`	`return new TestRateLimiter(false);`
`166`	`166`	`}));`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public class RateLimitingOptionsTests`
`13`	`13`	`public void AddPolicy_ThrowsOnNullPolicyName()`
`14`	`14`	`{`
`15`	`15`	`var options = new RateLimiterOptions();`
`16`		`- Assert.Throws<ArgumentNullException>(() => options.AddPolicy<string>(null, context => RateLimitPartition.CreateNoLimiter<string>("myKey")));`
	`16`	`+ Assert.Throws<ArgumentNullException>(() => options.AddPolicy<string>(null, context => RateLimitPartition.GetNoLimiter<string>("myKey")));`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`[Fact]`
`@@ -34,15 +34,15 @@ public void AddPolicy_ThrowsOnNullPolicy()`
`34`	`34`	`public void AddPolicy_ThrowsOnDuplicateName()`
`35`	`35`	`{`
`36`	`36`	`var options = new RateLimiterOptions();`
`37`		`- options.AddPolicy<string>("myKey", context => RateLimitPartition.CreateNoLimiter<string>("myKey"));`
`38`		`- Assert.Throws<ArgumentException>(() => options.AddPolicy<string>("myKey", context => RateLimitPartition.CreateNoLimiter<string>("yourKey")));`
	`37`	`+ options.AddPolicy<string>("myKey", context => RateLimitPartition.GetNoLimiter<string>("myKey"));`
	`38`	`+ Assert.Throws<ArgumentException>(() => options.AddPolicy<string>("myKey", context => RateLimitPartition.GetNoLimiter<string>("yourKey")));`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`[Fact]`
`42`	`42`	`public void AddPolicy_Generic_ThrowsOnDuplicateName()`
`43`	`43`	`{`
`44`	`44`	`var options = new RateLimiterOptions();`
`45`		`- options.AddPolicy<string>("myKey", context => RateLimitPartition.CreateNoLimiter<string>("myKey"));`
	`45`	`+ options.AddPolicy<string>("myKey", context => RateLimitPartition.GetNoLimiter<string>("myKey"));`
`46`	`46`	`Assert.Throws<ArgumentException>(() => options.AddPolicy<string, TestRateLimiterPolicy>("myKey"));`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ protected override RateLimitLease AcquireCore(TResource resourceID, int permitCo`
`57`	`57`	`return new TestRateLimitLease(true, leases);`
`58`	`58`	`}`
`59`	`59`
`60`		`- protected override async ValueTask<RateLimitLease> WaitAsyncCore(TResource resourceID, int permitCount, CancellationToken cancellationToken)`
	`60`	`+ protected override async ValueTask<RateLimitLease> WaitAndAcquireAsyncCore(TResource resourceID, int permitCount, CancellationToken cancellationToken)`
`61`	`61`	`{`
`62`	`62`	`if (permitCount != 1)`
`63`	`63`	`{`
`@@ -66,7 +66,7 @@ protected override async ValueTask<RateLimitLease> WaitAsyncCore(TResource resou`
`66`	`66`	`var leases = new List<RateLimitLease>();`
`67`	`67`	`foreach (var limiter in limiters)`
`68`	`68`	`{`
`69`		`- leases.Add(await limiter.WaitAsync());`
	`69`	`+ leases.Add(await limiter.WaitAndAcquireAsync());`
`70`	`70`	`}`
`71`	`71`	`foreach (var lease in leases)`
`72`	`72`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.Threading.RateLimiting;`
`5`	`5`
`6`	`6`	`namespace Microsoft.AspNetCore.RateLimiting;`
	`7`	`+`
`7`	`8`	`internal class TestRateLimiter : RateLimiter`
`8`	`9`	`{`
`9`	`10`	`private readonly bool _alwaysAccept;`
`@@ -25,7 +26,7 @@ protected override RateLimitLease AcquireCore(int permitCount)`
`25`	`26`	`return new TestRateLimitLease(_alwaysAccept, null);`
`26`	`27`	`}`
`27`	`28`
`28`		`- protected override ValueTask<RateLimitLease> WaitAsyncCore(int permitCount, CancellationToken cancellationToken)`
	`29`	`+ protected override ValueTask<RateLimitLease> WaitAndAcquireAsyncCore(int permitCount, CancellationToken cancellationToken)`
`29`	`30`	`{`
`30`	`31`	`cancellationToken.ThrowIfCancellationRequested();`
`31`	`32`	`return new ValueTask<RateLimitLease>(new TestRateLimitLease(_alwaysAccept, null));`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public TestRateLimiterPolicy(string key, int statusCode, bool alwaysAccept)`
`27`	`27`
`28`	`28`	`public RateLimitPartition<string> GetPartition(HttpContext httpContext)`
`29`	`29`	`{`
`30`		`- return RateLimitPartition.Create<string>(_key, (key =>`
	`30`	`+ return RateLimitPartition.Get<string>(_key, (key =>`
`31`	`31`	`{`
`32`	`32`	`return new TestRateLimiter(_alwaysAccept);`
`33`	`33`	`}));`