ReloadableResilienceStrategy
using Polly.Telemetry;
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Polly.Utils
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
internal sealed class ReloadableResilienceStrategy : ResilienceStrategy
{
[System.Runtime.CompilerServices.Nullable(0)]
internal readonly struct ReloadFailedArguments : IEquatable<ReloadFailedArguments>
{
public Exception Exception { get; set; }
public ReloadFailedArguments(Exception Exception)
{
Exception = Exception;
}
[System.Runtime.CompilerServices.NullableContext(0)]
[CompilerGenerated]
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("ReloadFailedArguments");
stringBuilder.Append(" { ");
if (PrintMembers(stringBuilder))
stringBuilder.Append(' ');
stringBuilder.Append('}');
return stringBuilder.ToString();
}
[System.Runtime.CompilerServices.NullableContext(0)]
[CompilerGenerated]
private bool PrintMembers(StringBuilder builder)
{
builder.Append("Exception = ");
builder.Append(Exception);
return true;
}
public static bool operator !=(ReloadFailedArguments left, ReloadFailedArguments right)
{
return !(left == right);
}
public static bool operator ==(ReloadFailedArguments left, ReloadFailedArguments right)
{
return left.Equals(right);
}
[CompilerGenerated]
public override int GetHashCode()
{
return EqualityComparer<Exception>.Default.GetHashCode(Exception);
}
[System.Runtime.CompilerServices.NullableContext(0)]
[CompilerGenerated]
public override bool Equals(object obj)
{
if (obj is ReloadFailedArguments)
return Equals((ReloadFailedArguments)obj);
return false;
}
[CompilerGenerated]
public bool Equals(ReloadFailedArguments other)
{
return EqualityComparer<Exception>.Default.Equals(Exception, other.Exception);
}
[CompilerGenerated]
public void Deconstruct(out Exception Exception)
{
Exception = this.Exception;
}
}
[StructLayout(LayoutKind.Sequential, Size = 1)]
[System.Runtime.CompilerServices.NullableContext(0)]
internal readonly struct OnReloadArguments : IEquatable<OnReloadArguments>
{
[CompilerGenerated]
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("OnReloadArguments");
stringBuilder.Append(" { ");
if (PrintMembers(stringBuilder))
stringBuilder.Append(' ');
stringBuilder.Append('}');
return stringBuilder.ToString();
}
[CompilerGenerated]
private bool PrintMembers(StringBuilder builder)
{
return false;
}
public static bool operator !=(OnReloadArguments left, OnReloadArguments right)
{
return !(left == right);
}
public static bool operator ==(OnReloadArguments left, OnReloadArguments right)
{
return left.Equals(right);
}
[CompilerGenerated]
public override int GetHashCode()
{
return 0;
}
[CompilerGenerated]
public override bool Equals(object obj)
{
if (obj is OnReloadArguments)
return Equals((OnReloadArguments)obj);
return false;
}
[CompilerGenerated]
public bool Equals(OnReloadArguments other)
{
return true;
}
}
public const string StrategyName = "ReloadableStrategy";
public const string StrategyType = "ReloadableStrategy";
public const string ReloadFailedEvent = "ReloadFailed";
public const string OnReloadEvent = "OnReload";
private readonly Func<CancellationToken> _onReload;
private readonly Func<ResilienceStrategy> _resilienceStrategyFactory;
private readonly ResilienceStrategyTelemetry _telemetry;
private CancellationTokenRegistration _registration;
public ResilienceStrategy Strategy { get; set; }
public ReloadableResilienceStrategy(ResilienceStrategy initialStrategy, Func<CancellationToken> onReload, Func<ResilienceStrategy> resilienceStrategyFactory, ResilienceStrategyTelemetry telemetry)
{
Strategy = initialStrategy;
_onReload = onReload;
_resilienceStrategyFactory = resilienceStrategyFactory;
_telemetry = telemetry;
RegisterOnReload(default(CancellationToken));
}
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
0,
1
})]
protected internal override ValueTask<Outcome<TResult>> ExecuteCoreAsync<[System.Runtime.CompilerServices.Nullable(2)] TResult, [System.Runtime.CompilerServices.Nullable(2)] TState>([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
1,
1,
0,
0,
1
})] Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback, ResilienceContext context, TState state)
{
return Strategy.ExecuteCoreAsync(callback, context, state);
}
private void RegisterOnReload(CancellationToken previousToken)
{
CancellationToken token = _onReload();
if (!(token == previousToken))
_registration = token.Register(delegate {
ResilienceContext context = ResilienceContext.Get(default(CancellationToken)).Initialize<VoidResult>(true);
try {
_telemetry.Report(new ResilienceEvent(ResilienceEventSeverity.Information, "OnReload"), context, new OnReloadArguments());
Strategy = _resilienceStrategyFactory();
} catch (Exception exception) {
OutcomeArguments<VoidResult, ReloadFailedArguments> args = new OutcomeArguments<VoidResult, ReloadFailedArguments>(context, Outcome.FromException(exception), new ReloadFailedArguments(exception));
_telemetry.Report(new ResilienceEvent(ResilienceEventSeverity.Error, "ReloadFailed"), args);
ResilienceContext.Return(context);
}
_registration.Dispose();
RegisterOnReload(token);
});
}
}
}