Does disposing a pipeline registry dispose chained limiters?

[lonix1]

One benefit of the "resilience registry" is that it is easy to dispose:

The registry caches and manages all pipelines and resources linked to them. When you dispose of the registry, all pipelines created by it are also disposed of and can't be used anymore.

Does that also include chained rate limiters?

Suppose I have a pipeline with multiple limiters (e.g. concurrency limiter and rate limiter) and also a chained rate limiter which itself contains rate limiters - are all of those disposed when the registry is disposed?

[migig]

@lonix1 Hi, do you already have this knowledge? I need this solution also.

[peter-csala]

I think there is some misunderstanding so, let me try to clarify.

Registry and Pipeline

So, whenever you register a pipeline inside a registry then you can't dispose the pipeline directly. (The DisposeHelper is internal.)

Polly/test/Polly.Core.Tests/Registry/ResiliencePipelineRegistryTests.cs

Lines 439 to 446 in 4f0d44a

	public async Task DisposePipeline_NotAllowed()
	{
	using var registry = CreateRegistry();
	var pipeline = registry.GetOrAddPipeline(StrategyId.Create("A"), builder => { builder.AddTimeout(TimeSpan.FromSeconds(1)); });
	await pipeline.Invoking(p => p.DisposeHelper.DisposeAsync().AsTask()).Should().ThrowAsync<InvalidOperationException>();
	}

You can only dispose the pipeline through the registry:

Polly/test/Polly.Core.Tests/Registry/ResiliencePipelineRegistryTests.cs

Lines 410 to 436 in 4f0d44a

	public async Task Dispose_EnsureDisposed(bool isAsync)
	{
	var registry = CreateRegistry();
	var pipeline1 = registry.GetOrAddPipeline(StrategyId.Create("A"), builder => { builder.AddTimeout(TimeSpan.FromSeconds(1)); });
	var pipeline2 = registry.GetOrAddPipeline(StrategyId.Create("B"), builder => { builder.AddTimeout(TimeSpan.FromSeconds(1)); });
	var pipeline3 = registry.GetOrAddPipeline<string>(StrategyId.Create("C"), builder => { builder.AddTimeout(TimeSpan.FromSeconds(1)); });
	var pipeline4 = registry.GetOrAddPipeline<string>(StrategyId.Create("D"), builder => { builder.AddTimeout(TimeSpan.FromSeconds(1)); });
	#pragma warning disable S3966 // Objects should not be disposed more than once
	if (isAsync)
	{
	await registry.DisposeAsync();
	await registry.DisposeAsync();
	}
	else
	{
	registry.Dispose();
	registry.Dispose();
	}
	#pragma warning restore S3966 // Objects should not be disposed more than once
	pipeline1.Invoking(p => p.Execute(() => { })).Should().Throw<ObjectDisposedException>();
	pipeline2.Invoking(p => p.Execute(() => { })).Should().Throw<ObjectDisposedException>();
	pipeline3.Invoking(p => p.Execute(() => "dummy")).Should().Throw<ObjectDisposedException>();
	pipeline4.Invoking(p => p.Execute(() => "dummy")).Should().Throw<ObjectDisposedException>();
	}

Disposed Pipeline

After the registry has been disposed you obviously can't retrieve a pipeline because you will get an ObjectDisposedException.

Let's suppose you have retrieved a pipeline just before the registry disposal. If you want to invoke a method on the pipeline like the Execute{Async} then you will receive an ObjectDisposedException.

Retrieving a strategy from a pipeline can be achieved via Polly.Testing. But the strategies are defined as internal. Also the ResilienceStrategy's ExecuteCore is internal. But with a bit of reflection magic it can be called

var registry = new ResiliencePipelineRegistry<string>();
registry.TryAddBuilder("A", (builder, _) =>
{
	builder.AddRateLimiter(new SlidingWindowRateLimiter(
		new SlidingWindowRateLimiterOptions
		{
			PermitLimit = 10,
			Window = TimeSpan.FromMinutes(1),
			SegmentsPerWindow = 1
		}));
});

var pipeline = registry.GetPipeline("A");
registry.Dispose();

try
{
	pipeline.Execute(() => {});
}
catch(ObjectDisposedException)
{
	Console.WriteLine("Pipeline has been disposed");
}

var strategy = pipeline.GetPipelineDescriptor().FirstStrategy.StrategyInstance;
var executeCore = typeof(ResilienceStrategy).GetMethod("ExecuteCore", BindingFlags.Instance | BindingFlags.NonPublic);
executeCore = executeCore.MakeGenericMethod(new[] {typeof(object), typeof(object)});

var context = ResilienceContextPool.Shared.Get();
Func<ResilienceContext, object, ValueTask<Outcome<object>>> callback = (_, __) => Outcome.FromResultAsValueTask<object>("Test");
var executeTask = (ValueTask<Outcome<object>>)executeCore.Invoke(strategy, parameters: [callback, context, null]);
var executeOutcome = await executeTask;
ResilienceContextPool.Shared.Return(context);

Console.WriteLine(executeOutcome.Result);

It will print

Pipeline has been disposed
Test

So, as you can see the pipeline is disposed but the strategy isn't.

Dotnet Fiddle

[lonix1]

Happy New Year @peter-csala. Thanks for that detail, it's helpful.

To be sure I understand you, here is a simplified example:

_resiliencePipelineRegistry.TryAddBuilder("A", (builder, context) => {

  builder.AddRateLimiter(new RateLimiterStrategyOptions {
    RateLimiter = args => CreateRateLimiter(...).AcquireAsync(...)                         // (1)
  });

  builder.AddRateLimiter(new RateLimiterStrategyOptions {
    RateLimiter = args => PartitionedRateLimiter.CreateChained(...).AcquireAsync(...)      // (2)
  });

});

I'm using IDisposableAnalyzers to detect undisposed resources. It warns me that both (1) and (2) should be disposed.

Will those rate limiters (even a "chained" one which contains other limiters) be disposed by the registry itself?

[migig]

@lonix1 Thank you for code which I will study.

This message actually regarding https://github.com/DotNetAnalyzers/IDisposableAnalyzers. I try on large project and find many bugs for me - thank you!

[peter-csala]

Happy New Year @lonix1 you too!

Polly.Core

Let's see what happens when you call the Dispose{Async} on the registry.

1. The ResiliencePipelineRegistry's Dispose calls the ResiliencePipeline's DisposeHelper.ForceDisposeAsync()
2. The ResiliencePipeline's DisposeHelper is a ComponentDisposeHelper
3. The ComponentDisposeHelper wraps the component and exposes several Dispose related helper methods
4. The ForceDisposeAsync calls the DisposeAsync on component
5. The component is a PipelineComponent which defines the DisposeAsync as abstract
6. For example the CompositeComponent's DisposeAsync calls all its components' DisposeAsync

As you can see on the following image the PipelineComponent is a strategy (in this particular case a Timeout)

So, if the given strategy is disposable then it will be disposed. BUT not all strategies are disposable. For example the CircuitBreakerResilienceStrategy is disposable, but the TimeoutResilienceStrategy isn't.

Polly.RateLimiting

The things are bit tricky here.

1. The RateLimiterResilienceStrategy has a property called Wrapper
2. This Wrapper is a DisposeWrapper
3. The strategy's DisposeAsync calls the wrapper's DisposeAsync
4. The DisposeWrapper's has a reference to the RateLimiter and its DisposeAsync calls the limiter's DisposeAsync

BUT inside the RateLimiterResiliencePipelineBuilderExtensions the most generic AddRateLimiter has a conditional logic.

Polly/src/Polly.RateLimiting/RateLimiterResiliencePipelineBuilderExtensions.cs

Lines 101 to 129 in 4f0d44a

	public static TBuilder AddRateLimiter<TBuilder>(
	this TBuilder builder,
	RateLimiterStrategyOptions options)
	where TBuilder : ResiliencePipelineBuilderBase
	{
	Guard.NotNull(builder);
	Guard.NotNull(options);
	return builder.AddStrategy(
	context =>
	{
	DisposeWrapper? wrapper = default;
	var limiter = options.RateLimiter;
	if (limiter is null)
	{
	var defaultLimiter = new ConcurrencyLimiter(options.DefaultRateLimiterOptions);
	wrapper = new DisposeWrapper(defaultLimiter);
	limiter = args => defaultLimiter.AcquireAsync(cancellationToken: args.Context.CancellationToken);
	}
	return new RateLimiterResilienceStrategy(
	limiter,
	options.OnRejected,
	context.Telemetry,
	wrapper);
	},
	options);
	}
	}

If the RateLimiter property of the options is defined then it will create a RateLimiterResilienceStrategy with a null as a DisposeWrapper.

So, your limiter won't be disposed because the underlying strategies DisposeWrapper are null.

[peter-csala]

If you think that it's worth sharing with others then please consider to contribute into the Polly docs.

If you need some help with that please let us know.

[lonix1]

If you think it'll add value, I could do that. It could be a new subsection under registry - resource disposal.

I'm unsure though. Like I mentioned, I made that example as "simple as possible", but in a previous comment also mentioned that it was very complicated for me (as an outsider). If we put that sample app into the docs it may confuse many people unnecessarily?

[lonix1]

Actually there are two ways:

• Put that code directly into the docs; maybe confusing as it's a complicated topic
• Or, explain in a small paragraph that rate limiters are the one kind of strategy that should be disposed manually. And link to a fiddle with the full code, or maybe add link to this discussion.

I could do either, what do you think? (But you'd need to review that code in case I made a mistake... It works for me, but I'm not a Polly expert.)

[peter-csala]

If you want I can try to simplify your sample code next week.

[lonix1]

I submitted a PR with the full example. Let me know how to tweak it. No rush!