Add RateLimitPolicy

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 7.3.0
+
+- Add RateLimit policy - Thanks to [@reisenberger](https://github.com/reisenberger)
+
 ## 7.2.2
 
 - Recursively search all `AggregateException` inner exceptions for predicate matches when using `HandleInner()` ([#818](https://github.com/App-vNext/Polly/issues/818)) - Thanks to [@sideproject](https://github.com/sideproject)

GitVersionConfig.yaml

@@ -1 +1 @@
-next-version: 7.2.2
+next-version: 7.3.0

build.cake

@@ -16,8 +16,8 @@ var configuration = Argument<string>("configuration", "Release");
 // EXTERNAL NUGET LIBRARIES
 //////////////////////////////////////////////////////////////////////
 
-#addin "Cake.FileHelpers"
-#addin nuget:?package=Cake.Yaml
+#addin nuget:?package=Cake.FileHelpers&version=3.3.0
+#addin nuget:?package=Cake.Yaml&version=3.1.1
 #addin nuget:?package=YamlDotNet&version=5.2.1
 
 ///////////////////////////////////////////////////////////////////////////////

build.ps1

@@ -111,7 +111,7 @@ if(-Not $SkipToolPackageRestore.IsPresent)
     # Install just Cake if missing config
     else
     {
-        $NuGetOutput = Invoke-Expression "&`"$NUGET_EXE`" install Cake -Version 0.25.0 -ExcludeVersion" # Pin Cake version to 0.25.0; see https://github.com/App-vNext/Polly/issues/416 
+        $NuGetOutput = Invoke-Expression "&`"$NUGET_EXE`" install Cake -Version 0.38.5 -ExcludeVersion" # Pin Cake version to 0.38.5; see https://github.com/App-vNext/Polly/issues/416 
         Write-Verbose ($NuGetOutput | Out-String)
     }
     Pop-Location

src/Polly.Benchmarks/Polly.Benchmarks.csproj

@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
+    <IsPackable>false</IsPackable>
     <LangVersion>latest</LangVersion>
     <OutputType>Exe</OutputType>
     <TargetFramework>net5.0</TargetFramework>

src/Polly.Specs/Helpers/RateLimit/IRateLimiterExtensions.cs

@@ -0,0 +1,40 @@
+using System;
+using FluentAssertions;
+using Polly.RateLimit;
+
+namespace Polly.Specs.Helpers.RateLimit
+{
+    internal static class IRateLimiterExtensions
+    {
+        public static void ShouldPermitAnExecution(this IRateLimiter rateLimiter)
+        {
+            (bool permitExecution, TimeSpan retryAfter) canExecute = rateLimiter.PermitExecution();
+
+            canExecute.permitExecution.Should().BeTrue();
+            canExecute.retryAfter.Should().Be(TimeSpan.Zero);
+        }
+
+        public static void ShouldPermitNExecutions(this IRateLimiter rateLimiter, long numberOfExecutions)
+        {
+            for (int execution = 0; execution < numberOfExecutions; execution++)
+            {
+                rateLimiter.ShouldPermitAnExecution();
+            }
+        }
+
+        public static void ShouldNotPermitAnExecution(this IRateLimiter rateLimiter, TimeSpan? retryAfter = null)
+        {
+            (bool permitExecution, TimeSpan retryAfter) canExecute = rateLimiter.PermitExecution();
+
+            canExecute.permitExecution.Should().BeFalse();
+            if (retryAfter == null)
+            {
+                canExecute.retryAfter.Should().BeGreaterThan(TimeSpan.Zero);
+            }
+            else
+            {
+                canExecute.retryAfter.Should().Be(retryAfter.Value);
+            }
+        }
+    }
+}

src/Polly.Specs/Helpers/RateLimit/ResultClassWithRetryAfter.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Polly.Specs.Helpers.RateLimit
+{
+    internal class ResultClassWithRetryAfter : ResultClass
+    {
+        public TimeSpan RetryAfter { get; }
+
+        public ResultClassWithRetryAfter(ResultPrimitive result)
+        : base(result)
+        {
+            RetryAfter = TimeSpan.Zero;
+        }
+
+        public ResultClassWithRetryAfter(TimeSpan retryAfter)
+        : base(ResultPrimitive.Undefined)
+        {
+            RetryAfter = retryAfter;
+        }
+    }
+}

src/Polly.Specs/RateLimit/AsyncRateLimitPolicySpecs.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Threading.Tasks;
+using Polly.RateLimit;
+using Polly.Specs.Helpers;
+using Polly.Specs.Helpers.RateLimit;
+using Polly.Utilities;
+using Xunit;
+
+namespace Polly.Specs.RateLimit
+{
+    [Collection(Polly.Specs.Helpers.Constants.SystemClockDependentTestCollection)]
+    public class AsyncRateLimitPolicySpecs : RateLimitPolicySpecsBase, IDisposable
+    {
+        public void Dispose()
+        {
+            SystemClock.Reset();
+        }
+
+        protected override IRateLimitPolicy GetPolicyViaSyntax(int numberOfExecutions, TimeSpan perTimeSpan)
+        {
+            return Policy.RateLimitAsync(numberOfExecutions, perTimeSpan);
+        }
+
+        protected override IRateLimitPolicy GetPolicyViaSyntax(int numberOfExecutions, TimeSpan perTimeSpan, int maxBurst)
+        {
+            return Policy.RateLimitAsync(numberOfExecutions, perTimeSpan, maxBurst);
+        }
+
+        protected override (bool, TimeSpan) TryExecuteThroughPolicy(IRateLimitPolicy policy)
+        {
+            if (policy is AsyncRateLimitPolicy typedPolicy)
+            {
+                try
+                {
+                    typedPolicy.ExecuteAsync(() => Task.FromResult(new ResultClassWithRetryAfter(ResultPrimitive.Good))).GetAwaiter().GetResult();
+                    return (true, TimeSpan.Zero);
+                }
+                catch (RateLimitRejectedException e)
+                {
+                    return (false, e.RetryAfter);
+                }
+            }
+            else
+            {
+                throw new InvalidOperationException("Unexpected policy type in test construction.");
+            }
+        }
+    }
+}

src/Polly.Specs/RateLimit/AsyncRateLimitPolicyTResultSpecs.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Threading.Tasks;
+using Polly.RateLimit;
+using Polly.Specs.Helpers;
+using Polly.Specs.Helpers.RateLimit;
+using Polly.Utilities;
+using Xunit;
+
+namespace Polly.Specs.RateLimit
+{
+    [Collection(Polly.Specs.Helpers.Constants.SystemClockDependentTestCollection)]
+    public class AsyncRateLimitPolicyTResultSpecs : RateLimitPolicyTResultSpecsBase, IDisposable
+    {
+        public void Dispose()
+        {
+            SystemClock.Reset();
+        }
+
+        protected override IRateLimitPolicy GetPolicyViaSyntax(int numberOfExecutions, TimeSpan perTimeSpan)
+        {
+            return Policy.RateLimitAsync<ResultClassWithRetryAfter>(numberOfExecutions, perTimeSpan);
+        }
+
+        protected override IRateLimitPolicy GetPolicyViaSyntax(int numberOfExecutions, TimeSpan perTimeSpan, int maxBurst)
+        {
+            return Policy.RateLimitAsync<ResultClassWithRetryAfter>(numberOfExecutions, perTimeSpan, maxBurst);
+        }
+
+        protected override IRateLimitPolicy<TResult> GetPolicyViaSyntax<TResult>(int numberOfExecutions, TimeSpan perTimeSpan, int maxBurst,
+            Func<TimeSpan, Context, TResult> retryAfterFactory)
+        {
+            return Policy.RateLimitAsync<TResult>(numberOfExecutions, perTimeSpan, maxBurst, retryAfterFactory);
+        }
+
+        protected override (bool, TimeSpan) TryExecuteThroughPolicy(IRateLimitPolicy policy)
+        {
+            if (policy is AsyncRateLimitPolicy<ResultClassWithRetryAfter> typedPolicy)
+            {
+                try
+                {
+                    typedPolicy.ExecuteAsync(() => Task.FromResult(new ResultClassWithRetryAfter(ResultPrimitive.Good))).GetAwaiter().GetResult();
+                    return (true, TimeSpan.Zero);
+                }
+                catch (RateLimitRejectedException e)
+                {
+                    return (false, e.RetryAfter);
+                }
+            }
+            else
+            {
+                throw new InvalidOperationException("Unexpected policy type in test construction.");
+            }
+        }
+
+        protected override TResult TryExecuteThroughPolicy<TResult>(IRateLimitPolicy<TResult> policy, Context context, TResult resultIfExecutionPermitted)
+        {
+            if (policy is AsyncRateLimitPolicy<TResult> typedPolicy)
+            {
+                return typedPolicy.ExecuteAsync(ctx => Task.FromResult(resultIfExecutionPermitted), context).GetAwaiter().GetResult();
+            }
+            else
+            {
+                throw new InvalidOperationException("Unexpected policy type in test construction.");
+            }
+        }
+    }
+}

src/Polly.Specs/RateLimit/LockFreeTokenBucketRateLimiterTests.cs

@@ -0,0 +1,11 @@
+using System;
+using Polly.RateLimit;
+
+namespace Polly.Specs.RateLimit
+{
+    public class LockFreeTokenBucketRateLimiterTests : TokenBucketRateLimiterTestsBase
+    {
+        internal override IRateLimiter GetRateLimiter(TimeSpan onePer, long bucketCapacity)
+            => new LockFreeTokenBucketRateLimiter(onePer, bucketCapacity);
+    }
+}

src/Polly.Specs/RateLimit/RateLimitPolicySpecs.cs

@@ -0,0 +1,48 @@
+using System;
+using Polly.RateLimit;
+using Polly.Specs.Helpers;
+using Polly.Specs.Helpers.RateLimit;
+using Polly.Utilities;
+using Xunit;
+
+namespace Polly.Specs.RateLimit
+{
+    [Collection(Polly.Specs.Helpers.Constants.SystemClockDependentTestCollection)]
+    public class RateLimitPolicySpecs : RateLimitPolicySpecsBase, IDisposable
+    {
+        public void Dispose()
+        {
+            SystemClock.Reset();
+        }
+
+        protected override IRateLimitPolicy GetPolicyViaSyntax(int numberOfExecutions, TimeSpan perTimeSpan)
+        {
+            return Policy.RateLimit(numberOfExecutions, perTimeSpan);
+        }
+
+        protected override IRateLimitPolicy GetPolicyViaSyntax(int numberOfExecutions, TimeSpan perTimeSpan, int maxBurst)
+        {
+            return Policy.RateLimit(numberOfExecutions, perTimeSpan, maxBurst);
+        }
+
+        protected override (bool, TimeSpan) TryExecuteThroughPolicy(IRateLimitPolicy policy)
+        {
+            if (policy is RateLimitPolicy typedPolicy)
+            {
+                try
+                {
+                    typedPolicy.Execute(() => new ResultClassWithRetryAfter(ResultPrimitive.Good));
+                    return (true, TimeSpan.Zero);
+                }
+                catch (RateLimitRejectedException e)
+                {
+                    return (false, e.RetryAfter);
+                }
+            }
+            else
+            {
+                throw new InvalidOperationException("Unexpected policy type in test construction.");
+            }
+        }
+    }
+}