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