Polly V8: Public API Review

ApiReview/API.Polly.Core/AssemblyDependencies.txt

@@ -0,0 +1,10 @@
+System.Collections
+System.Collections.Concurrent
+System.ComponentModel.Annotations
+System.Linq
+System.Private.CoreLib
+System.Private.Uri
+System.Runtime
+System.Runtime.CompilerServices.Unsafe
+System.Runtime.InteropServices
+System.Threading

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/BrokenCircuitException.TResult.cs

@@ -0,0 +1,14 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Polly.CircuitBreaker;
+
+public class BrokenCircuitException<TResult> : BrokenCircuitException
+{
+    public TResult Result { get; }
+    public BrokenCircuitException(TResult result);
+    public BrokenCircuitException(string message, TResult result);
+    public BrokenCircuitException(string message, Exception inner, TResult result);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/BrokenCircuitException.cs

@@ -0,0 +1,12 @@
+// Assembly 'Polly.Core'
+
+using System;
+
+namespace Polly.CircuitBreaker;
+
+public class BrokenCircuitException : ExecutionRejectedException
+{
+    public BrokenCircuitException();
+    public BrokenCircuitException(string message);
+    public BrokenCircuitException(string message, Exception inner);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/CircuitBreakerManualControl.cs

@@ -0,0 +1,19 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Polly.CircuitBreaker;
+
+public sealed class CircuitBreakerManualControl : IDisposable
+{
+    public CircuitBreakerManualControl();
+    public CircuitBreakerManualControl(bool isIsolated);
+    public Task IsolateAsync(CancellationToken cancellationToken = default(CancellationToken));
+    public Task CloseAsync(CancellationToken cancellationToken = default(CancellationToken));
+    public void Dispose();
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/CircuitBreakerPredicateArguments.cs

@@ -0,0 +1,10 @@
+// Assembly 'Polly.Core'
+
+using System.Runtime.InteropServices;
+
+namespace Polly.CircuitBreaker;
+
+[StructLayout(LayoutKind.Sequential, Size = 1)]
+public readonly struct CircuitBreakerPredicateArguments
+{
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/CircuitBreakerStateProvider.cs

@@ -0,0 +1,11 @@
+// Assembly 'Polly.Core'
+
+using System;
+
+namespace Polly.CircuitBreaker;
+
+public sealed class CircuitBreakerStateProvider
+{
+    public CircuitState CircuitState { get; }
+    public CircuitBreakerStateProvider();
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/CircuitBreakerStrategyOptions.TResult.cs

@@ -0,0 +1,28 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+namespace Polly.CircuitBreaker;
+
+public class CircuitBreakerStrategyOptions<TResult> : ResilienceStrategyOptions
+{
+    [Range(0.0, 1.0)]
+    public double FailureRatio { get; set; }
+    [Range(2, int.MaxValue)]
+    public int MinimumThroughput { get; set; }
+    [Range(typeof(TimeSpan), "00:00:00.500", "1.00:00:00")]
+    public TimeSpan SamplingDuration { get; set; }
+    [Range(typeof(TimeSpan), "00:00:00.500", "1.00:00:00")]
+    public TimeSpan BreakDuration { get; set; }
+    [Required]
+    public Func<OutcomeArguments<TResult, CircuitBreakerPredicateArguments>, ValueTask<bool>> ShouldHandle { get; set; }
+    public Func<OutcomeArguments<TResult, OnCircuitClosedArguments>, ValueTask>? OnClosed { get; set; }
+    public Func<OutcomeArguments<TResult, OnCircuitOpenedArguments>, ValueTask>? OnOpened { get; set; }
+    public Func<OnCircuitHalfOpenedArguments, ValueTask>? OnHalfOpened { get; set; }
+    public CircuitBreakerManualControl? ManualControl { get; set; }
+    public CircuitBreakerStateProvider? StateProvider { get; set; }
+    public CircuitBreakerStrategyOptions();
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/CircuitBreakerStrategyOptions.cs

@@ -0,0 +1,8 @@
+// Assembly 'Polly.Core'
+
+namespace Polly.CircuitBreaker;
+
+public class CircuitBreakerStrategyOptions : CircuitBreakerStrategyOptions<object>
+{
+    public CircuitBreakerStrategyOptions();
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/CircuitState.cs

@@ -0,0 +1,11 @@
+// Assembly 'Polly.Core'
+
+namespace Polly.CircuitBreaker;
+
+public enum CircuitState
+{
+    Closed = 0,
+    Open = 1,
+    HalfOpen = 2,
+    Isolated = 3
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/IsolatedCircuitException.cs

@@ -0,0 +1,12 @@
+// Assembly 'Polly.Core'
+
+using System;
+
+namespace Polly.CircuitBreaker;
+
+public class IsolatedCircuitException : BrokenCircuitException
+{
+    public IsolatedCircuitException();
+    public IsolatedCircuitException(string message);
+    public IsolatedCircuitException(string message, Exception innerException);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/OnCircuitClosedArguments.cs

@@ -0,0 +1,11 @@
+// Assembly 'Polly.Core'
+
+using System.Runtime.CompilerServices;
+
+namespace Polly.CircuitBreaker;
+
+public readonly struct OnCircuitClosedArguments
+{
+    public bool IsManual { get; }
+    public OnCircuitClosedArguments(bool isManual);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/OnCircuitHalfOpenedArguments.cs

@@ -0,0 +1,11 @@
+// Assembly 'Polly.Core'
+
+using System.Runtime.CompilerServices;
+
+namespace Polly.CircuitBreaker;
+
+public readonly struct OnCircuitHalfOpenedArguments
+{
+    public ResilienceContext Context { get; }
+    public OnCircuitHalfOpenedArguments(ResilienceContext context);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.CircuitBreaker/OnCircuitOpenedArguments.cs

@@ -0,0 +1,13 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Polly.CircuitBreaker;
+
+public readonly struct OnCircuitOpenedArguments
+{
+    public TimeSpan BreakDuration { get; }
+    public bool IsManual { get; }
+    public OnCircuitOpenedArguments(TimeSpan breakDuration, bool isManual);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Fallback/FallbackPredicateArguments.cs

@@ -0,0 +1,10 @@
+// Assembly 'Polly.Core'
+
+using System.Runtime.InteropServices;
+
+namespace Polly.Fallback;
+
+[StructLayout(LayoutKind.Sequential, Size = 1)]
+public readonly struct FallbackPredicateArguments
+{
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Fallback/FallbackStrategyOptions.cs

@@ -0,0 +1,18 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+namespace Polly.Fallback;
+
+public class FallbackStrategyOptions<TResult> : ResilienceStrategyOptions
+{
+    [Required]
+    public Func<OutcomeArguments<TResult, FallbackPredicateArguments>, ValueTask<bool>> ShouldHandle { get; set; }
+    [Required]
+    public Func<OutcomeArguments<TResult, FallbackPredicateArguments>, ValueTask<Outcome<TResult>>>? FallbackAction { get; set; }
+    public Func<OutcomeArguments<TResult, OnFallbackArguments>, ValueTask>? OnFallback { get; set; }
+    public FallbackStrategyOptions();
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Fallback/OnFallbackArguments.cs

@@ -0,0 +1,10 @@
+// Assembly 'Polly.Core'
+
+using System.Runtime.InteropServices;
+
+namespace Polly.Fallback;
+
+[StructLayout(LayoutKind.Sequential, Size = 1)]
+public readonly struct OnFallbackArguments
+{
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Hedging/HedgingActionGeneratorArguments.cs

@@ -0,0 +1,16 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+namespace Polly.Hedging;
+
+public readonly struct HedgingActionGeneratorArguments<TResult>
+{
+    public ResilienceContext PrimaryContext { get; }
+    public ResilienceContext ActionContext { get; }
+    public int AttemptNumber { get; }
+    public Func<ResilienceContext, ValueTask<Outcome<TResult>>> Callback { get; }
+    public HedgingActionGeneratorArguments(ResilienceContext primaryContext, ResilienceContext actionContext, int attemptNumber, Func<ResilienceContext, ValueTask<Outcome<TResult>>> callback);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Hedging/HedgingDelayArguments.cs

@@ -0,0 +1,12 @@
+// Assembly 'Polly.Core'
+
+using System.Runtime.CompilerServices;
+
+namespace Polly.Hedging;
+
+public readonly struct HedgingDelayArguments
+{
+    public ResilienceContext Context { get; }
+    public int AttemptNumber { get; }
+    public HedgingDelayArguments(ResilienceContext context, int attemptNumber);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Hedging/HedgingPredicateArguments.cs

@@ -0,0 +1,10 @@
+// Assembly 'Polly.Core'
+
+using System.Runtime.InteropServices;
+
+namespace Polly.Hedging;
+
+[StructLayout(LayoutKind.Sequential, Size = 1)]
+public readonly struct HedgingPredicateArguments
+{
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Hedging/HedgingStrategyOptions.cs

@@ -0,0 +1,22 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+namespace Polly.Hedging;
+
+public class HedgingStrategyOptions<TResult> : ResilienceStrategyOptions
+{
+    public TimeSpan HedgingDelay { get; set; }
+    [Range(2, 10)]
+    public int MaxHedgedAttempts { get; set; }
+    [Required]
+    public Func<OutcomeArguments<TResult, HedgingPredicateArguments>, ValueTask<bool>> ShouldHandle { get; set; }
+    [Required]
+    public Func<HedgingActionGeneratorArguments<TResult>, Func<ValueTask<Outcome<TResult>>>?> HedgingActionGenerator { get; set; }
+    public Func<HedgingDelayArguments, ValueTask<TimeSpan>>? HedgingDelayGenerator { get; set; }
+    public Func<OutcomeArguments<TResult, OnHedgingArguments>, ValueTask>? OnHedging { get; set; }
+    public HedgingStrategyOptions();
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Hedging/OnHedgingArguments.cs

@@ -0,0 +1,14 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Polly.Hedging;
+
+public readonly struct OnHedgingArguments
+{
+    public int AttemptNumber { get; }
+    public bool HasOutcome { get; }
+    public TimeSpan Duration { get; }
+    public OnHedgingArguments(int attemptNumber, bool hasOutcome, TimeSpan duration);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Registry/ConfigureBuilderContext.cs

@@ -0,0 +1,15 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+namespace Polly.Registry;
+
+public class ConfigureBuilderContext<TKey> where TKey : notnull
+{
+    public TKey PipelineKey { get; }
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public void EnableReloads(Func<Func<CancellationToken>> tokenProducerFactory);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Registry/ResiliencePipelineProvider.cs

@@ -0,0 +1,14 @@
+// Assembly 'Polly.Core'
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Polly.Registry;
+
+public abstract class ResiliencePipelineProvider<TKey> where TKey : notnull
+{
+    public virtual ResiliencePipeline GetPipeline(TKey key);
+    public virtual ResiliencePipeline<TResult> GetPipeline<TResult>(TKey key);
+    public abstract bool TryGetPipeline(TKey key, [NotNullWhen(true)] out ResiliencePipeline? pipeline);
+    public abstract bool TryGetPipeline<TResult>(TKey key, [NotNullWhen(true)] out ResiliencePipeline<TResult>? pipeline);
+    protected ResiliencePipelineProvider();
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Registry/ResiliencePipelineRegistry.cs

@@ -0,0 +1,23 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Polly.Utils;
+
+namespace Polly.Registry;
+
+public sealed class ResiliencePipelineRegistry<TKey> : ResiliencePipelineProvider<TKey> where TKey : notnull
+{
+    public ResiliencePipelineRegistry();
+    public ResiliencePipelineRegistry(ResiliencePipelineRegistryOptions<TKey> options);
+    public override bool TryGetPipeline<TResult>(TKey key, [NotNullWhen(true)] out ResiliencePipeline<TResult>? pipeline);
+    public override bool TryGetPipeline(TKey key, [NotNullWhen(true)] out ResiliencePipeline? pipeline);
+    public ResiliencePipeline GetOrAddPipeline(TKey key, Action<ResiliencePipelineBuilder> configure);
+    public ResiliencePipeline GetOrAddPipeline(TKey key, Action<ResiliencePipelineBuilder, ConfigureBuilderContext<TKey>> configure);
+    public ResiliencePipeline<TResult> GetOrAddPipeline<TResult>(TKey key, Action<ResiliencePipelineBuilder<TResult>> configure);
+    public ResiliencePipeline<TResult> GetOrAddPipeline<TResult>(TKey key, Action<ResiliencePipelineBuilder<TResult>, ConfigureBuilderContext<TKey>> configure);
+    public bool TryAddBuilder(TKey key, Action<ResiliencePipelineBuilder, ConfigureBuilderContext<TKey>> configure);
+    public bool TryAddBuilder<TResult>(TKey key, Action<ResiliencePipelineBuilder<TResult>, ConfigureBuilderContext<TKey>> configure);
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Registry/ResiliencePipelineRegistryOptions.cs

@@ -0,0 +1,22 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Runtime.CompilerServices;
+
+namespace Polly.Registry;
+
+public class ResiliencePipelineRegistryOptions<TKey>
+{
+    [Required]
+    public Func<ResiliencePipelineBuilder> BuilderFactory { get; set; }
+    [Required]
+    public IEqualityComparer<TKey> PipelineComparer { get; set; }
+    [Required]
+    public IEqualityComparer<TKey> BuilderComparer { get; set; }
+    public Func<TKey, string>? InstanceNameFormatter { get; set; }
+    [Required]
+    public Func<TKey, string> BuilderNameFormatter { get; set; }
+    public ResiliencePipelineRegistryOptions();
+}

ApiReview/API.Polly.Core/NoDocs/Polly.Retry/OnRetryArguments.cs

@@ -0,0 +1,14 @@
+// Assembly 'Polly.Core'
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Polly.Retry;
+
+public readonly struct OnRetryArguments
+{
+    public int AttemptNumber { get; }
+    public TimeSpan RetryDelay { get; }
+    public TimeSpan ExecutionTime { get; }
+    public OnRetryArguments(int attemptNumber, TimeSpan retryDelay, TimeSpan executionTime);
+}