From be35f9a8da4be5ea8ddeefeb2235802010c8479b Mon Sep 17 00:00:00 2001 From: Ali-Tegna <31090457+FreakyAli@users.noreply.github.com> Date: Tue, 1 Sep 2026 11:50:45 +0530 Subject: [PATCH 1/9] feat: Resilion resilience library for modern .NET --- .editorconfig | 103 +++++ .github/ISSUE_TEMPLATE/bug_report.md | 43 ++ .github/ISSUE_TEMPLATE/feature_request.md | 20 + .github/workflows/ci.yml | 28 ++ .github/workflows/release-nuget.yml | 68 +++ .github/workflows/test.yml | 67 +++ .gitignore | 33 ++ CHANGELOG.md | 13 + CONTRIBUTING.md | 91 ++++ LICENSE | 2 +- README.md | 188 +++++++- Resilion.sln | 118 +++++ .../PipelineOverheadBenchmarks.cs | 147 ++++++ benchmarks/Resilion.Benchmarks/Program.cs | 4 + .../Resilion.Benchmarks.csproj | 23 + docs/.gitkeep | 0 docs/architecture.md | 132 ++++++ docs/cancellation.md | 94 ++++ docs/circuit-breaker.md | 138 ++++++ docs/custom-strategies.md | 132 ++++++ docs/fallback.md | 106 +++++ docs/future-plans.md | 282 ++++++++++++ docs/hedging.md | 119 +++++ docs/installation.md | 114 +++++ docs/pipelines.md | 151 ++++++ docs/rate-limiting.md | 94 ++++ docs/retry.md | 124 +++++ docs/telemetry.md | 58 +++ docs/testing.md | 174 +++++++ docs/timeout.md | 92 ++++ docs/troubleshooting.md | 126 +++++ global.json | 6 + icon.png | Bin 0 -> 1234353 bytes samples/Resilion.Samples/Program.cs | 197 ++++++++ .../Resilion.Samples/Resilion.Samples.csproj | 19 + src/Directory.Build.props | 32 ++ .../ResiliencePipelineRegistry.cs | 135 ++++++ .../Resilion.Extensions.csproj | 25 + .../ResilionServiceCollectionExtensions.cs | 139 ++++++ .../RateLimitRejectedException.cs | 27 ++ .../RateLimiterExtensions.cs | 38 ++ .../RateLimiterStrategy.cs | 97 ++++ .../RateLimiterStrategyOptions.cs | 50 ++ .../Resilion.RateLimiting.csproj | 18 + .../CircuitBreakerExtensions.cs | 54 +++ .../CircuitBreakerManualControl.cs | 64 +++ .../CircuitBreaker/CircuitBreakerStrategy.cs | 278 +++++++++++ .../CircuitBreakerStrategyOptions.cs | 178 ++++++++ .../CircuitBreakerTypedStrategy.cs | 281 ++++++++++++ .../CircuitBreaker/CircuitBrokenException.cs | 27 ++ src/Resilion/CircuitBreaker/CircuitState.cs | 30 ++ src/Resilion/CircuitBreaker/SlidingWindow.cs | 151 ++++++ src/Resilion/Fallback/FallbackAction.cs | 116 +++++ src/Resilion/Fallback/FallbackExtensions.cs | 27 ++ src/Resilion/Fallback/FallbackStrategy.cs | 63 +++ .../Fallback/FallbackStrategyOptions.cs | 60 +++ src/Resilion/Hedging/HedgingExtensions.cs | 26 ++ .../Hedging/HedgingRejectedException.cs | 19 + src/Resilion/Hedging/HedgingStrategy.cs | 283 ++++++++++++ .../Hedging/HedgingStrategyOptions.cs | 94 ++++ src/Resilion/Internal/OrderingValidator.cs | 102 +++++ src/Resilion/Internal/PipelineComponent.cs | 159 +++++++ src/Resilion/Internal/StrategyType.cs | 16 + src/Resilion/Outcome.cs | 186 ++++++++ src/Resilion/Pipeline.cs | 282 ++++++++++++ src/Resilion/PipelineBuilder.cs | 336 ++++++++++++++ src/Resilion/PipelineOfT.cs | 175 +++++++ src/Resilion/ResilienceContext.cs | 74 +++ src/Resilion/ResilienceContextPool.cs | 60 +++ src/Resilion/ResilienceEventHandler.cs | 95 ++++ src/Resilion/ResilienceProperties.cs | 96 ++++ src/Resilion/ResiliencePropertyKey.cs | 48 ++ src/Resilion/Resilion.csproj | 17 + src/Resilion/ResilionException.cs | 28 ++ src/Resilion/Retry/RetryDelay.cs | 142 ++++++ src/Resilion/Retry/RetryExtensions.cs | 52 +++ src/Resilion/Retry/RetryStrategy.cs | 242 ++++++++++ src/Resilion/Retry/RetryStrategyOptions.cs | 137 ++++++ src/Resilion/Strategy.cs | 102 +++++ src/Resilion/Telemetry/ResilionTelemetry.cs | 56 +++ src/Resilion/Timeout/TimeoutExtensions.cs | 53 +++ .../Timeout/TimeoutRejectedException.cs | 46 ++ src/Resilion/Timeout/TimeoutStrategy.cs | 174 +++++++ .../Timeout/TimeoutStrategyOptions.cs | 67 +++ tests/Directory.Build.props | 30 ++ .../ExtensionsTests.cs | 197 ++++++++ .../Resilion.Extensions.Tests.csproj | 18 + .../CircuitBreakerStrategyTests.cs | 431 ++++++++++++++++++ .../Fallback/FallbackStrategyTests.cs | 269 +++++++++++ .../Hedging/HedgingStrategyTests.cs | 352 ++++++++++++++ .../Resilion.Tests/OrderingValidatorTests.cs | 234 ++++++++++ tests/Resilion.Tests/OutcomeTests.cs | 191 ++++++++ tests/Resilion.Tests/PipelineTests.cs | 418 +++++++++++++++++ .../RateLimiter/RateLimiterStrategyTests.cs | 319 +++++++++++++ .../Resilion.Tests/ResilienceContextTests.cs | 114 +++++ .../ResilienceEventHandlerTests.cs | 67 +++ tests/Resilion.Tests/Resilion.Tests.csproj | 17 + .../Retry/RetryStrategyTests.cs | 419 +++++++++++++++++ .../Timeout/TimeoutStrategyTests.cs | 294 ++++++++++++ 99 files changed, 11531 insertions(+), 2 deletions(-) create mode 100644 .editorconfig create mode 100644 .github/ISSUE_TEMPLATE/bug_report.md create mode 100644 .github/ISSUE_TEMPLATE/feature_request.md create mode 100644 .github/workflows/ci.yml create mode 100644 .github/workflows/release-nuget.yml create mode 100644 .github/workflows/test.yml create mode 100644 CHANGELOG.md create mode 100644 CONTRIBUTING.md create mode 100644 Resilion.sln create mode 100644 benchmarks/Resilion.Benchmarks/PipelineOverheadBenchmarks.cs create mode 100644 benchmarks/Resilion.Benchmarks/Program.cs create mode 100644 benchmarks/Resilion.Benchmarks/Resilion.Benchmarks.csproj create mode 100644 docs/.gitkeep create mode 100644 docs/architecture.md create mode 100644 docs/cancellation.md create mode 100644 docs/circuit-breaker.md create mode 100644 docs/custom-strategies.md create mode 100644 docs/fallback.md create mode 100644 docs/future-plans.md create mode 100644 docs/hedging.md create mode 100644 docs/installation.md create mode 100644 docs/pipelines.md create mode 100644 docs/rate-limiting.md create mode 100644 docs/retry.md create mode 100644 docs/telemetry.md create mode 100644 docs/testing.md create mode 100644 docs/timeout.md create mode 100644 docs/troubleshooting.md create mode 100644 global.json create mode 100644 icon.png create mode 100644 samples/Resilion.Samples/Program.cs create mode 100644 samples/Resilion.Samples/Resilion.Samples.csproj create mode 100644 src/Directory.Build.props create mode 100644 src/Resilion.Extensions/ResiliencePipelineRegistry.cs create mode 100644 src/Resilion.Extensions/Resilion.Extensions.csproj create mode 100644 src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs create mode 100644 src/Resilion.RateLimiting/RateLimitRejectedException.cs create mode 100644 src/Resilion.RateLimiting/RateLimiterExtensions.cs create mode 100644 src/Resilion.RateLimiting/RateLimiterStrategy.cs create mode 100644 src/Resilion.RateLimiting/RateLimiterStrategyOptions.cs create mode 100644 src/Resilion.RateLimiting/Resilion.RateLimiting.csproj create mode 100644 src/Resilion/CircuitBreaker/CircuitBreakerExtensions.cs create mode 100644 src/Resilion/CircuitBreaker/CircuitBreakerManualControl.cs create mode 100644 src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs create mode 100644 src/Resilion/CircuitBreaker/CircuitBreakerStrategyOptions.cs create mode 100644 src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs create mode 100644 src/Resilion/CircuitBreaker/CircuitBrokenException.cs create mode 100644 src/Resilion/CircuitBreaker/CircuitState.cs create mode 100644 src/Resilion/CircuitBreaker/SlidingWindow.cs create mode 100644 src/Resilion/Fallback/FallbackAction.cs create mode 100644 src/Resilion/Fallback/FallbackExtensions.cs create mode 100644 src/Resilion/Fallback/FallbackStrategy.cs create mode 100644 src/Resilion/Fallback/FallbackStrategyOptions.cs create mode 100644 src/Resilion/Hedging/HedgingExtensions.cs create mode 100644 src/Resilion/Hedging/HedgingRejectedException.cs create mode 100644 src/Resilion/Hedging/HedgingStrategy.cs create mode 100644 src/Resilion/Hedging/HedgingStrategyOptions.cs create mode 100644 src/Resilion/Internal/OrderingValidator.cs create mode 100644 src/Resilion/Internal/PipelineComponent.cs create mode 100644 src/Resilion/Internal/StrategyType.cs create mode 100644 src/Resilion/Outcome.cs create mode 100644 src/Resilion/Pipeline.cs create mode 100644 src/Resilion/PipelineBuilder.cs create mode 100644 src/Resilion/PipelineOfT.cs create mode 100644 src/Resilion/ResilienceContext.cs create mode 100644 src/Resilion/ResilienceContextPool.cs create mode 100644 src/Resilion/ResilienceEventHandler.cs create mode 100644 src/Resilion/ResilienceProperties.cs create mode 100644 src/Resilion/ResiliencePropertyKey.cs create mode 100644 src/Resilion/Resilion.csproj create mode 100644 src/Resilion/ResilionException.cs create mode 100644 src/Resilion/Retry/RetryDelay.cs create mode 100644 src/Resilion/Retry/RetryExtensions.cs create mode 100644 src/Resilion/Retry/RetryStrategy.cs create mode 100644 src/Resilion/Retry/RetryStrategyOptions.cs create mode 100644 src/Resilion/Strategy.cs create mode 100644 src/Resilion/Telemetry/ResilionTelemetry.cs create mode 100644 src/Resilion/Timeout/TimeoutExtensions.cs create mode 100644 src/Resilion/Timeout/TimeoutRejectedException.cs create mode 100644 src/Resilion/Timeout/TimeoutStrategy.cs create mode 100644 src/Resilion/Timeout/TimeoutStrategyOptions.cs create mode 100644 tests/Directory.Build.props create mode 100644 tests/Resilion.Extensions.Tests/ExtensionsTests.cs create mode 100644 tests/Resilion.Extensions.Tests/Resilion.Extensions.Tests.csproj create mode 100644 tests/Resilion.Tests/CircuitBreaker/CircuitBreakerStrategyTests.cs create mode 100644 tests/Resilion.Tests/Fallback/FallbackStrategyTests.cs create mode 100644 tests/Resilion.Tests/Hedging/HedgingStrategyTests.cs create mode 100644 tests/Resilion.Tests/OrderingValidatorTests.cs create mode 100644 tests/Resilion.Tests/OutcomeTests.cs create mode 100644 tests/Resilion.Tests/PipelineTests.cs create mode 100644 tests/Resilion.Tests/RateLimiter/RateLimiterStrategyTests.cs create mode 100644 tests/Resilion.Tests/ResilienceContextTests.cs create mode 100644 tests/Resilion.Tests/ResilienceEventHandlerTests.cs create mode 100644 tests/Resilion.Tests/Resilion.Tests.csproj create mode 100644 tests/Resilion.Tests/Retry/RetryStrategyTests.cs create mode 100644 tests/Resilion.Tests/Timeout/TimeoutStrategyTests.cs diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..05a74bb --- /dev/null +++ b/.editorconfig @@ -0,0 +1,103 @@ +# EditorConfig — https://editorconfig.org +root = true + +[*] +indent_style = space +indent_size = 4 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true + +[*.{csproj,props,targets,xml,config,nuspec}] +indent_size = 2 + +[*.{json,yml,yaml}] +indent_size = 2 + +[*.md] +trim_trailing_whitespace = false + +[*.cs] +# Namespace +csharp_style_namespace_declarations = file_scoped:suggestion + +# var preferences +csharp_style_var_for_built_in_types = true:suggestion +csharp_style_var_when_type_is_apparent = true:suggestion +csharp_style_var_elsewhere = true:suggestion + +# Expression-bodied members +csharp_style_expression_bodied_methods = when_on_single_line:suggestion +csharp_style_expression_bodied_constructors = false:suggestion +csharp_style_expression_bodied_operators = when_on_single_line:suggestion +csharp_style_expression_bodied_properties = when_on_single_line:suggestion +csharp_style_expression_bodied_indexers = when_on_single_line:suggestion +csharp_style_expression_bodied_accessors = when_on_single_line:suggestion +csharp_style_expression_bodied_lambdas = when_on_single_line:suggestion +csharp_style_expression_bodied_local_functions = when_on_single_line:suggestion + +# Pattern matching +csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion +csharp_style_pattern_matching_over_as_with_null_check = true:suggestion + +# Null checking +csharp_style_throw_expression = true:suggestion +csharp_style_conditional_delegate_call = true:suggestion + +# Modifier preferences +dotnet_style_require_accessibility_modifiers = always:suggestion + +# this. qualification +dotnet_style_qualification_for_field = false:suggestion +dotnet_style_qualification_for_property = false:suggestion +dotnet_style_qualification_for_method = false:suggestion +dotnet_style_qualification_for_event = false:suggestion + +# Language keywords vs BCL types +dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion +dotnet_style_predefined_type_for_member_access = true:suggestion + +# Parentheses +dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:suggestion +dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:suggestion +dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:suggestion +dotnet_style_parentheses_in_other_operators = never_if_unnecessary:suggestion + +# Newline preferences +csharp_new_line_before_open_brace = all +csharp_new_line_before_else = true +csharp_new_line_before_catch = true +csharp_new_line_before_finally = true +csharp_new_line_before_members_in_object_initializers = true +csharp_new_line_before_members_in_anonymous_types = true + +# Indentation +csharp_indent_case_contents = true +csharp_indent_switch_labels = true + +# Spacing +csharp_space_after_cast = false +csharp_space_after_keywords_in_control_flow_statements = true +csharp_space_between_method_declaration_parameter_list_parentheses = false +csharp_space_between_method_call_parameter_list_parentheses = false + +# Wrapping +csharp_preserve_single_line_statements = false +csharp_preserve_single_line_blocks = true + +# Using directives +dotnet_sort_system_directives_first = true +dotnet_separate_import_directive_groups = false + +# Naming conventions +dotnet_naming_rule.private_fields_should_be_camel_case.severity = suggestion +dotnet_naming_rule.private_fields_should_be_camel_case.symbols = private_fields +dotnet_naming_rule.private_fields_should_be_camel_case.style = camel_case_underscore + +dotnet_naming_symbols.private_fields.applicable_kinds = field +dotnet_naming_symbols.private_fields.applicable_accessibilities = private, private_protected +dotnet_naming_symbols.private_fields.required_modifiers = + +dotnet_naming_style.camel_case_underscore.required_prefix = _ +dotnet_naming_style.camel_case_underscore.capitalization = camel_case diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..28b263c --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,43 @@ +--- +name: Bug report +about: Report a bug in Resilion +title: '' +labels: bug +assignees: '' + +--- + +**Resilion version** + + +**.NET SDK version** + + +**Target framework** + + +**Describe the bug** +A clear description of what the bug is. + +**Minimal reproduction** + + +```csharp +var pipeline = Pipeline.Create(builder => builder + .AddRetry(new RetryOptions { MaxAttempts = 3 }) + .AddTimeout(TimeSpan.FromSeconds(10))); + +await pipeline.ExecuteAsync(async ct => +{ + // Your operation here +}, cancellationToken); +``` + +**Expected behavior** +What you expected to happen. + +**Actual behavior** +What actually happened. Include any exceptions or stack traces. + +**Additional context** +Any other context about the problem. diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..41d9423 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,20 @@ +--- +name: Feature request +about: Suggest a feature for Resilion +title: '' +labels: enhancement +assignees: '' + +--- + +**Is your feature request related to a problem?** +A clear description of what the problem is. + +**Describe the solution you'd like** +A clear description of what you want to happen. + +**Describe alternatives you've considered** +Any alternative solutions or features you've considered. + +**Additional context** +Any other context, code examples, or references about the feature request. diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..e85d277 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,28 @@ +name: CI + +on: + push: + branches: [master] + pull_request: + branches: [master] + +env: + DOTNET_VERSION: '9.0.x' + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Setup .NET + uses: actions/setup-dotnet@v4 + with: + dotnet-version: ${{ env.DOTNET_VERSION }} + + - name: Restore + run: dotnet restore + + - name: Build + run: dotnet build -c Release --no-restore diff --git a/.github/workflows/release-nuget.yml b/.github/workflows/release-nuget.yml new file mode 100644 index 0000000..7680587 --- /dev/null +++ b/.github/workflows/release-nuget.yml @@ -0,0 +1,68 @@ +name: Create a release on NuGet + +on: + push: + tags: + - "v*.*.*" + - "v*.*.*-pre" + +env: + DOTNET_VERSION: '9.0.x' + +jobs: + release-nuget: + runs-on: ubuntu-latest + permissions: + contents: read + id-token: write + + steps: + - uses: actions/checkout@v4 + + - name: Setup .NET + uses: actions/setup-dotnet@v4 + with: + dotnet-version: ${{ env.DOTNET_VERSION }} + + - name: Verify commit exists in origin/master + run: | + git fetch --no-tags --prune --depth=1 origin +refs/heads/*:refs/remotes/origin/* + git branch --remote --contains | grep -q "origin/master" || { echo "Tag is not on origin/master. Aborting release."; exit 1; } + + - name: Get version information from tag + id: get_version + run: | + VERSION="${GITHUB_REF_NAME#v}" + echo "version_without_v=$VERSION" >> "$GITHUB_OUTPUT" + + - name: Build + run: dotnet build -c Release -p:Version=${{ steps.get_version.outputs.version_without_v }} + + - name: Test + run: dotnet test -c Release --no-build + + - name: Pack NuGet packages + run: | + dotnet pack src/Resilion/Resilion.csproj -c Release --no-build -p:Version=${{ steps.get_version.outputs.version_without_v }} + dotnet pack src/Resilion.Extensions/Resilion.Extensions.csproj -c Release --no-build -p:Version=${{ steps.get_version.outputs.version_without_v }} + dotnet pack src/Resilion.RateLimiting/Resilion.RateLimiting.csproj -c Release --no-build -p:Version=${{ steps.get_version.outputs.version_without_v }} + + - name: NuGet login (OIDC - trusted publishing) + id: login + uses: NuGet/login@v1 + with: + user: FreakyAli + + - name: Push NuGet packages + run: | + VERSION="${{ steps.get_version.outputs.version_without_v }}" + NUPKGS=$(find . -name "*.nupkg" -path "*${VERSION}*" ! -name "*.symbols.nupkg") + COUNT=$(echo "$NUPKGS" | wc -l) + if [ "$COUNT" -ne 3 ]; then + echo "Expected exactly 3 matching .nupkg files, found $COUNT. Aborting." + exit 1 + fi + echo "$NUPKGS" | while read -r nupkg; do + echo "Pushing: $nupkg" + dotnet nuget push "$nupkg" -s https://api.nuget.org/v3/index.json -k ${{ steps.login.outputs.NUGET_API_KEY }} + done diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..dcae0e4 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,67 @@ +name: test +run-name: '[Test] ${{ github.event.head_commit.message || github.event.pull_request.title || github.event.workflow_run.display_title || github.ref_name }}' + +on: + workflow_run: + workflows: ["CI"] + types: + - completed + pull_request: + branches: + - "*" + push: + branches: + - "master" + +permissions: + contents: read + checks: write + pull-requests: write + +env: + DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1 + DOTNET_NOLOGO: true + +jobs: + test: + runs-on: ubuntu-latest + if: | + (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success') || + (github.event_name != 'workflow_run') + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + ref: ${{ github.event_name == 'workflow_run' && github.event.workflow_run.head_sha || github.sha }} + + - name: Setup .NET + uses: actions/setup-dotnet@v4 + with: + dotnet-version: 9.0.x + + - name: Restore dependencies + run: dotnet restore + + - name: Build Solution + run: dotnet build --configuration Release --no-restore + + - name: Run Unit Tests + run: dotnet test --configuration Release --no-build -- --report-trx --results-directory ${{ github.workspace }}/TestResults + + - name: Upload Test Results + uses: actions/upload-artifact@v4 + if: success() || failure() + with: + name: test-results-${{ github.run_id }} + path: TestResults/*.trx + retention-days: 7 + + - name: Publish Test Results + uses: dorny/test-reporter@v1 + if: success() || failure() + with: + name: Unit Test Results + path: TestResults/*.trx + reporter: dotnet-trx + fail-on-error: false + token: ${{ secrets.GITHUB_TOKEN }} diff --git a/.gitignore b/.gitignore index d5a18de..1e5b4f1 100644 --- a/.gitignore +++ b/.gitignore @@ -269,6 +269,7 @@ ClientBin/ *.pfx *.publishsettings orleans.codegen.cs +.DS_Store # Including strong name files can present a security risk # (https://github.com/github/gitignore/pull/2483#issue-259490424) @@ -427,3 +428,35 @@ FodyWeavers.xsd *.msix *.msm *.msp + +# AI coding agents +.claude/ +.cursor/ +.cursorignore +.cursorindexingignore +.cursorrules +.codex/ +AGENTS.md +.copilot/ +.windsurf/ +.windsurfrules +.codeium/ +.cody/ +.continue/ +.aider* +.aiderignore +.cline/ +.clinerules +.roo/ +.roorules +.devin/ +.junie/ +.augment/ +.amazonq/ +.gemini/ +.tabnine/ +.tabby/ +.bolt/ +.v0/ +.idx/ +.sourcery/ \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..28ed043 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,13 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Unreleased] + +### Added + +- Initial project structure and build configuration +- Core abstractions: `Outcome`, `ResilienceContext`, `Pipeline`, `Strategy` diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..b8ef782 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,91 @@ +# Contributing to Resilion + +Thank you for your interest in contributing to Resilion! + +## Getting Started + +### Prerequisites + +- [.NET 9.0 SDK](https://dotnet.microsoft.com/download/dotnet/9.0) or later + +### Local Setup + +```bash +git clone https://github.com/FreakyAli/Resilion.git +cd Resilion +dotnet restore +dotnet build +``` + +## Project Structure + +``` +src/ + Resilion/ Core library (zero dependencies) + Resilion.Extensions/ DI, logging, telemetry integration + Resilion.RateLimiting/ Rate limiting strategy + +tests/ + Resilion.Tests/ Core strategy and pipeline tests + Resilion.Extensions.Tests/ DI and telemetry tests + +benchmarks/ + Resilion.Benchmarks/ Performance benchmarks (not in .sln) + +samples/ + Resilion.Samples/ Usage examples +``` + +## Development Workflow + +1. Fork the repository +2. Create a feature branch from `master` +3. Make your changes +4. Write or update tests +5. Ensure all tests pass: `dotnet test` +6. Submit a pull request + +### Running Tests + +```bash +# Run all tests +dotnet test + +# Run specific test project +dotnet test tests/Resilion.Tests + +# Run with filter +dotnet test --filter "FullyQualifiedName~RetryTests" +``` + +### Running Benchmarks + +Benchmarks are not part of the solution file. Run them directly: + +```bash +cd benchmarks/Resilion.Benchmarks +dotnet run -c Release +``` + +## Code Style + +This project uses an `.editorconfig` file for consistent formatting: + +- File-scoped namespaces +- Allman bracing (new line before all braces) +- `var` everywhere +- Private fields prefixed with `_` +- Nullable reference types enabled + +## Submitting Changes + +- Rebase onto `master` before submitting +- Write clear commit messages +- Include tests for new functionality +- Update documentation where applicable +- Ensure CI passes + +## Reporting Issues + +- Use the [bug report](https://github.com/FreakyAli/Resilion/issues/new?template=bug_report.md) template for bugs +- Use the [feature request](https://github.com/FreakyAli/Resilion/issues/new?template=feature_request.md) template for enhancements diff --git a/LICENSE b/LICENSE index 261eeb9..5d12bb9 100644 --- a/LICENSE +++ b/LICENSE @@ -186,7 +186,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright [yyyy] [name of copyright owner] + Copyright 2026 FreakyAli Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/README.md b/README.md index 4ca72d7..50f6d0d 100644 --- a/README.md +++ b/README.md @@ -1 +1,187 @@ -# Resilion \ No newline at end of file +# Resilion + +A modern resilience library for .NET. Retry, circuit breaker, timeout, fallback, rate limiting, hedging, and pipeline composition — with zero external dependencies in the core package. + +[![CI](https://github.com/FreakyAli/Resilion/actions/workflows/ci.yml/badge.svg)](https://github.com/FreakyAli/Resilion/actions/workflows/ci.yml) +[![Tests](https://github.com/FreakyAli/Resilion/actions/workflows/test.yml/badge.svg)](https://github.com/FreakyAli/Resilion/actions/workflows/test.yml) +[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE) + +## Quick Start + +```csharp +using Resilion; + +var pipeline = Pipeline.Create(b => b + .AddTimeout(TimeSpan.FromSeconds(30)) + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), + }) + .AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 10, + }) + .AddTimeout(TimeSpan.FromSeconds(5))); + +var result = await pipeline.ExecuteAsync( + static (client, ct) => client.GetStringAsync("https://api.example.com/data", ct), + httpClient); +``` + +## Why Resilion? + +Resilion is designed for experienced .NET developers who want: + +- **Minimal API** — one `Pipeline.Create` call, chain strategies, `.Build()`. No framework to learn. +- **Zero-dependency core** — the `Resilion` package has no external dependencies. +- **Sync and async** — both `Execute` and `ExecuteAsync` with true sync implementations (not sync-over-async). +- **Simple predicates** — `Func, bool>` instead of Polly's `PredicateBuilder` + `PredicateResult.True` + `ValueTask`. +- **Simple callbacks** — assign an `Action` directly; no `ValueTask` wrapping for synchronous logging. +- **Composable pipelines** — combine pre-built pipelines with `AddPipeline()`. +- **Allocation-conscious** — `Outcome` is a struct, `ResilienceContext` is pooled, state parameters avoid closures. + +## Packages + +| Package | Purpose | Dependencies | +|---------|---------|-------------| +| **Resilion** | Core library with all built-in strategies | None | +| **Resilion.Extensions** | DI registration, telemetry (Meter/ActivitySource) | Microsoft.Extensions.* | +| **Resilion.RateLimiting** | Rate limiting strategy | System.Threading.RateLimiting | + +## Strategies + +### Retry + +```csharp +var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions +{ + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), // or Constant, Linear, Custom + UseJitter = true, // Decorrelated jitter (on by default) +})); +``` + +Result-based retry on typed pipelines: + +```csharp +var pipeline = Pipeline.Create(b => b.AddRetry( + new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), + ShouldHandle = outcome => + outcome.Exception is HttpRequestException + || (outcome.TryGetResult(out var r) && (int)r.StatusCode >= 500), + })); +``` + +### Timeout + +```csharp +var pipeline = Pipeline.Create(b => b.AddTimeout(TimeSpan.FromSeconds(10))); +``` + +Timeout uses cooperative cancellation. The operation must observe the `CancellationToken`. + +### Circuit Breaker + +```csharp +var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions +{ + FailureRatioThreshold = 0.5, // Trip at 50% failure rate + MinimumThroughput = 10, // Need 10+ calls before evaluating + SamplingDuration = TimeSpan.FromSeconds(30), + BreakDuration = TimeSpan.FromSeconds(30), +})); +``` + +### Fallback + +```csharp +var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = "default-value", // or a Func, or an async Func + })); +``` + +### Rate Limiting + +```csharp +using Resilion.RateLimiting; + +var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions +{ + PermitLimit = 10, + QueueLimit = 0, +}); + +var pipeline = Pipeline.Create(b => b.AddRateLimiter( + new RateLimiterStrategyOptions { RateLimiter = limiter })); +``` + +### Hedging + +```csharp +var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = TimeSpan.FromSeconds(2), // 0 = parallel, InfiniteTimeSpan = sequential + })); +``` + +## Strategy Ordering + +Strategies execute outermost to innermost. The canonical order: + +```csharp +Pipeline.Create(b => b + .AddRateLimiter(...) // 1. Shed load first + .AddTimeout(30s) // 2. Total timeout across all retries + .AddRetry(...) // 3. Retry failures + .AddCircuitBreaker(...) // 4. Track per-attempt success/failure + .AddTimeout(5s)); // 5. Per-attempt timeout +``` + +## Dependency Injection + +```csharp +using Resilion.Extensions; + +services.AddResiliencePipeline("my-pipeline", b => b + .AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 3 }) + .AddTimeout(TimeSpan.FromSeconds(10))); + +// Resolve: +var registry = serviceProvider.GetRequiredService>(); +var pipeline = registry.GetPipeline("my-pipeline"); +``` + +## Supported .NET Versions + +- .NET 9.0+ + +## Project Structure + +``` +src/ + Resilion/ Core library (zero dependencies) + Resilion.Extensions/ DI, logging, telemetry integration + Resilion.RateLimiting/ Rate limiting strategy +tests/ + Resilion.Tests/ Core strategy and pipeline tests + Resilion.Extensions.Tests/ DI and telemetry tests +benchmarks/ + Resilion.Benchmarks/ Performance benchmarks +samples/ + Resilion.Samples/ Usage examples +docs/ + future-plans.md Roadmap and known tradeoffs +``` + +## License + +[Apache-2.0](LICENSE) diff --git a/Resilion.sln b/Resilion.sln new file mode 100644 index 0000000..9a26e22 --- /dev/null +++ b/Resilion.sln @@ -0,0 +1,118 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.31903.59 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{827E0CD3-B72D-47B6-A68D-7590B98EB39B}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Resilion", "src\Resilion\Resilion.csproj", "{6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Resilion.Extensions", "src\Resilion.Extensions\Resilion.Extensions.csproj", "{F5340000-510D-40E8-8A20-FB2C721382E8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Resilion.RateLimiting", "src\Resilion.RateLimiting\Resilion.RateLimiting.csproj", "{49A634E0-7EA3-48D6-B15D-93E84738A282}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0AB3BF05-4346-4AA6-1389-037BE0695223}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Resilion.Tests", "tests\Resilion.Tests\Resilion.Tests.csproj", "{7C800530-ADA9-48CF-95B0-2E4ECF7A5041}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Resilion.Extensions.Tests", "tests\Resilion.Extensions.Tests\Resilion.Extensions.Tests.csproj", "{A0EC64D8-078D-43A7-AA73-74AF5319CABB}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{5D20AA90-6969-D8BD-9DCD-8634F4692FDA}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Resilion.Samples", "samples\Resilion.Samples\Resilion.Samples.csproj", "{65299870-8203-4726-B350-B4C85586D162}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Debug|x64.ActiveCfg = Debug|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Debug|x64.Build.0 = Debug|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Debug|x86.ActiveCfg = Debug|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Debug|x86.Build.0 = Debug|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Release|Any CPU.Build.0 = Release|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Release|x64.ActiveCfg = Release|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Release|x64.Build.0 = Release|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Release|x86.ActiveCfg = Release|Any CPU + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7}.Release|x86.Build.0 = Release|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Debug|x64.ActiveCfg = Debug|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Debug|x64.Build.0 = Debug|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Debug|x86.ActiveCfg = Debug|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Debug|x86.Build.0 = Debug|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Release|Any CPU.Build.0 = Release|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Release|x64.ActiveCfg = Release|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Release|x64.Build.0 = Release|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Release|x86.ActiveCfg = Release|Any CPU + {F5340000-510D-40E8-8A20-FB2C721382E8}.Release|x86.Build.0 = Release|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Debug|Any CPU.Build.0 = Debug|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Debug|x64.ActiveCfg = Debug|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Debug|x64.Build.0 = Debug|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Debug|x86.ActiveCfg = Debug|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Debug|x86.Build.0 = Debug|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Release|Any CPU.ActiveCfg = Release|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Release|Any CPU.Build.0 = Release|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Release|x64.ActiveCfg = Release|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Release|x64.Build.0 = Release|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Release|x86.ActiveCfg = Release|Any CPU + {49A634E0-7EA3-48D6-B15D-93E84738A282}.Release|x86.Build.0 = Release|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Debug|x64.ActiveCfg = Debug|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Debug|x64.Build.0 = Debug|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Debug|x86.ActiveCfg = Debug|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Debug|x86.Build.0 = Debug|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Release|Any CPU.Build.0 = Release|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Release|x64.ActiveCfg = Release|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Release|x64.Build.0 = Release|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Release|x86.ActiveCfg = Release|Any CPU + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041}.Release|x86.Build.0 = Release|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Debug|x64.ActiveCfg = Debug|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Debug|x64.Build.0 = Debug|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Debug|x86.ActiveCfg = Debug|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Debug|x86.Build.0 = Debug|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Release|Any CPU.Build.0 = Release|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Release|x64.ActiveCfg = Release|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Release|x64.Build.0 = Release|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Release|x86.ActiveCfg = Release|Any CPU + {A0EC64D8-078D-43A7-AA73-74AF5319CABB}.Release|x86.Build.0 = Release|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Debug|Any CPU.Build.0 = Debug|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Debug|x64.ActiveCfg = Debug|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Debug|x64.Build.0 = Debug|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Debug|x86.ActiveCfg = Debug|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Debug|x86.Build.0 = Debug|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Release|Any CPU.ActiveCfg = Release|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Release|Any CPU.Build.0 = Release|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Release|x64.ActiveCfg = Release|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Release|x64.Build.0 = Release|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Release|x86.ActiveCfg = Release|Any CPU + {65299870-8203-4726-B350-B4C85586D162}.Release|x86.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {6F40F09C-4EC7-45ED-834A-AF7A02AD14E7} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + {F5340000-510D-40E8-8A20-FB2C721382E8} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + {49A634E0-7EA3-48D6-B15D-93E84738A282} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + {7C800530-ADA9-48CF-95B0-2E4ECF7A5041} = {0AB3BF05-4346-4AA6-1389-037BE0695223} + {A0EC64D8-078D-43A7-AA73-74AF5319CABB} = {0AB3BF05-4346-4AA6-1389-037BE0695223} + {65299870-8203-4726-B350-B4C85586D162} = {5D20AA90-6969-D8BD-9DCD-8634F4692FDA} + EndGlobalSection +EndGlobal diff --git a/benchmarks/Resilion.Benchmarks/PipelineOverheadBenchmarks.cs b/benchmarks/Resilion.Benchmarks/PipelineOverheadBenchmarks.cs new file mode 100644 index 0000000..063f354 --- /dev/null +++ b/benchmarks/Resilion.Benchmarks/PipelineOverheadBenchmarks.cs @@ -0,0 +1,147 @@ +using BenchmarkDotNet.Attributes; +using Polly; + +namespace Resilion.Benchmarks; + +/// +/// Measures the overhead of executing through a pipeline vs a direct call. +/// Answers: "What tax does Resilion add on the happy path?" +/// +[MemoryDiagnoser] +public class PipelineOverheadBenchmarks +{ + private Resilion.Pipeline _resilionEmpty = null!; + private Resilion.Pipeline _resilionRetry = null!; + private Resilion.Pipeline _resilionComposite = null!; + private ResiliencePipeline _pollyEmpty = null!; + private ResiliencePipeline _pollyRetry = null!; + private ResiliencePipeline _pollyComposite = null!; + + [GlobalSetup] + public void Setup() + { + // Resilion pipelines + _resilionEmpty = Resilion.Pipeline.Empty; + + _resilionRetry = Resilion.Pipeline.Create(b => b + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), + })); + + _resilionComposite = Resilion.Pipeline.Create(b => b + .AddTimeout(TimeSpan.FromSeconds(30)) + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), + }) + .AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 100, + }) + .AddTimeout(TimeSpan.FromSeconds(5))); + + // Polly pipelines + _pollyEmpty = ResiliencePipeline.Empty; + + _pollyRetry = new ResiliencePipelineBuilder() + .AddRetry(new Polly.Retry.RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = TimeSpan.FromSeconds(1), + BackoffType = DelayBackoffType.Exponential, + }) + .Build(); + + _pollyComposite = new ResiliencePipelineBuilder() + .AddTimeout(TimeSpan.FromSeconds(30)) + .AddRetry(new Polly.Retry.RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = TimeSpan.FromSeconds(1), + BackoffType = DelayBackoffType.Exponential, + }) + .AddCircuitBreaker(new Polly.CircuitBreaker.CircuitBreakerStrategyOptions + { + FailureRatio = 0.5, + MinimumThroughput = 100, + }) + .AddTimeout(TimeSpan.FromSeconds(5)) + .Build(); + } + + // ── Direct call (baseline) ─────────────────────────────────── + + [Benchmark(Baseline = true)] + public ValueTask DirectCall() + { + return new ValueTask("ok"); + } + + // ── Empty pipeline (no strategies) ─────────────────────────── + + [Benchmark] + public ValueTask Resilion_Empty() + { + return _resilionEmpty.ExecuteAsync( + static (state, ct) => new ValueTask("ok"), + (object?)null); + } + + [Benchmark] + public ValueTask Polly_Empty() + { + return _pollyEmpty.ExecuteAsync( + static (state, ct) => new ValueTask("ok"), + (object?)null); + } + + // ── Single retry strategy (happy path, no failures) ────────── + + [Benchmark] + public ValueTask Resilion_Retry_HappyPath() + { + return _resilionRetry.ExecuteAsync( + static (state, ct) => new ValueTask("ok"), + (object?)null); + } + + [Benchmark] + public ValueTask Polly_Retry_HappyPath() + { + return _pollyRetry.ExecuteAsync( + static (state, ct) => new ValueTask("ok"), + (object?)null); + } + + // ── Composite pipeline (happy path) ────────────────────────── + + [Benchmark] + public ValueTask Resilion_Composite_HappyPath() + { + return _resilionComposite.ExecuteAsync( + static (state, ct) => new ValueTask("ok"), + (object?)null); + } + + [Benchmark] + public ValueTask Polly_Composite_HappyPath() + { + return _pollyComposite.ExecuteAsync( + static (state, ct) => new ValueTask("ok"), + (object?)null); + } + + // ── Sync execution ─────────────────────────────────────────── + + [Benchmark] + public string Resilion_Retry_Sync() + { + return _resilionRetry.Execute( + static (state, ct) => "ok", + (object?)null); + } +} diff --git a/benchmarks/Resilion.Benchmarks/Program.cs b/benchmarks/Resilion.Benchmarks/Program.cs new file mode 100644 index 0000000..feb6004 --- /dev/null +++ b/benchmarks/Resilion.Benchmarks/Program.cs @@ -0,0 +1,4 @@ +using BenchmarkDotNet.Running; +using Resilion.Benchmarks; + +BenchmarkSwitcher.FromAssembly(typeof(PipelineOverheadBenchmarks).Assembly).Run(args); diff --git a/benchmarks/Resilion.Benchmarks/Resilion.Benchmarks.csproj b/benchmarks/Resilion.Benchmarks/Resilion.Benchmarks.csproj new file mode 100644 index 0000000..1e33868 --- /dev/null +++ b/benchmarks/Resilion.Benchmarks/Resilion.Benchmarks.csproj @@ -0,0 +1,23 @@ + + + + Exe + net9.0 + latest + enable + enable + false + Resilion.Benchmarks + + + + + + + + + + + + + diff --git a/docs/.gitkeep b/docs/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/docs/architecture.md b/docs/architecture.md new file mode 100644 index 0000000..2922b8d --- /dev/null +++ b/docs/architecture.md @@ -0,0 +1,132 @@ +# Architecture + +How Resilion works under the hood. Read this if you're building custom strategies, contributing to the library, or want to understand the performance characteristics. + +## Core types + +### Outcome\ + +A `readonly struct` wrapping either a successful `TResult` or a captured `Exception`. The pipeline passes outcomes as data instead of throwing and catching, avoiding stack unwinding on the hot path. + +```csharp +// Success +Outcome.FromResult("ok") + +// Failure — exception captured, stack trace preserved +Outcome.FromException(ex) + +// Consumption +outcome.ThrowIfFailed(); // rethrow with original stack trace +outcome.Match(onSuccess, onFailure); // pattern match +outcome.TryGetResult(out var result); // try-pattern +``` + +Exceptions are stored as `ExceptionDispatchInfo` so `ThrowIfFailed()` preserves the original stack trace. + +### ResilienceContext + +Carries execution state through the pipeline: +- `CancellationToken` — strategies may replace this (Timeout creates a linked token) +- `OperationKey` — optional name for telemetry +- `ContinueOnCapturedContext` — controls `ConfigureAwait` behavior +- `Properties` — type-safe property bag for passing data between strategies + +Contexts are pooled via `ResilienceContextPool` to avoid per-call allocations. The pipeline rents one at entry and returns it at exit. + +### Pipeline / Pipeline\ + +Two variants exist because they represent different capabilities: + +- **`Pipeline`** — executes any operation. Strategies can react to exceptions only. Works with any return type because `TResult` is a method-level generic parameter. +- **`Pipeline`** — executes operations returning `TResult`. Strategies can react to both exceptions AND result values. Required for Fallback, Hedging, and result-based predicates. + +Both are sealed, immutable after construction, and thread-safe. Build once, cache, reuse. + +### Strategy / Strategy\ + +Abstract base classes: + +- **`Strategy`** — non-generic class, generic method. A single Timeout instance works with `string`, `int`, `HttpResponseMessage`, anything. +- **`Strategy`** — generic class. A `Strategy` can inspect status codes. + +```csharp +// Non-generic: one instance handles any TResult +public abstract class Strategy +{ + protected internal abstract ValueTask> ExecuteAsync(...); +} + +// Generic: bound to specific TResult +public abstract class Strategy +{ + protected internal abstract ValueTask> ExecuteAsync(...); +} +``` + +## Execution model + +### Pipeline chain + +At `Build()` time, strategies are compiled into a linked chain of internal `PipelineComponent` objects. No allocation per call for the chain structure itself. + +``` +Pipeline.ExecuteAsync(userAction, cancellationToken) + │ + ▼ +Rent ResilienceContext from pool + │ + ▼ +Wrap userAction (captures exceptions into Outcome) + │ + ▼ +[Strategy1] ──next──▸ [Strategy2] ──next──▸ ... ──▸ [wrappedAction] + │ + ▼ +Unwrap Outcome: success returns result, failure rethrows + │ + ▼ +Return ResilienceContext to pool +``` + +### Strategy ordering + +First added = outermost. Canonical order: + +``` +RateLimiter → TotalTimeout → Retry → CircuitBreaker → AttemptTimeout → UserCode +``` + +A call flows inward through each strategy to the user delegate, then outcomes flow back outward in reverse. + +### Sync vs async + +Both `Execute` and `ExecuteAsync` are provided. The sync path is a true sync implementation — strategies use `Thread.Sleep` / `WaitHandle` for delays, not sync-over-async wrapping. Exception: Hedging sync always runs sequentially (parallel execution requires async). + +## Performance model + +### Happy path allocations + +| Strategy | Allocations | Notes | +|----------|------------|-------| +| Retry (no retry) | 0 | Predicate check only | +| Circuit Breaker (Closed) | 0 | Volatile read + Interlocked.Increment | +| Timeout (in time) | 1 CTS + 1 ITimer | CTS poolable via TryReset | +| Fallback (not triggered) | 0 | Predicate check only | +| Rate Limiter (permitted) | 1 lease | Often a struct | +| Hedging (primary wins) | 1 CTS + 1 Task | Delay timer | + +### Per-call pipeline overhead + +Each `StrategyComponent` in the chain creates a closure `ctx => _next.ExecuteAsync(callback, ctx)`. In a pipeline with N strategies this means N small closure allocations per call. This is inherent to the middleware pattern — documented in [future-plans.md](future-plans.md#per-call-delegate-allocation-in-pipeline-chain). + +### Zero-cost telemetry + +`ResilionTelemetry` creates `Meter` and `Counter` instruments using BCL `System.Diagnostics.Metrics`. When no `MeterListener`, `dotnet-counters`, or OpenTelemetry SDK is attached, counter operations are no-ops at the runtime level. + +## Thread safety + +- **Pipeline** — immutable after construction, safe to share across threads +- **Circuit Breaker** — state machine uses `System.Threading.Lock` for transitions, `Interlocked` for sliding window counters. Callbacks fire outside lock. +- **Sliding Window** — internal lock protects bucket rotation and ratio computation +- **ResilienceContextPool** — uses `ConcurrentBag` with approximate size cap +- **ResilienceContext** — NOT thread-safe. One context per execution, which flows through the strategy chain sequentially. Hedging creates separate contexts per attempt. diff --git a/docs/cancellation.md b/docs/cancellation.md new file mode 100644 index 0000000..f13764c --- /dev/null +++ b/docs/cancellation.md @@ -0,0 +1,94 @@ +# Cancellation + +How `CancellationToken` flows through Resilion pipelines and how each strategy interacts with it. + +## The rule + +**If the user's original `CancellationToken` is canceled, `OperationCanceledException` propagates immediately. It is never retried, never counted as a circuit breaker failure, never caught by any strategy by default.** + +This is the single most important cancellation guarantee. + +## Token flow + +``` +User provides CancellationToken + │ + Pipeline sets context.CancellationToken = userToken + │ + [TotalTimeout] creates linkedCTS(userToken + 30s timer) + │ replaces context.CancellationToken = linkedCTS.Token + │ + [Retry] checks token before each attempt — does NOT modify token + │ + [CircuitBreaker] checks state — does NOT modify token + │ + [AttemptTimeout] creates attemptCTS(context.Token + 5s timer) + │ replaces context.CancellationToken = attemptCTS.Token + │ + [UserCallback] receives the most restrictive token + (linked to both total and attempt timeouts) +``` + +Each Timeout strategy creates a linked `CancellationTokenSource`. The inner delegate always gets the most restrictive token. After each strategy completes, it restores the original token. + +## Per-strategy behavior + +### Retry +- Checks `CancellationToken.IsCancellationRequested` before each attempt +- Checks cancellation during delay waits +- `OperationCanceledException` is never retried by default +- Cancelling during delay stops retries immediately + +### Timeout +- Creates linked CTS combining user token + timer +- Timeout fires: catches delegate's `OperationCanceledException`, wraps in `TimeoutRejectedException` +- User cancels: `OperationCanceledException` propagates unchanged (not wrapped) +- Linked CTS disposed in `finally` + +### Circuit Breaker +- Does not modify the token +- `OperationCanceledException` is never counted as a failure (not a dependency fault) +- `CircuitBrokenException` takes priority over cancellation (if circuit is open, reject immediately) + +### Fallback +- Does not modify the token +- `OperationCanceledException` is not handled by default (propagates, no fallback) +- Can be configured to catch OCE via custom `ShouldHandle` (unusual) + +### Rate Limiter +- Passes token to `RateLimiter.AcquireAsync` (cancels queue wait) +- Does not modify the token passed to the inner delegate + +### Hedging +- Each attempt gets its own linked CTS +- When one attempt wins, all other CTS instances cancel +- All cancelled tasks are awaited for resource cleanup +- User cancellation cancels all attempts simultaneously + +## Timeout vs user cancellation + +The Timeout strategy distinguishes the two by checking which token fired: + +| User token cancelled? | Linked CTS cancelled? | Result | +|----------------------|----------------------|--------| +| No | Yes | `TimeoutRejectedException` | +| Yes | Yes (linked) | `OperationCanceledException` | +| No | No | Success (completed in time) | + +There is a narrow TOCTOU race where user cancellation between checks could be misclassified as timeout. This is nanoseconds wide and not observable in practice. See [future-plans.md](future-plans.md#timeout-cancellation-classification-has-a-narrow-race-window). + +## Cooperative cancellation + +Resilion timeouts are cooperative. The delegate MUST observe the `CancellationToken` for timeout to work. If the delegate ignores the token, timeout cannot abort it. + +```csharp +// GOOD — observes token +await pipeline.ExecuteAsync(async ct => + await httpClient.GetStringAsync(url, ct)); // HttpClient checks ct + +// BAD — ignores token, timeout has no effect +await pipeline.ExecuteAsync(async ct => + await SomeBlockingCallThatIgnoresCancellation()); +``` + +There is no "pessimistic timeout" that abandons the operation on a background thread. Pessimistic timeout leaks resources and creates unpredictable state. diff --git a/docs/circuit-breaker.md b/docs/circuit-breaker.md new file mode 100644 index 0000000..4249dce --- /dev/null +++ b/docs/circuit-breaker.md @@ -0,0 +1,138 @@ +# Circuit Breaker + +Monitors failure rates and stops calling a failing dependency when the failure ratio exceeds a threshold. Protects your system from cascading failures and gives the downstream service time to recover. + +## Basic usage + +```csharp +var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions +{ + FailureRatioThreshold = 0.5, + MinimumThroughput = 10, + SamplingDuration = TimeSpan.FromSeconds(30), + BreakDuration = TimeSpan.FromSeconds(30), +})); + +try +{ + await pipeline.ExecuteAsync(async ct => + await httpClient.GetStringAsync("https://fragile-service.example.com", ct)); +} +catch (CircuitBrokenException ex) +{ + Console.WriteLine($"Circuit is {ex.CircuitState}, retry after {ex.RetryAfter.TotalSeconds:F0}s"); +} +``` + +## Options + +| Option | Type | Default | Description | +|--------|------|---------|-------------| +| `FailureRatioThreshold` | `double` | 0.5 (50%) | Failure ratio that trips the circuit | +| `SamplingDuration` | `TimeSpan` | 30s | Sliding window for tracking | +| `MinimumThroughput` | `int` | 10 | Min calls before ratio is evaluated | +| `BreakDuration` | `TimeSpan` | 30s | How long circuit stays open | +| `ShouldHandle` | `Func` | All except `OperationCanceledException` | What counts as failure | +| `OnOpened` | `ResilienceEventHandler` | null | Fired on Closed → Open | +| `OnClosed` | `ResilienceEventHandler` | null | Fired on HalfOpen → Closed | +| `OnHalfOpened` | `ResilienceEventHandler` | null | Fired on Open → HalfOpen | +| `ManualControl` | `CircuitBreakerManualControl` | null | Manual isolate/reset | + +## State machine + +``` + ┌─────────┐ failure ratio exceeded ┌──────┐ + │ Closed │ ────────────────────────▸ │ Open │ + │ (normal)│ │(reject) + └────▲────┘ └──┬───┘ + │ │ + │ probe succeeds break duration expires + │ │ + ┌────┴─────┐ │ + │ HalfOpen │ ◂────────────────────────────┘ + │ (probe) │ + └──────────┘ + │ + │ probe fails + │ + └──────────────────────────────▸ Open +``` + +**Closed** — normal operation. Successes and failures tracked in sliding window. + +**Open** — all calls rejected immediately with `CircuitBrokenException`. No execution attempted. After `BreakDuration`, transitions to HalfOpen. + +**HalfOpen** — one probe call allowed through. If it succeeds, circuit closes. If it fails, circuit reopens. + +## Sliding window + +Failures are tracked using a bucketed sliding window (10 time buckets). This gives O(1) memory regardless of throughput. Old buckets expire automatically. + +The circuit trips when BOTH conditions are met: +1. Failure ratio ≥ `FailureRatioThreshold` +2. Total calls in window ≥ `MinimumThroughput` + +`MinimumThroughput` prevents false trips during low traffic (e.g., 1 failure out of 2 calls = 50%, but not meaningful). + +## Exception counting + +- Exceptions matching `ShouldHandle` are counted as failures AND rethrown +- Exceptions NOT matching `ShouldHandle` are counted as successes and rethrown +- `OperationCanceledException` is never counted as a failure (user-initiated, not a dependency failure) + +## Manual control + +```csharp +var control = new CircuitBreakerManualControl(); + +var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions +{ + ManualControl = control, +})); + +// Force open (e.g., during maintenance) +await control.IsolateAsync(); + +// Force closed (e.g., after deployment) +await control.ResetAsync(); +``` + +Each `CircuitBreakerManualControl` instance can only be bound to one circuit breaker. Reusing across multiple breakers throws `InvalidOperationException`. + +## Result-based circuit breaker + +On typed pipelines, specific result values count as failures: + +```csharp +var pipeline = Pipeline.Create(b => b.AddCircuitBreaker( + new CircuitBreakerStrategyOptions + { + ShouldHandle = outcome => + outcome.Exception is HttpRequestException + || (outcome.TryGetResult(out var r) && (int)r.StatusCode >= 500), + })); +``` + +## Thread safety + +- State reads (Closed check) use volatile — no lock on hot path +- State transitions acquire `System.Threading.Lock` — only one thread transitions +- Sliding window has its own internal lock for bucket rotation +- Event callbacks fire outside the lock to prevent deadlock + +## Composing with Retry + +Place circuit breaker inside retry so each attempt is tracked individually: + +```csharp +var pipeline = Pipeline.Create(b => b + .AddRetry(new RetryStrategyOptions + { + ShouldHandle = ex => ex is CircuitBrokenException or HttpRequestException, + }) + .AddCircuitBreaker(new CircuitBreakerStrategyOptions())); +``` + +## Telemetry + +Emits `resilion.circuit_breaker.state_changes` counter on every state transition. Subscribe with `.AddMeter("Resilion")`. diff --git a/docs/custom-strategies.md b/docs/custom-strategies.md new file mode 100644 index 0000000..22afcb2 --- /dev/null +++ b/docs/custom-strategies.md @@ -0,0 +1,132 @@ +# Custom Strategies + +Extend Resilion with your own resilience logic. + +## Delegate-based (typed pipelines) + +Quickest way — zero files, inline middleware: + +```csharp +var pipeline = Pipeline.Create(b => b + .AddStrategy("cache-check", async (context, next) => + { + // Check cache before calling downstream + if (cache.TryGet(context.OperationKey, out HttpResponseMessage cached)) + return Outcome.FromResult(cached); + + // Execute downstream + var outcome = await next(context); + + // Cache successful responses + if (outcome.TryGetResult(out var result) && result.IsSuccessStatusCode) + cache.Set(context.OperationKey, result); + + return outcome; + }) + .AddRetry(...) + .AddTimeout(TimeSpan.FromSeconds(5))); +``` + +Delegate signature: `Func>>, ValueTask>>` — standard middleware pattern. + +Only available on typed `PipelineBuilder`. + +## Class-based (any pipeline) + +For reusable strategies, inherit from `Strategy` (any result type) or `Strategy` (specific type): + +### Non-generic strategy + +Works with any `TResult`. Good for cross-cutting concerns (logging, tracing, metrics). + +```csharp +public sealed class LoggingStrategy : Strategy +{ + private readonly ILogger _logger; + + public LoggingStrategy(ILogger logger) => _logger = logger; + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + _logger.LogDebug("Executing {Op}", context.OperationKey); + var sw = Stopwatch.StartNew(); + + var outcome = await callback(context).ConfigureAwait(false); + + _logger.LogDebug("Completed {Op} in {Elapsed}ms, Success={S}", + context.OperationKey, sw.ElapsedMilliseconds, outcome.IsSuccess); + + return outcome; + } + + // Optional: override for true sync support + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + _logger.LogDebug("Executing {Op}", context.OperationKey); + var sw = Stopwatch.StartNew(); + + var outcome = callback(context); + + _logger.LogDebug("Completed {Op} in {Elapsed}ms, Success={S}", + context.OperationKey, sw.ElapsedMilliseconds, outcome.IsSuccess); + + return outcome; + } +} + +// Usage: +Pipeline.Create(b => b + .AddStrategy(new LoggingStrategy(logger)) + .AddRetry(...) + .AddTimeout(TimeSpan.FromSeconds(10))); +``` + +### Typed strategy + +Bound to a specific result type. Can inspect and modify results. + +```csharp +public sealed class CachingStrategy : Strategy +{ + private readonly ICache _cache; + + public CachingStrategy(ICache cache) => _cache = cache; + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + if (context.OperationKey is not null + && _cache.TryGet(context.OperationKey, out var cached)) + { + return Outcome.FromResult(cached); + } + + var outcome = await callback(context).ConfigureAwait(false); + + if (outcome.TryGetResult(out var result) && context.OperationKey is not null) + { + _cache.Set(context.OperationKey, result); + } + + return outcome; + } +} +``` + +## Key points + +- `callback` is the next strategy in the chain (or the user delegate if this is the innermost strategy) +- Always call `callback` unless you're short-circuiting (e.g., cache hit) +- Use `ConfigureAwait(false)` on awaits in library code +- Override `Execute` for true sync support; default falls back to sync-over-async +- Implement `IDisposable` (inherited from `Strategy`) if you hold resources +- Pass `context.CancellationToken` to any async operations you call + +## Compared to Polly + +Polly requires four artifacts for a custom strategy: options class, arguments struct, strategy class, extension method. Resilion requires one class (or zero files for delegate-based). diff --git a/docs/fallback.md b/docs/fallback.md new file mode 100644 index 0000000..4b4a173 --- /dev/null +++ b/docs/fallback.md @@ -0,0 +1,106 @@ +# Fallback + +Provides a substitute result when the primary operation fails. The simplest form of graceful degradation. + +## Basic usage + +```csharp +// Constant value — simplest case +var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = "default-response", + })); + +var result = await pipeline.ExecuteAsync(ct => +{ + throw new HttpRequestException("Service down"); + return new ValueTask("unreachable"); +}); +// result == "default-response" +``` + +## Options + +| Option | Type | Default | Description | +|--------|------|---------|-------------| +| `FallbackAction` | `FallbackAction` | **required** | Value, sync factory, or async factory | +| `ShouldHandle` | `Func, bool>` | All except `OperationCanceledException` | What triggers fallback | +| `OnFallback` | `ResilienceEventHandler>` | null | Fired when fallback activates | + +## FallbackAction — three forms + +`FallbackAction` supports implicit conversion from three types, so you write natural C#: + +```csharp +// 1. Constant value +FallbackAction = "cached-default" + +// 2. Sync factory — compute from the failure +Func, string> factory = + ctx => $"Error: {ctx.Exception?.Message}"; +FallbackAction = factory + +// 3. Async factory — call a secondary service or cache +Func, ValueTask> asyncFactory = + async ctx => await cache.GetAsync("fallback-key"); +FallbackAction = asyncFactory +``` + +The factory receives `FallbackContext` which includes: +- `Outcome` — the failed outcome (exception or bad result) +- `Exception` — shortcut to `Outcome.Exception` +- `Context` — the `ResilienceContext` with cancellation token and properties + +## Result-based fallback + +Fallback can trigger on specific result values, not just exceptions: + +```csharp +var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = 0, + ShouldHandle = outcome => + outcome.TryGetResult(out var val) && val < 0, // Negative = failure + })); +``` + +## Typed pipelines only + +Fallback requires `Pipeline` because it must produce a substitute value of the correct type. You cannot add fallback to a non-generic `Pipeline`. + +## Exception swallowing + +When fallback activates, the original exception is swallowed. The fallback result is returned as if the operation succeeded. If you need to log the original error, use `OnFallback`: + +```csharp +Action> onFallback = e => + logger.LogWarning(e.Outcome.Exception, "Fallback activated, returning {Result}", e.FallbackResult); +``` + +## Fallback factory that throws + +If `FallbackAction` itself throws, that exception propagates to the caller. The fallback strategy does not retry its own fallback. + +## Composing with Retry + +Place fallback outside retry to catch exhausted retries: + +```csharp +var pipeline = Pipeline.Create(b => b + .AddFallback(new FallbackStrategyOptions + { + FallbackAction = "all-retries-failed-fallback", + }) + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.None, + })); +// Retries 3 times. If all fail, fallback returns the substitute. +``` + +## Telemetry + +Emits `resilion.fallback.activations` counter when fallback triggers. Subscribe with `.AddMeter("Resilion")`. diff --git a/docs/future-plans.md b/docs/future-plans.md new file mode 100644 index 0000000..47c0bcb --- /dev/null +++ b/docs/future-plans.md @@ -0,0 +1,282 @@ +# Future Plans + +Features, improvements, and known tradeoffs under consideration for future versions of Resilion. Each section includes enough detail to serve as a starting point for implementation. + +## Type Classification + +| Type | Meaning | Impact | Examples | +|------|---------|--------|----------| +| **Feature** | New capability that extends Resilion's functionality beyond current scope | Additive — users gain new resilience options or integrations | Rate Limiter, Hedging, DI integration, Telemetry | +| **Fix** | Correctness issue, performance bug, or missing validation in existing features | Blocking/Correctness — existing code may behave incorrectly or sub-optimally | Per-call closure allocation, WaitHandle allocation | +| **Documentation** | Gaps in docs, missing behavioral explanations, or unclear semantics | Clarity — improves developer experience and correctness of usage | Strategy ordering guide, cancellation semantics | +| **Improvement** | Enhancement to an existing feature that doesn't change its API contract | Quality — existing code works but could work better | CTS pooling, delegate caching | +| **Infrastructure** | CI/CD, packaging, tooling, or repository quality improvements | Adoption — removes friction for users and contributors | Benchmarks, icon, README | + +**How to use this guide:** +- **Fixes** should be prioritized over Features if they affect correctness +- **Documentation** should accompany every Feature (document what it does and why) +- New contributors reading this can quickly understand priority and scope + +## Priority Matrix + +| # | Item | Priority | Type | Impact | Effort | Notes | +|---|------|----------|------|--------|--------|-------| +| 3 | Resilion.Extensions (DI + telemetry) | P1 | Feature | High | Medium | Microsoft.Extensions integration | +| 4 | Per-call delegate allocation in pipeline chain | P2 | Fix | Medium | High | Middleware pattern inherent cost | +| 5 | CancellationTokenSource pooling for Timeout/Hedging | P2 | Improvement | Medium | Medium | Reduce alloc on hot path | +| 6 | Pipeline ordering validation | P2 | Feature | Medium | Medium | Warn on common misorderings | +| 7 | Benchmarks vs Polly | P2 | Infrastructure | High | Medium | Prove performance claims | +| 8 | README and docs | P2 | Documentation | High | Medium | User-facing documentation | +| 9 | WaitHandle allocation in sync retry | P3 | Fix | Low | Low | CancellationToken.WaitHandle lazy alloc | +| 10 | Resilion.Testing package | P3 | Feature | Medium | Low | Test doubles, assertion helpers | +| 11 | Hedging: Task.WhenAny memory leak | P2 | Fix | Medium | Medium | Continuations not deregistered on losing tasks | +| 12 | Hedging: HedgingDelayGenerator | P3 | Feature | Low | Low | Dynamic delay per attempt | +| 13 | Hedging: Properties propagation to attempt contexts | P2 | Fix | Medium | Low | User properties not copied to hedged attempts | +| 14 | Hedging: HedgingRejectedException with aggregated errors | P3 | Improvement | Low | Low | Currently dead code — never thrown | + +> **Completed (removed from backlog):** Solution structure, .editorconfig, global.json, CI workflows, Outcome\, ResilienceContext pooling, Strategy base types, Pipeline/PipelineBuilder, ResilienceEventHandler union struct, Timeout strategy, Retry strategy (with RetryDelay discriminated union), Circuit Breaker (sliding window, state machine, thread safety), Fallback (with FallbackAction implicit conversions), code review and fixes for 13 issues, Rate Limiter strategy (wrapping System.Threading.RateLimiting), Hedging strategy (parallel/latency/sequential modes, per-attempt CTS, cleanup-on-cancel). + +--- + +## P1 — Do First + +### 3. Resilion.Extensions (DI + Telemetry) + +**Type:** Feature — Integration Package + +**Why** + +Production services use `Microsoft.Extensions.DependencyInjection` and OpenTelemetry. Resilion needs first-class integration without forcing these dependencies on the core package. + +**Design** + +The `Resilion.Extensions` project (already exists) will provide: +- `IServiceCollection.AddResilion()` and `AddResiliencePipeline(name, configure)` extensions +- `ResiliencePipelineProvider` for resolving named/keyed pipelines +- `Meter("Resilion")` and `ActivitySource("Resilion")` for OpenTelemetry-compatible metrics and tracing +- `ILogger` integration for strategy events + +**Files to Modify/Create:** +- `src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs` +- `src/Resilion.Extensions/PipelineRegistry.cs` +- `src/Resilion.Extensions/Telemetry/ResilionMeter.cs` +- `tests/Resilion.Extensions.Tests/` — DI registration, telemetry emission tests + +--- + +## P2 — Do Next + +### 4. Per-Call Delegate Allocation in Pipeline Chain + +**Type:** Fix — Performance + +**Why** + +In `StrategyComponent.ExecuteAsync`, the lambda `ctx => _next.ExecuteAsync(callback, ctx)` creates a closure capturing `_next` and `callback` on every call. In a pipeline with N strategies, this means N small closure allocations per execution. + +**Current State** + +This is inherent to the middleware/chain-of-responsibility pattern. Polly v8 has the same cost. The allocations are small (one closure object + one delegate per strategy per call) and negligible compared to real I/O costs. + +**Potential Fix** + +Pre-compose the delegate chain at build time into a single `Func, ValueTask>>` that doesn't allocate per call. This requires complex generic type threading and may not be feasible without sacrificing API simplicity. + +**Decision:** Accept for now. Benchmark to confirm the cost is negligible relative to real workloads. Revisit if benchmarks show it matters. + +--- + +### 5. CancellationTokenSource Pooling for Timeout + +**Type:** Improvement — Performance + +**Why** + +The Timeout strategy allocates one `CancellationTokenSource` per execution. `CancellationTokenSource.TryReset()` (available since .NET 6) enables pooling — reset and reuse instead of allocating. + +**Design** + +Use `ObjectPool` with a custom policy that calls `TryReset()` on return. If `TryReset()` returns false (the CTS was cancelled), discard instead of pooling. + +**Complexity:** Medium. `TryReset()` has edge cases around timer state and concurrent cancellation. + +**Decision:** Implement after benchmarks confirm the CTS allocation is a meaningful cost. + +--- + +### 6. Pipeline Ordering Validation + +**Type:** Feature — Developer Experience + +**Why** + +Strategy ordering dramatically affects behavior. Common misorderings (Retry outside CircuitBreaker, missing per-attempt timeout) are a real source of bugs. Polly v8 has no validation. + +**Design** + +`Build()` performs heuristic validation and emits diagnostic warnings for patterns that are usually wrong: +- Retry outside CircuitBreaker (retries bypass the breaker) +- Fallback not outermost (unusual) +- Multiple Timeout strategies without one being outermost +- Hedging and Retry both present (may cause excessive load) + +Warnings, not errors. Suppressible via `builder.SuppressOrderingWarnings = true`. + +--- + +### 7. Benchmarks vs Polly + +**Type:** Infrastructure — Performance Validation + +**Why** + +Resilion claims to be high-performance. Without benchmarks, that's marketing. + +**Design** + +The benchmark project (`benchmarks/Resilion.Benchmarks/`) already exists. Add: +- Pipeline overhead (no-op vs direct call) +- Per-strategy happy path (no trigger) +- Allocation profile (`[MemoryDiagnoser]`) +- Polly.Core head-to-head comparison +- Composition depth scaling (1, 2, 3, 5 strategies) + +--- + +### 11. Hedging: Task.WhenAny Memory Leak + +**Type:** Fix — Performance/Correctness + +**Why** + +`WaitForBestOutcome` uses `Task.WhenAny(remaining)` in a loop, removing completed tasks from the list. The standard `Task.WhenAny` implementation registers a continuation on every task in the list. When a task completes, the continuations on the *other* tasks are not deregistered — they hold references to the `Task.WhenAny` result task and its captured state, preventing garbage collection until all tasks in the list complete. + +In a pipeline with 3+ hedged attempts where the first wins quickly, the losing tasks' continuations hold memory until they eventually complete or are cancelled. + +**Potential Fix** + +Implement a custom `FirstCompletedAsync` that uses `TaskCompletionSource` + per-task continuations that deregister themselves on completion. Or use `WaitAsync` chaining. + +**Impact:** Medium. Only affects memory under hedging with many concurrent attempts. The cleanup in `finally` (awaiting all tasks) limits the leak duration. + +--- + +### 13. Hedging: Properties Propagation to Attempt Contexts + +**Type:** Fix — Correctness + +**Why** + +In `HedgingStrategy.ResolveAsyncAction`, when re-executing the original callback for hedged attempts, the code creates a new `ResilienceContext` and copies `OperationKey` and `ContinueOnCapturedContext` but does NOT copy `Properties`. If the user stored custom data in `context.Properties` before execution (or an outer strategy set properties), hedged attempts won't see it. + +**Fix:** Copy all properties from the original context to the attempt context. Either iterate and copy, or add a `CopyFrom` method on `ResilienceProperties`. + +**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `ResolveAsyncAction`, line ~210 + +--- + +## P3 — Backlog + +### 9. WaitHandle Allocation in Sync Retry + +**Type:** Fix — Performance (minor) + +**Why** + +The sync retry path uses `context.CancellationToken.WaitHandle.WaitOne(delay)` for cancellation-aware sleep. Accessing `CancellationToken.WaitHandle` lazily allocates a `ManualResetEvent` that is never explicitly disposed. This happens on every retry delay in the sync path. + +**Potential Fix** + +Use `SpinWait` with periodic `IsCancellationRequested` checks for short delays, and `ManualResetEventSlim` with explicit disposal for longer delays. Or use `TimeProvider.CreateTimer` with a `ManualResetEventSlim` signal. + +**Decision:** Low priority. The sync retry path is not the hot path in most applications. Revisit if sync usage proves significant. + +--- + +### 10. Resilion.Testing Package + +**Type:** Feature — Test Infrastructure + +**Why** + +Users testing code that uses Resilion need test doubles and assertion helpers. Currently `Microsoft.Extensions.TimeProvider.Testing.FakeTimeProvider` covers the primary scenario, but a dedicated package could provide: +- `TestPipeline` / `TestPipeline` that record all executions +- Circuit breaker state assertion helpers +- Deterministic event capture +- Pre-configured pipelines for common test scenarios + +**Decision:** Defer until real usage patterns emerge from production users. + +--- + +### 12. Hedging: HedgingDelayGenerator + +**Type:** Feature — Strategy Enhancement + +**Why** + +The current `HedgingDelay` is a static `TimeSpan` — the same delay for every hedged attempt. Some scenarios benefit from dynamic delays (e.g., shorter delays for later attempts, or delays computed from recent latency percentiles). + +**Design** + +Add `Func? HedgingDelayGenerator` to `HedgingStrategyOptions`. When set, `HedgingDelay` is ignored for that attempt. + +```csharp +public readonly record struct HedgingDelayGeneratorArgs(int AttemptNumber, ResilienceContext Context); +``` + +**Complexity:** Low. Thread the generator call into the delay logic in the for-loop. + +--- + +### 14. Hedging: HedgingRejectedException with Aggregated Errors + +**Type:** Improvement — Error Reporting + +**Why** + +`HedgingRejectedException` is defined but never thrown. When all hedging attempts fail, the implementation currently returns the last failure's exception directly via `Outcome`. This means the user only sees the last attempt's exception, losing context about earlier failures. + +**Design** + +When all attempts fail, collect all attempt exceptions and either: +- Throw `HedgingRejectedException` with `AttemptExceptions` containing all failures, or +- Return an `Outcome` with the primary (first) attempt's exception but attach others via `AggregateException` + +The first option changes behavior for users who `catch (InvalidOperationException)` today — their catch would stop matching. The second is backward-compatible. + +**Decision:** Defer. The current behavior (last exception propagates) is simple and predictable. Revisit if users need aggregated error reporting. + +--- + +## Known Tradeoffs (Documented, Not Planned to Fix) + +### Null implicit conversion creates "successful" null outcome + +`Outcome o = (string)null;` creates a success outcome with a null result. This is consistent with how `Task` handles null — `Task.FromResult(null)` is a valid completed task. For nullable reference types this is expected behavior. Users working with non-nullable value types cannot trigger this. + +**Location:** [Outcome.cs](../src/Resilion/Outcome.cs) — `implicit operator` + +### DelegatingComponent does not dispose composed pipeline resources + +When pipelines are composed via `AddPipeline()`, the `DelegatingComponent` intentionally does not dispose the inner component. This is because the inner pipeline may be shared — the same pre-built `Pipeline` can be flattened into multiple builders. The caller owns the lifetime of composed pipelines and must dispose them separately. + +**Location:** [PipelineBuilder.cs](../src/Resilion/PipelineBuilder.cs) — `DelegatingComponent.Dispose()` + +### ResilienceContextPool cap is approximate + +The pool size check (`_pool.Count < MaxPoolSize`) followed by `_pool.Add(context)` is a TOCTOU race — multiple threads can all pass the check and add, slightly exceeding the 256 cap. This is intentional. The cap is a heuristic to prevent unbounded memory growth, not a hard limit. Using `Interlocked` or a lock for exact enforcement would add contention on every pool return for no meaningful benefit. + +**Location:** [ResilienceContextPool.cs](../src/Resilion/ResilienceContextPool.cs) — `Return()` + +### Timeout cancellation classification has a narrow race window + +In `TimeoutStrategy.WasCancelledByTimeout`, there is a TOCTOU window between checking `userToken.IsCancellationRequested` and `linkedCts.IsCancellationRequested`. If the user token is cancelled in between, user cancellation may be misclassified as a timeout (producing `TimeoutRejectedException` instead of `OperationCanceledException`). The window is nanoseconds wide and requires exact concurrent timing to trigger. In practice this is not observable. + +**Location:** [TimeoutStrategy.cs](../src/Resilion/Timeout/TimeoutStrategy.cs) — `WasCancelledByTimeout()` + +### Hedging latency mode calls Task.WhenAny twice + +In latency mode, the hedging strategy checks if any attempt completed before the delay by nesting `Task.WhenAny(Task.WhenAny(attempts), delayTask)`. When an attempt completes early, it calls `Task.WhenAny(attempts)` a second time to get the completed task. If a *different* attempt completed between the two calls, the second `WhenAny` may return a different task. This is benign — either task's result is checked, and if it's a failure the hedge launches anyway. But it means the "early success" check is not guaranteed to evaluate the first-completed task's result. + +**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `ExecuteAsync`, lines ~52-65 diff --git a/docs/hedging.md b/docs/hedging.md new file mode 100644 index 0000000..fb43e7f --- /dev/null +++ b/docs/hedging.md @@ -0,0 +1,119 @@ +# Hedging + +Reduces tail latency by racing concurrent attempts. When the primary request is slow, a secondary fires. Whichever completes first wins. + +## Basic usage + +```csharp +var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = TimeSpan.FromSeconds(2), + })); + +var result = await pipeline.ExecuteAsync(async ct => + await httpClient.GetStringAsync("https://api.example.com", ct)); +``` + +## Options + +| Option | Type | Default | Description | +|--------|------|---------|-------------| +| `MaxHedgedAttempts` | `int` | 2 | Total attempts including primary | +| `HedgingDelay` | `TimeSpan` | 2s | Wait before launching next attempt | +| `ShouldHandle` | `Func, bool>` | All except `OperationCanceledException` | What triggers hedging | +| `ActionGenerator` | `Func>?>` | null | Custom action per attempt | +| `OnHedging` | `ResilienceEventHandler>` | null | Fired before each hedged launch | + +## Three modes + +### Latency mode (delay > 0) — default + +Primary runs. If it hasn't completed after `HedgingDelay`, secondary fires. Both race. First success wins. + +```csharp +HedgingDelay = TimeSpan.FromSeconds(2) // Wait 2s, then hedge +``` + +Best for: reducing P99 latency when most requests are fast. + +### Parallel mode (delay = 0) + +All attempts fire simultaneously. Maximum parallelism, maximum resource usage. + +```csharp +HedgingDelay = TimeSpan.Zero // Fire all immediately +``` + +Best for: latency-critical paths where cost of extra requests is acceptable. + +### Sequential mode (InfiniteTimeSpan) + +Each attempt waits for the previous to fail before starting. No parallelism. + +```csharp +HedgingDelay = Timeout.InfiniteTimeSpan // Wait for failure, then try next +``` + +Best for: fallback to alternative endpoints without parallel overhead. + +## Custom actions per attempt + +Route different attempts to different endpoints: + +```csharp +var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = Timeout.InfiniteTimeSpan, + ActionGenerator = ctx => ctx.AttemptNumber switch + { + 0 => ct => CallPrimaryAsync(ct), + 1 => ct => CallSecondaryAsync(ct), + 2 => ct => CallCacheAsync(ct), + _ => null, // null = skip this attempt + }, + })); +``` + +Returning `null` from `ActionGenerator` skips that attempt index. + +## Cancellation + +- Each attempt gets its own linked `CancellationTokenSource` +- When one attempt wins, all others are cancelled +- **All cancelled tasks are awaited** before returning — prevents resource leaks (connections, streams) +- If user's original token cancels, all attempts cancel and `OperationCanceledException` propagates + +This is a key difference from Polly, which cancels but does not await losing tasks. + +## All attempts fail + +When every attempt fails, the last failure's exception propagates. Only the most recent exception surfaces — earlier attempt exceptions are not aggregated. (See [future-plans.md](future-plans.md#14-hedging-hedgingrejectedexception-with-aggregated-errors) for planned improvement.) + +## Typed pipelines only + +Hedging requires `Pipeline` because it must produce a result of the correct type. + +## Sync execution + +Sync path always runs sequentially regardless of `HedgingDelay` — parallel execution requires async. Each attempt runs to completion (or failure) before the next starts. + +## Result-based hedging + +Hedge on specific result values, not just exceptions: + +```csharp +var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + ShouldHandle = outcome => + outcome.TryGetResult(out var val) && val < 0, // Negative = retry + })); +``` + +## Telemetry + +Emits `resilion.hedging.attempts` counter for each hedged attempt launched (not the primary). Subscribe with `.AddMeter("Resilion")`. diff --git a/docs/installation.md b/docs/installation.md new file mode 100644 index 0000000..fa0e7ed --- /dev/null +++ b/docs/installation.md @@ -0,0 +1,114 @@ +# Installation + +## The short version + +Add one package and you're done: + +```xml + + + +``` + +This gives you retry, circuit breaker, timeout, fallback, and hedging — zero external dependencies. + +--- + +## Package decision guide + +| Package | When to install | +|---------|----------------| +| `Resilion` | Always — core library with all built-in strategies, zero dependencies | +| `Resilion.RateLimiting` | When you need rate limiting (wraps `System.Threading.RateLimiting`) | +| `Resilion.Extensions` | When you use DI (`IServiceCollection`) or want OpenTelemetry metrics | + +--- + +## Dependency graph + +``` +Resilion (zero dependencies) + ↑ + ├── Resilion.Extensions (+ Microsoft.Extensions.*) + │ + └── Resilion.RateLimiting (+ System.Threading.RateLimiting) +``` + +`Resilion.Extensions` and `Resilion.RateLimiting` both reference `Resilion` — NuGet pulls it in transitively. + +--- + +## Quick setup + +### Console app / library (no DI) + +```csharp +using Resilion; + +var pipeline = Pipeline.Create(b => b + .AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 3 }) + .AddTimeout(TimeSpan.FromSeconds(10))); + +var result = await pipeline.ExecuteAsync( + static (client, ct) => client.GetStringAsync("https://api.example.com", ct), + httpClient); +``` + +### ASP.NET Core / DI + +```csharp +using Resilion; +using Resilion.Extensions; + +// In Program.cs or Startup: +services.AddResiliencePipeline("http-retry", b => b + .AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 3 }) + .AddTimeout(TimeSpan.FromSeconds(10))); + +// In your service: +public class MyService(ResiliencePipelineRegistry registry) +{ + private readonly Pipeline _pipeline = registry.GetPipeline("http-retry"); + + public Task GetDataAsync(CancellationToken ct) + => _pipeline.ExecuteAsync( + static (state, ct) => state.client.GetStringAsync(state.url, ct), + (client: _httpClient, url: "https://api.example.com"), + ct).AsTask(); +} +``` + +### With rate limiting + +```xml + + + + +``` + +```csharp +using Resilion; +using Resilion.RateLimiting; +using System.Threading.RateLimiting; + +var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions +{ + PermitLimit = 10, + QueueLimit = 0, +}); + +var pipeline = Pipeline.Create(b => b + .AddRateLimiter(new RateLimiterStrategyOptions { RateLimiter = limiter }) + .AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 3 })); +``` + +--- + +## Supported .NET versions + +- .NET 9.0+ + +## License + +[Apache-2.0](../LICENSE) diff --git a/docs/pipelines.md b/docs/pipelines.md new file mode 100644 index 0000000..3b8e3a7 --- /dev/null +++ b/docs/pipelines.md @@ -0,0 +1,151 @@ +# Pipelines + +Pipelines compose multiple strategies into a single execution unit. Strategies execute outermost to innermost — the first strategy added is the first to see each call. + +## Creating pipelines + +```csharp +// Non-generic — strategies react to exceptions only +var pipeline = Pipeline.Create(b => b + .AddTimeout(TimeSpan.FromSeconds(30)) + .AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 3 }) + .AddCircuitBreaker(new CircuitBreakerStrategyOptions())); + +// Typed — strategies can react to result values too +var typed = Pipeline.Create(b => b + .AddRetry(new RetryStrategyOptions + { + ShouldHandle = outcome => outcome.Exception is HttpRequestException + || (outcome.TryGetResult(out var r) && (int)r.StatusCode >= 500), + }) + .AddTimeout(TimeSpan.FromSeconds(5))); +``` + +## Strategy ordering + +Order matters. A call flows inward (outermost first), then results flow back outward. + +### Canonical order + +```csharp +Pipeline.Create(b => b + .AddRateLimiter(...) // 1. Shed load before spending effort + .AddTimeout(30s) // 2. Total timeout across all retries + .AddRetry(...) // 3. Retry failures from inner strategies + .AddCircuitBreaker(...) // 4. Track per-attempt success/failure + .AddTimeout(5s)); // 5. Per-attempt timeout +``` + +### Why order matters + +Same strategies, different order, different behavior: + +```csharp +// Timeout OUTSIDE retry = one 10s budget for ALL attempts +b.AddTimeout(TimeSpan.FromSeconds(10)); +b.AddRetry(...); + +// Timeout INSIDE retry = each attempt gets 10s +b.AddRetry(...); +b.AddTimeout(TimeSpan.FromSeconds(10)); +``` + +## Pipeline composition + +Combine pre-built pipelines with `AddPipeline`: + +```csharp +var retryPolicy = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions +{ + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), +})); + +var timeoutPolicy = Pipeline.Create(b => b.AddTimeout(TimeSpan.FromSeconds(10))); + +var combined = Pipeline.Create(b => b + .AddPipeline(timeoutPolicy) // Timeout outermost + .AddPipeline(retryPolicy)); // Retry innermost +``` + +`AddPipeline` flattens the source pipeline's strategies into the current builder. No nesting — the composed pipeline behaves identically to one built inline. + +## Empty pipelines + +```csharp +Pipeline.Empty // No-op, passes through +Pipeline.Empty // Typed no-op +``` + +Useful for testing or conditional composition: + +```csharp +var pipeline = useResilience + ? Pipeline.Create(b => b.AddRetry().AddTimeout(TimeSpan.FromSeconds(10))) + : Pipeline.Empty; +``` + +## Execution methods + +### Async (primary) + +```csharp +// With state parameter — zero closure allocation +await pipeline.ExecuteAsync( + static (state, ct) => state.client.GetStringAsync(state.url, ct), + (client: httpClient, url: "https://api.example.com"), + cancellationToken); + +// Without state — simpler but allocates closure +await pipeline.ExecuteAsync(async ct => + await httpClient.GetStringAsync("https://api.example.com", ct)); + +// Void +await pipeline.ExecuteAsync(async ct => + await httpClient.PostAsync("https://api.example.com", content, ct)); +``` + +### Sync + +```csharp +// With state +var result = pipeline.Execute( + static (state, ct) => state.Compute(state.input), + (Compute: myFunc, input: 42)); + +// Without state +var result = pipeline.Execute(ct => ComputeSync(ct)); + +// Void +pipeline.Execute(ct => DoWork(ct)); +``` + +### Outcome-based (no throwing) + +```csharp +var context = ResilienceContextPool.Shared.Rent(cancellationToken); +try +{ + var outcome = await pipeline.ExecuteOutcomeAsync( + static (state, ctx) => /* ... */, + myState, + context); + + if (outcome.IsSuccess) + Console.WriteLine(outcome.Result); + else + Console.WriteLine(outcome.Exception); +} +finally +{ + ResilienceContextPool.Shared.Return(context); +} +``` + +## Disposal + +Pipelines implement `IDisposable`. Dispose when strategies hold resources (circuit breaker timers). Pipelines from `AddPipeline` composition share ownership — dispose composed pipelines separately. + +## Immutability and thread safety + +Pipelines are sealed, immutable after construction, and thread-safe. Build once, cache as a `static readonly` or singleton, reuse across threads. diff --git a/docs/rate-limiting.md b/docs/rate-limiting.md new file mode 100644 index 0000000..327f3e4 --- /dev/null +++ b/docs/rate-limiting.md @@ -0,0 +1,94 @@ +# Rate Limiting + +Throttles executions using .NET's built-in `System.Threading.RateLimiting`. Lives in the `Resilion.RateLimiting` package. + +## Basic usage + +```csharp +using Resilion; +using Resilion.RateLimiting; +using System.Threading.RateLimiting; + +var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions +{ + PermitLimit = 10, + QueueLimit = 0, +}); + +var pipeline = Pipeline.Create(b => b.AddRateLimiter( + new RateLimiterStrategyOptions { RateLimiter = limiter })); + +try +{ + await pipeline.ExecuteAsync(async ct => await CallApiAsync(ct)); +} +catch (RateLimitRejectedException ex) +{ + Console.WriteLine($"Rate limited. Retry after: {ex.RetryAfter?.TotalSeconds:F1}s"); +} +``` + +## Options + +| Option | Type | Default | Description | +|--------|------|---------|-------------| +| `RateLimiter` | `RateLimiter` | **required** | .NET rate limiter instance | +| `OnRejected` | `ResilienceEventHandler` | null | Fired on rejection | + +## Supported rate limiter types + +All .NET built-in algorithms work: + +```csharp +// Concurrency — max simultaneous executions +new ConcurrencyLimiter(new ConcurrencyLimiterOptions { PermitLimit = 10 }) + +// Token bucket — tokens replenish over time +new TokenBucketRateLimiter(new TokenBucketRateLimiterOptions +{ + TokenLimit = 100, + ReplenishmentPeriod = TimeSpan.FromSeconds(1), + TokensPerPeriod = 10, +}) + +// Fixed window — permits per time window +new FixedWindowRateLimiter(new FixedWindowRateLimiterOptions +{ + PermitLimit = 100, + Window = TimeSpan.FromMinutes(1), +}) + +// Sliding window — smoother distribution +new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions +{ + PermitLimit = 100, + Window = TimeSpan.FromMinutes(1), + SegmentsPerWindow = 6, +}) +``` + +## Lifetime management + +The strategy does NOT own the `RateLimiter`. You (or your DI container) are responsible for disposing it. The strategy acquires a lease before execution, runs the delegate, and disposes the lease in `finally` — even on exceptions. + +## RetryAfter + +When the rate limiter provides `RetryAfter` metadata (e.g., `TokenBucketRateLimiter`), it's included in `RateLimitRejectedException.RetryAfter`. Combine with Retry to automatically wait: + +```csharp +var pipeline = Pipeline.Create(b => b + .AddRetry(new RetryStrategyOptions + { + ShouldHandle = ex => ex is RateLimitRejectedException, + Delay = RetryDelay.Custom(ctx => TimeSpan.FromSeconds(1)), // or use RetryAfter + }) + .AddRateLimiter(new RateLimiterStrategyOptions { RateLimiter = limiter })); +``` + +## Sync execution + +The sync path uses `AttemptAcquire` (non-blocking). If the limiter supports queueing (`QueueLimit > 0`), the sync path cannot wait in the queue — it only attempts immediate acquisition. + +## Telemetry + +Emits `resilion.rate_limiter.rejections` counter on rejection. Subscribe with `.AddMeter("Resilion")`. diff --git a/docs/retry.md b/docs/retry.md new file mode 100644 index 0000000..9ac5277 --- /dev/null +++ b/docs/retry.md @@ -0,0 +1,124 @@ +# Retry + +Re-executes a failed operation up to a configured number of times, with configurable delays between attempts. + +## Basic usage + +```csharp +var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions +{ + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), + UseJitter = true, +})); + +var result = await pipeline.ExecuteAsync(async ct => +{ + var response = await httpClient.GetAsync("https://api.example.com", ct); + response.EnsureSuccessStatusCode(); + return await response.Content.ReadAsStringAsync(ct); +}); +``` + +## Options + +| Option | Type | Default | Description | +|--------|------|---------|-------------| +| `MaxRetryAttempts` | `int` | 3 | Number of retries (not counting initial call). 0 = no retries. | +| `Delay` | `RetryDelay` | Exponential(1s, max 30s) | Delay strategy between retries | +| `UseJitter` | `bool` | `true` | Apply decorrelated jitter to delays | +| `ShouldHandle` | `Func` | All except `OperationCanceledException` | Which exceptions trigger retry | +| `OnRetry` | `ResilienceEventHandler` | null | Callback before each retry wait | + +## Delay strategies + +Resilion uses `RetryDelay` — a discriminated union that makes delay configuration mutually exclusive by construction. No silent overrides. + +```csharp +// Constant: same delay every time +Delay = RetryDelay.Constant(TimeSpan.FromMilliseconds(500)) +// Produces: 500ms, 500ms, 500ms, ... + +// Linear: baseDelay × attemptNumber +Delay = RetryDelay.Linear(TimeSpan.FromSeconds(1)) +// Produces: 1s, 2s, 3s, ... + +// Exponential: baseDelay × 2^(attemptNumber-1) +Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)) +// Produces: 1s, 2s, 4s, 8s, ... (capped at maxDelay, default 30s) + +// Custom: any function +Delay = RetryDelay.Custom(ctx => TimeSpan.FromSeconds(ctx.AttemptNumber * 5)) + +// None: immediate retry (useful for testing) +Delay = RetryDelay.None +``` + +### Jitter + +When `UseJitter = true` (default), ±25% randomness is applied to computed delays. This prevents thundering herd problems where many clients retry at the same instant after a shared failure. + +Jitter is recommended for all production use. Disable only for deterministic testing. + +## Result-based retry (typed pipelines) + +On typed pipelines, retry can inspect return values — not just exceptions: + +```csharp +var pipeline = Pipeline.Create(b => b.AddRetry( + new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), + ShouldHandle = outcome => + outcome.Exception is HttpRequestException + || (outcome.TryGetResult(out var r) && (int)r.StatusCode >= 500), + })); +``` + +`ShouldHandle` receives `Outcome` which wraps either the result or exception. Use `TryGetResult` to inspect results without throwing. + +## Exhaustion behavior + +When all retries are exhausted: +- **Exception failures**: last attempt's exception propagates with original stack trace. No wrapping in a `RetryExhaustedException` — your `catch (HttpRequestException)` still works. +- **Result failures**: last attempt's result is returned as-is. + +## Cancellation + +- `OperationCanceledException` is never retried by default +- Cancellation is checked before each attempt and during delay waits +- If token is cancelled during delay, retry stops immediately with `OperationCanceledException` + +## Composing with Timeout + +```csharp +// Total timeout (outer) + per-attempt timeout (inner) +var pipeline = Pipeline.Create(b => b + .AddTimeout(TimeSpan.FromSeconds(30)) // Total budget + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), + ShouldHandle = ex => ex is TimeoutRejectedException, + }) + .AddTimeout(TimeSpan.FromSeconds(5))); // Per attempt +``` + +## OnRetry callback + +```csharp +Action onRetry = e => + logger.LogWarning("Retry #{Attempt}, waiting {Delay}ms. Error: {Error}", + e.AttemptNumber, e.RetryDelay.TotalMilliseconds, e.Exception.Message); + +var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions +{ + MaxRetryAttempts = 3, + OnRetry = onRetry, +})); +``` + +## Telemetry + +Emits `resilion.retry.attempts` counter on each retry attempt. Subscribe with `.AddMeter("Resilion")`. diff --git a/docs/telemetry.md b/docs/telemetry.md new file mode 100644 index 0000000..09fae37 --- /dev/null +++ b/docs/telemetry.md @@ -0,0 +1,58 @@ +# Telemetry + +Resilion emits metrics via .NET's built-in `System.Diagnostics.Metrics`. Zero overhead when no listener is attached. + +## Metrics + +All metrics are on the `"Resilion"` meter. + +| Metric | Type | Emitted when | +|--------|------|-------------| +| `resilion.retry.attempts` | Counter | Each retry attempt | +| `resilion.timeout.expirations` | Counter | Timeout fires | +| `resilion.circuit_breaker.state_changes` | Counter | Any state transition | +| `resilion.fallback.activations` | Counter | Fallback triggers | +| `resilion.hedging.attempts` | Counter | Hedged attempt launches | +| `resilion.rate_limiter.rejections` | Counter | Rate limit rejection | + +## Subscribing + +### dotnet-counters (CLI) + +```bash +dotnet counters monitor --counters Resilion +``` + +### OpenTelemetry + +```csharp +builder.Services.AddOpenTelemetry() + .WithMetrics(m => m.AddMeter("Resilion")); +``` + +### Manual MeterListener + +```csharp +var listener = new MeterListener(); +listener.InstrumentPublished = (instrument, listener) => +{ + if (instrument.Meter.Name == "Resilion") + listener.EnableMeasurementEvents(instrument); +}; +listener.SetMeasurementEventCallback((instrument, value, tags, state) => + Console.WriteLine($"{instrument.Name}: {value}")); +listener.Start(); +``` + +## Zero-cost when unused + +`Counter.Add(1)` is a no-op at the runtime level when no `MeterListener` is subscribed. No allocation, no work. Metrics only become active when something listens. + +## Strategy callbacks vs metrics + +Two complementary systems: + +- **Callbacks** (`OnRetry`, `OnTimeout`, etc.) — inline, per-pipeline, for custom logic (logging, alerting, request mutation) +- **Metrics** — global, aggregated, for observability dashboards and alerting systems + +Both fire on the same events. Use callbacks for per-request decisions. Use metrics for aggregate monitoring. diff --git a/docs/testing.md b/docs/testing.md new file mode 100644 index 0000000..8547f30 --- /dev/null +++ b/docs/testing.md @@ -0,0 +1,174 @@ +# Testing + +How to test code that uses Resilion. + +## Replace with empty pipeline + +Simplest approach — bypass resilience for unit tests: + +```csharp +// Production +var pipeline = Pipeline.Create(b => b.AddRetry().AddTimeout(TimeSpan.FromSeconds(10))); + +// Test +var pipeline = Pipeline.Empty; // No strategies, direct passthrough +``` + +## TimeProvider for deterministic tests + +All time-dependent strategies (Timeout, Retry delays, Circuit Breaker recovery) accept `TimeProvider` through the builder. Use `FakeTimeProvider` from `Microsoft.Extensions.TimeProvider.Testing`: + +```xml + +``` + +```csharp +using Microsoft.Extensions.Time.Testing; + +[Fact] +public async Task Timeout_Fires_After_Configured_Duration() +{ + var fakeTime = new FakeTimeProvider(); + + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddTimeout(TimeSpan.FromSeconds(5)); + }); + + var task = pipeline.ExecuteAsync(async ct => + { + await Task.Delay(TimeSpan.FromMinutes(1), fakeTime, ct); + return "late"; + }); + + fakeTime.Advance(TimeSpan.FromSeconds(6)); + + await Assert.ThrowsAsync(() => task.AsTask()); +} +``` + +## Testing retry behavior + +```csharp +[Fact] +public async Task Retries_Three_Times_Then_Succeeds() +{ + var callCount = 0; + var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.None, // No delays in tests + })); + + var result = await pipeline.ExecuteAsync(ct => + { + callCount++; + if (callCount < 3) + throw new InvalidOperationException("transient"); + return new ValueTask("recovered"); + }); + + Assert.Equal("recovered", result); + Assert.Equal(3, callCount); +} +``` + +## Testing circuit breaker state + +Trip the circuit and verify rejection: + +```csharp +[Fact] +public async Task Circuit_Trips_After_Failures() +{ + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 4, + BreakDuration = TimeSpan.FromSeconds(30), + })); + + // 4 failures = 100% failure rate, above 50% threshold + for (var i = 0; i < 4; i++) + { + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + throw new InvalidOperationException("fail")).AsTask()); + } + + // Next call rejected + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask(1)).AsTask()); +} +``` + +## Testing with manual circuit control + +```csharp +[Fact] +public async Task Manual_Isolation_Rejects_All() +{ + var control = new CircuitBreakerManualControl(); + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + ManualControl = control, + })); + + await control.IsolateAsync(); + + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask(1)).AsTask()); +} +``` + +## Testing fallback + +```csharp +[Fact] +public async Task Fallback_Returns_Default_On_Failure() +{ + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions { FallbackAction = "default" })); + + var result = await pipeline.ExecuteAsync(ct => + { + throw new Exception("fail"); + return new ValueTask("unreachable"); + }); + + Assert.Equal("default", result); +} +``` + +## Testing callbacks + +Capture event args to verify strategy behavior: + +```csharp +[Fact] +public async Task OnRetry_Receives_Correct_Attempt_Numbers() +{ + var attempts = new List(); + Action onRetry = e => attempts.Add(e.AttemptNumber); + + var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.None, + OnRetry = onRetry, + })); + + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => throw new Exception("fail")).AsTask()); + + Assert.Equal([1, 2, 3], attempts); +} +``` + +## Tips + +- Use `RetryDelay.None` in tests to avoid real delays +- Use `FakeTimeProvider` for timeout/circuit breaker recovery testing +- Use `Pipeline.Empty` when resilience behavior is not under test +- Use callbacks (`OnRetry`, `OnTimeout`, etc.) to verify strategy activation without inspecting internals diff --git a/docs/timeout.md b/docs/timeout.md new file mode 100644 index 0000000..a358015 --- /dev/null +++ b/docs/timeout.md @@ -0,0 +1,92 @@ +# Timeout + +Enforces a time limit on operations using cooperative cancellation. + +## Basic usage + +```csharp +var pipeline = Pipeline.Create(b => b.AddTimeout(TimeSpan.FromSeconds(10))); + +try +{ + await pipeline.ExecuteAsync(async ct => + { + return await httpClient.GetStringAsync("https://slow-api.example.com", ct); + }); +} +catch (TimeoutRejectedException ex) +{ + Console.WriteLine($"Timed out after {ex.ElapsedTime.TotalSeconds:F1}s"); +} +``` + +## Options + +| Option | Type | Default | Description | +|--------|------|---------|-------------| +| `Timeout` | `TimeSpan` | 30 seconds | Duration before timeout fires | +| `TimeoutGenerator` | `Func` | null | Dynamic timeout per execution | +| `OnTimeout` | `ResilienceEventHandler` | null | Callback when timeout occurs | + +### Special values + +- `TimeSpan.Zero` — immediately times out (useful for testing) +- `Timeout.InfiniteTimeSpan` — disables timeout (passthrough, no CTS allocated) + +## How it works + +1. Creates a linked `CancellationTokenSource` combining the user's token with a timer +2. Passes the linked token to the inner delegate via `ResilienceContext.CancellationToken` +3. If timer fires before delegate completes, linked token cancels +4. Catches `OperationCanceledException` from the delegate and wraps it in `TimeoutRejectedException` +5. If user's original token was cancelled (not the timer), `OperationCanceledException` propagates unchanged + +**Cooperative only.** The delegate MUST observe the `CancellationToken`. If it ignores the token, timeout has no effect — Resilion cannot forcibly abort operations. This is a deliberate design choice. Pessimistic timeout (background thread abandonment) leaks resources and creates unpredictable state. + +## User cancellation vs timeout + +Resilion distinguishes between the two: + +| Cause | Exception thrown | How to catch | +|-------|-----------------|-------------| +| Timeout expired | `TimeoutRejectedException` | `catch (TimeoutRejectedException)` | +| User cancelled | `OperationCanceledException` | `catch (OperationCanceledException)` | + +`TimeoutRejectedException` includes: +- `ConfiguredTimeout` — the duration that was set +- `ElapsedTime` — actual time elapsed before timeout +- `InnerException` — the original `OperationCanceledException` + +## Per-attempt vs total timeout + +Strategy ordering determines which timeout applies: + +```csharp +// Total timeout (outer) + per-attempt timeout (inner) +var pipeline = Pipeline.Create(b => b + .AddTimeout(TimeSpan.FromSeconds(30)) // Caps entire pipeline including retries + .AddRetry(...) + .AddTimeout(TimeSpan.FromSeconds(5))); // Each attempt gets 5s +``` + +## Dynamic timeout + +```csharp +var pipeline = Pipeline.Create(b => b.AddTimeout(new TimeoutStrategyOptions +{ + TimeoutGenerator = args => + { + // Different timeout based on operation + return args.Context.OperationKey switch + { + "fast-op" => TimeSpan.FromSeconds(2), + "slow-op" => TimeSpan.FromSeconds(60), + _ => TimeSpan.FromSeconds(10), + }; + }, +})); +``` + +## Telemetry + +Emits `resilion.timeout.expirations` counter when timeout fires. Subscribe with `.AddMeter("Resilion")`. diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md new file mode 100644 index 0000000..850c08d --- /dev/null +++ b/docs/troubleshooting.md @@ -0,0 +1,126 @@ +# Troubleshooting + +## Timeout has no effect + +**Problem**: Operation runs past the configured timeout without being cancelled. + +**Cause**: Timeout relies on cooperative cancellation. The delegate must observe `CancellationToken`. + +**Fix**: Pass the `ct` parameter to all async operations: + +```csharp +// BAD — ignores cancellation +await pipeline.ExecuteAsync(async ct => + await SomeCall()); // token not passed + +// GOOD +await pipeline.ExecuteAsync(async ct => + await SomeCall(ct)); // token forwarded +``` + +See [cancellation.md](cancellation.md) for details. + +--- + +## Retry doesn't retry my exception + +**Problem**: Exception thrown but not retried. + +**Checklist**: +- `OperationCanceledException` is never retried by default +- Custom `ShouldHandle` predicate may not match your exception type +- `MaxRetryAttempts = 0` disables retries + +**Fix**: Check your `ShouldHandle` predicate. Default handles all exceptions except `OperationCanceledException`: + +```csharp +// Only retries HttpRequestException: +ShouldHandle = ex => ex is HttpRequestException + +// Retries everything including OCE (unusual): +ShouldHandle = _ => true +``` + +--- + +## Circuit breaker never trips + +**Problem**: Lots of failures but circuit stays Closed. + +**Checklist**: +- `MinimumThroughput` not met? (default: 10 calls required before ratio evaluated) +- `FailureRatioThreshold` too high? (default: 0.5 = 50%) +- Exception not matching `ShouldHandle`? (`OperationCanceledException` doesn't count) +- `SamplingDuration` too short? (failures expire from the window) + +--- + +## Circuit breaker stays open + +**Problem**: Circuit tripped and never recovers. + +**Cause**: `BreakDuration` hasn't elapsed, or probe calls in HalfOpen keep failing. + +**Fix**: Check `BreakDuration` (default: 30s). After it expires, one probe call is allowed. If the probe fails, circuit reopens for another `BreakDuration`. + +To force-close: use `CircuitBreakerManualControl.ResetAsync()`. + +--- + +## "No pipeline registered with key" from DI + +**Problem**: `KeyNotFoundException` when resolving from `ResiliencePipelineRegistry`. + +**Cause**: Pipeline configurations registered via `AddResiliencePipeline` need to be applied to the registry. + +**Fix**: Call `ResilionServiceCollectionExtensions.BuildRegistry(serviceProvider)` after building the service provider, or resolve the registry after all registrations are complete. + +--- + +## Fallback not available on non-generic Pipeline + +**Problem**: `AddFallback` method doesn't appear on `PipelineBuilder`. + +**Cause**: Fallback requires `Pipeline` because it produces a substitute value of a specific type. + +**Fix**: Use `Pipeline.Create(...)` instead of `Pipeline.Create(...)`: + +```csharp +// Won't compile — no AddFallback on PipelineBuilder +Pipeline.Create(b => b.AddFallback(...)); + +// Works — typed pipeline +Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions { FallbackAction = "default" })); +``` + +Same applies to `AddHedging`. + +--- + +## ResilienceEventHandler won't accept my lambda + +**Problem**: `CS1660: Cannot convert lambda expression to type 'ResilienceEventHandler?'` + +**Cause**: C# can't chain two implicit conversions (lambda → `Action` → `ResilienceEventHandler`). + +**Fix**: Assign to a typed variable first: + +```csharp +// Won't compile directly in options initializer +OnRetry = (RetryAttemptEvent e) => logger.Log(e.AttemptNumber) // CS1660 + +// Works — explicit Action +Action onRetry = e => logger.Log(e.AttemptNumber); +// Then: OnRetry = onRetry +``` + +--- + +## Hedging sync path runs sequentially + +**Problem**: Hedging with `HedgingDelay = TimeSpan.Zero` (parallel mode) doesn't run attempts in parallel when using `Execute` (sync). + +**Cause**: Parallel execution requires async. The sync path always runs sequentially regardless of `HedgingDelay`. + +**Fix**: Use `ExecuteAsync` for parallel hedging. diff --git a/global.json b/global.json new file mode 100644 index 0000000..f657889 --- /dev/null +++ b/global.json @@ -0,0 +1,6 @@ +{ + "sdk": { + "version": "9.0.100", + "rollForward": "latestMajor" + } +} diff --git a/icon.png b/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..9f609bdd3731456304bb940c6a2a95278767151a GIT binary patch literal 1234353 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®PgnSG&OW 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%0A)> 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 z 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 z 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

SLwrl+V$RY=z7oJ9lHDm3(HkzG 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 kex_-CVD_s~xneb7IaD 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/S2SfKb+~`k zzVJ2sZk9aF;4rK8FaQOpD77KGEu;q3@1p}1o`Qx1(JDxJ)4r6IeUoXWszy#YM6yeI zRiedLACx116!)n(H34qkmOzj4eNRXe+J7A<4OGac5i>Y9Zh(5ZkLiJ)9!JFOQh5{- zq3QwE5;_DAt_U{)1=*%XBVC7sy#&7W_tJ@!t|hRTlcsPQs?J*}Jvv|`r^HaJFv77^#fqtRr7svx07C*ef4_N44z#4GJaZwA*DJ&?} zo!2_74x!hhBhN#vE%B6&#gzt~&AOl8T#< zh4nXi!T#pjza#9EZMlMP7j$^o2M9vRC}+l^cB{`c#Y9qqXQ>Uk2PGjI85C_Ad5%ss z54Wh_dr%oZ?YRCyAlHVbL>N7-JsRc)HT z5bebCGC4Tez9sFj9T&iOXM#jpvH16vuz3H|pi2e?RmK@9Nsfcb{>k`WW`S|s4b3+c zT7aV!yIu4c(?L|hd{NboMFq#lkK%=UZ^7Sw+n>Ty=byskj~!z_FW9z*ZBw+Sm?mJF zEOTxHp!p(RgKZ<9Ji}DPGMt&MCGc&Flu1}H+)f1coCjfcmsIS;JCq4tr`o3=ibw>G zr1TqYd0(M(qi?n+9%M}X2J0!pFJrJVOcoV@ltgVGM~p@C`Q)=4o4}tfS)GxgQ{M}= z^@|>Ws&;9}(2M3IYQTvg6Td|QR%lMNW&m>&Y>pb<^9u_;{GkQc9ujD?7Y$ZGy6FIB z7dIJk7s%sBGH8>-kurwF37<(kt>^)ypC`cv(c*Ze%qJ=ioeoipm1n9b^=w`Xr>{&Q z2q%L$)h|@rbN~gU_mu!Do3V`X#ce5T_jU&HI%he&E289ujS4!M zG!df++~yoPflPS-C=>BL8!jIW`A)kDL_La^nuGlxD;Eo&wsQS{P+GCt1OhqW zLI(I_hzy7|D%L{x8f;}C+i5YrLwLi@r$JvmgI){r6Vv5BvOd1EJ!%$B@I-~N!oCvqif6%~37}Ze zc1M_RzKFB8KZ%|ER-8?Wd$VFX0@{i34ZQnV&A9Siy%Y6k$M ze#jMR8Dv-meilk(7!API6SCm@aSFC0GtRw_z_AoL2_#WFRvZRGijxs5dVrrugCKWx zH2JlNrgB%vvyK=jf9Jp$URfUB=B&Dr+9Wae|=+R-6(Dc#S$BCYl3( zLt1mqB31$%T{9T2zV*=Y8k5~-*)UVHZHkL7*c@-LJK5mpzwX;{@pC_h>EsdU{ygoJ zU8O_iw;y?WAJgiKcKSoRnCCK@Y-NS%yA z+bXbx{tWu1OqX}oJR9RNSXDwFs4x{el2CGkj}imBn`ww|`J7^i|S9;_&# zG}G78KBJ@I==f1QeecKdBk#C@-}`_5V|et@hw=P#7uZd{m(hdBOnh3Rh1{4{Fqs}r zr2%z2dB<&28Z|v=gBFikC47Lu0pB+qhgm?;+kPP>KjmBM`$1qLXM~S?N9cFN!d)3p zy)ceyu+E%4;K7aSi8 zo_I~etrtyCNrJbnHQu54e0^Z6z+Ow7?D`6#~A*wILoFbR)#enTDJAkx7MrG3@ZK=k3uq@dQs9{UnRooda_>ibns(jaq=khit2?1VCA)9CRA;{h(r+ zi-1k)?@F%_1_p3PeA}hQvcmCS+FBJaP$Ft5j`?0+0pWdCz35VF{f{Tp9_*5e`Uzvo zI_H&%W9rh%4a_6kN-NV@l%cuk8Zs!7qJE=zHeaM-peRwF+q;?Kn$Ah+@BuIx|C7!N3LyE)Xbp%B z3UO$oFn*pvhY{zgsMC`Xk$SYAt;u^^Y+5pamXiRY+oB+fmX3XFqbL^N-CB;3E@_}Z z>$3${G6p@v2`sPBuvNue{lB5T6-2y{{u((;1|DHwT7R>BB_1lxf-BP>3jb{7mB;}^ z^=`RJgHkY6jE4>Yhfx^%3*5N_D2H7pwSuqxdg0MJ=Ssd(tUw6Z*2Akf)MWv-JK*d^ zT>QejAfLF4(?^c5-vbK-=X=HORB+|<1V^s|u6-%+;s=16KM(AmQ*0En+4<`346B7w z`WhXGe*rvc;62(YbvJ!&<+;o0| zA4#iAbGpmq0?GprQW;8d{3@Ajm$4@jO6cD{D`o|{DC9)2c@=Q-S%Tx&0Mjc4?W$m! zELb-$c928AfCZ&|JE_>A4cZqkK+Pb~;{7Us&g?ZuY2_jAP;h5d;qR_xgDQuU32!cv z5136id7#Y^%6fH_>Bg}GagYrKIzaOFnK>CjxF!ID2*NBjmt|#Uo2-DMHdC8h8qtZ;T>=MOSt=Y{{}WEH=s)o zyBC}r_^J$0{uVzavS0vX?onL*p2UAs5&C~teoTE?LYR}5m)kYC1(nt1v9A(GaD&^* z{k1JB8JsTbF=3+03Dqb{xtF-^dLjaiTm+)dkqmGk)lzrfBMhNSS2jRksx%ij_=#hB zEJJje0c^0_-N1Wa_ zMoq^x-K!aP9*%b^zN_re-$_3Jfgn!6$4vAv%wP>X^><{=Sd}%3uE{{3APLCdD_98@ zv%huVxM0ojd#jG+d~%S3%1FhBC`vb8Pj3ozHCrhPQL`xZ~ue=)0rA7UhqS_i6`pCyw(_5gN* z{nDW?UEtsU55EGpZ+{EE?#F*F$UWp@Th{!4$hi@I|zH-kQk?^Xf-<1dTjF^-1m)U+c zHE-p9zLWAG!~4YX2zW}b>BNwOH2Wh@4`>)iN*r~pv3ZD#ag4fdEc7xjUh@2k$z^EO z@l<%eyj<*-l#9SBu7=C#IDV)P*w!V_7rnE(G;r?#XiSFNr$^*{^m!1N%a5YYP(4#c zLuhGatD+pUhJYe#A$xQ#XtP!;ZG4%tlJp1FjjG)(!4e_kyC9|`WbM=wlb|h)t#=a+ zPx!g!1@K<3)JQ0GhpH$KYjjwt2;4|MOQ&FkAEl4s(Gh#B4@N6j4O}Z}HENV+0XHHC zUhEC!D|E~wf?r_Ey}@*1NHY{aqtKkeDVj;PSDm25!f=f^RrT6SLGX1}nk2eQfRFv< zU&Nfgy3`L@kae>e##uLT1CH3`o8!2zY|; zYQUfbG*R$la*+;T206*<`C8ZvEjB^Rif_Ook#&?dtQt*?W{l_RYP7AY-u>YFapz~> zg@=Fpm*M&S1&-YdIN#fZPObr0uLD zN;p~M*Xpb&m}TU))Pp4L0&*nJ5}ijw-^e<1803%ut3m{q3sc1^MqjgDq#C6!RB#+ zTnBWr%(s57SkA024g7G12BXC?t8GVxXOGRufMwU%1aCFr3<159eu`x_dgZpB8hlWy z>Ezz70Gf}JjRWf0wxnU7;q}d6lMa{5z9`yMC!o?ffmCK^G+i zs7JirFmuMYO8aaXBVau{1GC4W4hksRWc_h+D9*Q1{!Ic*Q%6%pJD%|HLtDJ_&;2dj z{7ZiZ+oKcoF31Qrg^i3|Cc~lYOrBE(g#d>zkpI(;Q!luwtG*ny8f}Tj ze!1d16ty3=mHwQ1oR8x1n0LsI5#v>s1z zJXzhxD1&|=t=Rae(?e34c;y$@&HgggR6JQ>0Dz{U1HigL-c{1uc~{Ao80c&7ib5NN z^@3u&$U!KA7eYqWvVa!P&TgI}r>a=GqHV->DC`AY6neVgeBXhW8vY-@=ikQ7mtKcI z`n_+$e)~M8b^}Ylu)~mweO@n6GqcYSmb%8qr3q)q!02O9#}E$#P0L&;bWq`|plh{x zq-mKy2&9CTH1s62L+NLzLRy1VdeVst-CpMbNm!0Ab+S#fuYS3V ztQeFs_fhg@Hj^w;sN{&MG8?#VIaYhDXCq>(&Vp80u15B#U+bLTabEyRYLlL{9H|ql z498pq(L}VFyaouGS3&RIbSmN+H-J=&Ur~ajyJSz*R@Uq5ZK>n$l#Qy(qs3U<@7!$g z;DZN&IRF^B%Du5r5n5u?)vDIlWZek8v0^<_4PVwmv3$j%4Uf4aRh7puiOWY#W_1JWVp|!OIzC8I)W``; zXuL`vt-32GjVr3<15jDjjf>S{&=AJ^**FznIP26pP9@spVybzY?_a7Vi~28gAQlFH zs5%D+{N>MMz*+rhT$8|WYU**E>_K6*fP8%ba6pg0D+mJ6QrF34@F|}egeNYNDbtx8 zL;{DnLVfnKrdKQZnpLA5`c|irv(#?ipZ#iKv^BV~wGv z4+s#R7*-f#izJf9A%mCUwD1@)8sFE1knyXIbV*=Gyj9JpYTlwW_DyV2^kvAhjNV1T zlV;C!Ssa{SJT&pv^vx?y=3q zGUt?a-xk5b!xA7?q?+X}HFXpe7U-c2YQm@s;?z=fLD{bmv~%W)?9iZTmpI5EWK*oY zr5C4M#Da3%?%M!S&(0wF8N}*2>9P~QQe`gPYauZp<$5O;t~f5F%ykCOd{VY(&rCdS z(bXcCiv|rT_+1sU_@E<@pb>!ZI9njDca2jMyYXc9M?(=S|yL}Vrikbw->jRb_(>WaI!6F$F`{&ehn@Xtk*lb2x&?RtCy zh~@%Z@N1dyf=~*h08Is6{#*p*RCK8AY0C*lAW;DA$c&h*zZ3y40b&9fL*zu7!ey&8 zX8YU%_61Wr1}4Ej|IlB@mF+|LnlJj@SeAP@zXu#`c(QTB1{Tz{5{VWpSQJCHY4%TF zi83a+T@A^j>X;QN*wU;$m(`s##t7IVVg%(Xb!guU8R%EA@$8$nZ$(q1GD@-)A~@!w z3|1jX-11s)7Y-2dpd=W?)zL;$F;{Vjv3Xyjjzd|&V^6h^O{+1NL65OnEjXxb%4fO? zHoJzq=Zd$#ZNYE&H#Rsv5uD$(z-V{m#-d|OJX3cGB=qWFeg`?xiptQLY>2wEuouWd zjr1$yPxOy-0K&C0U;f)#Y3#Ts^F(lm{nCc1qIby*_pYKX=LX}npvgZ4kkPgk_+ma<@Zh-f*9PIG3DVq#O~jRPmUbe0t{6{w`KjPR35oo)MB{M! zZ5<JV1RCLmY6gunCmCoR_J7Cd&mPG@T$h#{RKX5iPU8u3r{V{dJv^~`* zvdyu3Mgoh`u?^P)sR3!=>Euh*mWHxHIgA!q!r9YqD=A@1hDWk0i{BGOpNFfzfWt5F z)w&K}6pXdIm^@Vch&@}!=Sdf3Vx%ZbRM8jLWert{%b1{w#1^vwULXz7nv<*ZSMe8) z4sVbagRSjE^ zqoC(fyhLBCXH?O-9iVtOIT5hSDu{Km!4D`a@_+z+fozVT_g=uQpMER$&)mb&BU|W2 z_lzY$OsoW$7lq7L0Q~qf1W&vY*ndvL?WYwleF(VqzK)BJDcZRg13wnX2Ii>y36$L< zED{J?p{gsCh3nIh1HCx*1y$y}O0bVnH+eiz$LCc%Q;&`xVtjnCj=9o2_@0?s;{AvA zjmL*Ah7lBD9}A$fV!v2+m~H^MBA6ZpcCQfZo&b(s32Yt_Y_19Vu~mGTXFHrh?^wM! zSzy_3>h1U`Zc5!VO9Yg3R;%~sCtvflQPm9PtJ*U$;pK^>Ow;V}qBl0uz92H`ta$Y* zD6TG-F$uL4Rs_@G%O z!vZp3BE#Cquz_Gw2o!y}z@{Bzueb3}e(`_6jnl{QRlnx{if5j^1zC33O@a$w0N^%n z5y4WFA4jCrC0K2!3VX}|TMV<1Nb(qyL&hwvIIiT+(&cc@P<|38QtmV06@0A) z9wiC$b$*Q)7zle0cx&J)NV_IWu{*I%Qy6GVJn{L+T;b!9=_I6rPoTy1p)oSEbZZt+ zW(KBwO0)WG+g-!W+lqI*b-|Z>`Gn1hU_MXzA6SgzC11Ml(L!Dd9tWwZ2A=qC7P?jj z;DQ0{K6%6YgK{Cn@f|u6lKDEY#UqYc-6qCD3*q-In3a#*Pmw|d;dNCsSB^buNm{vs z(0^2K-SA?3DTtt>=0QVVLeI#t7_PbivIuZ)CzZBi;OzD}PHr6G>%aa##xtL~i9h!b z{yeUoG^lPc>z+V^5=PdkpZ0N{PlSg4lE3b^R@r|Ix>) zL2nVu`>H{HNRQx|q1m$M`X%#^bvCUrt458xJlI8sK5Imb8i+cQ{LTf;tX=5OhpcMS zJA^#j&)TDbxfmDc&nYK4cOC3*JYN=dNIV%JQa7af*e$dM2x+BHu1FSTo{VGK>gyBuP*E*iGhVPd^6Nk|`j z?#IB~%YEeV8?|S()n&D=dJF)HhIGG4%v@2F)Yk^7tk{RNFzl(7OMoI2yug=c4;_x0 z(va4>I3YQrjQvP?KNVZ_6@5!MKCZuXe7{Z_QmIK9%OPrOe;J%xtBgD{oPkGb!O~ty zz32E%+O2cLJ|l+2d8qfQR@2!DWEIGzn%#m-)aPl2E05S921nMlC##1i<~4?!tHQ;w zh@0F9{Gll73apjz7~ld5tnxU4@Z%*BLAfG78hwd@BtEK(mwoZoltCxcM_5 zz$3ryi*W1S8Fp4A3yTNSMLo9z7Le(SP5L%B6c0TFT>nhL#lHsJdq!~QDaE}H0cTGs z^rme)l#M`kV%sqUmTjbB0VR$z+{6K&0;ooCh$yW*Pekd6v~ewrPy4mHs$cX;4g6A` z!U0PkrWBe<>~pIp=^K2qSM)_O_imHd4Io#6=~2Paqk_{{3XWd^$fE$R0&3Xq|1|(3pc0NmS?n1DOQ9fBev~?DG@{u) zB-;r8!J$wfiaH7nYSJMA|&fK#(0Ey z>Q1yaG@$8Y)TXtxslBp^>$qYww2yj`IxA+O_S~Z9*iNT7n_tA=eb=AIjgyD*>tFrl zcK%U~>XI|3b&RpIq>-f60WVf_`Cog#HcnEbV3< ztX9dColSzWU5wPN&lTboURK^OnRaHw-E;MTMJ1QWSnf6PRb|*7UdVq@!U3@;1?m;e z;CI?E!~$c`fCy=_;zy%(a`@!9;qHqUxc=}7-t@-bi|1~> zgdhCp|0Av*KL+dph!uRzfL9B>xK_nfAQpTH?#AKA08ItYfsV~3PD?O{`cX+o^WReC zcf?`}3P)%_7VU*DR>byn@;qr$v(_R|l^Qv9LNu5QPxW`@<0`7bucd9udGzA%rZfp> zSOHGVSqqBE=i*P~rWltn+C3(VNIxJ~E=pzlxj5$6FC%f#RKVzXfzPzR$zx=d3$L56 zQ%3A~>4~Rm;=_z%1<)mMF^R245k)bjg$Y1H5wo{&)FbF*+DtVn zuB?XVPKah61^~$nI&V|8R2v`A!9!8K-B`8&gI={Kjz|urJ;$^XWGFMcxVFwlBpj*$ zIR82&OTi&m+m0P3E{3YM&8BJK>BFo>3j`E~&hE~AIBdM1D>W+z6G-(3KUEN-+Doox zs8?^&XdebLJfs2|TP}>2X1+|U$c{{zDu$~yL|rVd+}N%$038nSu-t1kjfNlE**)5Jhl{5_ ziRb>sPvNoO_C=6oMr#{10cKAnsw4E+j3sOBz3m;ad5z%4tAQI|AXr`k?tD^l_hW*) zPb=;{3+!)o^s|l$g3TnDCPCYJ7K7IiWWY0XQs*xqASn3EHWk-2irv2)2({5N`XZU6WIR907f@Qx5xL z*>L@iTAG{(L3MAevUIB{hsA(mP%akdJ>bbqv%se!R^cN+%z<$mEb-Bcp5@^Y;dE)9 z5=zw^B4!sXi_Ya*8ydQ0)~Z;Iwu;eOx~vF7UjS`x?=)ZGHI6?f$sN$vJU9mor}R0@ z()@slt`IC}OpmZFse)OdA}S5i7w^=wBUKQGh0wyP8h!obQ_~_Iq|2=^Vq0&!2Z4N> zufPLt85l8+78q^{Yy{c_ z$5$qtzck~+-}qhVA9_1BS06^dxChlX)cOhQsHy2fIlP>^ss&#~j?yMo^(Eylh1Tdu zGMg$c0u9OMg8(I?!1*Ayh6P_B+8;u3Lk8pkSU4fcuLU1uwHSaXB=&B;P%BY;fLP#XR({! zgkSsU7vPhhx{cjtE3=3$i$E6BiHjq`Al4zcP!1tZbv)?U>KI5GumMMd6^ggm9_bOm zBX!HC&yHR5{X-W1Fqw2cXzK%~Cp7~_Q2i~vv{4WqISvtGCxqcgPq}eiS&DAk$ z!8v(cR4>7Aw`^pZ=NkdWv@3&$Q2Avw z#$-~Lhk@p;KvF@GVZ;dYgy z0(|NlnPnOZMGKbv`IVX>yh)GLmB^P-5{Ra@+p%d(B|NmHo`LJNh`(7LoLt$~PJ zhCoRXp96u{d`8!(j&~#m9keHkflFxQjaNjy+$UiQ3xtg|5~JP6E{k09b=;-aTa zgdXzP!*P-Nu3d{QAj&Kt-*IW`r05ZUk8SmAGmP1K1w0*z!3m)+GDuD&X2UHZ6_X7y z4W_N17obW|4qV16fho-=)}b~ti-S`GfF;%P8Lqkxy3n(WOEfAhd}zAtug*Ay;X=}; z`6`kYbsu53(Z~1P-VEc_&8MSwVS4`Hu?>IgPelm}<~7ubrBMwKbPoiI*p{(a7gZ5y zOj9DhBqD`5X>u3~tj5S%0$HGm937@Yu}k%3d48a4L0nAYi(eJ7zUZTJ9MaaNJs$_b z?GWWMSFSFzHA4V-MZG$HqB09qOS}VUVGs@^k-MIkM7Vp6udYzcXuBPjJI~?PTmJnrVSBqTxLZIJim~Sf1pI6*_N^$ly zaQ-R9a!2jZ0=3Mq)@=2-O#*Bj|F#+-F1D&v0?Y_gcWQc028p{sZNV{NTvy%@!H`|V zPqo6-w&)67)Pg)N(OneS0&*&7SAcd6IC)%fhFhHalBdY^uF2!DeoS`7+80jFsBko%6`x!) zdrM*2k`OQ`Z(C-GL3g4;Q`*U(7C`cdgeYP=XxbQLpw*d{{fGM&5e=^<)4La$G zqpD31oh`zIa1zJ!3)3xKI5iFcD-R{`Q#bzQoOYBLqnJcWfiuuaWf(LsaQ zmg*A3T)N>ydOG#K(>N0<0Ac14w;wXd85tmDQX1<8B4I_Wj+{jOyEf(44-rLc-D*KL zV0$`YD-G}chVQ|}zxw;wUU>+Z&)qK&+d|H42A4ZJ!!g+*Ej4ZI;17htcbXI-i|J3i z%dup}6zMO)Y%;!E+ak_FN9DPSe7{b(iIcURjQ_^1FfwaPnyOG%KWO)>uaNr@ch}6_`#q3 z)A;>g@vZor$6t$Qp1+CXqn%uwTLeecAfz~V=hu#Ojmk15EF-4kIF0QP)RBap=-}f6 z*u;yDL!Eb~wm~qto;Io$#^p)?W zT}mb#eKWO679D2ys!DR1r?0G}t24L-mY~d7*Iv$<>M^`npt8D_-t?y7_Oti!nXi2q z-}5csfZMNo0ss6Le+*Z5ug3X&24HeAN!$_N!>5oV)O*Mo@m8`IsaMGKagBo=aUS+E zf@6e1Q^o->BMO4>g~ynC(WNVuG?6D25BwL7AM>#BLt&3r_~`0 zcpTKC)}kND_QaG+2}=zs&PU^qMo?`Sg@z#3?Jq8?^p|C=jCIiV>iWQEZgf&Ym!vV` zxLq41R)-7WG1+v~QZd|2l$4cx7E$0-0QD1zs7)<@E(TSQq2<1FN{!rP)T}65OP98c zI99jktf1w~(yUMu7)!N{6>%s9hZrtK|(GGtZda1Ih5>NSo3 z#QV9;6@V@((j@vXCULOU-l#yMUd3Q!hfl&f@WV>vLUee!2Hy(2@oYs2a-4y+5(FQ3 z6gC(Oz6fkP>-+KITi%Puf7=)1)~z#ae2*g^4_k{cU-nP)a6Sbvcg5TVO`vTDOvk|S zqar7t3EcR#4gIEKxvA*41^btPd!JI=eMYd{QtWR7%eg`?tk5wQ*a@6~)vFT=G>9My z21)Qn8v>n!eN{@ARCIbYR)YA2=oiKm!>zI5o`;p(0>W|@NmX28up90u=v zjOu~PA&W;#V9(!$Sg@-vD2QSHj-vWbYgfLr%vTaPA{avUAdj+5gX_~gBx z#NYgx@53MdO>e>zPdtK8J#!aFyB%cdSQhatR_oOgZK-(SJf#$Yginhsqv+^_U_grb zn~AelvR?Rnq)72kAa=B+#LrN-Y(RZ!v(UN)kFfnDO$|E7y@QVy8m>NquxFCNn*e6r zo)r6+ew}7plHRgv`bR5pvKR3rTNQXrEBoTOo9Ujm5xnmg7Mz?+c;c0Udw0}onNoMJ z`iZPvN5L>3fJBglG}i)qKJNj>3RLg|hJdZYx0x0clG6?YIhrhzmvWmbFR;(TAC>ol zPKY%qt9z(kGC_0v1^=!S6{5bj?)XzR8{AdV6p#(nquxrZ?${_rJ$=n%+#~19foic&>V%Fk5n4=q)E{k)jt;kP>DyI6qABs z{uw*7>f(CfR|?$=wnJt#X_CKuu+)KvgmEaEGf5F19iNK;T?K!je3{GoHEJLujV6h+ zS%b}2YE-+x^!tjT$`9J%NctI{Dbs0#!2^epV;CR`vSvsfr=&6%0loAyTn|0Ngrx@6 z{e!@qf9|)y+-0A^a||U;OT*-ckpHSgP*U{=l`F~Ji0w7(jPnL&;-wPwHtVr@70i|L zVhS)L*}1>H2TU9nkDx3DlQWglVysMMpozJ0>5mM?I=3!(3*~!$wBSJ34Wvc47BpPq z;#}lP^GK(<#Gsb=CxChpbW|M}dG~Z0V;evq#WYPgCjlCpvg6LQq`c7qiV?X%Ngu8> zqO3X6sZmu_nTbqLnS~O2xC9DyPk|Js`Q-XW)W?y8CE0MLHD4z4udqgOh{9fhBpCz7 ze!o{V79$w%yD`kA*aU~P1bjQvXi`TSsJ|Z~C=xKIl)lMPfub@SrQ4 z77upJJ}gd+0=+MocBi;_`Z+xN6K}yQzxqqCh*&_RGQP6L)IbTpr6Ky^`Y15Zg4wOA z2n4$hc?Ga}rQk>f$1`wxCb)4I&~rQ7V1G|B-vZ{F!2Wq)xeYA075&^Y%lf`U&n#%x zd$#~yM`W_OU=|Tp^O9N8v9WTKpf|BPU>iWTfE)`p$AW1Gv=acwz;p^s*9F__6E>%6 zfwv=p9t&g#tDWcHEih(v_%0SjziZ!@#qiO4WS1B{J^0qWcARZXRXNnwIYb)@K)O3j-D;>APry$iEqv!PqTI?Els3AD3{L=ND+nE#iVdaq zSj()s=FaJ2X#m`%uOhaMQ~=u>kF+&($lS~{+nF+EZ~*Ad1DMEqOCmWTQ`U>~bqWUl z+LT#o3YS082t=}`p)!El1e3qt)nJ)6HsqyO;gc|v>cK`sw83QCy;Ni)Y6oqIb|xbG zM0DvI@P%>D^$~P2T90M{vCZ1r@eo(zOdF7m+7{LZ^j*WlS0=po`+pcO{gv;>?(`VY z4VJ#x#7(KEtKl23)o`1UEG9??8bUea_suP_8YX;~lQ7C`vA@FJr0B%bgU}+^YpLK9 zTE36fj6zaZN*M*2Nz31&)zg~}W6~j|Vo9uWX4u=ep=&5N0UJ3|#%Bst- z3x!gqMF1?|iH?aZ!r;(&7NnGZY2I41Ho9(be0&`rxbsi(!#{Nm|HW5+6CQo+VZ8YK zU7Q|maCRYRGRb~X^d(&*asH*8#bM5Cm^~H97xutKM+X(Gj7J$KiGd90(9a|M13x*M zg?(zaVbj>k&+d_^B|8niM&T6lHC1rs$Z_JEC`bw4NnI)qGtwi$v zAhF`=r-~A)uT+G=;45==bNX8J;~Br+-XuV8f_J}r!EQU@;fH{`cQA}8XygQ$+y-ae zN{Jwd_;>2Li2KtPkiNvD1DfNN!WUQta#lKnHOvAh&PO8QCb0YP(FzTMf1L-+HzWC*s&uCkb0 zX}MZ-Qz8QKyN(lYECEBj7<3c1>U46ooYrR;Ui{er`7m$<4&!gu4%Tu%zLMP{q)FbWFdlrZ{tyN>QoV%bRSN0s zg}wmO5peMwUi#^u#GR-9Gwfb@ihFafyARWOOPH00l$LrJH|S`m>aYwn!G-$zWdm>x zz;*lG0PG;xbYR&7M`u7k2l|BodqDSq?ycao?iI^CK`$(zH=il`1#+7!P?+CV_|fbD z3fTbD4%i&q)>3RNu-3Lf+lp=V+X-}I*JNw;yF@x;fEM)fns3Wqfj#12jJ~)z_n;w9 z5EZWv#}#8RGj7SuE!Kq-g$0HbR)9|60XjON<+lP$Pmi!)cu>aMu(+g3r}LVm3#T$_ z*+64Q2Vk(p_8?e$*dsIPJW$99KDoyO_0l>b=Xwc0~-$KrN~V^RU6S%A>CWg)hCWo;POFD>5z0G$<> za#E*YW}NkH2VaO!Xwm^f1xd+0xRJTgQ1poP0ejOfp zeh+=;lM85{pOn4i{yd609Yv zu4C=MArYAGAlaSS#0#JuHS~)G_nx`HZ~ZM_ia&Al4fwC#_)U0eehSB%CvY*JL9k1l z6$jZ!mOK&~-FMxD-;P2P53JYVrG0wnR3azk-3F(wqbt9Xe+xGTA~bMaXi%8gd`)Wl zrO?k8=i;Oh5(EeOAQlMdYy=MlK71^+1;sAZrYS@IV&JIw66B$nPs8OuQ|?z2IuRKo zQVw%9LX=RBZD2g_q5h7`Vb{mZ$&^9o4+*T3@1-g6P-6+nPlQ!N_F{2}0s5*4@`dad z2e)44Q*^PYNP#CU;5hfMqrD7<2cPkCKLzIGmw%*~uhfu8v39|zMsV~O2LGk1qhQ#< zVJMEn;9U4UO(!CQE9@lS32*@n5WDe<`UD64TN*dqehm^%@Vrr_F|TM8gwkZEwE%4f zcxvYdiV&$uH~_+{M7KoNM-HNV8N8qDF?TSfBDUEeBV?)c4I6=bzU2s1n-J8MF2c+G zQv^vu;RA@3FykKgDui|T47nxDzrvY1 zJg3qm6K4P{supb1#N*U#ty3pJuc-y?gjBY*UTe;(Irpwu7GRl?S*YQ#Arw|?HU*Pr z0l}&HiLuCu7*P`SEEWLWGTxRmjcuAbBb{bu>`7*1Nk<$sz~_6prxD$gIJ_Z(a3WUh zpFE<747LbBdm9meTmYRi5C=hKn~81z?5?8Q1n4Z5DG0=tSduAtnHi?8D|=Uf0XHDF zl!~z4+Sq{hT-DYv5H6Ww*&)lKSh||~E;b>N;!|eu$AVYlyHo6RS?*>wS~2T%Eknub z9*%D@uZa6KSOh_2U;(1gS|(%#g)Wf4hu;;=?gXO&A;)NN%^LKs~UVQ#d z_=fL%1LpPucAFcRmpxQBppFcMu;K^m2MfNfbv$V!PREs$34>QtX{(_O(Rp4|IJDdx zG=vy^Iv~>0B(Cg9yg~a=4s)}bb4kbOE*OG!FSwvmV64oe3Kixzj_^9iSc?K>)?W?Y z*WhGrJE=&0#P+BdjKL4|W{fv2$>9S7l7j4^W76Ub)++Q`wL=0(t%WMWnj|@|BRoUf zmjUzXKAD(-6;#7GF8wSL_M+0Re3ByL@9_yEgotWu`v30$e#L(7r@-8&`&5Q-tu5e| z^Ncj>z*{lBQ1IDM-=hLU8WB)8x?vg8=@pjo<*dKk--*y`)Fd~;!eTPex+}63)ya1X)lZ%#%`bsB2ywWFHzue zT+ku+d$E$~7icPrbdev5B`?DxE4u&2PdItvEx8d1SqPf1-T(5d3S13Ftu0Qu7JNin zssPIj*`A=k_!6G|r$2_*{J!6e9ROVxOd?nY-i$T`5^Jj?9GnQpr4Ss{)o+A;aMSBE zf(F|Hsx$HASzj14E*SVD>RT(Tn#8yBfCaUzD0*8II*XS*Q#O|%t47dG0nc(nY?*~3 zvgH6opp1N?UfYe=IuY1;oq!vVx*&srMC?*{YH>YJ;;AVIP}&ucs1Jq=s;LL+MIhZY zd7lB9q||(~_M%`nWkbCkZa?jOmP{bAnopQ?R+kY44-QC~V9H5f~iY1L8^QtuMS>Uy;ihZ;>QU|X#wyRLp(E2EulA`Oe+ zW3+u#4ZS0F%;>^>$z;NgxGotR0NaHx9pk?ev*zWR~ue>>xc2t zZ+rvVr#_B$@(`B!9Eu65&9Tfeltm+D5HLg6q7D*_O3o z89I?@+LRFO7>WXPT`7s+$cTnb5Z5}JJSwCYb#iGxo&7LEex0^3v*ZF7v?I==>L=QS zzM+mHen*>Z@+nPe=f}yY&|63y=D`>7EnsmU2476F%NFd^(KZ+n0lKwdPc&I{#NOjmm}V@&%X|2j3O<1d5_Bho}O=iL>?89RHwS zg`8Mbo{E5HObRuA4$h^&D7DGplM)~u*$tOiw&*kc#gXsn3j}#;N!}tm0P^6eVEW{l z0rYY|KrgxzRc48=(EAEH&J{+HRofwxx!xbLkQwpH0(7e4>mP!p1KVB0OScs7da}zG z{d&>u32<>Q+huzKpmS%TXU#<>XASr$d7MH?yXZEHi^&`>fLvUY7!q7RRvkjtqE8n4 zQK+8EeX@b@{+hlR=|UJoN5nY-&hbt1K4GG&BM-o~o<}W16+fXHF?OgZHojEqzK#3a zmdU>e^c>h6P1v8!klVn2@%#RLy!iZGy#6n}8Pn-)Y;gq_a|f`EacJoig{M5rOcXS# zUuRr&5vAvPAnAt!HPrJ;-Ci|YU;U6s)>C=65)nU~> zghqJ zra_~CNsRGQk)ickkEgtl4kj?5t?=9W?es&l|1~c|E2UST0&i_zKJ8!#&jQ&sG<4j2 z^5^j4J3feqk9U~oxom%~4I|u&m8S83De;W)80=O@zy8ZZNF{z7ie-@3NitimshLST z5*BE)|GNO>9FPk|+bi0+Le3QJ0%&^x7XZ!yJqP-QqVHkbGWW2982r0lz_Q|IU_J-t zy=|?X&+Pa9%>K<6e*XgKdtkY+!z*m7tw8s%?X@%iiPe*v1$MHknfl1ObNSNO|5L-@u~omFjK*B(VQb=dpi}J z?PmeEw=x6GaHw`L1~jrpRIOHA+ZbQR)MP5}dA~vfw}zn6|r3-4O?l!ms8Y1MABC{I_p1TS>%fnT#9!|5)OHwPPQ$s6NX@_&_a=X3Pxg!=}oVQ z+u7M(wSgnckFyoYL|4N*eNcLT`F?1qLg683P?U^FX0(Y&*0FSsVHUAHmp&|m2K7LM zwnMdaQp5#FzvC~ zOlZ>{H4tWC(Xr6{>q`RU;TjC4x0hNf92an#JOeLP|pHZsIb&;G4l((e3XllP9C;Fw$Dl6hd z;$xnpp*46a^oD@ioRY*t=c^Hf6J9$d@S?GZi*lX6s&Dyn*cfPH7Y+_^6+MLSGQ_Sv z#T~n}zxA^R?-#aE744nXo$13eUu zR8zNej1kf+YKpiG1qOq`i7%<8#a9m5N#e%;#uh77WuHbZ`*OTAa*&8B%M|;yh*p{w zkMN}0=71he8opvx6U;Jj_fNgQXsO^nCc0GejyX=UgNB3>gB%EIwxC~^?9Un>qpDEE zZ*fn+@kCY(m}-9!Bd@EglGq&rpc-Nlr%DE|NVy(^*MO^LpAnpJ^ae|lfwFvcfrnc>KaVM35uUXM&g)Ts!75fXtd;u&Miv77_ ze^0SL^M7|0^F6yZpQ#1j?y1aoE#TJAf#nPyeDl8-ioUl%U*B8sZJB{S3v?C>@_FBV zwyl`U><2^4Cd;2EW20XjRo#ubR>+$SMOKR6 zY67Ue*9F$_iI{=Lr2?m=y||Q_6;h^Z`-BZdr1b-0r8| zfFf$)iAt&2CpqtS9u)vsTqlTl5L6Kw#E-a(lXwCwSC~_=SDYbt*SIUEm%67pEK2v; z4goP?0JKf664(ao*F_{6Kuf*WoG_fQgehq#rx$l@uwb)XV0X1)=@Z`fP2Y=)cl-o4 zCl5g{F5LEVrfw4^H%X}at!97O12y7XKS4xr#oQ*o;?aZ>Sp?uIIKGw7+RozZ`CJWz zRX-)(vBvV97=$1WS|LA`!#!fb$J>N@aLVP8@Um(fQ2m|)ABm*-YmF7cpTBBQ&HkHX zVtc7ml{z2{Sc{(WPy|6!`)A!X9}{a`)u10BGFfo|ZN{aM{@RERA_m|Q45B*sy>2&G zae;IF+wc4f`0*$IDPD2?D$w>2bZmDEwv%Gl6w?H3CNCY(Ea1&v#GN}qclj}aXkJr` zK$vf!ksU;wNdj4dB5wOBhXei#Pls{x-*tjX`(6Bm8bD|i+;ALFY`sKRC9LUUkt^rn zdnksvb^V@7kl-iZN#P48%Lse%l87HyuhxDTfCP`eg^f=KoHX}l!w-S@qKI|1biwYp z;n}AlA9$Z?+jy4s4<$$YB3h*VQLDlq0%;g8J1w3D(Yl zthFDOj_^uptN!&2Wv0``uAEe&;2a_|=`@+!^_YQJ<~xX20l1&U41N!?tJkKDfSvz~ zMNjy>8EBYr_R@mgX2Kg@|9kO=zxuz%%{#ZS*)3?30&Nd1O41IoDPsv>>|fn=lW_XG z^}XtKDxjJ+M)-8_VB)IcDM6q=UGPZXUnw(XE}+>yPmLF^O%nA^k^BhdZ{`R$h<2!U zbY-~Oegl%FdmvFlrNZa(BxyTMhmK=T8WV^rmkd_9oE3Qvt>Tj@k%lOyW)o0_#smVu z!9k6oA9C!WmqW~)Gd;5}4kkezQ_{KBg%;{e_7^m&!EVHkh-{PMQ|1=M4yOL*Pbs=I z;E}-!7dGT?n=RL8iVs+oM=&51UH10y2Nn3XQ90jdp9fo6<0C89q9!C06@iVVxXScC zc^ddt$LAr#pHRx6?V$YH zeH%R@#A#=PLH9NW2RMcDK=SGU)WTo~I+m(d0^@IIS#MaMslj3>D`=f ztF7egB%;zF+I?#glT{R1Y0b8%`L?{qmqj7|A1V=FnG)YtNZr&tb57MxXSMMleC${N z;20*KBuqe?6jM`70!$Oov}1dHgOjUUJo(@JdEEJDKZwoIL%=*I0*m^nc603#_%*H< z<;{AZA^_^ws!7N8BM3FLBcazgVb740#B)&;zTD-%42}xwWW=$ZFs%lsVL7jrWD&K0};F z!2seZumZUHg8*~Cz;1H|clR&i2cP^tV0VPC`qlp?o_qE-HnK&VfPGhNMg8y_*un$x zsir4dkw@x`x@}m+Ly*+j)MK)G2gQeg7Tv)6nnqUa>8$U|-;PS5udHhpPay<@gj^1F z{twRwVfdo|kYNd$1#amJXx6w(r(gsivKsYJClD9pGwS||omPI67%4WZ+?INeEr{e; z)oTzs&u)&Je*CE!M@J2x^EngtXIwak_8AeV;9^q1tPOQJq`JBh&Mf$&9RqQZ4ra6& zx(HGZIjOSGe@1H!zsmWcv=jIkMcZhQCFHEx*upAaKQ%Q~-PK8csE0?`Dd!TIe#^SM znsHft3aUKiqFNW*RWKWV+D35qg&9{~vB7`$rvDPpKmQ#5)?0oE4_|vF&XzNv%^su& zbO@c-0B>S~+@yY%tO*14#`vD{ztrmt;HZ}S$Su7nGD4Osyb_;q$g4N%3o%m49fgfc zdCc*ULu$Jv+YEKF!nd~;TE}ApT-ldbd|-sGyp;`*-R_x0zBBt>Yw{1WA3ugS{xN=n*h$DzU8o zapfxXLsB|&HO@Vm=mR5v(?OE_PJ>RP#N(FP1^*7UR)zo+SMs>JFVVlR=&pit{PX}< z$}*lk<$b8H+(NTP5nve%&{dv5aeU%=$}nNpz*kJ_}0F~RBsQSOUWRUx288Qq*@Dt1R`0;pI(_AMD9D+??e%T1zXll46Kpgg0Ce|Lve z{GQH$EC6Oe_ucBCEdXY*?WK#L&k`AR+`@{5nQa1HtgL0lb({WaX(q;%1{?YEqX>J)VIM_=cyOR0A)a$zqNC4 zsk6AE+n1h<7`7ywci)X=p1b;1A2jkKC&VH$`3kveB#p#Lti21GZ^g1DB2inbcGawP z7q)nUgQd$cfGFaJeRNPd+a%gNsMlTARn=)5mzf(7l` z2G<@w#{2%{|A1S6=UvfU{*7A%$tz$A)EOs_TA_VcM=q=nEJ zJGLgaMcqN8@59Xzw1W|(l!Vjnb4z;h9YPKT5Z_W?Fn>se4A?~51J5`Mge)QDL})Yf zg%(UFrSH-|<;)j;rOvw}=$9~*O=`stqMg>jC$ZE59^y=imTaRyOdZO_gGO7Sbf>&# zSE<0X**1Lm!wa5%T5)tLXp^fws+=@M!%5abNkfT&@99W%rP6Kp0E-NOBYoezEYTzz z&gc1fO?!x{SycXgr4vJJ6>*x=pc_+z)!;{u;2aU9oy=W$yz*H1{VaSI;MP-4^O!^MO=OR`dg~E*6@x{` z2u?IG{HZ!J@THCq)oi62<(@~6kY}@u2*7%#Pzqw4szyajEm}TN zkHy=pI3DofgFgsUl(DW|1FnvbO12{2@mPF2c0Z^SYHN;3&7vjj#FxXyrN;>VF<2_A zuFL7|a{$J15Wk7h{Bf{)8h9*y zIhfpn#jKaK9ST^*M1Kn8m7tV0=Q#ywYgdw#q{%zPV+<{3^l%&oQ9s;y`yo`<}{T7=mAeLS{iI-U9BY3 z7?aBl;p>TOI}6rCFw6ZV@p}xuVaZ^e_;3D`E*^jbWD&?Bwuc(BX-ZJSV=%5nIdSD7g{ zaYEf~0?wLs&H21FW`)?r*h)Jwuw?BcJ&S@y z!fVi}XUk!NpT?>H7U+@S>SH^+@6Y@Yp8Yf5jm^;p(48^6YcXa7rASNanj+Nenrit! z>i6O4cs}n{&Fy`Zu?24vJBn&)*b}%dRy5n7eW`Fz9%z4R;1T4;uwOuIgB4EpeH!5b ztf>D+*yC>!Gf-Lk)1-6gT<@z%3z!pMl(g#4v{>Dwy$x+2_BOW&8@$s%pLopsp%Owc=yvE!V|B&A{X->+fA3v#shzY=myAKGAfi|qMN3$l9BEtVv z|6!d3lP*x9Ylu$rR`e*@f7Gz6V{^Vj>2Dn_4lh&+&yXj@a2WncjKAQbxQf~IxF9dG zzD71sM23^5fiNN$_(Fam-j{+<4T5wbdmo!GfmmbI(rJ@Cv zh#Keh5{cB1^-@ESt`37hy)Yt~5J=lxb(Aux!HjHf-=#f~!MEdLByEI3eLHG}+`p-1 z+-ny`^xW^@nmD3nZPcdoEv=je-2LPppZ&Ry;XD82H{#1a`#0jHyPw3-_7uvwS>c)N zn;u(nK(s*C>*FIV`)UUP$v zd^ex(Ra{L^Iv++^hw$MO43H<3+FHX-Su=^(b;4WCPmSyBD(qt3XQnmpXK=HAgi%AK zt^lMwRTsYsG+K3r_ib`oTmr&V6iI0!ZLI5xP{8$s+_HF4p3ep1B40(?3KawE3HkvJ zlDneqf`MS~nsFG))xMjT|KNlBJ21EAtQGhB>?B#rAIrJ2$zmFjL6OF{apRlIZy3o- z7J>$FxEf~yq@_O%1?o`o4L5YDkn;4mNN!)lnC_agHBbu;ifs+EtvrnH4hpH*m#m#2 z)Pkss15wwD`W=3sT78XYSwnXC(SQ-Ct1jjUV}WQ+OY0^7b|(lnqs$v9{x9fZrsg(Qb<#W3JI z--)_$p1H_qRjL{jF--u2e3kh;{Bfd%+vH36l_h=P9f#*ZMPp`}@!QI3g|oyqAX>IeU^=9>;Ys0*Ozw%ENuLFYa)wBbQP3(kwc%P@6O z?H;GGv?PgooHoWVK;hJF@eBY;=OkRrF;)FeWoNfiIU$G{3bW(9=gh1#!gFkt z3n-(f4Haf0r$sq>Mp$!f#R|y)j}*B4pP4A{OVtk!VSlCnnn?%AYCI&Cw#eG?5F(ho zl)esYEp@0a=)L1;_b{Hl_jdfh{h-U?XCs5n2Z5 zh+6VFntCQ2!rzJj8Dtd%NUTP{zPdV2-xl0MnwOmn>>Cb8G=`-6>Jt=F3;wiX>=?8R zQ=D{+zalT=&kzTLPmr04%JIk=cF$~XQn(`fui26YBki~a`+`G?+W;T}5p@U**a4~Q z;5ZYpg^xB(=)K`R@1AkrKzkf6J@ha6NFhRCNJ-#ohq7u_v;X)+T#O|h?zkK){j?~k9RcbkpZpp zjwWq#p$Lei5ZA+s)ZtAuY)Rh4LGL4gFRLJU--P3r{S*aKuO2jCu`w*Zb)Y>6%=zbj z4$QsGN3?2&T*VCQrp2Y1~xIUfkP) z4fLq2)o_-O0zPQG1Sw#!zY>arMllw;))QNA{6OisvJR)8j@*Ejbl$T4D*gq>ZABa2 zrBje!5*MM!`GN(p7`GSc#UYULzDQj`RnkHe9|=2GB>-+fweEFT%Bd-u;)JAwq@}N# zagoJ9)6e6(YuH@lZ;SO)axB1AD zgNc=|G<((e3LY39OF>e}^l*iOYhm#B~0)gDt=7fvPNv-mjRAeRy4QZO71Z~=0 z#o5O`j%R-G@8ia1g3Nn}cC@hyZNbgj=xh8<7pKDDojLG4`7^TWx+G6R06zf2UUvtT z&v$b+yFX)Xh;1#6j5}+?-nHL-@fGG?`_DGI=O)`B6?ys;gK`#-%Rs^6!6a^F>&)r{ zA~?5F4v63!;1f^Bhxg+z**4o`XGBI#&ulk8Tp)sYCZg1>nW;v-)tCI;d9VUY#Z;at z!b$M0z_j(t(@8t6QBlt|NY^0|Xd@S}Sr)g>3AhLOI>&85H6V9rhYs|>nLjqc9YEru zce6fz!daspR!N;)Du;+|DiUs=aF+MS3>ChF&~0#DjtqlhOUDpHzLeSF%sMN5 zmY`zwi+E2#n`C-|`|B)=&O#K4hw=TWKNbHn*hcZjaJ{8p;PAEP*?NRWX+}H@CgYaW zYKE8v8<}2#Z?~fXm*Y-bv19DB`5R?xF71pYK83>Jotq0m!;|kc0NQ7CZ8+XNg!kY1 zN&Js*`BQlD-ly=`DSM`YO5 zML60r`XWhB`UvC&rx)88jA1;U9ed-!6Po;=GE{kn!6ONM4C?PfLqm1(6$zi)4Ux>~ zC3t+UvDaV{W*^q)FnnSwa1qzwrIL-Bu}SASo1_;&E6+QVyWUg)+g-!inaKOz({X-J zustzt(3*I;0&m-KX=CM%nYx9LeH1*4Jxlz=f?@niCz5@T^J9E4nQ4VLI54A`2D|g1 z7~)F{qX~O%X@f<8UgsK8Y+}f#`zWqFdX&$R$ao8T9L5*$-6IOM1vz!ypiA0$v#C6t z6;als?*VN!rOI29-`COK#n8Ow4Iz5_yJ>|JXAR?>n5aMu% z2wHtih_8cG<229|{y|qb9;)&Ov?ziRB|s{~I9}P4W781wJKO*wvIz?; zCPKlQB4MPf(HMtTdzXTbYFr73Pw6B!H(Wli9?$-ZAH}`*JcVmlj&V-`k>)GRVZBu@p?ihs&{Vsg0`e4E3Y;6z zI(Ah_RY85z%?GN1sL1l-HD<{Hkr9<`YRDghRw>hV_<}jQwkqAV57~0?zk=*XX#9Ol zR0G`F3DsJntvE!I+d=6ZP$Zb$=VOR6wEnx%si61X0Upg|r<4W}e7g~Rf*|>uCx9~h z&}GpkzV^MjKFJz%2$jMWaUf-?lQ4cLL|1D|NF#w|$$3#7@nhiP)H!hntD+ zf?tp+DylI73PiELc;52FtY)5?N|~Gi$s<1AMmr+SPx{MgsqunFQc~2nQw4*^hIe5G zjL@`b(PN=|TnZYCZi&~@QjM}{bRxxno1@=p# z29;u?zPG=ch}b8$e%61nJxN-$W7%#2eNmg@a>76yR_zty5?PXy1HK>k4#wRg=#pc~ z4>x_94YJyxdA|l=6St}2D!lyLk^wYnrD~kRT?-7lklxmIb0xaL(dN4T+zUUBANZGl zPUdzK55MvV`-_gF39=EDO|wH+CiO!~L?e)GTUiqeo;(-06d<<024AEtifyr`LTQV2 zK(7E11aqnbmFZ>u#qLLNh;}zvJ9n3$w4J|E6cR~Yo+;hamgZ!%E(VvHbZ*Nd_*eT| z!!z9TF6m3U&<_Ea0!Qji4OwQrsSHdyOc_iw(ztrx?HX>~QvAYuJC+V?j*<3=Vv<8# z=^q`$X~e4x@Fo6gW2<-U#e(nX#d&6(0d`5h?pGa3qy}CDK%VS)*~e`ae|F8fqP+yD z$lC76#1w#;`kK$E+ZFmV+zZQH0L$FN#=~pRE*BkV&(8QAzvCpC8F9RP@pG8Nd;Y6`kY&$4bhhFK0bwrN=a>q8c>d;8l!m+M$YMefQ3Ca+$naMJf&dWH;y+m2@nQ$KsL%szvk~?ys}!06>ST~?Rh~l z^kzhRL2_o$@hx$h?Q4yg5w#xVO%bTNP~+jch|qnx+k#T+a2C9VF3fiZwNrRH zYu98Dr)qaj7-Lmlx@8HvOt(Ko@>u6;otkuEuR7!xT=avd*nk`w_`7ASRM&8f- zrN~1v9C6Dch~tCIsY^(q3edPOQD@i!&Wgz_2;3))uG!9maK6AYr z{W&sQeZR^R%-3m7kH}hOBvov&NMM=O+oOgTUQqnvyE@PWnSb;nGvjPuM9pdR)+m1xnIq=+`dz`bx-5@(67}U=s8-23~SsHd#zOW8Ca= zxD3UBo9;DUAWamWIa&CGzHSDf$4{*-$A!b*1xxQ<>Z1X(l|i^TpE2KF@CX0EZ^t+P z?r+51vpW!3AlL$6#+Qb_#HESQxBh$0m(2dlAWrdhJ%CoXm=4Di)FBBE4x{u+1r;f(&X_Tx3@1>TuCydxwmPGO5>W4qImDQPWVIcgd|i+DcLw z?N{zK>Vp)s%buxo#2AsNNKD37{`a9s6daWAMLE}O{~83047|{I4?e*C6PN>%t?EZE z`RSZg?zv0NfAwiuy)K+64T>;CLMo>-P-eO!!Z;$HWoz9P>vh1k+_EEx(@sHGBv&yA zk1KD);g3UXqCUNKw31 z!SaHzg+SQ|N3H;q28h~DMWYIF2&AD&{;PqId_`-2oVY_{OJdd5T4+k+9L`g?rtH%D=A?Cq4lYXsH>#s75R@YwN_$9}2RKzfj24fW>V1K1 zuAraq@yw6^Pq_2cb2!}{Vc&s`Dw=0MF%n6rX<#MV%3cDt7-e3I`(hQ2ko(ONE&Rk5 zPd21JULgzQ_=91~TDnr+C3FwHaD@k_wdet6A~(iXU0Dk35CJD9w~*9~I@`)hK1-0( zv9#?qR^N<`5?*)giwp>mS!+}mf`AtS%M6U|F(yO0SR1XuR?Cxg_Jz9(lz~$zeLDRz z5jg%;nT@rGZZR(gkNB<@&lIzhOI55`j!k#O(_LbWNOh|a_i^1lj6jZNB+U7u#Y8cY z!whioEVL*@ZDq31rkte-PX~t6cj5DC7bF6v=AbrC&I*4T{05hA&k{&x^^hi_inei< z?izieH@zPEk@sObxdGjup|pm~*$f&I&=RAo zuCdfCZd9p`@1Y-4Z-!m){|o^qk)bveBGb?Mc#fKtyoGf$hro9X`I#OgAa-r%W4swk014Kj?8er_c|R zasY%>j^Oybz2XREf7V6|dh_kf@;47~Ji!;u{R`m)79|L&K{M;#M@{`K78Kg<8lHIu z_{cAGvGN@l{A}Bb@7>y?De#7G`A_i&zxuz%oqI20+A7c{D3+>**e!q_zARUB=v&)7j*Cn* zE;a}qepj3Vb@x+RE#fh81DDMTQ{`n+Xq;~#1ALl~a`80z*$;gy{)Bp6&YUK3wE7O1MC%MjEB`=|Wt5M)b6s+!2hsP)F-{E%AD9@8Y2{~hN~(G0?umei@d z9~3JD8sPD^>0(nR>--=_UMFj)vc@M<37E{JjFu2#z7v_y)sAQLweOIf@^K!KRpvgW zTryDbv;yC@di(zR+)shIPycB?69^9gsQ&27e)O^*;&Kp-K0GB7ViMtEe@Z=&QMDfq zlUmH{ID-Vqb+QbJs5w3aqY1n$d(}_nnaH~E*ngvAMS1c^7as>ROgez2GpL*y z0yRDcMVzJ@`0^i#BhjuM-A-drCN0^zkGYmgdUvb2H8sge+?3iUa2F0+nY3zVN0Cv2 z{%ZZX4H2m3c4F578rj-qGSrM`xNfR}Pi9*;%Y=gmY76Z+MQJ`uR=^XxOhUM&*iNX8 zX|~bGvxiy(Ht3k7V>c~mO`#jX?v+Ql{p5%7(QkM?_8)jVHm5hB`@8O7`$oiGm?SMo zs>qPYlqF_sR#R5D^2S^7AJ?nMkCf{n2?AtbsJtVV8P*upRn|OXfGa{aAhjWv_o%cp z8QD#O#ONDaad;>L9&lsdOm&omRr!52iK@RNxK2qefjooHQ>bF=Y>tg1X^_Yqt8JtW ztGm5K0P_t;EVF}DT(pLhKg z{P_F-IbQSXV=QtHI}x021iL0U63A|XY?~#eZUiz(mq|KWjph@jDf}rA?3AL>)BZr7_S3kc*nbW$2Zh6b|jxfFr{6w-`fO#hkhizNEK@ z*wP!nGj(h{S(JLR<$^`{I;3a=T1$ZznBF72ggN`NYq4e&Dg{U{M)`Pf%I;Y3@n7or zr4K2Nj|FX;1mPhQ0$_rjF3$95lYv|uHqNb|4CK{AbE3h3Byr?%{y|5(FYelEtrp$hB)5X@u6cAp#_WI%#p`lm*7jkSM_WW zp)4;m@-8!8WAVD6f)*t}BgsPG>;f}CdB>~%U5d}z_xi(kWCdrwqqw|TP4#t2!xGWm zI)i)SG7#>o&;1mbyPV(RGf@*zbrg=Z1Wu!Z{-Y9+`&rWqlwZG*ui9}mMfAD4~1$~JkkuJL&#b{p+^R7wdy^QD>*>^ z*B2PvSaM~kxEX*%Jtq!h2)=lnOW9WXan-0wj8>^+RkKjk7!$R3HAYc7D@I5W*^@y_ zUxgCKU$hZ4;X)@L#_$nY;c~#Qs#gb3qqtgWiRJBdinC4!hG)YE88}(369d)B5kL%1 zGo4(H-|SCd4?Ytg$LEt0TiGm|NgRME^Sd>gs_(jtGce8EsOPm6Tye~?VjbS$ zh*!YVD(lu>M9fB>Nj4qV%&KYCZnft6-P?HPNB$1Zp1O_eyM}qc zV58iIQXK*<{Ca5Rs=;g(o%MbQOmk6V5ZButimVZ3o`F+Nca>Ft007oBEAK+w>7Z`# zt(+?2tJ6IXAP8s30T6eSIYAFO^T)JIU2RwlL)cCOKSM-2CvB3&zJb`rU$rmj|8!qn z_uvVrZfEKg4OqGg6wMB?h~3NNFGNBKx2|@FH-mH$L_DwyoOsx_Q#aO8hps3*q>mnx zIolpC!n!<+1gBF&wl>B6Cdyz6aK9O?RiYp4z8+W8C}DQ~2mNy&m&>--34f2>Sk<9)R%=OB4hVS2_b#{>iUiE;(*w(3T*_ zWTS4U0b-KfA_|;+xO~&$D4nMcR`{U>W|=T%xH3aVqU{4eT$Bc2M(~L6xq+{u4INDs(+skwKD{uQg{NzV| z2A}oXt5EE*n*_U!U^@wRlU2vtG{vTIYpW?WW}3A$#-Vqh86bj_q`7T39wGjcIcR%X zH%~~@@=RtGh9b{Qw}z;1q^@)H@a%L32lYH`p4j2A>XfuZ`ly|PQRsR6O4Wivv$|o zMJLj~j;EBbh#S69Zvw&j4iPKudC~n#j^4l1Yx!u zmImFoh%DZE<{XcI#wq^npZcTt?Z4r7;MUzw;b?R0nMCjPuEh34eX?tV_$ z?hAlhqOy*$FVjCL_4+QT7hEQM{31PcT*$01IB@(D z2V2m*5s$f8TlKG?&P>x{Mr@AsNP}P8faHvn4B{i1WSm2CeDQVs1idL!2>*e9qm?RS zl_!d`8loBS$6p`DBl@7m+=GvQ)Y&cdKb3N@RC>!{0@8Wal)6aK<})kBMxj#-!Eh>( z$WqZ!npW#07=hDhBm-E*a`pl0=yX)@8p94{#3$Cvir)TU5H+2wn2d+1L@Gvh0_5bO zsFuO9&@dF(pnb@KkC6nJR5}^##NcTwJjKE96h*oMrG7NQD5%ik_kgBieCkMtfr>y^ zIYCt==Qbu|&5ACq2rbTTvT3e%$3zMUBemAV1AFtiVKBqMS7@RZUh!&0h~rwCS>Dtg>9klSZl+9cGRNhBl$@&neJER2Q-GWV)i- zN=_*ytQQk{pP6-K(k9ZPJqv0TQVTG1MZIy`uGqv$U|DpIkLF`!FtkYtdavsKS$c!U zmQp&UJpz?}>S9;brRRJH8Yjnr_)*zwQmVc=9K(Ie7%Kzc8HT<}$d!dF+|RMy z0J|e#GpYS+7Mz>JwzW=TfgStDmE$$(XtN68>Q~yB;(HcCBD_DRvjxH3N0g)?bu2l4 zt#c3hPNQh;tZ9^p4)`b%;_m~9KqGBRX7nGvlUa5-UJ-vs2~)`iis0gi76!x`l8=qa zWOyb}-~(46bz%`d+I$t&u2!eCZ5!VA-UZJ+qc}bl$Fq8JYA#0BEXO*AVNzIe%7oHN zivZLKAp~mJrZNN{>-*_vA+~hVU21}on(lhA<$_jpuVt1|4AJ1LvxG$r0y3avaEnsZ zB9G*uj1Fc@UTzKgNII8EB?}o9=c8MugkZ#%Qn(4cR4XGSha00*XJ9PMo_6 z_EW@5L|0~yT|g+pnOP~U=*3Lb#}Q3YF}lK5KH*)^@K!SOyE%D|PAQNu*a7hsd3nQqzEMC%{z75mc&RXIqD(sx=;Xzf8yi zV4H?GX4P8~Z<<-FUiND(9y?5)2 z6kx6Ini(Zxf)*>I(jn3j)2x!+89V19yAz%`;`r1$MvD+>)WN9ZbRD8^t*TQ z$-no*c=6*mu{}P<9jP8Lt=H%<#D=RXDrLJ(;3Y292Ybq$`&2`!e29ci4tsL01(ZDa zrLGLp8Ab3;7Y!Z?dNWAH!0_rMjR>#-&_%;b&)pq0LxKgi25*f zt6*e2JL{tZ6ElBeMqa{^O;ndIoB+l$4sp?`r%+C;9Z@e@vOIcbhJ+gAEED4O&oqlo z!?le9Q3KB}s4KxHVrve~Nkbm!h)A2p3FIC;@SrmT!a~}J8^eXcFfkq@4Op{|!7?h8 zMS-a-+DwvmRC03E9Eu2#)%{x(L1eZe6j4#MD-oIYL>1#fL=JzPxXQ7S=Nc@dM1Y2l z);cBuv?-1rKf&_sO?>Pd-+=R<`d_fQ@))q}o!DlhV)By49>eFC@vdSbRvv6%_7(zv z_9ufst!80~7r3sy#}@{O+5lNaft2jB3U71958KCQ6h1?3$+JX2YXSSXJuj_ir4@$z zsq-S}qMli%ZUE#Ep^ZWcFPbAaR^e;m+R=-apmYCJa_Ls_zOSzUHHJWAH=I( zdxAwTu$zGG1nf4zPJoRdvgS6eVahWyFhW8@iQ(WYA5i=md@B-|SQ&f(8Tm*Mz7~VR zjrUd}WMlTMC$}YRKjUa+TF9UulAUu~s+5Sf1UwP<)wHSMD{!DR93CC3wzstki^O9C z4!i>?rvy>mH`j&LZ;G7FIB2D2x4H_V@2+;C!2&AVouI4WJ?~s_^9A7eiUHi32K&)p zYLR#vil$N-9ISXvIr3qp4X|LTm^VT{mRFuFg@* zX{br{xUkNm0y1rY=AC|2ax!39W`%|>Hd^F7<|-?L!Xd)Ps}2hvtG=Jr-7I?6o=xI* zGgDgdl;K`m7Doz%P3%vA@Z{qxZlx7W8+1E9qTx>Vz3Y9RE> z!43-rq_r3p=UZ;=#xaEa(H$&SS<<#K4Olpkan&LRT>O%?>KFLPJrk9fR;%LisTz-ENw0*3v$a zP~b%upbuCj9m~E*4lYNc3_4b0e`v5$Dc9A`QK6Q&->7z~)fu*D)U2$66Uo*?V-9_d z{76m+`VONoV4|PEasHN?b|HKujgs)Z`0;^&Ic*VXl(Ha+IIxZ4_DN}|ng@wsA$w&X zwYmC{N`QQ}So?yn@uTbaRuJa3_1i*$(vg-j0u1u6ply$F@10NLBR}wuadNc9`D}r+ z7ARJBHCVXJHqdb9F?NwMRK}T7n^zKgiPz-dYEdB&y%K|c^qb5!A{qA@#C{|U)vUtWAVJo8s;6XnP^-ixBSo8oIV2V z7w5wgSP47Lbpw}yH~=Asz`(U=-bXfp2;h`aJBCITQ`9nQXu^X&40P~&)=z^4q-t=> z;i%eZP*Vg>$Pq1hDDJnoANVNnvHdV7W&5q5m9a?Rz)n^5fFm=BJi=3J%H@_*@7qt| z%Wb0Ex}4K)k&36>(wnp+N@M9G?g0X2poC1Uq<`1!O|B!J-UI9-FrL!;{W1@9kz8=%Q%mA z-BxH>MAPBPK$!U0Gv6}DJxuLOp8~PWKeij}={T$+CS}lUSL*N7VF7!QA&LK{jrQ%g z6$@z2<4u5NRvaHqnD>JBzH7nxU0`?OwDMCkGV^|5IY&^rQS<@jP$=&Nt7L|jRto$T ze}iLz47hR+skK$se=rPGBwY(P#<>&Uf*v*=4SoR9b9PP_nEN6OjBq<*oVE&}W`*Th zMhSQ5^`3RyBIv*@J0?3VVm0R+tg~m%@FidQtMPr``N#3v8?Tjn^Rw7aCs19|m9PG; zZ*z@>_v+RKvis<_YWI0ucwPQtcZ=D>MV6rqBhJL< zn3Wj{cA2`E&>X@CU=_;gt6^w?Sj!xJl;>f7DtXa0elGe*KH_%8dZ1rP{tf!5w~+o) z^~GbXp*IPag&*rP>3E0I1j6Ivpi-5DAE5cW>ev_$if>Y&s+6v%p=Q)kX$k1RB4K~qwpDs9@817$iYnP@g>&-w_7 z9Ok)2c2+g4mwc#Gp}=sCt6S1g$i|NVN``}k0|J1n%@{Uo6R%n0z{uI-IK?zz=`cw} zlH;jIz@yTD@JV7eaiu7erz!$5ITsa3x0OtKR`#bOyr9@d$NNQ{OKa(T2F?I(g$lgU zQg;QkLBY(1l0fdr>i%NztiRstwg=Gb17gdPq@(SaN*?PoWI9E^a~Dtl$PeT0hhM@Y z8(_cRW7B6y*|sglucDh>m2r5I|$RRPG8HB$xycjWfYc8VOc4F}jr z;^v&PWVR;;$EIXUzb$B{kLkUPx?H9+Zn{HTok8HUVC&zauu`?5qlg>#R8jn}hz=<$0 zq+UCk21K}xfG3YK0Lg${_aLMIy7*+Rv0Wb{52Wz-RW-eauHg13;|bRR4FKB{#F&J7 zO9WmfGW7w;uZYMQvkl2=fYVkoNYEw=(B&Bd3YlC+TbU#aB0~?8)zmXkJ2uTuGE@LZ z4;^7ToAJ@teFyIT`2QQ5D-Qwl-nY4PPCA{#=v*F95us4 zFl>ngO#!ndo$OVn^2yM*aZrK_gUJ+wO)c*MMQ0UL9}ao-2?|_lz2wPwTy(O48}CcN zlLRuF%Ah~&))dc*G(l^&X(7sydVtq7FEV3;URoQ55Mzq5<#%Jj7Pf_BvS3MO+Nsto zM5j>+2-ZU+XmfbzhleYSAeG&}Vc^dV2gQ-g)a^;V=Hg_v87q zPvRAyb%L|y0-H_8X0o8%R-~NN%I)6_zS+o|=uqIlx}b50L-1(AI3AdgS!5mxiC|wU z6qub-Vl}f{Nf*}yRAZ4n%Po-+gag|jC>!vk-cRE(Y;$c9@GAb0;{%%8Z&8DYBmMa` z_|`LuS%Q$YZ!^SA1lbGC5vz_BszCtCt>C$sq7h?fkkO_uhWB|<9Gx`WxvO~ZyJjr2 z2j{x$!Nx4;Qo8COcyM5#bHccuIXZ8K-%2{H{SIT;2$X5zC4(V#SS~W8u8kUFJ;yu* zPyBlwLd|NkHnPt+oz;Da@as4T{ze=NVVQCa-l-kPrVdlA5YcIi!gH__+b*S$BX{*C{mf7n@Uh)Ow{>JYkhT_yCl61V|<0OCE>yq z$7MqbxD($LIvt+T@@!iBU*;34P4dU5dCTr}>7miy`pfn3EB^Bzj=K@}0!94;GBb(@-o<_QQ>EBu-WzoB>2LJi5V-c zlY(q7L<98VB6}+b2<~GPAOkuvzLATAgO%_Rcg~+q?*krUX4D87;#hdteJzVZB^2sT zRD*0!aQ3bz@sYp!cW~wC2y(v1)D=_VWO3Xz$D2F*(mc7}Cje9Zuxe4d&b zuB*Ad%Jh_NZ52O#)%i#jGI>BKBD{#;S!W=zkv1*xpkmv?`C9jFMYfGqJxC`&6R%;1 zU^t75Sf3q)&*(N~d<7!5g%$IH-9uX(HQ>YF@~3g@AO3Z0P9Fy5Jya~}s@jrHjWpJR zqES#nN0q;W9ZB^&=x+~E1Vcz{XX7UWTgazy>8I-9nB--5dvXJj9F8*~j-f`Ne=U0$+ZO;|jYi z4ED6p>ElGzgFlSo44H>=&<}iU8esna*!$C{TeIXW418k0=X~G2H#4iU=8{lJ#v{$L zm%Zp^yWMX054YXTGTrUvZoK@%Z5!j&Hf}5s0!e5>LTH}QfFvY9YC)R?h`}HP$Y6{N zn0YorXe`y7m6?^5^S$>w?~eWv@jMax{l1jk{l{x5>r~zR&UuHuW5#zc6IPgMSbYXhx&2kpGSV=EfYm)o58^gFco70H(JR+}zJxo8F*+B8becX-zRQ9@vJ znpFQ@(S$}fGz}7`9$0M6B1!DK4vRS-7E!Iv zRP-iCX;J_vxj)O-MyDR_!tVU&`6P1!`<(C{u#3SS1tmXze8J-vALIY=tN$&0#jpQ- z+}zv%<1xlKqq})z5(7|4We~Nz7^(N!aD#u9DDoCj9GXXnARL@yeKUEZ zTb9V-=BHqB0ml37=7P&cW#Gm|Q~!E`_Sv!=u^M=nSvtIpGORIFIIlTLxuzgnTFG5a zgLSCyL|M%pj@J#`ZE@n#{Qy4zV@VYQ4CZ4t4f9*qhTmkLU+9jxpYJ0!K(mG`#s~m! zK#;#B^j&c$#WCeqqZ*T+iAv37p>?&BpT;}K-;12YoflOj9*ak$7+7wE)UH~bdJ5$J zya2ex55>by7EjY;^@da%eL$`Kv}aJKuO0^9q!V|9@A3ntEODLq<%hWbkW5D~j(~EG zO^8xO`y*^!Vb}LsXA)jcpbN-qfo+%2yuI_Ye5YNv8M5Q)AD zSF7Wiw6O1|_92VTsu%YqU^Eu6nn5s{Z=F&_`|k*h|gT#>sC}@vhGhgsa7L3+G;fiJ9-b#(TPibC=uxO zPWwl>iRtE14=wCWI-bmGid&avh-fc`7sQdHW?^mlp4$^SW&;%2WdMfapVR9(C56Q|}_D7^yKFr-{2e#onYcam7iQy$?HdS|30 zvUCIIx|j!@(vYs&kN|cfvtSWz4~C(+c*H#40p*wjnO;M`h8);wpFuV69H0w*QZASV zJ0#`;X=W(LWRla|C&@unYjhrrbhM(qj~3ZwP$uQT#J0_-g?Dj0@s=~Lo*H=n*L){l z`u*RI^MfbiRJ{qfpVCvkxS>UZu~*h>_msmE`s?+Ago5dQr)fQ-zt%1>a=wGw+AFdhw;SwF%LLf6t@6+xhqIayRZldY zuLR2#m*X%Gj2ejRJ?c)+6XrIB5gpcXAG|lxu@|@~JArDeeR?Z?-}UEy7YsYz`R)_;n;lozz}P0Xk&$yYu?@#*15V~P zGQ!l*V;~k+?pA z`}YT)d1m4#|KSdE!|B=_Za#*&60p6XF>6%Vo$BqG+brCeV^Ppv=s7BG$_r~;>ecO< zmdShh-e?i1j;aaRc!IjD%cKdUM-Ot$_x`nsPu=U}FQn;v6pjTSRhJ^_cV`(f9gO7{ zz%K@WWY~Pe}jdS~X9)8n&ejz*NZi$hf z`@`G>xh8`DK(_X@2UInr+)~`uBKaD8;VVAo%@M#3RHMWd)l&|q6sJ~(jZz_-*IYYh zi{{JcJ$Hh-a)fxOFx7r1LuoHMgsv^dj#{%2@wFQ&k<|WMyYobvn7r*$+3=EAz34C( zgp#!pDpBaK!7Y(rt+*!8PK8S)7O*l+;#NptPC!h)HL1FYCa?C)h`TlYq=aCXdK%n< zA6U;YoN$lo8xpwAW~h5yiVU71?S8vy;wGSOI8XfXR7e6+wNdytm8=E5Rs9KCH=z$_ z_wvn-F9XbT4=dVo%Mf;uq@8uG92Qk#xX6_+LuliUb$qX*9>_mAgP7q+%5+mHvy7e~ zqG%|{Ak>1aO^kJeD54_(TjAnhS|nX8XmT;o!Y2dwiHkWgw)?pJWB`)`NRHXUp@ zQu`KZA@FqU>n07nPF?gQ=ho|Xnq>2 zbEzB60j2{mh`a5SQ6lN=v*C%OqFup*g4-z^ECpEmE#NO9LptHOYXu)LmZll?Yzm-oB9hh^ z?@Ot$MG9`0b5xK3;G^^``)K12=iW%YPgt5>mYyC-ca-N1=S%}9-@!@-WSdK!a44=9 zQS&Zwh!9{(@JyL(V+0RUX!~&MhL9Xd?1RxriD#YA7=7$`72vk z0ed~tS|7f218fst{N=wIzv}<=tMJOhXK{Tm4sOA?NbVWiHGnCsu7WF>hij9juJFb6 zf@sM!4B;&tHnaJ&vVG6?h=g3@jf_rZ*&b=Z)&~wW&N-Z%mnI{YHC)XOZMvp8J44iC z6`|E4j7#Qt#l(?dEa*R8N_@=7Vj%o<6tWe@EKo1zsskX86kSFS%#+rDWRnz*03GHK zKN4PFhX)y&3jxQ5a}c*`BMW1htws=5pW&@f1y~f%jRU^P1HB2^(tHl}O1+wLVTqPA z6o>j4*goZ$%g--V$DIBAkLc6c#zmF7ENduoTwRg^fVZ+QTF5No&S=3YrYqWBooNM1 z<OSqOh1YevPjQv;(47rK|y3 zeY2*3>P0O)s*-C%+W}*Dd+Mon%-7Bre9+m&AEk!PxGGrcJE79NmZ2PAkdKQ3Gp{M! zUJyiIWsgw#a*_(?j>7rf11|WG%7k6i2p1$Q21+ziu%ancQq4L|=|&bg$ZZ05x%I?l z0Z78X7!xj78~#zITp?Ba#%Ux`ku4g84iVvS{e*JKC6!bLP!U57F=!6t1$Ai@rs7`Q zxNRkF^+Fr#4X|w(e!)wB`j6p*f8;OW$*1n)#n&DKdsS?LbZ?A8#q+U7A#f%X&$uw( zK|#x)1s0aJqR4{vwuCBj_lEM@^k`U`ZZBKaZ#$$_czenBqhZ15M5jQhjR+vfXIL7> zjppcpQsh|7O+TP=*?r#u%achx+ojz$r)U4&Fi9H7)#^+q61<^u<81*YBS!q?3$ zT%55Z<*|>^T*iqT+L>Z8H{sJ7fo%pI_+a!N`I(aabVc5;jpfH`sR z?I+xS*M^_`#_z)?zxgY1K25-$K%Dx)L~^-Byj=U1q{%47BHGYVoXonm3XPS>vl6-R zAaQ;8tg@Q#C8msWuh2;6n8a(|xona* znbqP>V+;6shIE+-bjPhD;X)GdC4z}M6>wbe&`;y!whjF8pZdM{y?^Bo;;FZ6xc8O| zYnGi;mN7-qxLAxBvOiko(Vo&F4oSB?3J`=n=bJF}{a|5V*KEC?4A4Pm`;KzzneLHr zU1_@;7|mxIkIY+T02mndTpJL@BMeqk?4>yj)66ppd4^l#{u3KM_@U_^{;)^%GL z!JAy(aC~Fb#tUKYwt1H+3v$JX-JWx>7E5jXmY9^xqlBeiXnnHT6jfzM9OkgkNnh2~ zMcM*|Rbsfm$1jt%ji;ScFE8d4?UgB$#B?~7BeD(l9T_z@;136E-|*_kAKDX7o$)na z``P%v{;R(dpM2$6T%WIEPR9j2`~kGnQo#bA@$pbRNjc0I$?b*51qIE%mJ`aWpCu&A z(d(RbY|6DlJ1XycySGe|o=;?X$waD2uT+UPx1{+tTc+PBDrOKo1+W;rc9NofXUuP# zz3j%_R_|9I$4q|nmB>oqn;d93inVsVJH82Fqc_pivYziKEC!*B;#ytnw63eY@F;!3 zF*L7gQ$V*w^1^C&t*`s~rt@(Av%_-?ib?5gKv$w~?$4(Xp^vs<%XI3jTf4*3)hU)S zeMU{v{0))eZS#=pP_z}W=dMigb39bWZbiPWP%KJXtWv?JX%tcUG{;5hRxgI9!Dl7R zP0u$2$SO)NUZ3s#Hs*#=U8<0!Hjcc<#X)fN?S|Ix=1WAu0WaJ=2*-u>_dtQfZW2FB zX70gkX9E#K$ja@v$3S?Po>o!7At*;5N*fP{y-H_+ZBh)Tg)ih4Hp<}1&Qj?w+(=yF^4b?hIfIZ5M4gFq7O!II~6l6%BCrpX6hv5kWhVGKkQA zHyCRQ5$fLigi#TLrT_r=oJ!eTm2&>>OhkTkpmu1}pb*~fHbClxFU5tV0aAQO{xaNP zT;0e1$!GD*w|z6_GoQp023&4-Y?B57=fM^!(>8=Nnjw)kR-L%)zCxLT2O3Vr-3);h z(G`JKkyC{!+WB;LnzhI-!Qq(Zbr1xKG{S)rh{;f^aH3@obgIR>@$%q~sk`YEMhEuG zgn8Qu_7*+C!LrU9d32*=rDZIT$GY>2&R({OieMO)4ml5O4+y^Kc0}9S-S&!7itz|d z0aX*z{on{^Bo*f~15SzWGRgy}a6E@I+jq9#aM9*lw2jn816AYhWTJnwa$S)}qW>v} zC=06t@Ug*c?4~eE_kbxQM}y2#zC_ewI0ek*9JJg7SDiWHEdQ0`(emg?z{bSbCa?iF zKC!*y3QxXm!_R)*_u~0)_^mjdA7P%J!o0b0_Y-EurA*AyTfzqid|({ZV{-qDTCR(V zC6Mz=`z=}p_2KHEsbn|MhuNH1C<0`U-Z-A{wg@I;pXfTE+OEDypmdG!Qw}Uu5D>qY zo>D7~=L6g_Lu))%&w7km&&b(D8nwbbZ&25|0oW?)OoJa9QoM4Aj^-1_^xzgbm+w~8 zSG32sti8`oDg*22lCi!1(C`#cRc9zNFI zQoXn2H|n~j{l+u4ygq94fGj8(MSQs?S7YRuz{sw$eH3X2nU5*4BQ?Pjy94H!=4R%n zli_E6a>uhD59gd&)E{GH4f^;vmx<5CSx+FF(h5DW%0xL;QSIo^2JenYZXwfFijMmZ zIz>?>Z-leRb8}}(Uy(@`Icc71!!({c{nrZG9F{FGX+&CsHB7j#QS$85M;$J~tO0k- z-7zmwGj`q>a5J!7&UpB-8+-3(J%w-imM_4+{m=h$JpanGxOaUIW9%3sYECTalCB3b z3ZV^?G1(Fk%32|iYwbMpm!nqn&?#7S2xnaiOSp|GwBow(+fj)zX7G@80Wgx3oBB2P zSiVOlQm;ZX9cfMo}ZJ0NB(V@U}wQdt-sw$|xEy1(p>T2I{qwLjMG9i6#x>45WG zr+JQTLDBl8_^BGMyr4Y^`vJ5!&TZZ?5dVum{oT3qTKUoa;D+C1}%_^fT(=Hb7M zTZId|E4oPrN{vsQ-*N~vi&b-g62KvkYF_LJXbP-4&|r}_cXZdBIl_y=@*)TX0CP3_ zV)uyfrCm9aN@X<&4~Cqz(7=WwJq-n6)}nj;RIFMFO&O=T)w=9xIiuNJ29)3xJ`@YF zE}j4?DF;L1^E)99ET;RltuXrDjKZQvL}*mZR_)wY4GL=uGa!=Ytlkqzlryu}&|>f9 z7GEqZ>WY`v$iiwgIQpH6H%0zl3ML?GNHTPd$PC z<^~R6^NBvowtTyTrcy4sdDKV~@Z|lD1tXiR3L2IN){ev{Bf~2FkOsi&BoDb!k%rcY zz}HB)11!8|TeH~=WdsTF-MBN!70O>Oc8?A(2O?Ty%aeP@`o1~DPvszzP*tBCvz%sL zQ7n?F&gc_;{-GKR4$>!`7i_Wkc!=-AT`=E zfWv1VcEiZCTm;gv8w22hm(+*5J7y}Tkwl`9GHNp}BopXqXkmhNy>v>_WZvhY59Hyo zv4M2_<)*7y&FR<}5#qop(q3`daeBuY_ujtY{a^RH@ch?(1y17vKfeXIc@z?A#y=61 z=+oQ3c6s3?Z_1YUONZX#R{a^GSN&ZZ)^#;09=dJHwPFv|N3mhxr?o+uT2nBjCu)Ay z&A~c7w54fw^=i~Uh`GtlG>svn5=}Mb3L)j-NIvm)+N)(P({xJnyQ1;Hcc~``OP=tW zbj5ev5#X?LHUoNyKshq9V0A@|zio!n9@TB@bNynCdAz)1aDf z<$!KzOMx#Oqq)7k`l7?m(W3OsvbO0Vx+GafaCgcWB}Yj+aiE77q9Wim=G^?~_`r&c zPDhRj8}N{o6BrRiH7}m0@EU&N$9H`46EmE1fr5V7(7qLXaV@J#-j~T%`C%7bg8AP7Abl9l5N3Wl>q{xgk5tZH#wYF79O|-4nMa@ zmvh!+pC!+9hZ=b@(}>f!f?3!|VMc}m>pVt1+1V}!r11zxZ8Z69iG{fHBZi}3?HBuV zNpKAE! zu0=6A<$VXc?Ug08err=4LJ@aPxC506qLN27GWs4}W2w}@nA3xs=NQI(80OuhK3br9 z^cHDxks7_`sAcu%4OW}sn7o0jgdZhW)-9w~^T(WDU?@ip-LO&Eb?q1)l_ zYW}D!%N8D(yTeXT0QnwG~W8;J-oJ03^-2v4%V)?rLeOV8eZDjq?KEe zt&Gl+YvLoFm2{ksgk4U&KqRI+c0=1&wXCy(G!{yXiZoD8oeU z9J`R<;$H_N$rwCVjuOxD)ajo` zQ;Bp2!=8tJh-V}!U5kxUW1iI{Gpa_fIIsm{IpSnt%jh~!`schbbx7kO8K%Q@4Ab0_ z4q=&kM;&3nwmCNJFq^O~PRBdF{TyjsU-jL1_8Wg2u7(4rr-8>e05)`v1gy~tnWcYx z`2%4a5{zZdE=+YW1M1!_zSH{y@X_9(qw5gu)l{(@sQ{KjSIX?6F0gR!S{v z)Abx$`G=+>R5MO^^s<4hT}~u)Nnpbyk2pi!P8bXg6J?gb2rkmKK^qndMp)c%$nW@!ktx#EIf zk(8+Ul2qe-18u{Hm@$cx{=Vm?ayVX1G*oW|KwfxlR%x24)LS%Jn~f%GsEdBea>v5s zojw@ZuTsfwEx^d&dqv^TJ_*Xs?zx`{z82|J;{u#XV=##h_ z4*=V-ZIRJblfh^&H}{B!TSzEtP^MNb+%%yS(>PI?QqI9HJk8P=;<=^x9-lSQw`Fu5 z;If5^*5i4uxw;#%HZiQ(R&g=RsHUU@|6O|d0AFvs3-mBHt(^N*juo;3v>}udgCZ-f z;kENMUndVW&==R=E!jB^`CBPNx%0X}Q4VZ0Ty&XNPkW)RFZ>#)INm#c{EhG18~!+4 zUKS$!@~Oig`1ytGnEN>>3&1V1@s?$1(#hFUu5+8%@+eeK$4M(U&`2Y-aulawz(@GGfE>a)%-cC^y|(N^GLbfT+sd(VVZ%bWlpPaiOv}9CQ5ALy7eX^vJ7t zb|{L(9q?hWts?!1_~_qLj(Xuxk+mE=;+jruXb~WM%G2hyl&ucHV&9(*KHZ;`{}7Fp z;UD^wr|=DTj4hYlGw(^>W;?@S>3504Atp{XVf)1C9aq@yZTQeveiuIRO<#?x6X2(( zfSZSKKV#0V^nr*n`Lhcu=R{V-SS`FMryE`Jq+|YTjK)J9nEFkZnB)fxaJHX)b|)K9 z&bQt!8pxv^0?~(&G9lV~ zyWLuRLn9G?2>zsx6!o4srmF0Xbk!?2V4gmDd=?hru z^NkW*-Pu+|x!U;az+^88X4zna$c+M04oT;YKI?V6E01kV7!n zdKuy?%HW_8Z}v*@aUmz+G2&ET^Ky-yYt4H5V9&2p+2mJ~1%}~HMeyV*wBLlEU&xNR z|GA&0<|#^e$)JJ;{8SFp(f}X5?NC~~GAyqd;Jq$m-RgqLQ!o`&Yb(-7O9yGaA+ue> zz~F9`m|TyplDv4dkKe@1axPFndvvypqcQbjd1zb|zzL|eCyt7RGD3p4rcI8OTs)cb zKuSP26mtb?6>)fw15Muc$ejML*D78Z9Tn<;u0vop$9^ktx z+;j+)6_QCA%`v(>En@QJItU^Kz2=24lpv1LHZ9^|V0kLG9;wF{SOB|xZ__8t%NIjAtQL1TAa$OtYYsA>)of-ER=Ls%wVby-;z6hi{26z=osmbxcWL{WddiHv z&r=K+U^_mNxHR+;M$zdWhChMlf9Ox)1HbRj;Hf9?<8pH&eBPD?E4_mY5Nq>ntdv!Y z0U6xJ1;H(0)OzqDE%8Jbg)67C{ZVi0*{Y$|aVPT%toO(a2D5bfc{n4vb4pP>thU6d z-j}x9m?wG9qXr!TW>gsK6zy4uutzJCC$_Dk+{_|n5|aO>u?LMs-8wi_mzW1NFr|eH zNsdR3;;hlOjXHU7+f48?-IFjcQPf`LqAPW!qS0WHuE~gz*&IXMnxZi~GFmVE3OUb8 z%PJc1aO!xR@EnfN38e9BaqwGC?wolFvt{g3r$u8^DLZ;&yVCGGTIrmsh`n*R zpYz^iwY52cW-{B#j~?;5V7cO6+pfWzTI#&lqpASKfHfJj%Jq@~8lQAowo@Kq^|wYj z6W)4u9drF<+N$MPT<><#Q*OS#Ayt}xl)dHAC+nS2?pExZmihpg)><0_p3!sRT;lTv zo_41}HheMpG8`-Gc!P&F_07|}*+$5bxZX=Em^lXAtPgleBUa%OgtI2+VGZoaF{KPi z=iqe5gVS5^k;gxd@BAOW3GaXAgLv;RdIC2$H@G?(&SyI0!WlOVIBka02pzW#w{3(G z!w5Omd`mns`j?Tn-EN8dEh1NK6kSEsS3+(T^+l|&zX7mjUCQLanYN-SMSG!tPnmgy z$5O`T-{azFu?xKYZnb3wYD~gS)05h75ss?ON?oPis7OJ5@Az!acseTtb7wv)ToA5( z2d=IMUi>8RGd~{sbi0ndB7tNDKVgriBdbO!#PnhW3%Dd>}0S#RggLYP@9ASQl+)a_7P&r zmMNU`cayRQ*{(I2&1TyOP36dJb?7K(mq0K`H<%<%G2m0tV!|UsMrz;^p zT+Zq``I~aAvCiQ=M?vbsP3yfu=j}-sFV*wh(6rX7$<=kF$g=($%^7u0n+$^HhX%Y@ zwBKT;7un!=A6op}$tAKyRtS%nD;Vt-WNzbAhd=1^W=6z9ms-m$q?sStqQOxHwDb!! zWdusae0u!7C&-Cf2pNP9$2??8)404CtF-qc4RoUz4$tu@i_6Bv+Z(B zngKIMTnt!+uEFt{i)D$0qo!n+4zB_POrdWW@a4T)5Ee>v&1W)1TyfA@D5A>T5{JwB zf;Xj*;^v5s+tOH(uQ0iTO6 zjIx43^?gWhON0VA7CI(!$IRL!ce1nK>%vikOFULPwA=@g5#z-({LCHl71$(ehwPC- zMNgjC(8Qy?if>Oxb$4J-qm$%pgr~+1RBCCRZNgnqWF(ixVD@rno5f!0oLCNS1p5YJ z;X$%!X%e3AFp>>z(GfVyh1zIQlm@s@%zdUqvt+;0b&~*Cql`wQvo4kw^eV- zqrf!7~eYeSpQPauC@+= zzNOp|g;A8ssTQ6PYf(ul(j*7s+Om2_IQpT5r(s>Z;-LH1jf7FC;QTB&fzryC0qI)u zB5DI}7_(IdvU3)2$;IJ@;pK@qI*Ho+di`7LaWld*goD9=s2k}| zoS()|zWVp^T|fM-c=5#-@#&v_AAWIMpA4rf$JiX30jDjZ=f=pWImG6{*xXnHZW}|+ zvXO++(@tZGEOF5oJ)^NyR>120ppmY4a%P%um~7Y`O@lhTt?g8Mlv5c(zUt*!pQm7? zWV3`L5A3jvcag)cs3^oxizF=bH2`JQeaXe94>(tyV;Sp0s;+VX^^7m=OF}n~zGxVg z>Z-moB6aSD^VPuf&p1BtQ(?!Q&j4md|H)oz`kR|F4F__V`W+A|Le3>KqUK#ZrD(q# zU-?(+^h*a|O~}Sny7pnsm*rXFtZ#UP-4o+Ud|AU`>apQ;s+xF*4b$&&*T!U^zDHJ) zv|P32Vn~)Jxg&Wt9d!Kd>7=^=*bI*!UT}GN;{WxV{ylv5zx!X{rB`1vj8l&9f-xq> zSR%VEQwVVDMS5DeK zO&@B`t>j9O)Rci%ZpX4k^gCrht}oEjmJ9I`EUrT_tZ3ZxKU`0y1Cxs(nmdV-y=i?S z%E~cm4MdU`hWHF=yBPqRQ~JF!yF^w8erY@>`4zHDYsZ#SE&CL?9AH4f(HqKsmD$VO zhTfT>3D}x5^|myH+$gr&kn{73;Z6Q|Gdt!EpP)Cdiu!4Gm4TVddojD-Bk*8Yp^wDI!Y9}h<2|HuN2vMO1j*om%!dQ}HXWy$aJJ}T5tTPQXu;ci7 zvzT`MPNvpFOQ)9o9T}bPB!m(KWOHcNV$U-XW5CmMb8Z^Q8*`>5h5$DqKQHJ zRIX>ogzPIj;tx0^LJAs}lX$B3*jn)6u>HB>Gc_Xsi{mUgiy9LVX4!|QqIE!ZG-#DA z&6i^9vsk8vuNy<&M%hx^0K_TpXe{UvO|+fw_=zoKOJ3xc{kiIBRyQS4yD+bQA$qpN*%b!VITvV6$?}x}|T*QI0gi zK`E7Ab&x~Lhh-{kF?Q76si=s=qoXZ=;@_MTmwoEgOB+EWgT}76>7XOgpoIVpKh?@ z&J4kPh^~m;M~S^Ur@1cDunlKJA3LKgRWW;`#)f0bBt%!ErXj z$s)D&WN~=FMyH(>1hK(k;@!@_EKk7|r|O@jAmZjw(10)})vfwzIe~g#&fbMgo1+L7 z-G>7=tdWRIj7!I^+Doz`{(H?ej$t$z-0xe?1r@Unqj0{PW8&DY^b-48W|`w_byZ`I zL-+LM$t&(Y2xSM4c zv~hGxxc{Qe?0y1si-_|B*)My2RVB!<=BQKF z^IG{I@^9*IC6Cf3qyujUd^h+WP~5z!Le-E#`_AE~03T8VD?c}ER z5k84uM_62W8mrG^9Xg06w2V?6y9A5|1~*Xa6&xF@`RtK%v=5t>Bgz|Jt+Y_iJvwqb z&dkhdtM?6I@|CUFIKX+hm+cp(A3I z`#=BFg93yva|Osi;nlHbwVT{!gCth_%j*p+2Wkr=cXPUfq@F!6Q@eBgPGNKi6kV2) zl!6kWGGg0DOkN6J#ls}=nlv&!1D);%z|Fkt>^79cfULE_HjD9_Jr2%7rNJnW*R8hJ z3Rq2NOyRgi^U!D15-+6^;X@( z-QAN^)3dO*$#Rz#u1Rv#6d=9rFhL)r5lv<-4(;}IW!3o3Z^xN(+{;&{7SPcm{8rmi zSj64ppzKIBVBcZe6}CC>{15ydeDL@FS-j`L6>eUC1e+6Zm%>@qT4XQa($ok<^l`xL;&B0l2Z+y-o$FuP!!_Q1#4aeChay#Cxv`0(d{DIWg8 zZ^h}s6<`lAFFU56v6w)jrS4ve!AW*C$L`AiO}>ZXD@v5+!CDnVk1L*a0i^S?`jTMqeeqGgciKq@l1DQarjBYBxN2_(CwOT4y?c16|1M$IG9i}m`krlDjLCd?;ct>$5fn|iE?(~%VAYS&rW*W38MT3&7 z`#*M-{MZfvvGvu0$sH4qG3_nze|m1MX=i zjOAvw-4;F*=GZ>7oWu^`v0>f}U>Y7ie}lJw+5>#!H~a?t%fI-4hgTnd94C7K zrk9M7?m?y-$bjMRjE1urr6Z`vwS|@?B~arCu{4#$qpdmvc*sOmQM=nV>$(-(zS2pIQD|-wn}Su@^L(iKyD*r$`;*7 zsgZM$+(3Q$}0#Y zU3M*YN=n;$`{|Zl@a@7Ri7og2dp?mK!BPqkvJVnsuI`caV%h4g`R&6=CxVKwXJ1BE z;0bh0sY=o9GZ#~Ic$9Ju}YzpxR3o=;;rbUQhsBOs|QB@ z>-Mwp=%(h>RWQd5suPe-W6Vhai}+GW3o(VzIQ@%=yY199AE=c93{7<4-@LW@-BTD)#x9G(Na|*qPiW9>p?j^i$(PTuyX(o00s0T6T zK@FbW1wTYaG{=wP0k$X4XWA)EZ`;UC4}w%|S{oxsaqLXp1k4R580=(t|ND15`;6ms zPTFlUo49dDMUi^-F&fOSw#)7tJ(N*%4k4QItjmy*bp*9JWSKIWohvfXU2wv=S=q+j zbvNQ9dBR@B>n;E9J+-L8OKIM6V~7)W2t!n;DLM~*++I+fSttUYcFmkwX5wZ5mw|nE z?3am0&ppO3`DO3LH-6O@;h%ixFU2d5K7nEP;kFBRy`3&IIh00e@N`zjd`_^c8C{rV z>!hvjT@$vHR)zq&j;VK#?owvffw18xh4 z)^9C0x|pp`1#YkWQ@%Ip#>0zhp;xA0Tm#X%_UG?qa;(YZ_)kTmu-|-v@HrZyT@%A2<@H+> zK{|8cY{Ah&D7L&K2W2x>8pen?(VX>mWF$2lgnAMb6*5>UTi)>)C}|Pcu7EzhU*eZ;*(HT^0PK!7~*03WPP-BVf%|KaESrJo3jV+2QJDASG z%nxw$6Mq*!`h{PE^D7VW)VAT#+_Cw@DWm5)P?d7R^b=dAlk!A{d!CS1JMvajOVX*y z(SR0~SU&l3^NyNes@?b&8B#2eBrm726Hh5O%vE#EkZB)9h5>Jj>uG#x1X4iVShcCEQ!==oAXLN3#0HM2OG(014sWB2>O=`-%(mH+V{0lzuxZtf%`@yjqBLGcuxVFCdpE9d#X^OvSaF6w#)t`{Qqv#ecLw#9{8}FkdFz+=u ztPFSYSt%cZA+6A4YJIBC+A>~8I+jM8=#~IVT4a}GKiMUmd;^_I-Grq9VND^iD4mr!t4PQJlP5K< zyNp0uPsI61c~aw7DkR8@t;`01IUoAYu=;z2gDyJ-K6C5Gk!2 z;?&jwoQC7H#V}6ks5_<8guF?|3lE0iuzQqTKTJ4-v1%it;hIh|TdtwW?KYj7I@eko zZi;9NZSU)15v_0b&o;d5Q`$VY9B^do--OMU$)mI)i4Jc(L_H?>O!`j~JWU~*K^o1L zAr48e3%N*fEAor~)~uq$gF}Zy0j2||mXAmOOb(qBaXRZ>sjYqi=5E+;9FL#B!N2j# ze+jCXW6+#<_zI1*;ZopeT6V$Oh5?D;W ztIQY%J2X%m?!lB|3giV@E8^nZzIcZ7mm7}DgU1c=pX*bS(fWnMxZI#4Tr&>F+PltY z#`1RGIKS0oEieF-EwMb)+xJ5wIcj`(F6 z=v_45IMg#wr(S3wqm7zxKAyZ z{guC~1_57`Y3&jm6~i5$*~KD_Rt->ck-RRYdTU5Omo#1#Cdkq-Ycgn4EkR zRxO%ai*E1Ovy^|4%SIZ|apW|xB>AHCFhX5DR-_p_D?^(*H@qhrp~5}lCg?P%oU{~> z#>l*oH2r|H#hA*dBRM)+bPgCf$V+D857N>i*qwgc@<*y;t7p?PAf2#utt_+V@S=m! zowOqE;-us>noIp>$!ILUug^hjg8wUZY;Utpk-QmGxe&>6*F zR`g-WUFzh?rO^DO4B+#%`xs6;Mhf+@a(q_(2(3du=Ja&rWmH<$qB9_TD?2Bo9Bsy; z*~8$Tkuy20nZ_33a|8^hEeg}S!Uqy}=5n35tsDBz`7_9|O!6LHW1-U*DW)s}iHv*~ zFq5}d(P1!n(kyYvT2getk!H7TbR_0K3rFPu%qBMMz|CX$Qyb2o{s6E3;9tXYzu|MS z|K0x*ak-9-WX zK;EEJtYt&&^D*w7uW=c#-f)sAg9T%Qf+;keo&QtpI26k-4; z3tk@vrMxD_g)yFT3NVE;?B#)0Lk-ROp7YDY4kT96CUy%w2m1<@lr< zmZ`v{i(CJ4U@WFZMJNDhK$pMgW7`0H0$1mO%QSrOXLh{$is5_?SY@BCnQ}3rHqWI$ zOCa<}w!j5(!1qfQiU!&>7-i5bnVWV-G&yB2_F#!+lP?<&p7hnpo3?^y@J`9!j-jw^ zChb8s*0WS(!!;@3+?WgecUwk%Oz0pBmZO-{F)tpGb2kIF8y-Kp!J`)+;s5p@{cHG& zU;CS3mow&g48vJ+CL~_jCG+5ruZeSZEIT-z6`!bK|m9vy%gFKS!I&3)P1?^)@D=Z)VACdmI;@T)6Me_<1uq=6=r4 z9Cl+7Qz|ju96yVwUh~3l(@^cgOo;$!Iq=3GZ(k0rmS3Q%KeDsZzicD4Qs|o7e3(Nz z{$h_5j(&il?OKtugdSOy`RJ_QckRL)dS(vlaWi0r=K!}K{@(dsDiJ?Ede=)$+Gt!$ zkB2cf33g~tyR`X5i+Wj0`Pkw#v-SNFcNMC^{%obCnutEaCW-Ujx*20^8>ob?#TaVV z9cX|tdbD;-+B5k)#~ajQ`cB&P2*t5*f)fUsE_d+L0WWmMSkrDiw1LCAz5ipadTGwA zSsd-!dX=NLGgLYn#&^IJ}2fL@Y}HP zqo?pxs&dvxW4$;&+l?JL0>}e7GO3aQIR$&Vh3~av>^V1)j+%{nkA%p+i%cjM>b@r} z=5y?~bdx2F`C@v+$wNFnmG8n(djW*U0-lPLD)!%H_j;->YvEp8EHNDbaSH(#? z90ajMUK}MI;=afG)m?M!bqF0W+X};0`1#hdcwT{S! zXObkhL+IjJ8qhc?qbzaf=?p7XW+|6VGG?843QN~`YFLM=Wp3&x319T*4Ti#Hw12Ce zb>acIU*?V9KR>|3@hZOQuY5Cp_#ga_c=!A6!>=zG0L~}iJb<%>LvAx*8-}xm^JL3w zbbgKYojgsF9NyfHDTY*9WTb2$XoV8l5d5xaJfJp?oDQrOd80mxx0Nj-G6-QESoMaX zbRIQvP}H(I`UtO_Jt(%%|v(-+)4cAT$Fx^$I6sIll?VwE;;>io3!WUIL5p-H}C!X%XH zbF~9RzTn)`A=eDALZ%bPHSazVaSI$!6G$G)Z4vEqR;=G`{6e?s+3S27h9(5$H?ZzbAPn*lBVHMSyot@HPs{oEh;(hD$LPrw-B_VjLTGR{^(gjzF9EPGqIo>wMGVZ*aE`4sHcaO9^ zow(^v7>${}E4<=kx5I2+uD;zlBHao!- z%`ArAsyYz_&=&d!E!*Jl&P4Z#aee~+;&b@%FZl|*^b;S$({Fu%SNG^)n-gPBC>^~m zcoj+GXi+ERcbFYw=((hGzAUVjT;oHx~)S(q71I^(1z z#JK^(v49ZDZdi)$*tGp*f7RAmQ%bLgd;$W|t8*LWPLh=Ate>P|FW?R!|+|1j1+ zY&>Wz629eoE&7sFmeH?)UT!K-S~dOO5Hd14aEX|wY);3O^Esv~7}{n)vy-}jQ#Zj- zIuRO42S+-k?v|rW?w5S0=2PjRKWX34qboC#t=Sx7xFX@YUKE}N zTAjPNNjEKVWzw5GEw=7c?ztCi0XO$nAsUM2+olHTZ4?8IrKA&ZZlz;LoBnxUiJgu${;tW#5>kZD^A*jhGxE*S zIHykzlmE=;4vZ0zT+5~w5Xnid#;Pt|s3maY+xdGM>}Ft_8y>%WgSlPsC13X+<5&G3 z{!_gE=y_b7Pbquo${pf&Anof`FRpY&08<-hMR0tI&g?FyIftCY#a3NBX>6rdd5i?> z0W5rH4F{3%h&~8aV%rnpp{L80r|3@7mh=#13tO_-=CO1l!obr_yUrmm5!{f;g*|N}eyB7Iow`WJSoPFR`3_x`AJsJ)4B2co zbEv-)UW4%ZDa@wSDBJ2zIXeCdjMgGywssk@^R_r0A(ysu_bf_DCs>`By{$yVKl!ii zM5hy_wu5XmSBn8_(q$WfyNb2wF0G788@@|PmuzV0Xt8kzOm%xhTw-lxpPi!qGoGBe$_tKfxGFcX&NKL(NNy{y+ zv9ht8S}rh#Zsyz#lmXUhB)v8jWLE}+>zU}A#s0gb^ig;w^C{wtr>UAL4OFMiI$H3^ zSo=rvpnKIqYE;98^4LrZ4AnuhLzGCL+G7w?tO~FV$mzw1HrAy>!@1=OW8WRVr_2{` zHzv1Q7>BW3^b~206>*3`qAWSh0`!vKiA#6SoV7Ly=8;AUq{9Qn`_{$~(6&Ww(#aTc z`l@-P=x#vzZ*q>U?DBNR2h9Oo+^=ItBjsI0o#}uc`(Gu+_rSkgfq@49-52b4tbF9&}l?lSwk7AjVY{cQ|~SgxZa*MQnjQlcAYY>aZSQVm2Pr4b=F~R%>FKG z>dCQX?Mpr@dbusU7FrT04l&2J3ao`^I!SPxaNvBs;f3cNAAbJ@2E*xGHbv2T;z zi2T+AO8QKWhOZiLNMKv2e<>pk;xI>vDUc=|+nWu&2FePr#)|<07 zmYwp0^-=SR*s{+r>~GZ-+f>f_FVF*l4$rKbl@#;ZJ`|Z2v@~18G0>w69cH^h{+Of|!>*vkrm^*$90CxB*z`Q}_qt%Y= zA~|nydiflVA5rm;pgG(;$S4Qu$O!{r9^2`eK%boMo^=!RJ_D;P)<2K~n_B5M%(p;k zK5@QU+L78WBn6qaNBZ;}`(oj2?I6skfLDfgubueDwu@PoIP+s)hp`+xYl3IFyh2VX zNYsN72UO}6vdnZ%>X>pM$p<9?$>>It8z?HARpd~$L_;}nkjBCif7~MytuE(g5=t_6BNk%sGJYMWvSyu%vgTj2 z>N#J@G45H?%B0X+tBD1AHB#}($+6II8xbun?lf|qK?T}~&KYCZ6(=P}-;J_{9JG2U z&0y)D=}}9=cSIefdwAss{{VjcE4~ZYS7&T<;wJm-P8-)ZleKVPeO}zv6e`rEmCc82gK` z>$d^vl(Y2q#jgKEu`6Y18Sl14ktwzU@;Y``dSg#X@6Ngucbucf@~N8+g#y`VrC zQ5!DhXtS;3y65;B)#e07yER8+q@#)Q(YkXCihQGfj+$}_PtunhhQyM&(oD74LOp{P z$;YvDAz*};0Mz(Ww6*b+o1PP{!!nY=bfR$D5+iXSnPuIv#`^_8+2X$Rvn6~R)(G*K zqdEn7Y{=+g^V8Ml&pqS*@efao6ZKjC6}>7_%@|R)I3mp>S~1%%&3RBbK#@%%&r@MPd+>$xvB$D-t2JB)x z`K);`mraj0EnsKSW>J>@r9SuF;B#Q?8#bJ9^V|hbf7TQD_TTvh_}6~PzkydCehk-F z*Dzzvy?hc{-k?*c={0^l=f%(>-O}okE#2s|+YTC&2GY6^F09G-4uF@e zUNA!EKR1!P?sZL;YP>ZaU&|0f9M{E6uW*)Cv~%escUG=zQ8Db)1!h?cA$#45P;z}9 zhElHB(_cJ|B?qLMdqg^b>1fgqHU0*VqUO->?;U?uo72*0-gGksYM*tb&}lNem0%8S zA=R{{Huc_)v}(E}>Bcs%^#g8fUeYo5LLcm#^7CeQ%r)(Lc?qz`&{8P{sySd2L+6^4 z8;e-$$bedW_Ow%DnWo zAgb*sc{OU3s^mYyXjX+%y$p)Qi`lwq@?wE?B>u($rZx+2=yn`q^jaW&`$P`S!T}{k zyI;VjwGqw8ITt_T+nhD3sm}DiYhOw4n#n#DMN^&vw-##H|YyLW&_LXQ;ymU*F8V4Mbe6``Xiv38_bmX0pu$(_*NAA+a}gE6=r7P9I?$tNv>74gJQE;Vy0PR$kD4h$ zG#GBMU7a!Pgy+8foAJT#_!D^hQ}?l7CN4H`LZ-B4CzL@#A`7Z>omqq$4-BYwT9X$f znOcQ}#nSDvl^GjdcNwrc2OtL<9Kc`zWsEu^$vpNM**3}YfSgH-EYqtZDr@BPNmHK4 za8y)W%a^jPrJ?N{mNlx%DfBMN0uMTsb!6W*;*f}x|0Swp0Mln2qA}QBr2}f4KWT;w zUK_RON$lmAbKz0tA~mBye-1574PosWYW~s*>A9$p!;y=m*>(u5L@AxHFa%FFoU~w% z#7WVUZAtc-7iWfwl*zCd%lU|CJpkK;ogFqN{0ZRvi=V`!4?lxve)E^%wcqpA80Q<{ z{0{idLpV-=Z>T~yB|^(NR{}zlD$$yMy$z|6b_7-$OrFHz&oa=pf_rAR$Cap_I@m1ckpGwdz*&%PdZA&DN3-HSrRtoh7))Yc70qIFc!qrz{*C zYyG*#82BA@s#)Qn$ck{(d`j*R!ChXZz#C)3TK}(}9fJ-y)c8o6Nl>HPlMQ}@yZesa zcU)iJ$B(`8*YNd!>g(~b*Pp|?KI4QNe~7EIHPAe{1j=>A)z3U34i7<}i3*KyEpLnYVLc_Q$rp_@tXdJTcaK1Eegm81Yb!)H|KXuw$0yELaR3O+FiwVX8n9s*9LUYn7>W&ED>SuC+QvU6Q|NHx z##XQ8SIVn4S(XWy0DLa#%8YU>bEE0N#CVuOtHs`*aUg86Su$i&F}Sr-4FFS63pOts zIbK}SSjFR92IlwJ49tv@sl17>6ZQ>bKVb~R!%sZI`+nKm@txoCMfev!$@rnA7Ks?KLypxH}JhXf|J`wj%AO zC(6$0pRhJ=f5Zh=qIlv#I*(z_+>p&w-b-WC*u*g+3f{H>_DM&o5tEZx=4 z*h+`gU%6awqPz9)t~Rt%cUcb7oGqQwiVT~%POy5&2ViEy7==NflCR#wggJFiU%a(3 zaqi`uYP2oo+3`su>Hqj^;Rilo=tC;a&-o0n-6zJ?6Bw6Q@$46W5kB!le+}<` z%RSsYzJ$)VK8ET7;G&6946D;_Ddf+WjMrW1iFthkxslC%VhROuEY0SSZ_&>b0?9x&bToG zFcFKDj9SA6>@!9=()s3IX~ea2?oG0CS(&%?fOBlst_{P9k#P>#sM9X@gnux)z-_7h zGZE2o+m>+i0F4Bor#)NFq0g!tRnewlJQr;>Ip?SvbOtyVS=Po5ZhE;EU_+8MqiWK5 z=fg414nG0=ykIYX}@G}JVK0(#-k>=oBFB7)5dQLB376~ zpOv01u|sF*D4b>!CVJ@W};c}$Z{Rzwy?p?hNf9DfFf^Yo6Z^gsQBfR51SJ>x{>np={ z0=5%yIyp`o^5k5{Hr#XoM60pJaSc>NFL}N@Koq%_?<}LRXm=|?2^0JQy$!3HawwUS z#IW3}XMAa2>Q50}W&c#9T;bI;fy6^mi#C%z1`?5byg(;n&X1Slk&`cYQpr$nlVFEg z-A7SZ&`r@Wzte$&(~lzXfbNE)c|yT-&z9Rzsd-n#rW$rPbEhEj3}F*kXnLG;2M zy6#t)zB=fZzCHgdZ4_u>c?GvRFE8aC$Lq6PFcWE0?gm^8m_cEWpS{7q^l$!C_{OjM zQoQxSTX5r_#Cbcz#!Wa{jfL+V%i#c+$3_6E$ACh1$EF z-kO{a*jQ0Yj4s=$9J8g8U^`uLCPNNDM8Rcw?)(m;!wun|3{Pb?-ai#NCq3WCpU;#d z5fIn4@h!G$5@9fe9AGGR5EaS2-rbSwRqAV9&!PZv+?R8(C4?~zg zZb^<9qZabUyx9hHGmo30kPK@%E}vP|A@6a))CE$79Um6&?13_r0-&SE%V8p;zr1o% zGm8Mve-*3M7bgXog3Q$%EvcAvx-x60W&Ow*M_f4v(IXqQsBHr&6bLu@zxCuw7XH62 z)4IXun%)WRMw@{VO?3ze5!0|FLC=O6`B5<&Y>&(!I)K+Hj@E=TxJU=!GxqZ+!re^u z?Lsf5Ft5GNP7_@Cvo?^c@1#3JqYr-PLW@Sj(Yhk+sie)S){4)d>73LmMv3Z!sJDjm zh2U#O^&o8!VW{Rjc2o^>cWl>h0bcw7{_*GhW<2^kAHaK`x`)>H05GB7Q}I=!PwGq?tz~;IWTad z8gkb43NUA+y#=HxE9l^yuKGxEphD1x7F;7_qgfk2z=C@*-VN{!ui3`LX^@65IKT56 z+uP1~`3HU&AN!nNhsS^OPsPcrm;1oHX*A_^n1(eySW1fPB@%EI3>0Qf@RbbXEA^d7 z?y^0^y0bAk9P9MV{%X2>8h?!zNvDXP3?CV&y@b(W0OTYp4>{CMIOB#yZ&@I0qN3{L zct7xdRUF^~!54j5CxOnQnAVXTT1`E6cauIjrjbroYdDs?4q+bg2-fs=lbzZ}BO&Kt zIX=EeTo=$Yih=DsIyf++rr6chQ}~gO{AqmK5C3kA)5MeS*l@W_TwNK?8{*%He<#ZW zAQFc`X%3xq>a>e0Emb-w|6wo+GRJIeD-WQdJR4rNXpZAnVAUwPWcod$x0otwZQe#h z=jgVaCco&X|S2=5M~1KTz*r{P0CJ@Lvb)2{EC;BL|PmL?vCLTL;(!iF=C@jIgm6Yg$@ zjMSylUxZ!JbBW`A6C8STek7mKnM3eM6O|_4`KAOFBkgMPSKGN{X5m#WSjwD5E_-WB z609+-MX3_>aWPB-Iv-&=qqPC-hHc+qj|cXT@AyCd2mdm@;)}irH;*pBc!=|6*tW+Q zV+Sx(Zy(ksjBd-iFEx&Gq;)6FB4d0Wp6!t5eW}>Onapc%ZwA4y8#`J96wd35^&chA z7((mAnL5nQlQzP_Kj<;E*otV!JY2aUn8JbA*K{UC1Rrp-t>8MWKLO-cR#zODYnX>Y zYl$YD%L(7d&xJ+n!-I*?4_WIZHN50bVl3Y$QE5wjWw3^+yQoAGW8s-M_(*nz1j=E& zzL~vrcT-ZS%@5_Ta|#@2dkuM1)H@7%dL zia1~Xdwff*;sk+Amc}I0(O?Y#kEXN@UdG7*Hba?{*{;lUui)4z<6y;ZMZI-K?ti+; zz?Y=PYO4mcIgDM0+CC_@yFV?e=>TE0)0(^WpWm}QF)`nSFsqq*vISY(|x91Ng%XWvPImM5W_4uqI# zkD5a#bkPYMFjx8>#qe>wK5HRq$b;U};W*u~U$T!@BX6^zR3%RuSEOEgA{fOHICJ3) zX3P9c1n=}yaWzdz8(QG<=70`#aC6ue?~Q!kwtPR+Q$6uh2RlS$#@M*rPBi>2DW%dTj6fuq9ahAn|_-4oHNY=pW%JTQ566+nTu8CEW=M7Rcg+<5~>&2 z6Wh;JOs?5jnX0r=m*YU4z8W&BZz9E~oLo}783yX9Yrt`k+F8TD=8tp3IUgzW)2Sf*52ewCQ}t+)TZ=X# z_l^!!>Nza>$c)cr-v-2?93%T|^$e}sE=2AHSGM7NetM41w3DgDb60)mYlP#7U*Z8315Ncj~qol$78Zwa&qWo!1zPNDSKthvg8SO@P zr|lZB(&+JrS=vW_0q}TW+c(Tdj{U`nU-LP?0>ANB{|3DL z+KV`ycbrZ;fEzf%Ij4Wl7(kNTsxfK~4)dYI3HZGYq^rM%L!Pv|^r7~k&1_lnsZiJT zBjpn*rDv^BqXcZrdJG-kO+f02(xEABob8#h@L+$%Qzt^UXd$X>DMcbzU5h58h=+wWQcC?+^Wfr|(;q1IpDH%83;1-#imZ)V3_{}}E){fh7YN(zQss!h+m!KcdyF)P`~0kd@Dgd?KJ zlLCE_9c`hI1mBHQ8m`T^Ry*5#k&X_vk>c08l=?Xa!`NHKJF6w*tz$L?6!GJwN&^LD zcuQFLtpPEDj83`e+(RJ&<>KYXTb3psRg}b0tkxcoojH75c zX#G3?n4A|~%@B8W5>&I2YI17>jZp?U_si1SqTr4@{a&vAjNksl18+fKcP`)1$*S&PKaIGvxyD}U*S@b|yqtMS&C zZ}7JBz~h@8CwExiAw@NzMMpa6cx~CmT<{8DSVc#X8I@j|cpHT$G_*VEBL6b7il^kk zfjm7vVW}NY%lWI_{*-})i(O^khCJvZ7h0TFI`=|;L_{D@MlU+}AXema7jrgOO z_e^u$66P6BCO*s>daSwRGoK$&`ry;%z*H{kfv;(QsMsi}!a#LVJ zr_GWteZ=!45$odnlw>2K?L29R>04}{i=07OY!w-&6A8(G1BxW%+zd>d#>9C{V4tuD zhU-ti#?4QC1Rww6--egJ{>yNB_2bwc{36VUk1^d4VRpqgCR(u;3Ed>Q8O*{6m%i{- zcXa%98AjxiB;w9!zpao>xxYAZiXa&=#p3+rad+UB8Pbe~#V^x%bb-HrIsD_IoC4@r zx2!ftTEAVUkxwKyMth{jP-D*akPCkakOpXPKb=XE7mDmI`AEl|Tclu+{tdeV-RxolY3r3BT`u`hNVLANl>b_vFCUTPG$auCCJ&XTaGa zz5Zlz@WZx2hcpcHtS?ux*vzY1f(2BHifejRXJ#Ou{nNn?I z10Xt64a8CMwvmR~uYaZgg~M)7bUD0`rHfxjYdB<9z274T4`fYpOuX2dh6_|Fi?)wR z$Dc`7RKI|=;Hi98K8nE2ya4BW0}o#VKJ+sammN4=L-zhMR$c)04J<>LETXZSylQ-} z{gYI+Wwuq6TLt$(yfsG6L0Zfxf!tj*A$MipTY=l>hcztAj<$TZ&p5CEFOYn(bE3U$ z%d1?*MUVav~ zonbaH#*Q&Afb9`=$JV;+wFCz1(ypn;X3@`-hqHmDng%tG9kGkJ@Az5KOgUe2HG7rA zvdx3lCYyt`PN%u;nm(UXc4N&^KLM5`*7QVQT$5UssrKbtIkd`I$UePA7HZweHNM%p z&RCV;LT995Esu#KFM8tv9m^bQZmCBhd$0%~WkBnD8K7(^Yfm-5JO3+rcEnO|*P1Pz zqjP_>Z8xt2Up9bu6A?$L_on&0nH_Vh$avwWUkCiPL25P35-Qv=4yKg#Lj+*o7 z@T>{ZjVU&f0x`p80%R&@I^ep=O=aAaPbxl_m#8J27%~_;U|MQ-SodsU!9T|&6xQJM z&SK1XEXP?)eo`q4Mn;TPBvzl-vWeDRnJ@$k*8@>gtmfK4UF+Z)g-Un;KCFzd1&bghO3?raJYY3Qv=fk+XLs(LWz*TBq-<%D_Ucy6hWG+gvdT`eAVjbQy0eik(;Qcc_q z06yT;Fn3^{udtn-#It|!cjNDW`M2Sn)9@BE-0VBf9Qm3D@bS?(xWJi-v>5 z!YQV-j{(gs(?G^n#t~_QW2fO1c&LKvG}U@hYWJ#B#6Z zI+Sfdsl2u!(tmTjHb&I4Gr%V!794vT`q8w@*tbkEjs*$n8G?!R-^v-l(<@zzHFp&4 zm*~*^jZMot=>T`c0!#`Z{&EvzY+?vlp3drUY&LO?9piF=KYhmhv@5*y7ymXs^0}Xf zSO3`e;Cz3>xPBYv(5%UlkxSh`NX*uF4e)e^RGU<=8HvQu zQ_1+#4Ai4!&a`9eM4Vw)Se~d`QqXhm!Z<8=vqA7sotjCMQPFgkoU`>%njzUF9gb*n zJm-^+E$Ri3#}2bi(0u25CK{WweFx=kyXJ=JJT)4ryYu!mrMCJ6=8lNqcf;ky9os$N z8-M$6!vFrC|99}>%b&n$yTZ0T#$@CsZ8kVRLkoeL9cJ}-;yFW4;BF1+Ij0sp z61He3SS)J3qbw(_Yzal(TFz^;i`h)ozG%2%{98Q9NX*i%)Gfpzp9yC~Ohc_Ns-@CP zX!M4r*Qx^u2Zxx30)#DFe?HnSoTTJWA{g$kKKUwM1^&VSe(5rGZ^qA?*)hjYSf0QQ z#(1%@Q{%Yytlhe{J}tpt9IYKH)$S4n8>92qW(`M9mA||RxL7EZ;aSpymKnmtlyujC z#W&qKRZQbevQYRIaCJTgBmkQY%*zddB@Wc*U05u}c8*kQ1`XQLwm|Du3I?m4iWQoJ zpuDSl&u6*YxB%G(%)z$XG^V^gO2Hq3I$@xF;AL_NxCo|9-B1av)R}5^8C##je*f^$ z@p(R@$(uP}vzib&xrW=r?ibWhL!|bhgR$6xGvDA3FQXPU%y(8tCG2UK z5#~NVZ{MkuYr$A1o>GWFzAVPOWoIq)eIO#vG|OVnvBYnpGX~+(5GTW0hdjy{43Q9&5`Mix=cA!V(U-aMbm&l`|Re?B! z+6q280g=X(C6Z_uF0?CrGDW{RiscZ`hyoT9$~ucSTJ$3vySesxYy*7MqKfk|xR5u; zHe%6tf@91ZT)p=m@Xig-|2IE^kA1;!#?9aRZ*h9+oiM+Ld3hX-(ut#!smXKASyRGH z$Tb_@QN2>-O0u0p$$YEcJ&0U~`tFgaoHr%QF{imry2M6nuxXxxD?ur1rH}O>XL(=0 zT{H@y?b!7}G^w;i<5_FZ`itUcEdZLRJBp5jf<6qYcxYZR(%Ce{$+}^ZM zE~uPPdmD<7oVYiL?qh)EiaDkk$A?a0m*8+Z&{Ejc>9pxQ@X^pw(Qh$^bR`Ad9Q0b* zRH7YgHO@EyP|htvHRRagno%I~9RQbkgX{A(Yy*Dx-~2B8;9vag z;Cx0n=r+fBi^#bXopU3c@MCz@duur7NC~f^q6vm|2VFcjmU(Y8unZ^ZM$V<8*P@f? zTi-|F*Oq5JoqnmOkTJ4}eDP}nPWmq>`*?kgZWfOvjV8G*?A1jOs!#r`4Yz(WtLYx& zabb{+#&+nGTO5TdanNkmY-jgKV}0S7iD!Ox4=3!EX_Jg{y^9DsR=F`AWg|w7sly{; z?vv^ry@!1VI#&{x<3JA$PmF|u3n^E_3ci;l}1+d-l=(!ub{TDsJcYWJ$!9Vl9e+e%?dgz{lSCN_vJ*%E*V>6&11hw2&Lq}WCRy#Q`bO32;qeJ*?I9=z$Ys16MhiwXr z?$gU}B{SK!189d?b&oHdXLr#gzj1RxGKT&7!UN#uKj-+cZd#ge@akLQ+xmTDh7jt8 z-!U2O!vN0XqBwBsH9Y6_Zc`kE(m^-d@oqiQgEF#{z|v-)cm{v=Rp8wN_^o%DJa4Mc zo7pkfCw(An?GHQf8URDjs6@|=Ru*I|US=^|iq;b8R&>v3CJGw2(HwQCzqUrkp}ilB z9!4H_k8cgibI}CT=0zF0P*hQHx2GM@+;c`l(gaI7Ssa*N1+(21K_dot^6X6f^TII&HoPN)EUd5wl0?X*@MHzS8`{iH)hn!?6}$Y+<9L4ljC9?u<)6ItB0`AIOm$hujeEUXGCN(kld@T9lsswWY$5%uDx27@nqpqjX%Xd@ zav&^g&_`FK9R~-<3Bj6l?ofSOlt^=L_4TwAk88986n8~E(R5rt)h%=s+pE5Lcu(Mq zHT^>FL35DIg3;g){WqEpjO~`x1I|91-T^8FJ7=w&Y#fM*C+Vz?@nxED7R#cp%+V&l zS_#m^XYe4WogR6}`7St7j;-){8{m21&LB<1ZbwB;Z5YmCUfsq(;>5(G!w?%$6)>I@ zl{hqR0+MD5r|p!Y)YX|P?ZKCIfJMOU^y;V0yV`59S+ehsaDCqJ>h=P@^>2JLe)vcK zIzIg~pM+gM#!<7}c4x5?U%HLIU&D=`|X*MW#Wt1#wnn73T z!X=GJnXhS)@T_Ct>6 zKjhd>z&K6em)S%HYqe5yyymds7M18nZc>%qHbzFtaSY38x4sfgBGY7>WK(O+xv=TrqtQUo&TL|pGS2smvfF`q zK{(}Z0KXaVRKky+yTL#E%RUX?^3`94x7~jyUVr>D;P(N$L|UuOs{4qH6cn%~e8932 zUAOoBHhyI%(oo`OM&!TGC^wK&ozk=XQO(ZlwpLEEWL*8^_p+-bBXTAwJ+yp9u8pZ9 z*v6E!F5wOXd>Z9`_>~Ex)qklM+C;l>K$;8LOFpa!LcY*tcn^?i^g;R>R{alBCY{Y_ zdL-`0x;opZ9p)j^l_f*{EOjRv1E4@Kg@;d2SfM$FvTgnB z!hixLpK4s?;+|6PcMfrBp?^193p46{J6!PNPp#Ejk2rjSA1;eP*ovKWy$^;Nq6EuC(Y%5r7s* zc7TcZ`))|}e0-|GKV_hV709RrTgK^`+RfdTp0-@hot8${+SE{ubX;%{)VkiQZG_?H z)2dKE+syk~?A_K5)q<3wfYLbbK+gZHkJkVf(y>E>-F#~Xq9~A@uzZem*X6|AG0tZU zJj4fo(^ukWzxPk#bbSw-1N***abR^)Yb>qfGYr@^*x0H7b{!y7#su-~Km~{-92!rB zW)(`!v}QEEYmh_C69{Gq)H7c1vyGZzJb;~AkQsyV**tKZLLRv%d|0`6vD%-uH{2 zz&yW>aoTZp<+vV(E30~QrvaQs{Eib_Z~tp#57mup!BngxWru&|@F|+(cRPMJfQxUA zwFhR0PVfZ_)ouy9AsP%@XX)G8zYb?3iCc$UX#DjOIck{^t9KYFZnoZ&OwJ#AzbOc_ zwm~Z8UlOy=2fr^k&N%{rv6_5JEPAzGc!0yqX#jWMOpIRv2@^+<{WBnqGc{*C#e6@S%gLW z&mp(oq;ZR*#jh_zKyFPQl#`-Bc4L1ALTi=#CZM`FFtuI17@6j--$J>jpc3Td2Z`@(C zRCVQ^t`IiD(9HP^x>s-3#uML5kJV-CgbAeXErZPTpK7aMc!P2BoAuwEIW${v{j4qe z;cvll_uK-_ZE~ymq8>MtclXsX@X>hU<8OAK6o5}T=GM>LUk2=vYiraAM;x5WgGo_{AIsr{L~Fu?qrphJd92!sMfb-w9~@2*`Ao*QH-YbOX({s z&BfF5y26Iu19~J?-@yz|J|hO(qFot&=sWv9%1|8MS*40E-)}E0 z6cv^}GtZoT#m2QUwej~>9eSR-3^DCFchR0}I@v;-F4`OBq?zzI#BO~bSBna4siLLF zh>}u}w|A1(HYyUc5fd9Ffu#Y(U96(8PFa1Yj5TsrlZR1O5kb=L=Tert$vA#$u>tqA zs)(bS2+Nu`q8H)TG@pFFOr@1aId&>u>m&9~@9b6$He;hEm~^hkw1ddGn4+PN_c-a&T}HN?UP#BCA_!1XAm(5i3h8Pl ztTt+VG_dJV<4JgYU}Q92%mw5)!${Z%NA8MDWiZ0Q5fKT*5NXT-pOz<{@_AFlt|Od|jIs+JGK^ut4({B?tT`lVbB@BG zEyJ?Bg1pCZ25nSim4&16lup;pv7IKyHen~Ww*&9KhnuJG;rT!L=kc-6`Sp1CCx0hS z_wNDM@5Frk8m4ik99lRuE7BIGu^3a662X>69l6vNLcN%J^0q;{q@`NQVck1;ZQIB5 z-Lm8DAV)%*QYSc|wZO82E_g>DcBpz^9*`1QWK6qVH0P3H&B$3~p5Dnr79uh)7wD)PCdR1R zb2cJPeLGd!`p9eSi5$?PRw7bOn;1Mnv}UMEj^r#2m(yu5YD>0B_BB#353+zSFfh81 zGL83$^KMA!nxoMa8oWTo8;8Exw&BwaAAA4At1lYP*F*LIBX*)rg)0i5&71J)5~{+t zqiVOh!_7N|in2%25_0S!?9^w9CPd+>B4-H$2N&;he@}AF(v&2>aUKD!)f5q)_gGI? zWD0H`hhbIgv3hp`fu{q`W3Sy~1KQiQnbG|43?pj~KmOzm{>#t(75I(6>hp1P zc?D6>`3!OdvjZe6ni81kHh*M}z-YhE1;CQyJ=DC~qTKHarks4W)~LCm6R`T?`cK(a z4#BtBLGEkM+)QZ@N0WBYO=Zi-u&|~po1MT0I}cTvmEw_Z8}%B3vO~ONl-j3A2fg@g z7rEiGVw68A4Yda6j&sfl@u2_;g32k$NILZP%)nB6U3YceE}T+}HXLZqnk`27!nAe+ z@bYlWh`Ia4sBhxWo82+z{jY7OPr&UJ>%jy~sU4^gL4?-H5s)IMd#MCY7z$Q9{boGA z0SlwYi&jP#;czKN`C1Ix+A6~Z6?ZG4n{dpDwlC96==2!YD7qACfBT!wx?3<{hx`3G zXs4>}@Hug2iv+#X`|<`K3bpFDUJX&vqZP8@gZj9;*`7?9)yx?-6xk+ZBd38`aFnw( z6-tZ#sn24nC4QKeRSQDxpj+FLLcrRX;7sd?F15lJ%|f6BQ&fMgy>gIKDc3Go7{}?*JHR6>H>E87~X2 ziig)vqe2=Q?P~ekiO@1CGE8D^YPK`G780gGlu^9<4!eE_#=}qIBcJ_+_{jJCK|FmL zxE^sJ#0icQBj*y=Tzn0KjbXO+#Y-ZP;qGHF1qEeDSbKI60haZ}y!Hdw9_MF+e9bds zl@+1IjS5Q~PG5F>lNF1utdXW8oI(siNJrI#S7cuH<%nl#Nbo=c0Cn0ZAZOy1PB2a1 zOi@f*aATvjW3E$4XT3{jBgbOS$cXIQ;+-)@E%uxIr1R1?#9t;L7+m6jAwyTNrXWql3x#PL- z{2qMr3qA+-V}A+biOyC|c?u0HPSo!8Ey30Vr5Y$sTpI0Baa}f; z9h!|4eYIsM#-PBk-b8Tu#l#aoWs&JOh zs~Boej^p?NN$G@t{9Gm_MV#8G#YIK@lddyT&WQD~;F^>GEU{=%ZA%LF_QJYw$%sz1 zW$S9=Gs3V46#|pQBp^%tEAaRC!wDc#UoRBLEYZoN!nBDG$0w+Bm9-7h}badw#MO4 z_TOv+Doj+V2a&~raM&ef?_H*l&|K4Xh`4Ev%ho1SxcU1Sk6TjbAh$ZJAnl&zBm>s22)6#LV<0l-LrWJvw z{>Kbk37+-q_6h6;yA0qaaC+HyJbrk=mwn}bhX3T>`j7G2<7Y9(rc}nFu5yt(*PpW- zVm0I}2rPnVYmC`Tx?ou@F9fV7I1RqwyPSUEl#_VMZu^3id}B)=eBcmem&5YZEwq&m z`xMsaW8o;~gnGkDj!8~A)H+ziWVG+PbFX#Q^hVK3!_!@|1?fcN0U66(&Sm1OBkUj{ z?AY*9d3L#e0H8{7RY!gGa@VKxhH-gnFudZvKNmMXbKd#to9y#ucg!uHeczvT%$F&~ zU7-)AT^dDP83{gxlf3)4ZO^Vdv@EBDQCmgQ4mWv~)lg>@3i0AN1_=QCW9qBliwBUx zEcn6`4kH(PXJ50UVWZXKT?{A%UjS$pL7;O&Oz`zqO}s*W zw6^<1#}vVxt)DhBjh~T+sqL7zpPM$G_!xMz&+I@CjqI#^flcm;>dzNE%}whIH(B;bs6jr4(&0C3X_Y)5BRr z8RG~?*vR8)ZOht5Jl&P_FlpS!yW3`99XF+GPN)tMRe(<`12K2_X=KMU&0Vy6)^YRV zVT%diDaa*UqMhCABsg~{f{}8&N65t7C$bZcF)W;!vm#7V2gG69Nq35rL!}gx#3}*; za-2>s@`uN~*!m2HVVshS&7-!>m{HSaPS`un*goToSAX=U@bTaLrFiWdz8Kpp9|Ioz zBH-Z-d|tpf56*Y#!lu`pF^dN#=BK4XI@io$I0zRDD<;%G;$7=-{gUE#bD_ zR4!P(T^reSJ#U1SExM#rF^>nV(R-KuHJ~nIWfdEw7fQcVPA6Q*4H@4M`CW4zleL$V zhucIz5z?tn<6YvmRJ;NXKzwv(ENL9l0Tn}&D6p<~C^M}6rqC&kBC!LuN2Nw;z~M>b z1jJk2x!9lZzz-wgT8v?P3V?0v^T;tfF_&&X)vl!+s%BzSh5CW?QnW@!X6%qgB-GnV zyPA<9Jzp;l;q!^Bx8o;Y{oDAWANXoK|N4t~*Dtz{{btAM1Up?%Z0Cv7HgUDZX{}cV zT&2T~5p$c-QP0gW%Nle+mvq`Gbg9u4=Oo08w()Xvr1Wjbokrd{#M($K2NGbdJ{(f- z(H2Y!F-D@90DdGs=44 z5_q&&AU`;|>HVv{=O#UnItw_T3=dxcKK9c)ZXN^M74@I?u%lILn^{SBZf=UQ_v)6m zS@9&2jzQfevaI^GjZQr64As4Lf~;Du8NJ*~%4$*Ec|}anY&!Mfp5v@FNk#vniIFCR z)8w1U_q;!4&zNL_Mw)%G&UD!x(0uwtobj+DBIhu$zdT|09AEqGzY+iDKmRN6+M`e6 zyxmVck(x?Qnq;I=FbU+!oB`mK+FEN7l2zv0E_!&?GiBmXcGa`X+M0MiXn3=!K3Djf z4p+~#lM;S0XqCos9?4F-pgO8nv}P@OB}s6j=NSD*+A-lNf74Dns^4s!W?AQn97&H9 z5tf+EAeu9dmGJ7x?8nQP;hI!JgJ9EnX*Hgv9=lrsqIu#0;(^5?@FC{$*iCu`6VKsO zAALUMn2QfXY(8$lOP*c?>iV$xtduU9mSMfwh#UsuCKf8qT~iWsJRLof4Gn-z^RUjO z``DM>F_%Jtu1mtond7t?*m!aZl}Ut0m-8;QS~;gA8r>yyp~r4ZK586}z3Z?pQ0?#@ z9V5`1QG&4x2X)c$vEb&7Kc!Z?c+i3??fGu{c&3N4S_7If(6COqN>r6G5tG<*C8gbU;xMRNTn)7dovCRKSY{ z>MSF8XG63ij{3M;sS2iz#uF1X*olm=Aqodm4!$>LH;vWWJC#wme!lzM*g~hhg}bb9|c^LWhuyZKNu& zj36Niy6A)b6J+WhWvPuc+6JPCu(x@!CJy0>pcpWWlWEa3bN8I5(K--?rE(06vcqPu z6L1NHL>W>k*|%Sd=~&`QiVr>y}77Wl6S zx^mdXd*0yUGtS@WGNHyb4%d!ZN0$2F4bSUiTZ6y5%*tNcLO}22&(Y$Nmz8j$Q>RHb zXBus(a@HkZ_j$9zkR+_-Z&)lji@4fVw z=W<|BIxxs84xVCC<1al+v;*a+i)+n!*W^6)z-aS1G>@o5DHhL7qi>&x9il0^T_eL> z<1vdU!H5)O8t(xv4!z5qBQKFBtghBGtXJJ|M!K^4$2Q~wl8gitO^U<2YQw9Y7F6RC zIA0rHdC~FA`*%zSwzFfpNq-}I>4&b#}3$KU_2VwVAx;0;BB9AAK&piza0PKFaFo?^5d6qwLQo#y3B8oCBt(? zSy5r>Kx7sW(vDCHWwV2mZ)+y{?Xr)^$67mZV-p6hTjTzOWpO>(G)c)zwYoN!y4r+0 zopVyd(#4Bwx8Wn-p({XoC}>bRfeq%^CKz#E*A`sl%+gNLW<#P;7@ywJ3OP%wS&m$S zVtKygdfU`&&)cLlaKIQE((DNw@F_&DNS33IFX4_)K9eZ7iI?U!pN}hl>#i5xbe~T- z=He4}D^AbD@ge|NQe>mc1C4q8<06cv&MohTcUlD5Q3gof(z*{WRz+h_?xJgl2G)dE zgEQUuUY(#g1%kjO+**(8r@wF=7 z=l)cKrF9nQZa?4morQ>cBYl(HHfbo4LFc-}nK;T&&N;`>>+{r(k6^DwM8|<7d+uy? zV#Yd4>wxZvcmN&3HIAc9o_X*D6|La&QakZ}ryd$skRyTQ%teqq)JMn_eX{Ok)h?Pz zqbyV*$6H~LO1h8yNRwE8)qLD_w_}fn{?guISFPsU4vXE+G6ma;(yG&RcJx zx#=2v=uJ7NT0!!zA{ANYXcI4by|0#UsAO1Ex_6weV z_XeLATwMdFYv6nW&ch>}HJx)?i<+aOg_Q&7AYS%IO7t%pdJxWrc|H-2zQiFnnHoO2 z?}oUoahq_7rlb3B*cx4BmNnrJ`d}OJY&V657{L~{4|t-i`sP>5V~jz^8n4kk8YAkb3^u_Wo4nZDNR-&mGe9OWOXtp5m?+W)N12m z{WOzj*<7{bL&eYpgTwRs!PD1W8*wuu=Xfs;gc!g+V4GooVaGrF%ifFc_{J~8``+=X?7BE#=)n@|$s2t(S|R4tE&HSTfiF)MrV}_`^B#Fe>F&@5 zSzG&r%+4{oNxXMG-PhaoBAKuS@))$H^aFlt&>UkpTC?%?5NyKDF<*M{;JFuoe}4e~ zo;H#lg0#V?2oAK~C9P3m72O?>)bi7aXBq2VIrn#x(rED2B|4o< zZCjgR_HRv9t*|s@ztDffZPI9=;qEzHqC&}|?orFj*$2`Psy2$AOc&w+OG6t)DVnAf zI~=tW1<_h}nDCiss<%t$WA#()nn|!eTSW&z&JU6_G`Zi zfA5RF7WUB>aR0#-ZuW_N8*z9hCd}i6UEd6z(Q;$U+CT#~wzQ!~2FRr`*4QPWqcP5L zFg$@8qJYgGX8yj>W7TIV#TIR5hPs&~!7Ka-&Be7tPYa>HS6uCFr!qF*giX6fR zz20^8*w?1@i@KfJ(i0AOTf-wv8?eu#Q&qR)u}QwmDK ztQ~05S(AOB&T&yF^u{7*){mTBP@~c@0F**V4PEqi7qN>PSDk5Wp75eMT~aJAEBk{? zqrS5~sy6O~y+=Sp3#tZNcM4LbwB2+kaD;&{N*J{HNL^g`XmC2UU#^zfzEe*0u{JvI zdO~=xg15hClAw~OWth}+<=l)IKSkh>*f{46#)__#TaLy@{+)tLU2*&ZedImTNUiXP z=8@saUDxJ3x=EjDjE!zMXQGFu%LA0ErI^n;;2uMCkvo%O9TU?ZyP4to`fd2*@BbtC z?SJ%pf%A^Hz3U3NxLscxuC8HM*TB_@b>h08YZZakqqf%PQOOpK zu0(2R@6?jL}3v!tCf2KZ{Ye*pZp0&lBHNEbK z?<%L(9bU%Ufe)qPA}x+sQ)oY$s@RMF^QHS{jIS6`h+PU+G!YD0{8OS-)!BL9?t?ayx=sbeMQ! z3%9y#SLlQiR;By83@6<{vX!9oY3-=p@cEJ+>OmB=RQw`A>Y} zufGDkZ2*7hQ;s=&$}yKJ5?q$}ZultNABUWAM(;Y!Y!&LJY+W26F2{`?5FOWUtry#` z-g>XMOv@3zA(n0%6avJ0lw7S;0BsATO5m+n#SWm^;u25`CziN1LQ*OV(C^OOw?$;t zdi3==cYI>d<)mByXgD@N=^JnODVTrm=T=bSKWzoFv~yS1j(EDP(;B3ySq*>4JUUjhmfG5-DQI}cw3Tm251WGIE8Mv2%*Mw zxN#@ZndYV!$X!rCz(6~vZ}AI4Iaumyi2~7tFki3x%?-BmHLk9n#0%f^E%-a1`z3ho zr=Gz%(^_{p&c4IuPW2uC8xb+Jo#J2YerL49DUEb4Ab9A&sHm)1Xt*LHV$GWiuECKP zrBh1qBv2sR=KDDx^MEW!9MLiUitX5 zc=nsV9nb!TUyGZ+`@`6td=Csyz#l!roCEHs0B&KT+8k;+&)aQ1ReH6_LER6;Stpv# zACe7yZ#{IKdzXv6*V*%+bMlapf~MNzGw$nA2`=I>A-uZGcg5h8bE_@});+qz5IMEE zAQ?;RKrNDcq+pXMiwNxZIo7e!NUc6daf;PJ@iBi*^Bl~O50KMvG2vBVbA~CF# zWGkUV3k-+W7F#CirqcYZ`f>yF+%WQO5{G_MWA zaFdBBF_xPb{WQ^m9>baez%5IFB$6c4FcHsemQjCtw|q5P42#4p&96QqtWno793N6m z=S-&fHkT@R+A7~4ZMx#wvI(SDC54(3gE(t&Q!gL03PfMjt5y)W2I3BLY{T%}hjx7O z*@^R&#lb|*&83QJ>Ij&_%BPW@Q$;O}j??_&HKDW%xFHZu#=bf4n$U1m#3G{N37RzX z+;D4ymK+LX8&8YvAQ8t)TPRy3Yza!gn!jYrCHhiAJmsCno=3(?zj*^AzNd38Y*|Lm z+0BMAH~0WCM%)E4{Q# zVXi5P23Wh)8^IReS|b2UfmDQS9T67Vv<1|#kM>1+$V*2wbF=9Y3hy@G?l5zsE`k?) zf}(8s8o2a=7ms!;z#F}wo~MMj1CD7I7M5Fo`Ro)Cl5ld&-quWP-#l%L4nqQzb0Vpu z`Ro!5=(Z3T7D1vKBvc?3_#?P|G$8!I64U%<{+#}o2H=0;Pba_l%<*B^deDkfH#jtBg&qecwiC$s*~R)NnOs0#kyv>Ls}sj%t9n z*w>dQmhbYZm^EQ339NvT*8CfFa2R2^SPw~6*|upMY`ElFO27p0xWi-&0b@Fs7yPw5 zn#!bQe~hu6aK3scUi$;zkN@e}7x7Ph#h2pk|J#2K zk6(X`8wbt?j5%>*xm#&t*~K?FFbuvse1~DQ`X1ALEH&05!pm|200Vr_In3uw$Cbqp zd?)fO4jgE#HAWbnZA3ML$!qE_5nj=JhTXgtx?GG6^a3RZ+P3AICwyG+0j_ixItJr( z)@1fv*qfVbx0%vQ5v#g%n%N9-u7e*KIGd!~gT}Zpc0{z=0F)-&-4gAdnf+7PMt*FB^5aZsqiLsRdX&1-#z_ESCecZgV;}bvlKj6jh{a)bj z{xOX66R;=#3HalOz`Ve)!LbF|bDRtiZeu2!TcW4&P?NWfg>{<}>Mq$v1VhhAGIZgc zl-O~2Y(@RGEA{;Pz#^&JBJ^Np92#ErNy&Lemo+25$;}jl&^F03EEA9U@~%lQgfQ9x zY})u9JgK!?@sc-p;Cm6tE&9L@7+w%{oG-hD&+anp?kV1tUJx?8!AQEPwgFf4WsJ{C zRXU5T1@1;`OMmtie#$2Kxv> z)Ra@$79$&~8ct0q_tuvmbHBkDXV~eC@Bh*7#?=p<@%g{ zwj8TT)YiC`F%`*EKiql-)i(ein_=#TkN@n&PFE*9^{#=N$23`NDds3v0%^1yQI!{j zvVBq41h()-Tz43azGsWtt?8WW2+XmS=<+tGnzNekl0%&lNfR>PjCK%;K^xulY{)*O z@M5Cou-kp$bFM?M0_mwcx0Lj>NvGv*V)FN8$9#0b=YRG89Y6iC_v82c;qSwP2k*w^ za)HmNWn133nF0xj*n-+L3$mJ^?OAJ`i3(-JZJFMLqqmD1Q=`x0_;aFU%#vYO9ZV9AJnaz4Q!cKXJne?#p6$(+eD1$$=z*CNi8vul5gifcJL0 zk(9XPk-y?m+IW_>0~>06u0(a5s3wo6hHS7G`-Pqb70@6WngR>tzJ2QF|%y(z71CM+T*PgGPom=2r{1KDU*AZ77f4e>0%e zY9fFNRgXz)wr4?ci(Bv=5ys+16MvRoReHSQBN3#4*gQwI`%|*jh z=ZV7vb)H&w5&4L@YG;K)9(rJy!F|d(R?`x6Z3sh~wn1r{m74g2U^Ta98v}A{S~L3^OALXd_uM6=8VX@Xb;*H8N=c^08>T^pNSn`Mv?ghwlUzliVx(P zJ7nkF9s9*GPC55-U`OP}+>xo80CwWkeB>4*XCj4J}nBcD_|uhPr_ugoi>>Az-JKnfM{{u3X-C%*R&;k6(59*oyN3VZ6)fSWVs!^cSs#2opy z376H~&^L_Ng;(PRu|aP||Ml8r>T=g=xh|fj{x&(Xq{IhS`65w9Ua@kMSI~L`S9;SV zZW7I2^O-}Hc%h>>+oE1*wtyT=*)C;}dpa2UJw6~BDy1{jAM|XDXTp7}g-$q-A_~SK zd~rU)QBG&A%!`tWP0yqPsd<87&Y8t6*LgMgN*QXuDYe!oUyiSo!!59F0mGy#JoRXg zBB@sjKYW@K6l-b;w1kCvoCq+AAHaqi_OJ`+IPebLfZ4>HWqBF^3|}%hx)$SpM~8jD zo1=YoPOSVC{RPgrnU(!|QDO>&Xld?#HO{c@ZT7qV*6+ggxWecC%Kr$%Ctm%;Zr9f* zT+-v|7W(C8I!5XR%MjvG=7}}_yhQ_JkVjo|@#yH~o{O7h{Anq5Lqy6|9}&W_TSUVF zuEPO_?l;>`js-6s0#Mc%oqJR8mzbbVO-yD)d3Qclgm=M9y9!BUwP_K*N8<@Iz_!#| zJjp!usFZHUmjQITJNuU-A^;fRhEUQ%pO7N5(9@?4^8$b7{kv`V4ENp&+&s*;XxBH{ zMi@M!$uVNzihiO&`v|L3jBEdNU>Y}Y9MCE3GaVK~n^&H;dCFdrh2(PlCC;IHd7pZr z4ZiD{MSfEhj~3aUfW}2SNZUFU{j`SS(vWJb`kTpE4;j7T+Fii6}^~$)R*OOw_tS8C{U)rc0W#{v` z+)8+eLMZ2;iZ9ZOG7ZDr>;?Gc!|~oziza(Be?FDUT7<9zfZ6`68D0njq%pgR ztX#%>Tj|J2RS$tGPK;|^e4yT`UuByD)jpL6YRQo5sYcNoUWaJaVrY|PQ_r}FXvP^0 z3ktw_#3w7rUs=B_p-C#3#DCE2i zZ;>9hzQYmb<6QOL$dn)1MM}FlZHm| zE)@~zT3A&Lw0-}hU*C*!6A-ndDf`cR$U3847oOrGNR)ePvF}925!Li#HYi4 z^snL{{mTCY&;0H`gm>NmPd~Va$2S*jK5=r7+H)2MM6iC&Hu6w{Q`Cza!?5Ln02mJ2 zjBK50FBUc8EEiBM{gGqf!a$;=vbkDRnybbdQ-ta?$3{*-l7NAS(W(Bse4S|&S?&gzIkMItof1)C z-10DvlryYdM?_?eIZym!i|5BFVKC41V{7%{vQ74708SpO)y&%(n_+B@v3aC5pK?)f zxnO%Rv3=G9%zG0r{Lvr6hyTmZ#%sU#w_=;Gz@GX{;E`e8JYMxB$hk9-*aVT}MoIAU zA*IyQA}H>YS4+mw>5b*nXIL_1(LMDq=AwwL@~(QM1rW8mGQTP(zHEiob}9O76P+l# z7|}SENVl$6j4-w4C^L8;cEn6JUQ8n=B*kQtIgI3FJtE3QkcXBrq83{XIR!_Pe+wRn ziUy+=0js`=TV?Psa^JmLV0v&}&Uc7swpq4}(bCf*Giiv1Kmn3DC4sYLP0aA0#yjh&wnl(&M@z1sai&}IoC7<+- z`VF{JQ%&^CXX2W~R->JG=V0sP-;*z4wGTBT2BkU8-0Y!7z4qadRGB+zOkJ@0pzRp?M zyGNW6h$V{#MO&&lr>I^mHo5q=A;nS7`LOqjC&STChzzz5;BgcQzPvo~*7uz8&A;RG z@W1-3e+Ca9J%`h2z{U;CCSW^UM_J40Zl5L-h;u%YcC#bk(hd{#CE!PrK676 zGr?=?je~%S3%1-mP6rz&J(2s37ZEQ1xVHo%-1^ii#8p%7Fy}Q16FxqPZGQZXT6?p8 z-t3M!pg3&;z~y4kIs7HsW>{9(XoNh=t8NSzrRTh)q*7}P^*a}EJfav#;o>gCkA`nI zepkg?0xQ3k6CocOtxbjc#oETTOCST*n{cqktKD*RuyAFtXvNT>4?C5GB3OG41w|~C zse9IVsOK*Kx)u}Xt;GbRZ66(UD-Iq>{ac-arTnWHOc{H`&oUy{1mtf>A!$xQ z6{;pR=X~c#YRA(?18;{#4ezt9TuEpSsi>)J;6Rq94tbxuZ$`IP|Bu(^4C;BIPc7!V zJdZqK88tA|AW4%{iS!(0N3|YzK}V=zw%r0^haO7d*1Q{E)Mu~ocA5)eaALu%};ZBjdbF~Ux#Xs#b5J* zNVA|pp6}VvLcx8&ZG^)wMWt#MQeK#I!E@XG$~X+w=9Ya=Z7Jq z@yZlYLlm#C-U=9IH-1lkV3Ez5UZ$q!R(3 zbNckXbcYzDaHLw8Z4seHxgceuyiI4a6)w^_WD!}Y-;FI-jl%`kkVhaq%nM02ySs1a zc!OcZLGgn6ZEWo*94J;nG-ZoC)5m7MpD{&E=els++V!d8;OIP(a$FJO(wNjEE&h2~ z^yJmq@R@Ix^RwyBd_r{}<(x~$sZ@$JMAv)~zFg61e90hX_*svbELCPnx1Rk~9XtaM za9BhzLf1r{!jVpbio%mzMmbJd$F5THNWXc)EQMggH>^4|%~#Q5LfznMP6%P$WGloc z9gJh>a0VB=5HArQIZ~VRg7bF5X}iWZ{pD}R@BEX09B+BsJv?~pz}S(eweC2d9p~Y= z+7QmUtXsNmj?MDBnQG1@_q7^oo(Cjk9kv8KoN$dk+mN=wy@iUn9K(ej;*PqU_~a?q zL_3$CrSm!ZZXXh}wm1RHF_e8#26)O@^~L@hQRe*ADTg_02@|aY(cp|WBZ?X7*vKR> zIWYP5mO7L)*`uXa$du;MuUYz)+{>69U>%RUA z@#OV=++1D@IL8f!T@X>cxz_a=wozMS3B6X)$)#HuaVzP)Vm7^yvt_?5w)(O*iuQOq zE}wPEaF1wxT_a?AxmR}PXXmoHWT>|%yzI0kHPlNMEE_}4ky03lAex_ydg?Za(R|+b zs6$zy{cFzThEk#(%L{Fm!@I`+8`S=U$-aC49PB9x5o&a;?TS7{8DvdT24 z0q4TN4tX~BPtIx2#*JV4se>Q#^C`z%d`Q6q*q$41p9H;Qke|B=)YZVLi{1#6EKgRS zN&nfFH76Zc=M?G$sr?RPECmo~Iso8~Mlx~jDDhKTRl8yxW|Z;Q9YtjjV|jM@YQ=hF zbUAJ$IaXE|!i6j1jk003{+lr)tQ>{)VYti3Zr`=#&w7IfQh)U50eGW+990kFj@G%r zDaTJ>&dT;!r~c>dwpjw+>9IXQQL5jKa{gzHD}h;hy-f%*L$g0BIv9&>b4QR#w+<`? zvTp&s4)FjycJ5HztjKeWAkc&IuJed<&;F;C289;T zbGYg{Mc#r7@PUfNOPRtsVdtq+<+(tk7Y(WlzvkE^#d@{lj!174J@#FbJ}>z`=um_l zP<=e*q8^xY$MtrGZ6|#7U;H-woZqNw$d$2-{$cF)=iT0odGZLxUSI zA?6aC08VpDNGHu`Fe43w(OkMSLbxULNb{qEM$;JE*bNC_1GZsEzJRfjud*%4mgJ+` zx$OOY-+E{Dk6BOEQ}6nYWam#Z#@VlQ_P5r0-*?WMHLISgS+nMxorb8-MV77lA%k-S zG4>oYxck4A0*ei>i-1G+Wt_R4qd-3v`I#=s^~Hg^5HH3uVZc zEbp=IkuR*Re4@rU9iW1GMZfOxpLWzC%Ts;5zX3P_b^zvw9AEUCe;)peulhgX>gpjJ zCmhCv9c}>Ifbb8NCsO%$8Ek9v*c(fG43SH{SHZ~IbTG?pt9l$&Z(V#peQ_0N@-t<^ zvm`C2=n#II0UV?6jF@HrRR>V!w9NCd6V7&Ew-japu<*P}h=x?CNB z559o$)KA8=em#%^S{X*Qw}m)v-b;WhkPoQWnPxP3OK$RSHc0vd#gnLvhE#os9@&+_sY#!-%Tp)IsY6-L@Jj&DVGbc_Src7h%6VT{M{p}+k%@J-+SgZKr1 z_CLdGf9dDp#V7CMg%@9j9oB%*reiR;Ifi7AIkve1ZgZ+m`wC_ptR_SU;3vAU`?br8h;PsO}BVV)iWI3Q13B@=`BT1*)c^wpc2zX}ri2tH~hXui_ z%tI31CO;GeQ|4Q-SzhktvlJH;RpO*Nt9ZS#;Vw zq^-$!#ZIoac+$A~Xp}9YKj(&t1Av(c580YDhmk|v_*{L`x8k$JD)&u-3uVh&7E1D< zm)-mwtnCu+9FMrd319t>|2$4}!|(aRF9qOu=|dBj$AOc3EdRI2P+qz^Csy|H0JaU0 z6ywqM@VTY;h}$ZI96Vd}U-q`~`(oVmvP0TgJt$3Il$mx5yautts*aK@Z?Z|#KWTr) zUIxoIB>jpjate;nR{b%o{2UyDml_Z@%1V@%!Nr<}C|P14(GzcgHRR3_dbFQZ7^9^w z?Y64^Fa|#QfepvI6R-Kiv4TP;%3uL{jEl@{xXlJUPZVxbmy|SggaMd$?nR;m6;Nw><#fdI`Msghv;EM}axL zHmrPrYd3ozU{`=&rg|nQq*}wm%gGJCOT!Cc_)2(W<$xirYpt=bvVlsN4)7aIjvRN1lghGF5-0NfqvTO6qdLDTz+7e`_(((R zNN25_*SNC1YzDoN*M?Tw1CdyX~c z%fil7KuxMzQB)5u{f$k9V+4@{syW~h6|-@~;juSi`<{P}Z~KkE7eC{V{$9M{cm7s9 z{Hu*Vu9mzzjfaQVrs1 z$Q2B5^Ee?d+8<@FzKOOTEdyF`tV1D~QAQ4V)SL1XS!C|@9t?3R4a{n3tRt2g#Swz> zhsuR6*yYS`aVj~irjZXl1TwN*wAE^X20lc#)BU;|@(rQ4!vpGnqS z;q!U@{59nlmisW)b1a(-dzES>?B7Jz5Ak9x~G8s+iY;r3^Z> z-%U>fL$1)l3V5y)4q341Xb{pfa)=Y;Nzh5#nvs;i1uWpr0nc8fLk9OT$Sw}v+=!kX z-X4pe>(~mbR%_`u&8fra!bqMn)cgZjD-!4AJMw*w)q>65S>*?Fb1OB}Uh3kM`{!`mu0 z>M)g<%S3DN=?sJ1pcAR>zT%w*5tkuf^$gWF&}^h^@jFSPXV`dPOKuY9OrR0F_NqP) zq0g*;q&*w3qaW~*_f8y+j;EemlWud?glMYh;+c)ZGW=7EFLo6^lh#;L>y3=Cv!nRI zjJ(!)xvXz}otSd^di8+?PPX8b;2ixeqG{u!OTxoWCUWbaY+%VWx9YH@FWe3p&sp|W zm#gKMFTa36?y&)O6Ne{UI{aqB?j7+L{?Z@D5B$&%;G4hm>u~4dIZRxwNjj(FMC6(< zMt?zmBv;ax;`yw%08l`$zfGQ`e2R^#Fd1^JK_;IiDrh_9(e-5{Ur`({zJ^Sc#ZZi+ z?r@USL3>vLLnKXWX=f!n$aM4`lFxCKKkvuXAY+Q-@Cd#abY*c1Cuzre;zd%#CA7Qo z3T2kQfKIS*g2<6>8@U(eob!@lux}fa_O?0E)eJ8J^S$f$HyQBNJMO%CuUGq0R=@T0 zobLzhWjNww#N3h%l{x0={5LUA$C|?JDb?<7KIzykm&s!d#sVmZb7x(z6r%*LR1mqB zHA_?IS+Gn4WX5{wXm~iD4si#R)iTn(>gRF=@`3GlaVU1`zBJcp<})lM<}dMQ=hPt` zQa+P28Tz7=)13{woC~51kp0nqj0$Pl`d>@yu`5z$QLoD=Y8hcvTD~d#2#BR&?S%=doKxa6(VI$GAmyS8I**z>e(`s)rHDaq_UD`@+AlL zO;Sp~;Ct~3Hy|{5rxSH8)424J8tf>Yv~Gi)Jr~ar#@yhW0doM`34U{f!<|pWz{~i- zKli8bj^F!7@R7gw&vEhcHSXQL#I|j?+17p^o6nW?fEoLf$$tmL;Q))&bx1_0)QEeB zkf`;$bF*z9^sR#D{7wwCHT%8xbTc>)FbJpFjnA+C;66m0HOw-|AG27xNtrf`RdD z8|4SE)HWdTs7ZJdt)w*X9N^-Y31GDZ>e%zm1=m7VqvW;hSohu`W|2PrZ{H`*`i;-m zo$__|0ZpXOvYv^k$^yx1Pn;H7S&LpTgP6A3mjiyIyD_rBFnlsZPXq z{x;lG=0mzG8!uR3f%PmuF>S|H1MflV_sn#n{EU>IMRe}*7WL&GW+E+mt?avHYngz( z;KRZu$g?JU5=L8E`O-dphwV3&^mulU#)nwaN?hRB;V=el8~E^h94~#)aXi>M0K#Gv zvRqZv3A%0=X2WPVStr8-2%YumK>x9+`V0&T1 zxvWkYpJuYbLKH?>u#u9;7ZC;Ovqvk4uVl zjFd7D?6WMIU()Pb*QtKFJii~H28HxyLMsf&Em%oDkFC#kQ7>gMN_p;%DCLiOmI?^? z#CG!lcDRS*oyTzX&%Yl3`b+->-tfnMA3piF{uVs(Sw900P8(i$a1D2hLDR~<+H7DR z$J&>9){JoM>+YC_!9c~doONH;8ilkJxj0P0oP*Qa^c@HZAGc&JIi(*p{bY#cvh}`? za_sC7eLEb7>YC_J%ktK;7?cATn;!Y*u(1x+uT` zSK~n|yU=@o5?4lGXUK$k1onc*3|y8&NZt@*=UUo}2zt5!TMV4;0XI+Fg&hyRec*j~ z`5XU}1xn>h(NuV=TPMJ@JUgq(l9Z}UGe5FEtLNDs-YbEwo**OzU8acTE4xy( zurDxcU2P`v(lh^)Ezo~lcq(Nm&jQnXz%5A8^?cDfZWp1Ys^Mf9Zw;6|4qPFfBL`54 z-_cB;FpHF_)sC6GmF6T%k^RsOXZE>tY*DtpRa2S9EV>*;s?3#}8(PW0=>(=<;dmIh z_K83L?f(^C!VCCgzy06Cvu}PJ&%gTtj)x=6297reoHoN|+(H1@u$H-QKyCg$;qy@Z zqgUtB7KR8ot3E`U#C0l0c}P+`Hl&{{x|UHGVg%77>s1~%L2JSe`VTo?P`|A8TfNp? zVA?b$$4I}|dz1uER*Lsz^{E`1;--0FSC(+VjK+f+VP=x zPaF@1$DT0UT*t}@AI0l%1{O_T9&gOZEm)2A1CgAZ)5$a`cYRhY^i_wr zVo{w4iLDSx_KzH!+r}?Z?_LtXKB;bt-r6ZL$e6-}70^Vp8k+wc*IemDmJ0F|VamD;mp*-%yprEE>$ zL8paU%H(*5ZwO1^;h0mCQu1A#g31QEB^Dq`oNjC@hg%>xR$P$&t|3NurAY!y1zacx zLhPf1Hq2uBre|6q)!t(@u!k>QPFA7@pd?h?bP$MTCJ*jL=o~HyXA+QZzkFAQ)~i1% zZ#oFxW_8>b*nsM@-daG|kW`hlMhe%+A4~V6zUKLKo}u@AITS!**lMN& zxu=oA=M8+@aPh=*m^UxsC;r_38SnqPe}Yf@BflT_fAufHW1sXaUViZge%fHify2`1 z^?qirB|FHz<$urGsF>~FV#WFafNy{gUn%;L1;D@;KZk)|0jC(NTLz(k$z>Z6+nrn8 z^EnYyBWvX*Y~8oW?Av0JAvic}WzJRs=`&A0w5Jp7uk!RZ};-w)Vu@%SfWo;GX`U-pO~GC{O=uoGyg zBO?3-XsQvZIV#PXxk^k{OesC>wj!{$;js>!NpjojA+?2!jEMpwDre02tQT6v0JW@Q z)TJ0!5MiyH4A5j#%M($R510niFLF?Uy1)2d83V};!GJ^*=_BLXCjcvVqh>o?`iBLU z*~u_z@-riCR&^x?CWfwu7e+8Oz||D+k-$(xYNr>cImpOoli!8x>qmJo7*(doDxN1o zQxi=UtRV)Gn&yT8$favm{h5<1Q)ZBuIT@Xk?v*@0fVKA}4Mp0C5-x_RwQ1>{7^+X3 zS+uGwS=H@k>ZDbD+5dT4I8O&5@qNIzi93f29Pupv%D4YzeDtM{;7@(U@5gg*d;&lD z?gzLy+*y+|8{AGXJFF#lv3-Ca1~A>QZH^feL2HR?@yVqZlBAHC5q(E?SuqzYi^&VN zP_eI`-B~!Z>IfMV+dBDsvM~8ly%v)&%LNO3GSRfy9zq#xKr|X_tC~u0&AKfnH(;wg zj$8KGsUAd++BkA$dBweQHAA253!US6Sn&^zm~6svn4KN~AAHZm>)vcQ z-UY5_^%>cc0kJ~T*4}JOV!i`D+-;eony_&hFEGGLc?n`y)H~ric?!X4$b@X-nBeG2 z9Exrbold!t4mbo|Y@#`M5c2e117EQ!4QB8agmUwcm9j}82kuPtsFQg&TN8o6ax1qL znAfV?2r8k{73)!AHwDnhD*3l)V^_)fRT;xUC^jaV5gjTu);)^ ziofKiqM`!Omp_Iognp zpELxJK8IXtp$jc4k)trUbY!Jn>}?(S(XAfc5XxNWEw>Zm*gqIbTevUNAQ-9!GFzc- zsNa$exg-hCpWr{Xo_PPG6ItcjTi;jvbphand-q;%4=?@(fL~*dhgdrwaR#GVxD_xi zbIya&%R!c)jg4e@OQ!`8OBiY_>t<%lz;wq`2HD|tF}+ylmzzVM->GXlBS2@O9FDXj zriN#=F`a*xazrtWP$xip<`%@`nTF2f@uS60ZzU+MoKpE;>Esn5{2;Fi72< zQfC{5BLAQFUP0+p0C8+&v`4Z?_c2N>Iz49 zjIl-wlf^hNeZbw^H<-`0HJUqC@XbB{Vq3pO^K4FsPpbnQ=Gqf$z;W7E&<<`G5s;fF zI)Ndc+iKwoKRf0Y%Vnk)-hq8!E0b=b0$9{hCZ$k~^#EXB&s)sg^N@u@=-PzgpgJJ% z!7@@tH&5K#LLPHZJ*xq?8P>_MAtG~j3>rD391|{=J3mu2A{|IRRgM!`~o*rNkA^#R6NKIfzV64IC8d(OCl?RV~~w;uHrUAbdzM@FPL!EBG&zP^W!B=>a3J_pwmUJC zeg~8UqK`>`C=qEVT6mW2FFWGMKuQRLThW`(M+5h%Yoj%j?yMDM>Xw7^VT$a`vc>z(3c z{Vr0NJAlJDV4DLEZr+P8dE;-wpZ;B6g-?3w4fxZ!UJ@96bn#+ zwsiZ@CldBHnZ8$F&RBLis4P1i_N*#G;b^OO{i8l}x(cd4Sw8JRf<|)>@=$~Uq? zIUyO7PUKJhsz1Gdd^?b)W8|f+zxATq zuolrtn+wN1ndR`x>T5!mscH46$`XIJ{Pk4<;=EA7*J6s!tVn%RV&Qr!r38oHj|{ajMA3 z;^-q7*_n1)^giv5o9}fDF}6(HH>h(%pL`et-ww;8Q7j>Fv18V|lC)4&s-beUuY4bX zbKgAL6_}KVcDa^k9hZ9gfnYf?vn^vl+PVIw_CZR#vM&*hy&2OUZm>D*aA(8zKfe6n zd%pts>^St{Z5tk407^|BUF(Y60l*GV{$))2-3DBTl8-dwnue1B1&ctk)gHY&Wigp; z58p~0a9@~I@xRPGuw14PgT;z!gu}M(wPYzLkXQL@tfR+ifs+O))mg9tx`jU}h0J)(y1Basm0IuanD#cQEku`O2>9|%< zGn|Wkz_>b@vzxs+tG*hndh(j0=cufqMTjS-(~NrYQw{N=e~4DIOp?d`T4k9z#^Dmv zA7Z?!IIO^-hg)a^xrDa`6AmF4&W(E46pmqi=O*W7aG!2CA_A7-*iyU( zpR?M`T7rmNJTNIHnN_h4x!~s52H;|B0OmSP)`9Kvfcf+##y!BdYi#fOLEQXZVL*GpYwK3qyTC| z;<+Gf|2x^uv1o-0hP2bFed5OCa>n4Z29DS7%#fH^xvbhR*2V=^+>T8UqD*l3X(20n zTf?A}<=mLe4b&#}S)T)u;a%9b8#E*ocYh=;r9!RpD5Jz|W8@HfeP1`37bSy~?0FuI zCq7Db87f%Bw&aZrAnAnTN}Y=Q_H3xP|2z(vU|s^TC#T^efahxiugZ`X;Ag&AAQ*YCqGe$6k(pZT4C5TE(xPsa=IKjFcP?ly*P zb0zlpDS~p_%37Wi*k)z?&h^|1-jNnJY)m_v#VHL?k(Gw!i%jBc_FGNnt^VU+npl>= zm+$E0c;~F>+5xZ)$Qc`E%B75=1lUS4H&>d_Xj7k3v)aaif>*TeR#mLPjdA0W`kg@_ z$}dHnr+|yt;=lk`v?aa4!8(LbCJ^Gl<`ef{JMh|1TF>9yaBo$ldYEi;LBD8*fiw1r zNgoVfDN#fHw_pKnpkQsOHu==%p4&64Lkh#p7I53pZnM-19?Bu(N2HD#gJsE6F&5!H z$JQAdoXfsJWIY18gqM5kk}hsxfe6?wcVq?QR(8MTzQ8y-=G}>_<2C%QgT5cIQNT`Q+QzOUNCQ%b8`aJ49xe~($Mz|eX7y1EpzR(@dCbp>posRA z{ix|!i@)tuqCW0qxzfgk--v5O%j8BYAI`hl2f%LhN!Q@u@W1%-gRlEffM0zF z_`Dn7s~=^}#bqD=kyp({Ufc!nV2mgKb9ej~W_AI$3B!n}mU(WN#zQ7mi_@&f7i%9) z)hz>V@s49zl+cSzsSlu_(&RWB1te4=iyH*00xa4I3w#k|Y(UhNFI%L+2BZ2}4hl_` znN!sqOf2VNz05>k^<-fXmd1l7iG2dn@jU}P;%^86QWX*yOhJeB?fM}dvaHXuh_uB7 zKI`VAeWF8Cja93jfU5zdV6Q<3C<%JnpX33O&(eHWDL_m|peoY-E5-)R$zKjE8Fp~8 z#$^d=WpP>1J0pabior}#Z{+U6M9ug#xlTUI0IA%b)^IqxTV&doky`wy!00M#4X{S) zO=P}?hwjP~Z#`1|?aqfvHlmmF4M*^#Xj@e#!MOxDXS`jUxpgD_oUZ3Nw5FlX?(F4d zo%vq8nIx2vU!RNKF*cZO(KnayaRI;n2{^8C`Psh$Z~CLZ50C%vJ|B19^bF?QFkilk zvGW1b2Bz5>IL(z*<}tAH2uiJy6_%s40(gu3&0<-nt);AHQNVf@j#$=exipD=JGXky z%s9SX{l%<3IJV6r(=3LZC#=a3s>bwM;umaMS$}I2@3oxJq+f#HTLkVx))${cD}3#t zgyGmuezrx&h{2N$VED`f9sI(vJ$Z@K zy$jr&9$>!n`*HfZ{|PUB{ojVa@87`2JwH75954@ahCHXXn)F&IM_`=}D8Q!h`C-ghllooD z&0tYtkdYn8Oj^Zb-bel<-!(SgdGy4>UH^vO#Fp3@>1h$iQ(Se)} zNoyPTE8ymt(OveTOwvqTEOIGR6`)I7<2)0U6FoH{1ejGeUo=$8HWg5Sf0Yzt3k3>j@A|mOB5Jf zDrk^?Gt|C%3<6{mNjoP_>ea=D^0n$vC8SuFAHsU--DrIZ_u7iWG8pXUflQU*bn=NO zpEW%Fi7WUyPZrxjh#nh7$T8c@ zK(j%nAnA49uK-cVpzw+ZQ1RX>-bFTqHonh;K8zT;=!yOJgXdn8aJjdvEg#d?q~&@h zPMSX$j%aIv!gsyvyKwi;Q`oi*@Jr+dd)YZlVl-oa zVML$6N?q}kp!JJcl^1r&)qkTM+w)Me?>GUJc4OJR9C(yll4!5P!k|&q5bA@s@pOJ) zv@PdOylSfKswc5Ctpm7C&LWAJO#4)QNnJ`xB>OJgL*X{mxDA}FA^*!x>?g+%2)RBn zz{>Y6>tAi@wlh&xtao2{K=5#w`^gO#W``Fhwm<&h!Posaz*pP_{-0Oa<RlFZ=k9 zylO6@>SF*NjPbIH0dp4lQp`>m_`;dB93TKJ(gxL3xwY#FeV{^{40Y3wj}`1QHf04 zoGibZ6eDbWMKL~$>5K8~&%M&Otcd_954b#=B`T_CLsz}G)vPtu>9)7iqoWp=fms$V zBt;OFcMHIG4fH)h8F{M*V_>yvO~;x!qCt_gnI?KYaL%lff%)(ThP6Zl4r~s;al?dR^T?`;%rJ`qm(8^nfCDgdtgN&t&KhD5xmf0E zKxBS}jL!(nnE~4xpv>5pZk6Ye=>}l>+H>s`G8>r|bE9x;Mw_ihU=0KT;5cmMnQUwJ zc?AaPB=IEI^?i(0zQHo{4(@fZ1?%C`)73fAhil5*4htG*`~;6pt>KbYvE;%49FM+E zz~!EH;Yj+O0X%gCE`h5DFW~B5zY|w~_Z#u>AG{6t@b|(F_c89i9+*e>(+zST8^KVw z*yLVCP-Ka!Ounz5se~zI0C>`+r9)Zv#K3@Sb_lYpa|{auTmUd+S)&#GI@%0uG*~R_ zWl@4_W^g~mxPf3s1(y;8ugYevCzcqFmX_ljs;Dv=?&>T>eNJ7eBhs zpk-R}dEaUPc939#i@B-a`Wvl-v zu?7)+>geNKWNQq=QhsT1jk2PMj$T8v946njQ z1U2%i39*`BVn6K@7`*-U2+9@L9KcrX$vq0Q=~7a0?RdDvM{hogJKKGH^{@Po{kQz8 zFU0+e`*`6euYqfWAArpr+m*pjhB;UE9P$3EUCT z>MYQJa02i?Tl`*W7{`q%{eNY%! zIBeRU=painmK{RIBGff@bSf`uHMqM1tfP*8C7#7<*20MX)%h0JI--9MMWM*CVdj#*su>5;C7;xOM z-I>5~`83C;2fpYxEYEkmCxH!K(q~(|C=FX>mI14Po$!#X z-(QZ+40p`%BilCr@Pq5G|NpLxxo^C>?eSOZWgq{MSItFUTmrZ{9v}aua~}VaV}1r4 z*JdLQ%2fPpeN0 zmXO#ovBGOGu2d9Xs+=$wEH=zEhJ4r#8OXHwld7heER=$iFUb?O(ugcIQV>%+-WY zS)AHul>((Yrpw;5&BB``#7eKLPHUe@Ze@##1D-`$_S@pGWRM8vR+(cNOQD1B?FSx> zUM{8a6}T%Y<2!tIy`TCX?-mA0+xRABE8DN`$hx0FsVIvB+VVZberDz(_mn+kS!(f= zW@6NOet^MHdw7{Kf~YxKzb z(N->1Pj^6qp6lruUwtW~FOc?(qzFAAVP#RBt_QZ8QJHh6l}&e=sQu?0`PY3df6WZrS-yv6!e~H;zm3?I z06;A}%{Pg84e&rfqg72rA!>w9EVZi%GRjL67YjQJpxfoDi`8bCmYHrd$nCl5V{RxIAUbnWCSf+=8#YG@< zKRI1oy%5@Kmci<^_iH>apUK$fs$21~>@$5%M?zThpRvBeS?&zVXfu7Z=60mA{?*N|2|`Lz8#4 zLn%~^2u6`3jOxQH7$*8h8%4xL{Zs`|EsttMkUX-`CrA~=DX<2Q(%6g<&;1eE+O zCS#+fniS2o&U0rM1y^>Nc?o-bDzT`I=@YMe);@OSD-T!U+L~b8$!y$(`M3M&^dG!@ z^9|nteAy-Nwrf1P^0JTr$gAceFD?Mw+`D)0^$#Cj{!RD!g@8XW91d99k9ydORNmn( zCMp5OG*Q=^^rwK^LI??}R9Ft&14{DYL!sz+5h&;Y#!`(rp=H#dzJSo1>CtREC+J1i zb)OM;s53zzvPku_$h8CDJl0jG35(U;@s83NaEr%{F~*(4(aR%9HxxlxKtXS>GPG~% z5*lOllFo$J8);x<22z8y1h{P3UdwiNtKDd5nRX=0VX5i;yTN<=lR0I=ceOCs<9n}R zRhDuUy_Y3;6@S*7n!%^y>@sN0peZdiWgK~$7iD!iXA*&&YxP+H@7AYEjk?=p0Oeoh zSoUAg=!aWv=zRUSUqOU4cP9&j(6dBfbHr%0G`3qU;dl$+;960xcscQ z;>kC?4mN?Chu40Z6B`cL4l5JKedGRa=04VJIRKw)Ke!ozxZ!|r7K1HtHCOBbXPH^Y zJpg6|{BnP~xIbfXW|W65wxk7WxvV3cloepxeBC>Yg~dE@fth$CvgWW!AQ`fEQK@A) zo6~Wy2&PGlH8FO?emx??L!9c;VTzFFX?oKaKQ7?FVdCO0fX6PdJvMMNukheK@4?kK zza0<1@oTaDi*Ew(6Bx(WU|c-2GWoVE7!1=7p3KYspJk-d8Er;!hY&?Su`F>+{~fdg zrBh|Eq6Pspg?b{M{)rfM$vo=O=qZHHwCcnWsP48Mc1g(X8d0fH5vVq7x& zFN{5XiFHh8_hZXOAeU7-1&lC++!}1>i)lt!Y^e~qRgV!PJo{k?ec79avNK#=O6*|| z1(2)>xhkG$pE}MgEk&XzY^75<%#8=zuck&&ZX8!I4g+}Yn+%V?2DrHn89QKgP6VT1 zSSb<{#RoQqpbG|AP?>#vB%qH_pV@AL&E!AL0`;u6nn1OcI?Tt01Wraw`(%*2a3*Yh z^+wiJoy9{UP|p`;WF}o@zByvm>2 z7IrxDw?&zQ+eEFPoK@m9U1r)g3p?q7-yy%{Z}9u@NZnRoOp`&HC-F07D3DtfP`s1H z3eWnJ7pU=Amd!n{(-<+gMk=JQ;PlF9_qyG-e4jiZ4N9LS4TIx3?>y3Xl8zuBz%-0I zZl|w(`TmD~JD&fR7lAJuaqxq_^s2t><3IAMxyXxwwaf9f*;D@y1HRJXTSWOsN+(M9 zViLn>xDkK7^lMj>f$q1(+?=SZ3kK@N-%lmuBawr{_uX1I2`W(Vl=d9_r) zvjo_TZ*@9ogI!TCYZQmu8XP5ft8HAiuxBm_A9u(f&Sje^IlqzzYKZskXFtkI6_|^b zgaNIctzYr7YHtq|?b-}tsaTZ#{nqp{2&6WW z+nuwGGnubbf9^mWE+S1X@rbj&IFQOf^=--}hEZVNqpx-*us+30W%w%K#lEH!Agr$n zjl2TCpmvEYzWJVB(q-kSuV(ISly-3jLRdWsaOp1^+H>yg2gab8&iJ_Zx|;(bpR8{B zTsk+7hU4W09M`yh@x1_^!`(0aHTdM;_P@t#KKnCq{FG0^)g^Gcf!|zjhSTO_Zgv@a z=4@kNn*$qiPrAyO^OY^YKk6*Z=VE0q=f022QYh&tl*S%#$3M zTVyt2TlB7lamIC2)ScEQ6&sbCK!!AVf*FFj>0l=v=h)NzIBR85hnrg|&U`eW5Uaf# ze{O>&qW&?abX?5s&g)0%KZjCaJwHqP_;>VKuKuJT^GU!?Na z`-6sO{WM~1J4+=J^C)8u@JvvSjJ;Wcq-j=D6Y~MonhHk+8623qGHO1>FtKG*>waa& z6>kAxZh-CDY>QysoaS>|6DiyD%*b|x zEm@XMd#$-{%TEZo&i+!Hio~{#cZGlCb7F&J!VOp^^0<~SWw{ldRYtOXC)3_mur)YA zEnjqt0m@j14owt3Q05hKO=xK=4lMR0V;w>I7}R-_HLJz1P>Wh+SaBpmNz%Q!<9NsM z>>CH}KH<2&3Cv>vC4yr!aBI|VL7C0g(15phfh{*?so6OXqyLDr)CqUUflA&gv*2@M zpxkTA0dsDlB(V0DD=1lXNFnWB3WzY%D-%z#TiOE)k2;=POIdv#xM3?mH-@di+~oxB zt}&H820Z-0#IOI7KZ0+5$2a5tW3R#Hr?p@3OziXO^F0m*Eg~Qu-*w4zjo*q1JsaFI zd$-VEl$hVlnm)7qW~Xz)$j|SK4^!_i#@BZTgII=2D9C&Ha`UO8?Ftyt{}F(rUUquB z9jvVf3{{j@CksESeEy=7CWUP^k+gWn@7#l1X#&u;gfL;63+~Bm)7mZB>|&eSUw(M~ z^?zVx%f0m!2S0R1y^1gU_>a6QE)@vFIsoF~825iaaQKt%{y1Pa=D0`)0yYwyBc&_s zB&;ufPh~2FGe+!zF54KfuHG{X4lquM!3=E{TMQ7L!2}fo1Qn$QQR{?N6xxJ>(uhSH z^7))6Pc9iacuXxKJ}h9iQh0BFt5`N30^l+e;#p0_qS7!ErmE`Pawq}@{FYL=KjV^%^vOe{?*jNo2naS)oX z#Xm`AdT&xj6zod}%D-Y=GnTY+scp>gtcbLQxH(o7#j;ML8HwT9E+l;3FIEFto>12s zZ1t>~xhzZchx^It{w*5ttpK43f7J*}U1V}&et)M1`*zjq10e}Fmg@(a)7#UJ@`oWA8> z;p(6K1NhtjIdJ`Bu)`CuJI~@U41T(SZyVerQ;QUFL@hl}xoy~%vL?S#j{{RQaFp1; zMn?*_&`$;D#QlzW#B7}mThH|+EQ)hy^#e;*BdD=>PMHsSje&a7JE}v2Fy5~K7eh|P zqr&M>w?Ig`e`<4gE*19VgG+ljklGDITK|W?k@N))qU>E_B%jy89Docc8|7SN)~kK&D~R0C z4$p$g)Dq&jj_q5Pn#A6PX;<4rynOW${OULS z8hq84e;Izk&-`@UpO4|ik6hvAMF7(<-Eg{gY$sd)T?5;;wk_PQ6eOY6()9waq1~RBN z4r^KREMXWOG9fUzlIKt!)i!wfWrGpPvMN`c+0b2FhXvb26 zAlxAWda;bv4l9GvFC2CWjEl&EzVCR~cYP3F`lWvm?|k?7;m(~Wu+0^m%P|ONC{yN< zKJ97`Cunxx!;a-Wu~Qy)x8k1CXH4es;#Uc9^bd8+wY*&bjw}}~%tuP5TGh8_EU{3$PJiPw8zX*KA9pF>0fv+wmKDx@6dvrCO zx&z?qaJc^~-4B1s9X|u`YlB@-?Zc-?i~~w`#i~o`VbJ37Hnj1$V{Hc>UHXvjXf2w} z-0W02$S>Np=@!g-sPYKJP^S@LdD1$$UtcQ|1;PwK9JU=5W&8w0>AZN6E-^NR+g4Vu zK^*>c$dj6QN2B_tugdpgdOn}7ca`5L%BU7+X!ev*Hax-KTYJu1(_0$!*(*J1oeb>T ze_Mf#vi9!zT?ktiFFSkF6GP5Mx~VOwa&^{lPnuXomp);6Ie?Vnbf8`X|GBHPo^6st z#qu&Pu0ohqEzh-vlC#XP>P;Gb)Xb^Z?eojUQm=>h4g&w=&?TNvd1?&wbH0Z0Jo}BW ztcnb~5P5kkyDI3c@U^;w<%D@IZ=KU%ha(QhBiybqU;OdKxljBIyyiE2A)fidFT(ND zKNWXB@%6ZP>dqQO-Art!mAdAe!%hn6mnK?TfT#uYF== z!3AGgxM5%&P%tr$hH)`~`$x>Xz~Qvv;fJ5c)%)I$?K}PrUi`=Z2shvMEx<>A2!;)K z>^a!+DcH&3H#eBRr4PH>T8L9pR}(qu)QP^Sod~Xom=)I2i7vG?^l(OTC~avd!!2l$ zebAnfOfx$7?vQ00B!p%<{>#pYvO=%*G}EGAG6jt_Rp3omCQ$%1K-XzU@<1n43Xf=q zOgOt|#c01<2FI#SllFR}7um1XqzY_$WX_Fb3Q|}y*xKGN;&b96?;CR9WyOUqF?HjN zKIJLtxa~SOTB}F~+H)zDWDmQv51k(XYQSXs`)fv^Ovc_YX*nABEP3CVG&Pz6!xnLe z%85g>bL)HLrcvDKpcQ5_lZ^_NK@QUFLIHifvI(vrr_XwQ_f}5S?ON{oHv`43UsDq7 zcsO8;13vun`*9y{#vl46zY$;dE4~14e%&X+u8(->L)X}@*93>V;dE`7CtFKg-F%x| z+M07SD+^@0ur2nYTXE==DJS|_$uy~(Gnt#bPj;Hfh@oVxKri<=1@i2kytU}6n~EA) z5ABwUe-t!!Sy#F6TSh9xnAV0|!h_5}9|sAZndq$GaUND?()P(b0_k>bV@$W!qzsKF z(j1HfaGDd3Jq^6(69??L01{mR!~lCi2f#9M1QlN zgzx!zpu0o)K(eRS3nwoEbEK1rlf=mNwXmf1d$z~ca4`G2)2G4LW-{YHE@90*=MDp~ z$e_Cej7z|e4nM5AF76%hkH6-7@qhRoe*hnSc!k5b69>wqo=XIobkOdQ$$OhPQYdLh z%kJuP^||Q;!rLn0=NO5c#GNLubKJ33!hg2jsY+OF!Puq zARaC`T|a3`EAn^F%yDU68Y+1PqHLvgx{y7LNBN9Vxuug}r9%K}Hr=yK&d7A9i1je5 zRI|{K_t9TLTE;X2Ju0t&m9xj3y%Bh|xR}sW-9|c!YhJ| z%p~|Ll~=xqc3$4vUk&H1W?=b3-Pf|t!HZKKjAS zr{G}PIM6th)r(SdgICf}3{0N2sEh`6Tl*;+(x-;n6GHsz)-LK9`Q}nLrQNHIZN{DS zS~&@;Ta1AsJJ%spdlUxTc3cgrC=O#~(T(FJuo+G-e*_aB2JkE%|93wRuld4XhR1)& z=i>P0H{-E4y&kx;4kp0W#CUK8J8duwY-Ve3IvBQC76(`c+Tadsmi{4^q`G9#@h}Is zbr^(Ci)2lUOuOihDKb70hc?uV<^{mbvd)i-|&9=zk*fS2D1-~=15 zh242AY+L}_HGFRHZDj;Z>QZ(u@lHjBa_dyWuD1ki_n5t}%rU?t@L9nb>U!;Ew(hP> z9!s97$Jot|mApE*Z$brJ0C1UR2B^F=AZ^$fndp<4)I@#+y~K)g;&Vn{FnRx5QCs&p z=tvvji`Evf@zxLVc?btlu72`aG0se$GsJK3q3O~am~y%b}oA%Wv=kg!tPZj z(V~w*wi-~n@R30%=Acnlkq1FcVlF)QE~VVM%V!CG?ag@d z+tK<6KxVq7i(}GSDM#&fYJ*}N`&teQ$~^>GPCje(uE;!DJo2+ernU67S)NWy{_y@7 z)jmCez=meRt*pTApr}70a-Z%BITPhmXDsOFQp~aT(7OLx!;^1Vzt31<50_#{nwzgA z-rD1=^T${Ft?N^s#47xAAWvI`ltcT`R`yg(DW9#0k&=bA@0`d+(&pJe$ofQ%7HsCp zze$hE8qeox_t{Be14J%j6pL|KG>k*=K2B-1gJWD8>=Kw46Z5z>_C3x6j`xrFum8l? z;*b89e*)uhA8Rsb3mmM;3T|mo{6pA)kuqetY2W&W%L8Okef3=M|&%qQDhz zG83<1aJM@Pr-xdbRYYR1)Yf#`0#9bzFJ3wEA)=T_PJIxYPkc@KD1*e^v>ovdGn`p| zP1k@>tcUxocS%3{PA8M&9At={`&6+zVZV2Yd1x~ zEnW61yw2G7D!<5&1AqFLHQ~D>fKcVw*YiN zi@#!u&IX=KS2+%a1%)!VnSmup?oESx$t2l#zeD*oVR5p<3L+mc#wEt#fNgsT+w}(l zJOB=_$GuJN>oVLt3Uj4DL>w57B5qieMMlh%I9M@=Glb5{hSV07abF%fZ=B3^ zqruS1`Y69Ug>U)ixcT;P z0j_@(2FJK~8g_gd?iY(cv5t4dUVh|__Eu>b;0eIqaG)?rem8&z57l-1KA#Q6Rlm+; zsBDJX#xhkxYu?-2h~4vAoH0L_QHTb5gntFh|Yo$1c5LED>T zrL%4AS>pJPu`pC0RQdcKVYyxKi*+s(7|k}8?MDjq%HE{SlqVT@lYuRld|Q0ZHmI%C z;Ft(n4u;Z}vpprNdVsv{r`MK(YFQ#3QVN!Ra4=BJ35}#D+l#E9hgqBPpo8kz5uKdA zMhiIF{nKkz)| zkiXx0c|M>4K=Pj$AS$JK`gsvrh)qjOVuENQ4oz5nHpQn_)gX=wkFSN!Xa)DI4Jp6*mYZ{1uM%3Gra*i1xuYR z_VwfQqi~J#0`kmJ2Y3M8ezJYhx7-6am#`j!_hxHp>k+V{VO#>ZSf{i4!C`Sg*2U!o ze)n(r3;3IV=WpQd#dC1KVZXa#lwpKzvBFhj050qfg}vE2$Y&ytL2+D_tlkMbXq*gC ze}5!j)2@kppY1)GHLn7dog9rfSD3V0|&b71Msy^%QPJBxcmS6ldit!cm4oA`vkn-fNwfA zwm!OE*=)Q@FNLrpfa@`y{u7S*N8vtfc^HR4!a*(Z@+JaoimzSGXn9AdR>Csh#@W*z zz!nTDR{gYCc664{;pnBDxBDBXE}?5hN_1LkkjTS3JhGT(63BKTDQNnldn_yDIbk zu8l0PoEA&3tBJWf23TdK*Og^2k7)TjGE3W3OfCE^9jk3e5S0d&SwK1vleyS5$h~d5 zTC3c%JD$$PZO_(hpgxlf>vhQzwJgCMxePM;)nkA&Y%Q5MTwKD2Vez{FS@nC_o8K*VaEO? zKG$Iq6r$;dIoEj)9I5e;33p&b&~EJ&7v18>r8+R~QHOMHeN(-v0mQJm@|}Fb+;PA< zjg<#UOaOi`I1ZQ>hIw&-Ukt=HeJ}tw*AH;@k&j@!|9On>{b9WPZQqR#zx`V=|Lu1H zct3!Farp!emya*mI8DrxuR|+V2h?)JkhcnK$iP@(Ld4ZXF1sTpn3-9Od-=2WR|8`G z8EfD8hyy*?0ksu|-1Cj(XZbrPK5&eIGsUqiOK>nV*(}OQ(cjJ5gF!ECM>y@WwDycE zF)+#U#ZIg9%ikEx(EzFeIU`=#w!`^r2DG$(9ng8TtKh0K=Q3a_6CIU3Nt%d5(f?v+ z2@00>fANojo^@4fhqj~4w-xRxU&79odCwQ5y!~_p+WoX?+28Bw3NA$RRbb0duW*y? z{j5bB`RURFE+>mCe(P1mtWRrjIiebGPbNkIz}$l52(aknj+r4d`&h;%7(dgNW|k0V zETk@Ec^+-_TsT`kLfy~jX+fJ$xSo?3gve93CaWJD7j}fh@zJZFz#ZJjm;TIOh2Q+k zejPsNEpNeVPOpcbfQJumaCNh-JxDDkYfb}mvt=e)sg>P3LzcGO+MsaW5uqQphl0T? zWiZO!2cA+F$O13lrK>rbOqmwHn>a*+A~ZeSy`Sw>A6KguUyS+^w5&U}(g`@x;Gq-k z{ph0=8|F{eZu`^?H%#b{-!eFagm!~t4&eSXhWpRPgxW*~mH=Z?_G%?lTu0$X@_nqp z+!T|Sb#*h)ev|I2`$_uB6i*i@`p`^lOv;9ImGFPMFM0{b`4VzGmV6gTwoK7bk?i_LYkl~Ae?H|NH`Hp{vyBANv z=M8)XkVL))Mr^;a_z)ZXjZyYYwuq>$2KG3<8hU0=WlYKY>N`|G)$+Nr>r@#_TcTND z8GKt9>^Tl6O~lxpJWvog@sZi7X?D~qP44_ttxo#NP7$f8SL&dZoo){o9w?C13-XF) zj6&W|SV*}a0?h`MGfA|N@vvbU+%^XeX5%z5|IEXOU-#8(8SCfW#Qt(s$fHYD_0fgS zj|%`dhr?69dAk2saJ<3HuK`?QCCLq}SOGnARrbpF!WuMi3rhMs=~vi%b$gE0k!Uwtm1nAo_Xbs zB{EC9qk^<`ehM%{1|$mk9}D)xpVU|p2XOV1IJA3b&wU-e69dv3kO)8IeM4^_9h${P zky+;kBAzSP!e0asJ1u9H&Xhjc>qhk(2biQy(T>0yA`oft6__)}#fS~4FAvy`19s=QPC+{Y*W1L+OD_W-{4o6eAH>b~ z{SdCc_xteDzy5AqefPfxKK#P~UWDO3#@%OtaWC3%1^5kC7SF((YiSp<->R>xCq#yF zN%91J+Z_&{1x6I(+exbqaSBHhLk7^hQ->_8Fhg*Hn`w(ku3sqQ`6J5Km3)@7UUp8G zsHXp$c0rLYG?e>H%79@#Kk}K@{;aR?q4+16XR)k@0~CkYCgJ^}XFZc>Y`}iv4mR9k z)3k+?>w9J>w9%XNKkYor3k)to3Jl1jy?N3JA={O&flA{1nn>sRIu=s6-$aaoxa{BZ zJIsV9jUFw}ksIN=@C!rNF!cK6AFdp$I@Yw$B}PdZrBO(l<=r z?@p4Db6e>qF`K)zI|FK|0iNx4XmAePdnl#e!9D3pO{)yeoKw58`YCW7wFFb&EqP)a zUHT<$r#YCJ=fTMpEIc0W;%Z*u;r07*2hZS(f7Tb^OFrk<;TQfpKO4{7e+CB|xVbvv z`f7vU0OkkyX7B+&(GJls54m($?(ylc+^;k<=h6qL(2{bcxpHZ~Ex%L8R$R}QkHnVI z53v6J-aTwC1XgSV@|(V&7zmMvG-&%t3ncS*agKGx{``lLDXVGLSubUZy*2j5$IvKj zqVWKQyoN`h$X2Fbwjlz|N8pL)40oSeS@3C#4H;Aw=_;OQfMj8{*BNCwFCp;Vc<(}< z#q+Xr84-sG$(cfB%75*&tb-3h3}fJ!>XHftGvS!YX!Q=u9o*|S$~E!Z6-!r^+}gty zhP5A`Egsv!GGh)G{Epa1&vAnjraA27xVU%34}ItJ_@ZC?d+@IJzZ-WC_c8I%*?I1U zAt{jiWvc+~$g;0xw{&MbOoMW)gBw-y^@ zVRLvde)AY#kT0OfcRCl{9WJ+?gHO* zg?>36U3+AHbfI{10pJ=JPyKw`@K@pfS%AM}W_QA8;2}d?&KinNuN&}+_@Im2>hdT4Ox4#-($=31#v5@-C zo|%SNn(zu(weN|V*#T-0#b@~aW2<~-1?lTKaIc?rZ-w>90E0ye&^mC=VzqqN{!&_j z&Yh)l%Ruqpw2UYPQs!u?`Hoj=v`E0-dBUE@e(N)g&8IVDs!u6apm$INHKjn9FnKR@ z(YoBX%!A_2Ev+m<&xaDy9^3uKPi?>@d`4q@y|u3(2UGxd3$B++rot|l!57Aj;{oG% zjJ<5GuswVpr_%&*0LCZb&Rc&Lp7{LF#?znqW<36uPse!f85~~w1n|TYINZMvzgz>X zn+e=(z;;?~KTL;BU#GqLlGP0{@S0d(e9g!k){Y`@%jG(B%Mv!j0MHk!U`FN%0>iM` z0-SjmuwghHfQ!Q_Z}TghUU~`R>LuVKFXHCi@54*~=7;d`yMF*z-}Ak={^9Qf9{vP? z7ho6|mrr3Fp9IFm3M8H;<~HH62OUO^p<+N>0VzeJ9HcjJs%wdG;CL6&dX_@qP$bL( z^t-ojLv*6mx_dzwn!Aasg{nF#U`Bg|EU0XjV!iDsW+YN|$#(w^u_ab?22V`vnDV?P z8itfB_EaW@YR@=r3o%8@cW|E`ZL`YYdQvwqs>u?vH^jK{j9I#sF_^C>z9GvOHU!-z zD^^<^ZPM>xpd(e8Kdq{Sz@(^){>2IKUk0Y0^E_HL9Nw`0=bsHu_y$SmzXUl zamLk{k-nkNu$LZ4x0~e@nSNLL^nDxtvz2mHPN;qCZ}|M07DbDB6F z*ZJ2zkANRg!8o2ULA%EeCWXPe+#gnb4^D3J88pA$u(L}xB8=s>CZ=QQU10aEdJLXSZwF7>CWWD>R;c)ND)3EE~=?&nd{AjnTFEg+Zj( z5^uxiWsq}-UnsaP_OIJ+WuBukvz(F>aJcL6?>KFz-+goQ_rDYPvPIz{E2%{<1tEMuDuclki$ zVr{^X#c$TeD*|pplY@ zQ)QI0t)9-IdIITe);kUkX4a3rynSHKYb9+wjyUbJ8_WhQ2AEsM70U1{V)VcWyRf&x zr46@TdwB^7Nq)tL<~St7rM*Ryl$+iJ%EM@dLHCgs{?<(kb~I@a_*`D4SJ^3RG`y0r zkn{pPMesJVG-GgJofg$)lICXFsV2Xsl347Ef_p>xn`n=|aOUu|M`LIrQShc-?z!A( zse?Nl*-t5p`Fo97MX9O| z2P3^IrFo^xk>U{LZ0o=X1IF2ULv0vg|~=rHGLspj@oPKnf3kNMT7PiXADa^YF;6$UtRESv<2;f`P1(PjTj5 z=5&IdW>djH6;cP4Ii}?XzLjQ1U2K2IZVj48wvD)1^n0f_?+d1*^f~EBo{CM(@=4z< zc0@*)O^5dbghCy_Ba1KFQ#Nwn`{Z{9<`6oc?RT_HJk;~LXIl-D3oZ73O2;(I!LQmS z0JUr?-l5&eV0z08Sn|5JC|t!bur`f!ERU^E$l1>baJA zm;Qu~ru%Klhj83qJRA@#&xXMm%@_ zX*{;w!NqpK!_$VF>*?3?WIi3f!OaHNmTW7_*c?7@VAJ6~muyaM%&CGhmbR3F-g_oP5J+p0I6>d-op0pZq`mcla}Z<{13iD~os$zf>t36z zBt2!LC_KdZFcP60HH@ZDzy7W*LAeieR<);Rc>xqyWK{ysWpfheY1^c{B_7vo(y}je^FgF{Qj_qwPKe+l`z(0H$_<{rQO&e~%{1twGRa|?B zcyz66p~d>|W{fBQIDr4e-H*1``5YJSBgY0}T0s;s$Z|b|kSD0_=ZxfP23vwvwm^$t zNA7N#;vduEHSWG$yaTzdYj(xK>3r1kS}s3Hnlu35DBwg5Bzl`1T(YBS+PYU;l3XBC zVWxbh1CZKNEmK?)Z8jV2>5&MXwO7v~H+@7@`}Qo=z{q)f6F*r?NAKVV8+tOVKN;d!Z=>Ino9_wR8^JkJ|cX zGj36{jL?d_lV|3wX|3J6!G4<|;|9n(ml4fhS%MyzWi7__R0U@(r)U;dReqJo{Q)KJzTb(@(-4zmIwE zG1$FJ*u@3LomH+MkC?{+8wVV1zzz~{iaq2GF~HoW!?z8mn-jLv4Ytz>jS*$IXvFkDH(PaooK3z1ZIW6Y%HX3q1dm!1g?V6MzGTJqA16gIzoh9PYsU zurlH1DNe80;A@F#@{}2d#A3>#Zabv7SbEdErc}h-D0xLv0`o;~&t`dQ!levO{7dsD zxSpTavOMTj!5t-DzgQRYW*GEeYi%tIiSkUJjxv+ZDpP}5toJOF&SY{7#ByYrJyf)M z#)WoEepgUx>DH(|mU2zn&j4SyVLN)W?Go7I{T-NFzGuZImJ#h_RkSS)ri8z){AG|| z24p%=ShfvGpS!~bmpacJ$i)x_^%ewHRYs9MQ(`SKJ7LoT%L=o4DXr5wFHnBM3immf zB~>v&+1bdR|S$^F=Rb(Y` z#idkFrq!g`l=_MmN(<7uXgOlbgwAXWm$`a`GNbI7_AhvX2-X>3W8iSOgwG8xU4ICe zFJa(K_{C5CJp7W+`W$@D&;E4$%r|~Ao_XqNJbveKKjL8Sj_qdi&E2-?zy@qLfS=sA z8<=m7xvj-9zWEwDJ7PaD#nSa}ot#-g8Hp`MlU&(Qm!XTF$sg;t0Q8+Za+zaDB%zHx zyS|s5mcU{{>K<+phe+^o(FMRG`H7lPue!1%b&SuiADIc)pm$hrESFd2AqC49*&H}N z4%~UIVH`97ZNTWk1W!33Ht~iLw2^BDdtX9Fclo9zd~$nG00ZtG^UIzq^V1G=vyp$P z6Ju0Df%3y{p?&dfRj}lb`)wc(Zm2GzUg_Ru#OkPT80_Hj7r+4#khAr92u*o<$ExEr zCpJvX8^^@NVIJ|@fAb&1-}`4@<9ClwuNL?Lup=x|3Kz!HW{^LY0=n$X$lq(2$@`p) z;QJ^7gI5dJ$I98z^jwbbkfvAcde<%uEajFOd@aYnD!g;|z2rqYRKRzAsn&qU-Q@eI zkxvEzXu~-f!=@MdXYZG?Hmo6kR=TeNsXsOh-e}zyX^9KB;n&`tuHW2%u>pQ?VEVTG z=?6F8@F&;)a!;Iqw{6%nzcu33dELg4N7uRxxzF4azs`O9C3pWMGrt1t(uuke3#0Q8 zN`6b6#!J-z0%(KbrUQ{1-qiY7J<>VHKmSHXn@~(tjI2lI04v z;u5zm-v{Q{6@px8a9=4fC%{+%TEFeKl;}eCjvuCWwK6erR!$@TR-ba{-7fEW*NgvCq;0Y0V+H0Q^zei9wb_|*s`f5N zclAd$-h2O>@W8Cn*~{6=akaPB=IaiTDc`k;R-W>d+$#)V+Wmg{S9fH@IigCJH(a`I zg&>I`$xrG0;!@DFV_puN?!oTe$9U{9*kc#4%S+hh9ULx?McxE#u2mm)GgtX9Kfuk4FJOD= zqnIzf41e$d_~=J~7d`@a5d zk6CoecYt;VzO(?AZ6&IfntaYT(j?zmHh`4ru)6}76`&qjOasV zETx}fY?IQ!^0i-(e&P@r(X0#?{v;2IZQAG@RI10or#+mz%+t=ct%YjjhnBJIh6F;~ zQ*JBk&Wmq8#Uiu4`%Jv`&hiW8eq_xp9%crjwK`CC%PbDb2;Dr6BZeJu<0rg){lVbL zYw*^)pNgORsh^I|e#_7D&v^5v*&CmG4o}{D+@H9A*X|te;D|#W1a!J~Y}eDb8`zxY zb52WkTKFN6Db4M#LNlOyh^4-Q>?)hu`GZskm*>;&j{aPtjH=t%-8VyFd0|eQqu_r^ zL-4kO`TBl;Zr!0A$j@1wciJ%WBv7^f4y!iSMsCZN92U*v0QfYxP272M;P|-ZK3*_j zj;fz0%r0Mn_%6PTZi2UmEM}5P8(bgd91EFf$%EZu4(T7osPxAeU_;{DUS{eqWv2SX zBltUHTv>1y`c({G--vYq`r}~h(2YaTdaw$TCfs{J%6P`<#_qs$Y;(fy03Z0V598PW zhCl4z^}XMLI~R{*Ek`)QF<>|>8e|m{SJPyaGx4|EN$$m(0wy?JXs%X&_zHDdxta6} z%xmi@z9s(5!Wiv4PQk43W)54)*7TRzZ}onS;j0g0;g*b=B+X@~XU6i=BeF2hQb*#t zjQ3P-a)k{K*C-6{GwPP_RW`TyZo4)q926z}iiDoiu*2Pn?MJq0zwhemYrkOy=Dy)t z5N?0%i+WXEsdoQs6Y{^&>jJ>dojZ3v?dImr-*m_4!Te>o-Cc>OfhJx#UI45%1C}6z z1RFRDg)&(SSOs(nq?Zchz-85tj&lae{7fy=by-hD!Ktx{BFID1SwP^eulOa(R?Z6Alw(~p@#=V#1IYM3k7$>nO-+@d0)S9D(nIP? zfD|yv|2E_-gN>hpa#=Siw*~6X91Ho(LDBxX>YKp)bRw#KS(;XP3(B7Tq(21zGeZhx zwC0rGmgwZa%IEz+Oy!UAwyK+L5Dg3~wV>m^+MAgPN${krXRT*+AS++Bo$AjO%RKMx z<=Z`$n*-pIopdH*Koc3Rtg-iq;03*{GUqPA0}fEn8&E-T)IJxaZ|D4F(CloWCld-g z4B&l>=o|5feHP1DS9o!C$dX8w!}?|8y((E|2ltGRCC%m&7EZYh31ImE>;lt|7~>fD z=74W-U!yMb3Ct7VwoY`#&62IP$Q6za&Q0g?GOWd_^`GGw1B&H1njK&xrk%&S4-1EM ztv!YNH4Hbv*cN^{52aYTXal;TVE^@SQ)igqb+Z@Mza;~}+T=LO%iYBT zYeXbdPg6e5vEE|zDo`mjtK`$}lw6j}R=nu}4+d-uxpfR>p3c3tEr-q2j~EybXVR{c zZU)jI_lwIe_3A)@0pzp`Tn=p2#$0B<){{jxebGCz{^D)6$5bcLpVK~9X9Bd_rBiKS z0;H`=&w*eqYot0-6?#eBL`SB@@1)<-Ht!}W!HGb65sPnAutF!AJbjGHcrfJNIm)k~ z#Y1+Q9|JU8W!E?m83Z2v!IcUtXf3(*3Vz1x zKG}cf8{cSe{)E@z6P|q?Ui-vTc=Fyo+&$dE<+#9wAAQ&XHijL>@L>ZZHmbJ+;D>d1 zhpFpdA|F~%ff#p(>#{ZNrV;u^pk-s(hpK=Bl`v(ZPYh}eRMutMWx@M|Ndeugvuqo-|3}W`FwPWu^eW8j__eJL#~h_Gdx!$4r}>0PkxS*o>|X@`McivJbu$}{g3gk z_r4o+axG-k96rrsn4a^)WESx(aoEy- zS??=`8V!OMZhLm-%J^n^=XRzNQXqPW^2bdg1Zk5?{{hGJ6>*3cN)tloFwkVHu=o7R z;g0x>>JQX-0*$YM+UXYZ)M0tm zUdR8n3HaamwE;L>U0wZ<*`03(@L85xn{s1xu;QYd!<#z?)bjVKdL|{NLrw8a&}Z=- zm}*=ep)#vIhw5To`WtEC&Pe5~Vh<{9u%&dyC+j69`8k+T_mdfS=xl61iPpE@1z@E; zJ%=van$!j5{by|nY4dWV+?z+? z^2{0UwW-QtZ&jQ(mi1(Ji9rMQBNESlQ{r>(ztEn>P=AYOH1HDxagQLFQ30IRQWi<6 zcG27xTcW~!e|?PpD_KMyQCem#LWDlUMw?(n-ChooubpyHGygDaT|>bzR)nf4{S0ki z!U}nLZs`hzc5+n=&hMu8$oFV|kQ8IXDm7Z#V2gjsiPS4y@O-L0QxyWb#~x*69_qL0 zSV6Uki5uwh-^IYOrrr;iu~gM-_B^XCN9tVQ=@iBOZfu(~C@|sM2An1~Tmh58BF|PX z!8m5nhN8+CWuF6e)aXJmTJ_>%f(_qM4MnSAdFrUdt!Aq#V4=cvZiAW~TyHuljNCgy zma|IvOGw84 zAv9FrvLv4YryMjnDp)0bQNt+F7cCsxA3HgSdQ-;a>5?b8bhOOVn`3Z1DR=UC&r3#@ zOWMSaAhQpvBdY6n@}-U9+POA)xa%j{*P7=vAaXZ6Us5UcD0c-B^F&%3F({R+jP!K` zOQ5pGo_BCYXq92zMihsTlf1hO%{4gBv!;zB(i{}~;ztH89k|&xz$OL;?p?eVcKIv} z?x%TUKd`;izxO@=5?}Y8lds)E@8d2W$7{yZc;@k^@$9{){E54d+uh4czr48gyT>Dr z$0Lr1BMvs!iIu}}7y}pM5{HAuIW?C0I(=f!iEU1twiB-B33F~ML)sHn7Tu$8G!fgA zd+V=Ppp@B986X1t!9;x6FC%d>ZBUj>wXa|f8^lE`*rV(MYgwc7pbR*C z&N#Azb<=MVEV6-d7#Jh?H%7^huTobKa($oEvDw7&V&L-P0327U+=dO)HaKkU`%1hC zF8j(@THgoL;(|_RV6J%F{3`x6&#g9${~M7-ORV1uHbptVb8>0%&MUvqx6N&?V`sTY z8?dE=<6t;g1k}dJ)0``Ky~dT(eH~UpIWfS7tpM^EIM~49uy}4}IZktn1@|6@Jj_*= zM?ek^_}o^;+??WzIWCR|cT7C-%xmz>vv0r;zxPMr7%OS+7WMOEz_ zrzqTQ`Iy{!N^SDKx#?fd!pz=cxioYfeuuJNW!&|t;LUn>0vLvg&F!66SD*hQz|#ld zov%pZEByYdx*i4QKK^w8FwMqy0{(*ge8vo$V_X0kGJ!ZvMu*O^K$6ZqjVOQxgzE%k zgFAfGer|>0j@vRlcPfuuYQPYO?8{Q1Ax>SyB^1l*9nV1tY@aE|XZvqGldk{HI>X+j z@n=&t=*N|N>BiChiaOJAPT;W^2#b5`61=H6Msr7_eKBVl{7vG*{fWXa%RSmQ4tmWEIYTXN_3VWDoCzqdcByCN5_8gC+Ad(@r317*=lxqP)SzSX zLllhthpbZqtkm_rjWuT1yXZGUNxH4D)_%d1l)-a3mn=A!Y&A<8hkBj1#f5&?2Z-s} z#p0W={m93_Idv~q_XlvhV}WB!F68`Rq@mpvz7I~tljXy z`KYh?EMC}B@~JoYlm~>LR(g?sowliPx0j#dXwW{4Gp#B+klBd~*)4TGA*K4X z=_Gy6JeVo4ts_U1k)=ll#Nbe6NVBm$-)A3^m_z)^DUobyP7bXJ%0uC3^v#?%OLd0h zU;~dGpThl%C$UVxhRtuVZ8!M9d>?-Ng&zYxda|_*!pfwMbG(HzrhXl;BtX$X_JeJo zUH)SS+3x%P+5P3aXY?Wo6OEj#$K?C|-F>-s%X_!cv#%HOS!uYfK0xj0E4Rm`JjF2H zlTG(t@zQ&K%jbRlAFJ(q{u>$)pYeWwHNJT9fLccM+tbC+%PW<+=l8zP_wCx9ntE%w zjy$$Lb)c2+m8y9J@H8$DPlrAq1L`F68s*D-{2~h{8g|x@Cv1}kiV`EaLIxRrUH`6^ zV^|a6*jT2uxJx_X1le6Lb8?6@L4MuYXVxdbr&m-?Q5I6|geILos=bxKhkcvo8e-*zqtAQ zcHpZg@QWS;-gteBknwsYfO*wij{@WSmm`wJ3D0Pz}qAG0X%fjj1V3{K&wrY^I^TL%A;bHGfT&2{mhx#^7CXy|CKIF zw@q9up&~)n(K+X2Od{H?ob{r&(}orF5$bLuHGu46E5F)W;deR6`E#q^>!rm%A|M@S zZNIx(owLiLt=$!na9ptf=g~(oG5g}ZXym}IhQ5>oB?9MVD4o$B; z+cJc%aV_Q5ty(YlQuveT7@n=Rtzke3Pk%pXS-j@4$L@8EYHW#59ZNIDH48kaoVC!f zdX913ff0a_+r1jFGU`H4b?>wtbHa+2dlH93B^S+F_fUhGm{;u<83aSqx2XXKdE~K4 z5$a@E%CGURBg2zPi})zr^(kn|f7z)`jVY@_qR4RjNxsS|!+JlfwEVFPB5|pNa`lK# z!I%_yMil5U_1~@PZd01S#%JLzl5z zygN~?YJm1`J;OmgA1j+vDlBidev|iwp#2gUt*0Vi_j{8 zNe0TSbvd$6G?1iC(7=NPF#zvs1ak+n#F4r<;56ZQPGAwfRG{{G?(h7TquQbCxKZ;nJ zj8My;T3K^^sb?U0%2?Vi4&cPrP*+`<G$;V)ATkmG4iK8 z(*AGhkH<-tCF}J_p`!*-d$_n8FQvQKLKQUqy$C&@v~8EziJiT#vP@hMYwg(gulQ;@ z#b0V9^-2gH6*NKfF^wA|f?3@Wm{Xr97_szz?LVm*m1y?C06zj4IGs+Ill7K$L?cw_ z+Vd4M31<9dkDCQ{p0P^GNKB7(l|hB?q*FL(K}iS!+gbs_5}~uUP3mG`(ov|Y(8qLA zKA|;te%Z+ia{(e_A?>|j@al$WrO0O0;=R`M=5_ek$+g2{<%5?BS$~^&AB9iYVGPV4 z_T%ZBa18)&+<>>9gU6#QuSbEoSH4ta4>vcz^52^M|9;R6Kfin-PX*4oO*)WboN5*~ z_QRm2>fkA@fT8x+;A3JIqArcOIRVMmtY9gYTOEHyOt7wbZC{xkim9^aZ&`M>vu5?f zn51)t_+0OB!zmgJr}5z6EIkO#>_P>Q=o}Uy3W^*aWP)yG@=2TY?WBD)z)Z82z*o*u zSwy+^Y!m=~#Xu$-sIx=6M>?&yRk*9N74173DXUfTYTpPt)PPojDg$Tj5DOmiV1W6^ zGluGAr`1_$Scn}&Du*HzN@u28{y#%LGH@-KKxIGeI8&L7d)}pMge;9VeG%)8r}bek zg2m0%;Zzk^RwmKywh}U z@mjOam?=kVPlq71EF22wpvjq8;?kIM4NAl+N>p|AksV4Ip|C|-%DG_^c~<~a*kI+y zf%wh$Ws{zyxxROlsQcO?2jI7~I+%#|D>1%-itr)qN6Vgq*Ynw7-V*|>%A)~TkI#Nn ziE?dU61P6(N84c$x)T{Z+{MR0FEt0F-K_2C(eKnxt;3QQjX&=*jJxU5!L&S2ouf>9 z$Jz=|?Lodlec~%?&R7W@_t5cu7@ZQcw<$RT4nPJREl8It-gH*WcF>nN%gzo1Y&Ok( zR6N~p!-NIR769$RcZ=uuNR`2w_-(yEa$vHmCJ)zxQ;VPvW#`;U+?y-gq46KgL<~eS zAodCX4+iM;24cqh#XgHZT>Druj|_;VcJ7#Li^ZDIl*O=HHozrAo<2=fE@axti}gHO4?-Xm5^MQ1uzLFIGo*z<@1+^RW*@D@U} zo|GQz|Cth`jvZ#fbfXV~MWX>HW$wwELW{kDieGenu4=%V~Iv*EvD8@RYVL{fv5BxtqR7 z&7~&*E)jGFOo_v`G75;n+h|pB9a4TiFyKCa@aDnQJAuD_SSPW5^(#T(qYIA$ zb06!X;A{Xcfwx_oJ@uV%|21ZIcl~Y`08|>&-u303QD7)L_u6UZIR{&{^p(z{$CveM zWi#*(XQ6X&&Lv-*38+DzhYxnEl{GjRG^nLB3is8Hz8pvb3u=V4jC{wz&{;uL%#a#t zmXO{+Eua!-itW=uN)Ch4ShTL(`ygjtjP464?iazX`MU*54b=DiF>+O(sliNfy_spL zsJlqy7k{a-qV;Fnd+N`4mBsqVRC`6SxHWN}#w(k^*3~%x+yyr+{Mzt1Ml$J6k|ah_ zWPr0?vkb(gPTk@$mAvG;>LRBx-1Fo%hpqisIaCnC)UF(mGjO>QPIfY)uxoqM zF~}q4wY0)I>%6W(o&}3|Gcm6VzP6-$EdArzWjL1*JNuXS`qL^g4Kz?7RHbmRFA>C| zA-j$;FEX*KRQo4Om!ir|q65bA!z<%wffB|0v}2{|XFRK4BxE;d|> z-PLbd#hGo(ei~kbd{*kHMWOx-`les9G0jvORO;#I#5ovn5p5(aH zuOp$4X?Cl%XJNDKQGOTK;nu55mDLZqLL>SleGdoh0FT29`lJQ<@7X}tN_=#QRl}Hx z4;Wtl8t`IezG7QhK79n(k2mc#=-Xhg6Ab@ZFOent1D_KR^Xc+0-tghcx&q=WU+Q|T zGzlaVa|Q*BiDJFuY1A}vGdquXZ_Hhz zJhGEzbs69gwk5SFF$aItofRJG~u)v z^2EPJ$-2Lay#SY4Gt4*8~wik&F z{EeOFTz$I;-329ug@)=wbe{DtX`R{J3>|e^yLqdYwcl)aU(m5+Y+vJTR5UtYp{Cuf zl=WROqcV=mhpa)VC>u|gOcGs4COlMkz}$wX>-rSrLDDU-;O_>A0ykF)iF=_He4~}zK)I0K@Fw}~L?iDy z0HwJw(&RVoKJXQD?LRg?S$fBj+^>sDnK ziSpUo4`sO5mx4~UHg(-L*Dh0u!WTm>`Rk2AS-^hn?Oe1sr_{Zu-&3`-+*MlH+Ir#^ z>nA@gDVYsuZt;ptZr@VqI@BTTNW+{%>qlbYdZcWn%Hyi17Tqt`YbZHbW0|?inC__T zvE_SYaIX&JXtrZ#AMt!SuvKUbklo^plQOz`f;?2s4DrZe5Q#R@?4Ai1psmWz z@?9JFyiApa%~%C;yuaQz5tRYE1Nb}VY5t@2)5~-1GgnQ$<=S`YtL}P~G51ruP5|uj z$3OC&FTC*74?6JaCXuwO=BnN0?V`v}FW zETXm?N=2RlEAd1;eyth%0!?`q%ql40a?qfN*HBkFD&l-)8<5d`m%4j8vIg|{qPxZR zUj&wXLMvU(zKvHsRRL9_gQ z?>LD`vvZc;YQ@ijNaDH)2)F)ml=Ck1HkkAlj&TV%d(tMBo$^nnWDv1Bqcf_=_Vw)0 z@o%jS@ZjSpok&YF*1a-9$djf_JIfgi^vbr#+s5Se<_0#7%4}@5eerPJh%_GtvsW6t zCH~D>@V-#;9zSp7)Vs>;N1I&WSTYe2I>T28hfA#w9E2UWuc$ zi_SsnAUZywoS|x19}xdEFV8Z<(byxCCD+z1FY!>Z_| z!}jOb;#WFUEJ^rRN-KfYR8TDof>-GGSK)5q?s2}Jatibyl;`rlc@8ZGxSoo*zXT`S zzh+d(;K5KJYPt}XD{;hQaCNIn62sJT#DF1jNbO8KwC}5=)qu)sqrUPtsWbm*kMjF! zPx|)007`2VxI~%!C?RbgB|^(4w)FB!uqoNeuS9)Xzk->r1^KvXvD}-h+DluItQC9` zs}=tbOsXXKlJ6{U4KRv+<{Ort{8D|R3ET^6by~+B83dn zBI&Ilf3dCkXd)58iD*OFRc%1%c-V7y2e)Wm55z96!5`n@%<9VuMnmW*IxU06Wp|2! zo>EWSmXuMicEQhNnQIY+I~4D3KwO@UrV8fdyW}m*(&mb)mL&`B1`bu=!nGhFo3iUD zf4=HXf29RO1sF=;QcjjV$lp8$;N92rTi)N*eXBz(bhkby1Ct3UtXZ-Hl{kvt*7K;S z5E(aIcy6$MRY8{*Ld;sagEh z*p^ga)dwTHo>;YtSyrHY-zETJK%Kus?7vl3S_Imz z;#SCL@~H7~FYH-B7mj`Vb~Xu8c8aLzzbgUd%oyB!vB&`orvh?a2G)grqL({y*it82^ z>ku^}dqngv)MR~W`;PD#&S6Eqj#o{H9lcn61jwRVi{H+3V7!42D~m%c2sbnqkl-M8 zv#(MrtI%09)}?bAmEp9iQX`@>7v)ly6(azbvGO!RtwO8^v*qb<&}oi0#I6^81kmC? zi@rUW(+z<52@o;`O3w|38ex-n^15Y&?D~&H+PaC18I*J+iog3S-6R7L`>G^Se4^eq z$J%hN`on|gG%yad`}-O5+bBup0(9WwSm!k?+KR6;K1lbk|9h6Av6JfE9fM`Yx%U3a z8M=sh(Uc3_(e5??kT$D>u;Pv7ENP&L&!@vCalJNR1v4bNwzTE3B5!TxZO3Ukjmd!1t$cW#~|JR6=Sg-KEbpToFu?3Y%-!di<3>6*7_$%Fulw z#)QVM_$c}k5gj%1kwJAW59y!93)jNY2yq}Xk|Vib#2z9cyEHvJKG%2cA2vH=Oa|@J zETrS>y`&<`5|YyA+dnUZgWgB%U*%!1pnj_$0N-7#?Srd?M{T|QpzziQ{tXaI$LMIc z0NFwth2yk)`+<F~P&A%~{PA-=A~v_0LGAS)zZ~fbN zn>Ho8ZjnJdrLt?qPo<#(yw%)noU3`00C<)=qxjK$cmYI;Naujipnz7~1Ou6d+(oMlDsm6m{0_S-nWf1+cv*)C#@~}(4rkw*#{ECOKCKi5_Y)LRE z1)~MZII$nS-4XE zanvuqJhQ|t@jE&pb1a--W5(s#t9FO^(S2S|$M*p5I02u33E-xf(3th;lIu}m?x%L8 z2Alc60><+&JmYangZK@iv{Z1;vU>+FG31q@JN=-+{+Y2~80nNFz#XqpMO^ z{Y3AMEc^v@IQp$MKvPhlp_R-xL(O>XEKE5%V&Ib>tDU-kOjs~39v}?sP=`QkRZ{m| zn);W4;!4*56@HQ6V5T7VECp?pGc#ppC2uvZv~?ziCD~MtPy_SA>Y_{gLuVpism(jG zb-2=`$?1G_+WNA=#>r>=>Ra8 zykKU^lzgmbd}x4U$yMobzF6Yke_u^4qm+#Ra=s6ETz0*_e6D%kn$a@)Qq7(95OczI9MU#Bj{!Rz7+Yk#mFXwB|GZWdX zeoY%>me|$K334E3`%@43JfzMj>lU78>ni;Z%rvV#Np{m0q$hDwgZDDok+Qkd2a02J z=9McZiQcj?HE9|l)t=n0LY#c}=!e)iTLx2d5_%9RJj*5$TY5J!$R*>}d>%qm{RWW{ zL}1C{93PK*%GYo=SANH2UBfAr*}~=MO%q-~_%8u~nivS2VM~lza0jWo>M{dn97w|V zQ=1Lo@=S2q*(^dG+;U$7IKtHSajzqNVAy!xa3a7l=VH(@Fn!^Jpsy%VIc=1YxFv*y<-T@ z7$=sq`?9wv%j`$B3zjJ>XgfJ%F-be+hW*?ECag{rSZs*~no=hL_}Vvb(JaBXX1pwm z_0{z)$dLrB79`=N4M?82OK_Yb#b9&%<}-LSxQsMKqVJ1t}zwq8`&4dpOMO6@=yA_ zbz%9+4i6`l&nok)KH3_wf6W$ZpOhUhxbDxA?naZ~S>6|tTz*yYReQD`?z}DfTJThO zun4G$;F90M1{SOOiR^d!QPqY(1W~m zs-FiXl`mBH$pwjFSQv|)$O4#V<1P%}cXhh{XY0=Q1Ng?y_(#{R*Q3DPPwk>7;D^KU z9oshFB}p~7>}3jq?2t?QFA_(Ky|j3v$2Nb0I(dh z9xD?~qHbC#I2&Cd2D)4homJUqy*2Y`e4nscsFQ%M#-;^a=!`imELK_+mX}5$2Iq|m zp-Pth(Lv<<#ffT(8uZ}a&asz1kvGpx3z^8jf|T)wj^oZ=X`m>^M~xW!+t`1sLJCXb zXb_8Eouza*AWp)LWZ?ksG&zl8a>m{v;J+O3lICS+a>PW~(7F7_!!~XX3q`6F{RzCo>w~eH{b$zJbVpd{uVT7ZXl| ze0g%F3^IWRcKcR&HMl3grO%oU*NZv3D?dj$Y0?@d1p1l0QQOWx9j^M!>vxw z_U4qXS6?Q!B<@6evz-nwIAx-badKwKnmBsOPg1c5%@Mt|!!m9ZT`(#Ey|aN(wYP0X ztr*;B?tGJCsmW4?3^bj8%OY}Ml6qt@;DGYA>_Ao`ysxF0P-~Skz$EojTUGGzb5$oT zFh#Lk@IlK^+;I8<0L<1=)2Vab&d97jZS<+#oW>3=me*ij2S9>3CHLfK%*b=8jN)n5 z2?i)>7nsQ=rwI!fW*;kyj3F_;zt>~Y(crhT*!6i?Dx4>O8!{+6Q+g9O&BlP|7h+xO z=0#QbbZO&6=V^O*dPnvTkVdo;OSI2>8x`cs-|@-xT_I)0M(`oPRkYfM zD9a?knsQ0Ip-R_@Y&OM(7h;#WA907&((8nZHaeEUW(PUJiL&D!M?pZ!>e+doe^_4y zcOdr9TQ{f;ZZ^GL0&u3QT`b$wg0d!1C<4bFQ8!V-YbLHtsK8v zQQqiJ%q|4hzG?JZ@srXKHHoAkFsk}M?J{{p+gz=S@=}Hc2gUACmTEgIeIQ8+>2!w= zxNqOTUCr-UcOGoTsB?9Abk+4JF!xixHUQ)1<`dp&_U?ZR!_Re3-70Tiy+bwR5m-p) zoJL}d)a=S)QD}x3;v%MjxuIpK7 zJ5G7Wc4gd#Wn8`qyETAP1letO_78!XP8@jcYNgrG&IJ2Y9Zs#MrOo$dHgeNw=m1I$ zLOzH{+Dio~mWO3F87OTDAYG_FEnH`cWS^b9igt z2l6A{mL;`qu%7%%7b|*iHP~W=$$nEOCPlo_EzXPWSSH$MLKEv(4w1rDh9!O|ZvYJ* zS683u@J`3hC0vN~`mM4GU%5m3*i9Xg!uXPT@t#^C&w(I$SvW}M;J-tc4= z2BB)-?p2N{KT*zW=^M~y{?j%KzZ08EUfS4Q-`mmC0{FITlk^WW>Jt*F=O$&dsEM7K6X&uRjDib;;%KiSTfK1s+*E=>ExA`K74H&?pQ);jtu@vZPD+!Y@R`v zGTgzVeUPwEGHY|N|GTsOi%+xt)(h~~*2>mi%yjWt+H0ye`PHi<;GR?INuvoKvfotp zqutq|6#y03l6tLIKiGe@XLQeWl3sJECVSbnA4#5+uZ((EcrP4P ziMm6dy+j4;nrb8Z$OUcB+N#eZ zZ3AVd>#s7xny8m=XRw^q=&z6)DSIp?);0-<77k=*?ub<%Eoq2gV0P~w#08tI2mf52 zsbH4ik9OI9+=}Xp`pyGvP&j5HdSvYr&fxCvP zpCy6IXc7RcBWqN{P5rRa`SoeE=cUAHh9fW^+J^nyPV^M@+KL;+nd%F-~fM!|GefF zSJ|F;7~hREja4EaiNrm(9F!++({Bi%TV>6bJ+ub}%XUOVf}SF`vWCjgAPou%;xo0S z$|?gSJ`ida1+hN9V5HMmJjvc_ey8r zo`D4mOc6K;{?NHh16A(mt|N5;}^}OJ=jaa5{4k zkwR&(*fiJzZaqfXnpKq@!hp?wDP)#S9@i^LR<@ZmRvpQoYV%soC{FD1(>NgLD&bjv z&-$powX{5_wc?$QR@5d{uaH;1uyB`Tv&VIhY%JDM8&jkD+IMZB@=?a2 z@E|fE0|4?pWmNhl0~OT4=yT2JErnN|v$QQG^AI9$FE5c%zH2tC`!tKq_LBkb+RZFN zbc%Ib;ZeeIEt6z`AO{911NuDqQI^FZ_8{B9{$u^rac0U%Ux9uE<#JUvi7U~`JTxIm zN-W6o)es|;A#JNCzsY0v63Gd9a|cfXT-B#gku9h!bxRrG(mu>$7G=oD4{DXqQ~(C6 zN@w;8S^Ug>uGnr4v{KGY_+LQ}HGu{T{{Shg2I@J#hdvNX($A<xb2P2WZ z?qR)WBg<3%F+*qBm3|*6q;{dTY(&|#e1>gtqeqVwtYZDKxxKC57q$(tdnWuI>p%HU zTEVhXiQ;e?bpTN15j-onU@>@)w%eiVYV8|Q_Q*a#wkv9~dMA~-P7f8HNc~0~Ejv{Z z6?G);H`|!)&vN7$26(a$LU(-N0(qBUm9X65rP^{afueFNOwr@2qd z?B=vHVzW@$I<$E?CPURnn*yNmGtCDHKs6!DOq?sUL-^TwFJcgRlK5gzwb#oI&aj;Z z$e3B{3%jwS*)oA+*S)KS7XW_L&A)B^_9knOJi0#S^(bTR<6pk}i!sKxZrgk}fX@JM zg$QuwAbGd+X&-?%`Mto_yEi0HW!Z^hrnfpm?MZia_R1w*8#oiN9L}6OdZXwDfFM-l zNu=JyOp9>{%6p80MxOg&rPA|h{^N*QVgnGTrwMCaYgovX0~TS?E3!teO2vwCe3BMWX!cdd$-F83j|EJlL>R+_7`cf8+Pv6K?MSEb8>ACZmP9EDoywr)`V zTK1Lxdef=-cNm`ocB~muQU2YmNUobm3LhiV zo3dyMABJ!VXmXWU0O1+3ebpv+s_mL+9cecyFX|d5=C}cv+%-+rF`%=SI-f1TC8_)7Ek~P@%74TY2t!!5S+%qdr zdMq6?jFoQ(hZxS3V>4Pu-!)ofGWk5?VASJf{$!RL1sX1cZF)|QUY%7Tpo>mV zI-LTcu4dO+B>9n56z#n)n>8tLB#@C`n!yyUHniW=?7P&rnyH>sp`LO%8`Fq7|CW!r zLuWtB5mRSHQ5BN#RB+n84G+5&{L`P!i$`f-9Gn+rcY0OV_?>YosfXQYC?ny*YaZvF zZ$;XSW2Q7m=`K%)I7|noxqHs=<{Pp1kY}XXa_G8mN3xHax9_uRZI+)Il}-9)kT%R) zqpA;7k6@hr5+>$rec+v3uXx+Y%c>A9^RPFE+;Ik9K;1Q(8g6+s;#9zir(5b&w^V;o%2y*lq-P~ zb37=@CUA6$>K=w(pE|CKye)&em)Z9=l#5*G>cn#IbOb+Fk6*-Cap`m%9U zzqLC`WZZNzw=M* zIwsuLf94y2iOf)UVDSA?^cAqOa|~OOKC2A?G;Y1Wh;f9E1?Q`M6Vu7lq$dD`K`zRC zElZ-%0J*eQ^kH#{Wrj@JYCDs9$`&q}90tv#3p?!VpbM&Vls{9qT@&cw;K3JaFhvFu zH!Bl^IA45H(2?F$o#C(Y19>35zr#V1!Ter4Oq3SfR7opxGGoqVLL%r1-80qm9fl{* zN6L2Mq|(>uE*!0L)_>I5!VzNBkZd~T?|P=%TKq?rCH#~6SD#tnWzb)~T_R4FE{^;1 ziKfSg)U(Q%vEm>5!wf5%?qFsI3tu4bryG;MoztAyl-YE`SHXD@aXrEB;x*Vj;w|Ye;&LIqC+xGO;1WDl(8eh9P zHQ|xoFWM?dXTo=T#h@y6VA1F)V8#r9Qntu?4z|DKkW=Zi?5aUbK)@SOLlfFV?)RaBOmAo z)ov8YtQ0?^9g68UnV8TqApf_xIsu=8bI5mA)oeH09I*>2rv-rx7w+?Vo7+3yhky7I z@T)I@ufA0S9$mLzk22HQb=gOJcbuL5Ws@%ikDe2bf!X zB<@SGoI-1}GI6uJMrMl@{W;GU&dBl>n36ur!BO-9Pr6f})@JDpfATYDyK-REw%Ss| zYix#aN}7&#iNT_yQ+SyCXsh(9k2IVipLX@6KO)c2!>v6>B+Dz!);X6B()$Dftl0Z>P%GB{EGV4F1ygIVmzJ>}|A2_%b5)U5KNns-|B6u;Pi zDPJX%>a5nx>#ki=gs^R2XlEa!!V}hYo-fi;v}BY;%>trd4{fCHc{vL>|7oi z0!grukLd}${Bd=?HL-%czeGth@`||BIu52(uXp`ZU-#0!tC)Hpzl|I)ibcs_Pk)zX z`>qePf4ct3?cGJHRm31oDyVD(+)`4tzL|5N+ju_N%^z}qs@4?cX|;#RI!P<(bJ3T* zokYipZd>KIRbuIhPACCs9=sL!O1!QN39mBFAVl4P4AQ1f3qVrG1jISdC#-1Tkt6xBsB8*EOQ5{t&_ds0C^&fEWfGQbI&I-Fd(8W;udA_U=t3w zRWvJjfS7_{c~wTXOGHzJBoNK&#f}T!cu}n->o^#ztmoI8Lv8*|Gv}n9Yj-{V!Y!ed%aI>|AMr$IvZJdqd4J?eA$CH#CE%s zvBQmhyOp1=#YqaL;E^?Y?YunJnr{S9^7WP&gc`- zXS)MWwe;#g{?K_&Uo7j&KInFU{op$sIWJ3VmfP09=s^mpPEi0qOA3s#>-^d;KXKs9 zW`r-K2Tr7|<1eD;YZTL=Wu2_eXkB!TWq(b>xG?zloB98|Ui!T4(P^wdz3Wk6?x%O9 zh)>(TWB7Q#0dIErL*#K~>p`>q8)!P3Sx%I19%nzSoUB6d9SJ~s%%%lfg30>E0fYn` z;xWSjW;{EJz*ur%O8Bitz<_k$7y(lUB?BwFtee^FACRCq1)N8z_Te49Zon$$1`mv5=8=arpP;?3{Ar8@a>?^=_N z_K+CwqHt$M&;Wk%%fKai6+DyYt9;APRSV>|=u&x)2Fk?%BAkNsZqs|Ue3Avsc*62N zK+$&=Z83}F?$fwgt(g^n!8(Jgv&c8pdZ9e8-u|WCD^sqNqm-fhR6+Wj;TYI0vR?X- zdI#!|ILkok4}`Q7eL)B#Q{p6B*WN+iS8Zd@j%0z*=P2D%C&h{;{oM9E)Xlo`s=+IR zjmkzcu_4|HK++>ILQIK};zf7g_Sv1{8t-~mzNr$-^i<$JaqF_%c(rG;R9T%Y5$}?@ zoH}SsD6*xR+CskTzoJLKBhb*R-Mv+B55|O@Zo3p=%Em|; zbZ{wSeU#Q4mw}`TWm7+@Pj(0!`x%r^k&g%+Ov*iKjN@n+)a1!$s7<#O$_4cy z=A0N&u)AXnL3&lg>g8naeokc1W!A4|sWJzHzbQJSfWEg~qHh`4VgWN> z@a&E1!-}Du>);+^;&fl3dEck;Z!Gss9d#|+JtjP??b*_3D1MON45+9MDv}e!l8TJt z*D10!F?8D`=7h{D3JobS(vS7;Y=OJI4ebWG_9b0?CaWM(I?_=fWs>rlBwB)CJyR1= z*{jmMX91=iMhnZc8C}$r;}EQm-*&R00inu5LT>WBjC@M z04lI9(yTn&+p5^QCuJtZjlp|FDaA9wVxI7w{PB`MVxs9gBYq3IQvyn-Bhy93(`Anm zDuc#2vL{-W1r1P@FGxDeK~vz9wL_Q+==-^g2y>rg4qR|@ftNis*4WCz*!>-@Xiaw<1jq8lPbgg`9{oWr4gtX)h zpnWui-rHWU0L>6SQ}3$Uake)iM4sC3Y<0>VFhgI)ZjdA+0I4tfP&-Yav`+?=+-nb$ zaD_DE9)3|C|ClX|$U$1ull9aJYE&SvWy)KpHK{S_kv;u+$K}2>Hrmf>IEd_loE4NS zQrJ+)fKluScI5*|%@Fz+l*>Uw>Ol0332v~j*?+_sC>B}~kj&>|w^>%sQ>0PnE zd@;es=t*e;Uo_NC3EIxaI{CrZ^FoOW9qUPb!?SImU#s`M+lwk=BwzUZobeWa7Xp`u z&;x1vGCkUBIUQTVnPMmmwXA>rwp%!!HYivU?TebM_|9jW9--vB_oG!4MK`j-W(%aL zu-*^tOFfwW+b#DDoqxGqCT*AP>X3zCXufUtzp9;5z9@>yaQ-f8R{kcbByqMYO55ps z21WbGJH^}EGS0ew2mxuwis+DWzP!hZ=*$|A)FiU+`nZ~1m`8ie@|TFvRu|c>btgBh zSCV&T^M%fcP_UFY10_o5gfChSw}nW5Ws!XVwi`@;JMgv#>onH4-R$3fbbajW(H?U@ z{mTIy@zP80^Ev;OuZ>YI0Gp}nX|zSCTQs{aTWjc-Ivadgoc@AY#&O+UIueiioaJnI zfq()_0YlJ12d(aa>)`?L0LywOK<+GE7ew==o@JbQTg#wBr8BKlZG{Zb^*wrHESpJM zHJ~fM(k0kJ;?6E2O%!X%)^w70&0KYO8r&AJa0US@SE2ae$=m7;pekUvXwTPMNY1u< z#(H><&Vr>8=)vJvzV-&qt4s6Un8Ankv599|6lRmf`3V~x#YexU!Bi<+|Ea4W>r;^f zfzqg~DC~zb9bB_UfVCxbwXX=O;4lRozOuK9?93lQ1ASr8!7*pq7fRJ&js_DW*#K22_Sp6m8nA8Sp^z zi87c$OQ1TOa_rPri*pP$^Gh>mibnmdVS=z&F|1=O1FmHU_zZQ(gGa_evX`yUy=c;L zcQ$MNI?Tsq@Y-^3Eaej`Z!_kpL*!2lsNJ_z8!=#2Q10PY@3TKtzboMH z+21Q0bYkr*$6|ZVMcT=v&y$Q*b`67_K1|;8-kxenAN)E4AS`$$&)Z;-BTkeKThQJy zXu&=$AGm%3UZDxH#H7EW-fq4`tn!*0Y*fXRuhZ zHehyuwes{@csEQ=-sFFd_Fe_@dB4-kL8xn8XIRg7&i|`r?>vpQKIdeE&;}FC$RMWF z<@Ju4W%UCS=Sc3?rDo8(alFXD>!ke9ZWcDl6*AN=D9BFG}{h181 zzvW-CDXK%1VNZ;RJ`o#}FqqgUvgPuAdsp;D`$u$=k7fC(U#K=_V6)Q%zS6G3G=47( zL-IG_y_Hmx809+&ms(|Bx?q52NLLa_wSB#xQ}7{OtUtz+(jR-f)e*I{l|BQFKc&(3 z?>m54c^2Fdoz?P-{vfy2>&cexC!Xyu7DvL)%5c`$k;R4lrER=HQ3EI%Sl@VS3?0^ z&$bg_NP0T=_D**G%gK}8jJQ`kTSlrJ-*P4BD1<9xnYARNtZMH$fR#g=cGZiMT98TK zl%FiTb`+no9tsLO6>@LaXkkjX*t>_rJz4Zd+st5?nL)5*P8y6gU}3vU9%2?~&+EkZ z-rvOo7q(iE?8yg6MnV#4s)Rw4w2K3g5O+3Y%^8~P!k@jgK3Ae$bfr~SmY93eUxeSr z<9f|xWTZ2GIY>&@TNSXfFC*#CQ~wrW#GKGUS*9aZ%Wrg=EqoLQFr7Jj7MY$DhCC*e zWXIpte+q%Z0@72Rk_4zKufsYt5*l3^@53xIL*h38dsfS!*0aGnDA6uUoZ`bW<61or z>C|es4M^8PmmrXK&2n-}lup69H3L9IMfvTfP?H)~<&!p{wS|CMJ<<s~F1r3?j;zjX<(=l#VAdz`(vCE}*{lfeL$&_CP_a0$LelYP$2WF2QIu7`MGA zZUf5#)q{5r_jSfYcP2#)xAc zazn7E>^5;0;hPx;bS5WhI=4YEgWJle6Pn6S(m7bw%7iF`mkB+p*E=g0G|t4q)D(G2 zEt25sPUec6sDZY0f9a*la6Fg}LG{FS^?&?$?%_ zq3ug7X3x3o7DJuTrRPy|4$^nXEV8RvIpjylZ}m~>vG4RmZ8568RF?<>7vo8|sHC>J zf2NG59r0aTfckymM=UM(dPFfX`?IcQ_lWZ%+O++~W#_Fw3MmvzR$08i>pu$Vt{MBR zuHL^q0Fw$3Hwm(vW0=uAtTIIZDx}Fq7xvt<5luL^k0l)^_}o1aRA~w zaKaU+jS(#CTy}>vqkL;0!8i`;wH| zc___ifARdYwB0By@a!)Zt2muSC)B1r=yqU*`JBsGhXX!Bmf!K2y2ERW`uf=N_TX;n*HI#(uT1!{l1Uy-0 zBY;+tlR`C3s*~JK15z4qX6qC&x#|QeL06hM9c;U!4ITDKC{AI0E|RR3C-)`jm$%!Z zoyO|0O3Mzr*K|hW&)#4~Z>>@+`=B@#5uF9g#i?54dd1J%mYenAB+@X&L3|nP;z_gbNov#>9qpnhd&@44boRD70-gV%BaB0fZdlxl55)=cE>zOiQ4P-Q z1`UB1tC!KOI}x0NRoNlXjJby*NJ$Af)l&{|2e~r?y(3o#_o)wjCkD_i%+w%ac51fI za&V~*fCbYsTO#DHfmfzuR$ui|7M*#ipE$ySODMfp-AkstoU(-Y)TPRZO8RyI9nG{O z|4W_<9TLJlJExXZOZ%!VkdEQt){6LK2x`TG;!Rak{b|*wh2xx+Ce#KwvYk~m^_fdb1u8&1*+JTE;%69QPvTPQ;)F=4 zi;Rm!X1{y>S|4;ik~$A8YcLb%^hMr z1Af5DigM6$vKcJ^>49Z%aLHHEUllMIqyDF*e-!l-IK_8KKN4c6cE7pMpaD|0Nw<+n z@k<*|PLyEQ)6(mjDQSYasY7gP$x!(Ydtngl5d6}yhuTT*zs3MI`(G^que|O0-BJf- zjFdcg>KU190K^Uz%X%|l!IF?DwZXImACoGv z`>fx22ZA;gU@N{_$!X&`ajY7s^g(Q(PGHvH$wFs^zo}s7ZBRQ|P^+EpXc_ovQR1F= zPRo#aXD5jvrjd}q0|xN`$$$(Bfe0ZOfW;s}NJxnoATePM5n_szK{6l-iX)OJZW3b0 zb~|ymohEh^Co~}m4g^RD0UT`PIB~nX>Z|X4&tkCG^|Q`>m!0me>ME4yRK4GG-}l*P z@AZ4FwfA1%BU+p1?_IMpT>WYHYG71~gE8_ORMAV+`4`QKWiY zejWyGv6$4n?karM_vi1Szx?uP{rkQGe(neOIDXy7$HLri?DzuU>tDmK{o5CQ=br@d zpGD!TZhWrufQ*&8#HJ6B5lKL=L#}#u^olM;pb4~?4se`}bHT?Rg77+fo!^`*;OU9- zLMP1#@Ds7yX$f4bj|k`hgZh9y%W-oTgzeR@X;I>~cvM1CkQ7#m*Ctfr9(-;svt+=_ z%D-li>qaV-la4|~abE_w9qKbc>z52@qWWPGKjg^p`tFKU$xG7l_(skq#)Q3Pl)=tm zC^rj#Zi$F+g>&7t4*0ZjYoM>4qir z{-<8Q0C=;Y@Fa^{oZVBhZ{sNd&FYI9ldnSG!2{i4_^H~IXp(O^WN@~d&q536S*+qI ziQfrd(zksS@~Ikosqm9W+oxdo!V!ocCXRA%{g(J+H1L1HgoJpBs3gnDU(!$`lT6l< z~;`6JdLbOUopS6}LmzQh%&3X2R-49<wyYNKg_6fwvxnTjJ-6Wuvb8w_cg6p# zyeoX*^zS8#Oc{W}#kblI{}l7Neyps%Fz;wBppUFyJ@|N#ENz(Ukly)?70nUVr{7&E zDBIm5Fn&k`UYxrUYk2F~t5V>&k=Q!440BgtyFUik-QZ$osn6&u_4~LC<=>Ca(?%jc zdEnsn=pW=@jzM7loW=nm=$tf7&*@J)pZQ+8~SIlxj6O% zXNmJ#e5=<@WaLMhgJhl1;zWUjnl4TDwQT z>@%t#M{e@t<)aXWc=5ZsfgAYhs_XNg#pfUV;_2l-@`8pR$G^YhV`1($b}*-_>;A!? z{Br%w--^cX0{UB^zLHnUu=z2fB9pBJA{~C8RZHIC_3dC;b<&Dqf&mZBoRiac?b<8= zoYX4&RkEPyjyM;=R9$$IzT4H{Cmla;&oCHNfDVJsU>+;|B&P+I?U8087;!AYhWMSc zHv=!FaQI2!k0Dx;5N`#nTYwp8IxlR8hL!a`BNgo+lQadS0=ypuhG{byK|@_Wk{w{( z(vZijPeD7$TpUPUI@-080qmXfomfTyi3$<*6he)31Jis3Z3UZ=lX8*C4BGZo7RXG& zx-?(oIF^?iPHCCa`X_S@`y(~R$vXAFNfSTE7>@7?}z-$&kpJ_@~Xz& zsH?hf-#i8HX?J&@=ZXc7wkg@_tYc~tm#Xw_9c};MM9a)T4|d~ZMSWE8yvN@HVUKco zZ!b*j|OKK=M*r1K_hcdG1soTtPonEjJI<=R-jwCIaR` zc2M)o$MQNm$DoY3aVMOL_4pyYR!P+w1V+%7 zym`kLm#nRg^l5od(!4jC6jBMmfZjK8w-;}0BOS!kZxh$e?}R_`r2G$o?b2JP3BAZ? z|K=)>Ui6tCc@q7x2SwSZeBcv&KS(^ckUU7P##Z_iZ6e3xPmA99ViEJQ(a+L{B;-Hg zlj>49!>p;z7uyUmnI@DOk)K!>#sppNf#hE=`}AxKkL@_#p~Jv<>KhdumHi_6`U3Wg#qft)1;3-=?Irdgiv+oqCdWUMXAQSYj_w|$ue z`l7X$Hptu|V{KJnMWxM01ut!f?W4aGNN@x$lPk`I!PktPK1QENk-N7ddLhk(y0RFC zpup@(nS?MjuZ43i*(Uu<@o!`x91UiNhkM1j(I6M0@=hep-X_14a>)Z@mXx(H2W5<- zt*jVl16VreOWu4}m`5B#XgyP|8aJJ2gT}+z0|$gj6=z9dyzHm}Z!mB9Do#Xf%{#$- z{>X9clQ-jB=Y8q@XMXJmf8t*Se%~kHfAIw$$8YHPSeW~bAKwDFKI8lUT=m!g3=02A zoX6ImcPS5G5lRX`yel-S=6Zcy2Y~@ZYz#nwk!Jv4T(WQyWfZu}(Gv~@axtOM5Q+4W zOdBlM^r#$^A`A$f2jDBN96<9TB~PQ-G;B zA4y895r1Ns;R0gLt{|Q8wv&~qB^eWpf7r3WetLb=JTESF`iZP4@vxCwDV)=qLTD_#p39 zK~T$V*2OZuRYRd@B3FJ9(C+U#I6E@-hA5l<{-329^8ei_HAZ4E%IG1I$~ujHRcPLL?f zXSfAol7q?{pW%_7co32doH9TSvD2cZ|557h2^jOX!{Db$i( z46UPYit^a>rMm0Lyw;QnZ7PwEdLdpm}et57%2b!T^|>{A+|Y3G#u)eztg=dbms+@T);@H zc9p5+Z+>3rl6ETQKMEkXvOkY{6^N-`9Z~Znjt$Acrb-R5o z-lbt|kK8%^^TTn_1D!2@-kfkiJp}cE%Z1F1Gt^|OTsQ{t(?~VcjF7dE_>kQYH}~j% zx$4t*8vSp5M*sXd`)^!0Ya}1XZ{YZNE9-CkXw1T9HU3%P`inq+&B(*u@&=x_Wflru z#ko?h(QzH$|MXy}9*6DuZE$W^w=v-MS$-E(_~qfq@xZQ03@h*24%=<7%zLE3o`GB> zY0+%D`1aUxM4I23WRlc|p7$|*DLF6w;>5jQ7DyiId4A$iZ+>mjpoJNjkE6MUvJ|k4 zp2@U#QabukRRTfrEiDdO`i+w->W%syK??GFFAKPb8L4-`jU0MtMXZ~-c8f}Xm{-zS zw7=&fAJcKaT+|5zRwC9T;=|lCh-7}6dC8ir^>|7om8lDJB9q3rM`?_X(5r1O+5VBc zzSEiQJ^DFIB8>FVPjw2k4vES+bPW?$cxIXDw)nKylsZccvQ zBpHMQE|hRlPOVZ#Pf0iFH)^S?VX6){?bft>=r`wEuHFb!@S;kXiPz%9moAy@t_{D!bq7G|xZKM~y>(t#P5L_dnd|u*sVqol{;d=~rN6ee zbpvtYaP$Y9ijlSsRP?#R1kR$M-Kh>1&cN$7H^WBgFc;sfu#{9T478pZcR*uR=ptmq zfhG=I^0~|{3Ku@1z+32xvJ*a?a`ZdAlxe z@jtwNntm_qIw`2j@~k?2^abPX`OUK4xXn1H4T-+YPnR)|J`%Sa7Uk8Z2Q#+i56SZA z=308P+%7Fv6k`brg-@dIm~_yG>i~B^h`-p!HP|5x^xIgEk6jwKamAR_#})V-ZS{|O z4BQSIWCbu&N-kUzr(Tb+0qKW6RbdCyA9cd9S1i43gQ?%aCdagBA2O6o+xC<`B@94W z9?RY=U)y-{7;z3^bD@WnDRuB7FC=!sw5xyTzPq9|dT`PW7ePR@>n^kN>q(KST5%lK z?<%pF-zhM~qKFl=o&}1GL&V>ROPW)L{YWbcOo!*3|GIJ@qgVNR&-a>*1o^eESs0Gj zia*Y?K};8A9W1tZ;wSe>Yv@1wgJ1jAKYf1v?QcEhE|4cMRYFYGoyhqD{<-I;0mM=_=hEj2fZe%f7o#z2={>VR zJ1&qkzAPs2#R=19=5;d%Bd|WuCR{!{SF83ot?vZVD?p!pGvWraDLV{#t*9A{yg)?n zPpPAzCA;aMbjeIO7+;XrA zt)-|uc__RWOZRR$M>~RPBentoW@o)EXq^GK0AHp$3YKYZDUb-J&jzG>e8jpBn?NQS zz*6E;&ZA0$=}lP|v;(tOzApS#!96CEGNmE7)o*vzm4v*(y{wChL}bR)tv^u-nlH>* z3ob*C={?s-BMqohj$?JmW>u21U&~f0)sVu4zsg{sY7AFaa5wtJT@cz@Fjz1AOH|Z% zK-s=^$o409A@+kfvLDbqe?V!W;yfrX_pS;)J^aU$-R&X|-E6>GH19Z2A%mf57w5bR zGca=%kC0YJCHJZGbKTfOLLF1x9f!Ce17u}U#WnU6@?d&$$G&mbJ2}~tpVdnyM2k3P z;X!BnzckNy8I&t;O+RgVxTFNS(2u!)?Op4$|9s6F&Fg_Cuf|I)U>;N{phiCoWVokALjj#j18nRF+E*q zY?(IUSUC+djmq4%%ojJrsy-o|ShuV%T@rI`qeL%;1}~Cz1^dbfeW2!GJ$PNRV@pE|x>N5zh z$L~Mnv!@R!!(y5#KhFhV(yBPb-!0VlPoHuRFZ%S9KQ(Ud! zhvWGoj?A_3TeJ3+%y*0|;9*}a0xB6%dxQ9{OyY;#`C8~AWd!e@Pxl=Fbgt(_aCYRu zAAOH}3!ML|$9f3VqwQKy;>5~Qe{jYbo3T_#HbK2jn|Uz|a<_bux5jAE>xX}v5eK}* z#QXLg{F;o%QP0j^PCp{ctNmaH66x;{<=>pvOw0LR{*K4_@tc+Esy5-K-9%tjK!4iX z72e#7Y zC{N(J_Lbdxgt6jcR&P^(oRapOmyU?lGtoP8 zy3H&wzT>J1SNdJW<@qWuZp39{L#!zppPBX}ftV!vlZ}fuP8~RX5fFH?7vCknk=0c> zN=EGx*0#FHAz6}hddq;%~iogjWw z1yNj2pYs1Mtc77vepv-p>MJXlz1Xm;taOcNz8-X3Yy8(XpB6n~)s|H`M%p2Byo@nH zUxzFht7&7PC%I?p2Uzl5B)9mZUhU0sHWBLoZfrVtUAsJxiXZwC{*x#QFJe zd(unGEp*?7`U>cOtv`SN7th(>y*U0je*MQs#oTZ1kZX0{fB35FzuLfms?onzsP9y_ z3n*Mp@VGL*>yz$-QbwhnK>||`K#Wt%iHLat!Dm;r>Jp%GF{)xlxBET=mJI()Ww?lK3v0_T zZMS>gE@nfK3#ZR5QMU8aLyM(UBj*U%+TqjKZNUXEM1@`b8Zt~Ztl7)$)x)Ci)Yc0C zC)WL9K5Lr2-CIJ-1%qwplR)*pxSkzVUfbtg^b|$sbtxPDA}G_^9^Ub|spDk+)m6^R z;5}l&l?Taq=>8=oDgFFhC>tCdEWe`lrgiz(<9Es-D@WHDFM3V8c+yi)MN(huOww=# z4JSu!%;c3NPlbvCsW-T6+EOXf*vhX@+oU;S2vWieZcQWgV}d3QzOkQS^n^>lGluo7 zioLK%;y)|4zU=%jzjzpoXo~8NkqIkxdh+4L3mSEv;cNABr~(y)@Eek2(Jp6F|oCZopS zvJc57?%6xM_z2w6n}a4kL4Suo*-q-6{W-3de)fd&BL9|zy|eRXEo_7`IU|1-RFME&kvZv?beY|NQWOlBMI4PTMWGu}K(w578P4j+B%w~@Ptp|i|ly86FX ze*Mhjk{)N}n?B1Y(5bS&0i|d?ND{J$I4>OD@}vW>tE|kss$MX|j};*=0dT0^`9}eL z9x+`8ac7Jb?|=rfUvB;i#ChuuDN zQ1v~D5N|sSbPSrFN3+WqKY3`iu{c>1;Kb{ZEa)g&rGXlT6m35LkkMNkX zY2uj`8E`)_V9k%4|Go2gemL6PCEkZVPJ+)4)II+^22E{}*y^6CRn6XgjL&2&cXYY4 zRaH}=w{_GKxP*<6xs5fpgWtHCnx>egi(Y3O!`ZO?d*vnBgo|*bhABbcv}pM%<)*$m zCO47`&t?L~a}uUW=m%BHj~`N?&(c|Qw>J|x3L@o0mw6-+N`Tt@5ORnUT>a~p>o=c! z%;kEozdw9z=@$jv!pSsjAf=ytBnCu(Ii9OBD6dm7z#V=_Kd-t|g#u+?*FGKgXc`Jy zG_pX49WBsp3G^tmlZP#xdde(uoC&M^HZd}Gjb8ZMyY?qeJ{BIcZS<$m8)V+?+T{uz zm>kE3-MzJEpE|tV6UO?!!OAHPoc3Ooy+oHBw+xkil%M-LaaL<0vXB9;y9rk!t zd~ADib@##6XrBv^5$p3q>{$#6G_FVcVDm6}hxzQflOutn5G}3F?}Y9|EQm^0svS%O z?!NC?n!}CmGaZs&N`J16h%F^BuGoHdC7Lma?sAqOZk^|w>sd87niB@2`bN#RL0v`M zVnvG=A#K3K0leU5QF6VNw^=_bsrbF2IIpYA zv|)`v|304|6Le%{TH<0>rkyGvo}0=%@fHt?2ZQuM{Ku>j;be_1stG@KCGSbthg6vc#QZ_RltIqgcm43jEE!LNhdi-+mQ`Mef zjpw++zJdqgMd(j@_hRmPerm|;Nh6=dw|_&l-!@buC-yIWNZtkKFlE}s17gANJd?1b z>$HdT!4eJT*$6{_rOtU?^ffSc591o?SDX14 z`C?Oc?KoqF>-t`_M6gu&!Cm%2TU|`vjWLhhI68bYK5VmbzEZBtCUNY=u|yZ3ojGBtL3o|lZ^^)bxcVN+%)(HvMdTuqehxvVeBVK^ z3?bzphPT}It-PfkOGXpBWF$F~ZyHzX6OGP(toO_h!M97S_(we+!Xo$)n8nptX7J^zLh^mTdS@T?a8w!`b&c#|jd|16G zTi<)?R+5*j0%DGkCP@8y{VUUqr!oq93?-|hs;o0zAD4wJM8}+v<#3g&VZW8WBv|lv zrnNhq{#ap)wQ5)-ua%FHg6_$EccMZwm!&hAAO5}ILO$##sC)=}@}E3k#AxY9NpY;^ z(5IR5_z{rVS7?gX68O0ku+^d8UaEJAMFC~Gh>&_Xrgw=pw%)K+4|&wY1}XWG==Ico zU(H92(J2yQpH+30g9_K@%bMIoWoOt%-#;5Nh8C8LqY=AOJ*P;`b3ADrD|) zpE{+BRkjJ*WRvB}F7_v(fj&0;4`}Qd#IEVkeDOxuWcbKYjLK;?P5OM=m+HIba~KqZz59dYtqdV=K3;&d*-Zsz*pKOLMkNoL=~5u8|q# zTdRVevOZ8?{wUGupZkY3m068Tm8a^iXRH!pz|~S?50N zQ{bf|(N!UwB$3`A zGDFIE@Q8o%yCtVhb9NDozX;KC3+&k}a3tDu$mp`Ij@??%3|Xm%xRztl;Kv7)!7a@3 zXZHV${~N<|TDW`J*l!#bgK0V`ONri?L3w!-W!Dx7QW`iFag@PJrDkoTtO2S{7gc6K z8TKRZNFNk@gni^fJizn^iW#e7knGn({{r`r3FY*#=fZ66tfC6*j>m}mV!fcX;e7ycp_);8$8jru8wiPa76U?p|BrIq8a2?+bmqyXyQZR(}n zl27g5j`R(zD``vC0B7{CQ9nkHpjMNFbS$kE`FdXX+8=j1p2=QndMAzGhIIpK1t8~T|V6G&AW2;l})_X zm?H4!Ep@i{&5KFx>@`f-Hq69Ei{Ot%42`W(0#jm9K>V)pldFR*3zOLYTC5rQ1b}pi z#Uy4D^y>`4m2&g-7E3HzH1kH|try`UA)~wip!rN5SC~DKMZeJ|t5AsbORighcaX3) zS>s5!l+~&_+wdRqa;)GU(fWC4(-rJ9WS%k*8kcYc&Doo7bE%1$vs&I=DBe!@l#J=8$cWK#b796|NHHXh3gXDI=u?%SBxa=VYdyIeBKPPfHY9saI zd?)No_6+@Y@X(m{#v)c;K?BbG&g)}6G*-YKQ9gotFCx&m$F(A5>kfJX*F`Coy&N(f zp`O8V!{Iv&KYFqKwL8|LzWF>J*{i3Ro(EyK7Ef;=5BY3C3R6k9g$ScCitJI=g3cH&8kN-!~bnA0M}} z{^pLJf1d&T4Dh`_SA|~$@O_}ZYGn&fsb8*KfK=gXlLR|2aW=A^Enz3Gf~H5@sAiv4 z=&Gu!E>z?08|Ti{T0YHxKZILB?|zu18OzO8^%jd#{NGIGgm5jd4_q4g82_t~``K(? zKwXzW&_GxZhAMC<5+6QW1PF1IuYXFXvbz@9OlHde@#k11%qoN>JPI)Tilm}Y@%!__ zO{Ld1-eaUE=5J3=U#}-6dGU|}#gYvWy34NC=cnLBQ3wnYC9m(s*e@E#C~8baCfHbE z)iz4uxvXb}>&4mXrS(sXJemzP`+P|3y?}Y?^O&0ra`S$UyHD~tV|g{TQ)H*xN&6nv z{O^yD|Jc@9n3*>RrWM2@jneD5T|>zXCK*BDyt@9)y>gQ`GO9igxF_>T#8hQOo^krjlt#wgvm(}E zW$U_rm}hJd3BxlgJ<+(45bY1Kjitp+x2gxm*vCXjxkr-JI~iJlpOjLgX@*_|;-eY1 zJqc3=kTk(B228lU+?62okU+g7kyuIoSWyjBeNtD#sr(H877a9jXwi7DpjQ4d&|Q4Rd?H7eR=56RYZy{glR>TRkVHty@2X;d8wWfp}x^ z9Sp^J;QqzfqRhoSu}aFoWXTnio@g|K~Hz;qK@p!vat9K;&C*!Y!o5;j6^lQ#kbU_O;cxAr=4SsA0iDd ziQDUOAj(6CTE*aU1k)E;l)YCskAA zGKOfaQ-rzcJvMWG_)=A0q46)@Uw-gM&dHCLKK!VTk6T%P^T&A3`F!8?^Hu%ds>0vc zeHQ3cMMQMoC_J4!Q=`euvUj*tSQ7vs9%MX^*{wPytI;m~vYF=b@yWHB@S&tPIdxHR z#I~G83yhM@_@rHl1T}V;=L&l#NY^Xos1oo=Jrkt$T$z=HwwVrKJi>`C6(GH1ZIMh; zJvwE8;Z6oS%}tMe+v$`>*BS=8-A#65fPRp?2qF;o`Z=OdNGTI0UmLo3$};Hgq47EX zx!qt_)5*X>CIWhn=b%-wgC}R4aMkY8R>D9oFQ?+c9}ve znd|!oi&CFrd$VT!(A$EI7n_+&+dhAta5{z^K3$K;f{zZ*ZemgJL0{e+dIr95ZXv&P z9;x%xpUje?HqQ8(ir=Hn^LB!EWuD9X6Og>Stc0Nu_T^gz?7WYPf)v(T#M$HXH;-e# z7V9#To=HdgbH#8eU!How`Nw5cCjXOkASM8{`nQ@MOF8AY7J6r%A*D1(6>rszHudOl z_%+GKB_UJZ7S^Gcqg&1Zo3p{h08(b!Z3iUDV|Cai?2C!x?`!~pCSy0cPVRAqs;Do< z&_H3@<#PN&ny$tR{FjV7V=^m<>8V+1H+?Oi3j3<0h4hV|3CBhg?GP<~8C&JH75xKp zN~GVW{Z9YnkxHMSOS_{!JNySQJyEeri1i&~=k}ttlvEEo^%MhC=L0wias1c) zchJb*pMu_aw8y898uNq@p_h4~R@{o4ZocHh>%;$!OeS@jI1%jOR9)SHS7{HxEa(UR ze*#Wr=N$8lxw!q<3pV!4@eB~d^*aY!HdrcPXv#TtUXEiM;h*OL-K`?fvit<)nC+ z>GLnr@1bYM6P4R!fbLuI&~QGN&S%Kuu+ZD+g_5sOu07(nCHa66$@$0 zfl<$b506j90nl{T{-Tjmc^dpy>m5f^4Lb+54}?|t#G$D|o`a!^4&-O12VveEU~`RdEHK3EAV;iKlIsD{-}(=UKu^BrOqQ1|s?LZ(N=%;N(g$z|@QTNbAyCv8`_=w5hVIG>5t%lTJ`EWB$!-qX-+-c^sCTMT25#qx_J^vI}u zb0Ax8{BDoGFz~{2ktQd2Y6c~;Gq2}DvThFzs-sw+7jpuk^m=1YsAASeYWWmT_G`yv zREhG#hn*XTST!j<(&V}lWG6T_>csWgMJ<~1sK>cIL3+i;<-=Uy)}kc+4p1dt*++z3 zeZ^R2d{6d!+w=}2rs(xU0GAVfnnG$`G+1T_qjc*OC*Ub-%PslBEGp=oK0!>yc)I?o zq%_@?F3oZ3I`;*{L}v6R4C%8eIvG_?_S1#Xt*2p^WYJ4%J$7IDqZf+Xhzkt92h?3J zF^9Nk{wxyu##erN#ieN*{ORYh$;5O^Y!-=Dls)YkznFlm+&JW&`Ll-P%>dZEYJ-+O zfO423K-ob6U7-z`kiYrdT1y8hTouogjPn(OU>xoVI5OEj`Xk=C=ZH0+y}G>)z4Wz0 z$K^gi*+Vi;NaJW5ekq4ux9BAu9dg|INid06F1@)QHaVf~{BXtCmIUqV2!JmHQNLVR z4m~k7!{awGBOPzAO!~dZRxvtse-}3xfL!d2ILe;aJ*1?aR_9-WA^8a_^kjR>_vmkf zu`6yp+W<8ybNS3iA5BvkQt$GnCv7J@O{&ct#yF|Bl9Yf&L6FSWJS_1TOA2wZNd1#ej2@@^00?FUa^pv)|| zdfM`f-HzepFq*pv8leG}CX;Q&wAXbdF(K(Fn)f3Jbo}#ASw%)(RGAQi_54r4Z~ih_ z;Do^Xfp!0kMG@RLMU?F9KH?$!OuXKA9Ji<%?5)+ghm9jq2f^iOHI(&~CP0%gtA55; z{|tDG7-wUyEaJKVRX=vZ#Bml9cQ!{pl2#=dX$7prE7@I>jD{vyvda`26Ljh<6A{pk z`?UL1&L$*U3UuUrKKDb$hnPEtvY$}E`Q4Z0WMyRorw_@PeC!0wiP$6xBhRWm*;67g zV?Axu3w@+z#K2pPaq@O^Qmi9LNal97L8p0CZh(x4q3+ z{BiQqTeO2DmXBmI%oP(lkA*5-V;rG;<$YqYX8c*uA^>oHy0HxA?D?jwZo=I5RAHG zAj0BiBD`^)21gv&{uQx^))=PZNVgP$^)mIqS^LPPHTCXW5m%LBcgrU?MjVf}Ja-%u zuE&BSeLzwwtNn>FsEm7*bo{8=PxR@ivV!F<9#ggJzA zdC*{18w;qZp(KLTipi0S*cJkD)P{CT%7{a3U*ktNSVDeMg}a$Ml7eFccjQYg8D-zy zQ@5d5Wk}xS@wMW?T?5tjPwdKEZE$E%D9k6{|XUWv`?cwk;%@$q6=)|y_U5cEHGtVrdhW3~F$H~RV<|DU`>P}Js>AW2? z%mk2q_NL$Js$i}s4v%&zt1|AlG&sPKxSJT-+YTzpMj*LjIqrGO^uKt0?+5?e)AHZg z!S3VuO&uQ6fx+6ubiz&=K3fcHI2;=|Ww%};jT=_`*iaj|#Mj8f+|g9vDV5LEq!zYacc?g8H_ATJ4_U`kZR%O#15Re+A%I(qv6as4+=|x_3kXl<>ci z){waO7#N?lFo2WTq?vN*u%;Yf5`pz*Ln}MgQ$YD{ni-5s>e6e*UcBj3lNr&hMKPug zi`YZzf8UDDqm5KKH_3?&`AN7s2W`AvWG0y-rwG%O@Vb=f%>V zKU{gH6oWv(<{`)y@jz$Y7**}$^O78+>uK}q(rf?RqUb5@InGk%;R-U$@0x@qFYm-m zz5*!he5K_5_B>s7X9vbKXlfWnd zvj<<$bA=0|{#V_qi$pZW*CpR4ZW|*rO*@yA`gyq6@N!K>4WZ-Ec0Fvs(A}1?4pxJD z+hi>Wba95U;ytpPSX)&RSz# zak+JD+8VkQST-Hmh{iA596SyYEf>q!f5rjYhf~8H2VU~@=Z1141d?&cN7BV>hA)|T z&RadVdddZsLk;udfPzJ;YTb^xbO8vb-M_c$Bxi-=Sh8F5o#1bWE+3TLqmV-jxxD4I z3NHy{V9g_=P=g~+Z>W)PS<(o3VJbo<8!#sj0$MgWZ({#aSAEsEfA#+I!el1 zZMCVLI6QQRmQVk)n|OE_)|hnIEnTg!p5>#&j}oK(S8PAVja^#vj`?A8@v3p2KjbMD z;0lPWR_KRrTb;{bH2lzm%040|iL6yWJ@bkNC0ekKZHN0c^kXLS`!HuE%x<4HqKc-x z9!WoUn7P|cI0_%{oQ#pe;G1R}=e-+`7ug1RrYAluObGi4HYEqocpn2)>Klvx2aNE% z(orF5R1n{>&fI9v#QR?TSmH9(vjf}nK=7{pe68^~K`lb(271LEv9}O;V?AwLP)sZe z8#cX|w!6ZD!aDZ*#-btS6x$RHZ|_@vBdgT4llnSB2+IY9o3?zALEmy#Kq+2 zq}lh7U!AlloVR(f6z6{#ci~Dk@>0@A=x)W8gOMVKafzUs`aJwIV;S+Dwl`@-#`Au) zhd%j+`pX3{@UBoVwx$mpE7}zc>n(SQZ6|&y0lV8bJE;1a!zhobv7eM-qj87+POj7w zhm=*61RzPD^@*O?NIzry!acWb6Sq!-&~jRG$WnsAYFbZo_{GRpYP*!?7K{#}6yiTPtoYf2PxdRq3x zKt^R@i0tOF9TC7Q#t2$fg{8Pk45qv@08GqU3oHJY<7b82;!y!5HZgL1;N@DTYZvnX zRcIZ0`q@8DjGb3ej6GaK-?>IFeP~F3thsB+i2Am9$I7~l zYxMTXuXJ%#R_gj0IOanp-ZL$?r(N;ll=pnEnz(;r>D^fem)YW4jmOvB$1!QUxId?5^T&iNCob^Y*%37~pAYf`9f(n%KjI3IV2-tHhpADnP- z2Jmc0s%z*X1-j41sdfBTh{~m);{jZF09&bAKp8$KJV}_t+m#!Ly#&50dIE44Z-y@O zkrR73!7NB+XXCRBf

4Wmlos4q3C2lGh2EMeYGl)}Mi5SPcV9PS>Z7ls8OD6Qat% zZkqIzKRhmcKI7p`2;$%C=)Y!Abd>B%0D@S6EKpS=B23Ky+ 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

|1JJZeVw;3u%24Vc@%AbO>&zh5rK;y>@G{G^r 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 mBMJvR{?=ssYnCO6AHAZwT;5nYib( onRetry = e => + Console.WriteLine($" Retry #{e.AttemptNumber}, waiting {e.RetryDelay.TotalMilliseconds:F0}ms"); + +var retryPipeline = Pipeline.Create(b => b + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromMilliseconds(100)), + UseJitter = true, + OnRetry = onRetry, + })); + +var attemptCount = 0; +var result = await retryPipeline.ExecuteAsync(ct => +{ + attemptCount++; + if (attemptCount < 3) + { + throw new HttpRequestException($"Transient failure (attempt {attemptCount})"); + } + + return new ValueTask("Success!"); +}); + +Console.WriteLine($" Result: {result} (after {attemptCount} attempts)"); +Console.WriteLine(); + +// ────────────────────────────────────────────────────────────────── +// 2. Timeout +// ────────────────────────────────────────────────────────────────── + +Console.WriteLine("2. Timeout"); +Console.WriteLine("──────────"); + +Action onTimeout = e => + Console.WriteLine($" Timed out after {e.ElapsedTime.TotalMilliseconds:F0}ms"); + +var timeoutPipeline = Pipeline.Create(b => b + .AddTimeout(new TimeoutStrategyOptions + { + Timeout = TimeSpan.FromMilliseconds(500), + OnTimeout = onTimeout, + })); + +try +{ + await timeoutPipeline.ExecuteAsync(async ct => + { + await Task.Delay(TimeSpan.FromSeconds(5), ct); + return "should not reach"; + }); +} +catch (TimeoutRejectedException ex) +{ + Console.WriteLine($" Caught: {ex.GetType().Name} ({ex.ConfiguredTimeout.TotalMilliseconds}ms timeout)"); +} + +Console.WriteLine(); + +// ────────────────────────────────────────────────────────────────── +// 3. Circuit Breaker +// ────────────────────────────────────────────────────────────────── + +Console.WriteLine("3. Circuit Breaker"); +Console.WriteLine("──────────────────"); + +Action onOpened = e => + Console.WriteLine($" Circuit OPENED (was {e.PreviousState})"); +Action onClosed = e => + Console.WriteLine($" Circuit CLOSED (was {e.PreviousState})"); + +var cbPipeline = Pipeline.Create(b => b + .AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 3, + BreakDuration = TimeSpan.FromSeconds(1), + OnOpened = onOpened, + OnClosed = onClosed, + })); + +for (var i = 0; i < 5; i++) +{ + try + { + await cbPipeline.ExecuteAsync(ct => + throw new InvalidOperationException("Service down")); + } + catch (CircuitBrokenException) + { + Console.WriteLine($" Call {i + 1}: Rejected (circuit open)"); + } + catch (InvalidOperationException) + { + Console.WriteLine($" Call {i + 1}: Failed (circuit tracking)"); + } +} + +Console.WriteLine(); + +// ────────────────────────────────────────────────────────────────── +// 4. Fallback with typed pipeline +// ────────────────────────────────────────────────────────────────── + +Console.WriteLine("4. Fallback"); +Console.WriteLine("───────────"); + +Action> onFallback = e => + Console.WriteLine($" Fallback activated: {e.Outcome.Exception?.GetType().Name}"); + +var fallbackPipeline = Pipeline.Create(b => b + .AddFallback(new FallbackStrategyOptions + { + FallbackAction = "default-response", + OnFallback = onFallback, + })); + +var fallbackResult = await fallbackPipeline.ExecuteAsync(ct => +{ + throw new InvalidOperationException("Primary failed"); +#pragma warning disable CS0162 + return new ValueTask("unreachable"); +#pragma warning restore CS0162 +}); +Console.WriteLine($" Result: {fallbackResult}"); +Console.WriteLine(); + +// ────────────────────────────────────────────────────────────────── +// 5. Composite pipeline (the real-world pattern) +// ────────────────────────────────────────────────────────────────── + +Console.WriteLine("5. Composite Pipeline"); +Console.WriteLine("─────────────────────"); + +var compositePipeline = Pipeline.Create(b => b + .AddTimeout(TimeSpan.FromSeconds(30)) // Total timeout + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.Exponential(TimeSpan.FromMilliseconds(200)), + }) + .AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 10, + }) + .AddTimeout(TimeSpan.FromSeconds(5))); // Per-attempt timeout + +var compositeResult = await compositePipeline.ExecuteAsync( + static (state, ct) => new ValueTask($"Hello from {state}!"), + "composite pipeline"); + +Console.WriteLine($" Result: {compositeResult}"); +Console.WriteLine(); + +// ────────────────────────────────────────────────────────────────── +// 6. Sync execution +// ────────────────────────────────────────────────────────────────── + +Console.WriteLine("6. Sync Execution"); +Console.WriteLine("─────────────────"); + +var syncPipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions +{ + MaxRetryAttempts = 2, + Delay = RetryDelay.None, +})); + +var syncAttempts = 0; +var syncResult = syncPipeline.Execute(ct => +{ + syncAttempts++; + if (syncAttempts < 2) + { + throw new InvalidOperationException("transient"); + } + + return "sync-success"; +}); + +Console.WriteLine($" Result: {syncResult} (after {syncAttempts} attempts)"); +Console.WriteLine(); + +Console.WriteLine("All samples completed."); diff --git a/samples/Resilion.Samples/Resilion.Samples.csproj b/samples/Resilion.Samples/Resilion.Samples.csproj new file mode 100644 index 0000000..9bfc003 --- /dev/null +++ b/samples/Resilion.Samples/Resilion.Samples.csproj @@ -0,0 +1,19 @@ + + + + Exe + net9.0 + latest + enable + enable + false + Resilion.Samples + + + + + + + + + diff --git a/src/Directory.Build.props b/src/Directory.Build.props new file mode 100644 index 0000000..a1833fc --- /dev/null +++ b/src/Directory.Build.props @@ -0,0 +1,32 @@ + + + + 0.1.0 + FreakyAli + Copyright 2026 + en + Apache-2.0 + icon.png + README.md + git + https://github.com/FreakyAli/Resilion + https://github.com/FreakyAli/Resilion + resilience;retry;circuit-breaker;timeout;fallback;hedging;rate-limiting;fault-tolerance + See https://github.com/FreakyAli/Resilion/blob/master/CHANGELOG.md + + + + net9.0 + latest + enable + enable + true + true + + + + + + + + diff --git a/src/Resilion.Extensions/ResiliencePipelineRegistry.cs b/src/Resilion.Extensions/ResiliencePipelineRegistry.cs new file mode 100644 index 0000000..0f1bc9a --- /dev/null +++ b/src/Resilion.Extensions/ResiliencePipelineRegistry.cs @@ -0,0 +1,135 @@ +using System.Collections.Concurrent; + +namespace Resilion.Extensions; + +///

+/// A thread-safe registry of named resilience pipelines. Pipelines are created lazily +/// on first access and cached for the lifetime of the registry. +/// +/// The key type for pipeline lookup. Typically . +public sealed class ResiliencePipelineRegistry : IDisposable + where TKey : notnull +{ + private readonly ConcurrentDictionary _pipelines = new(); + private readonly ConcurrentDictionary<(TKey, Type), object> _typedPipelines = new(); + private readonly ConcurrentDictionary> _factories = new(); + private readonly ConcurrentDictionary<(TKey, Type), object> _typedFactories = new(); + + /// + /// Registers a factory for a named pipeline. The factory is invoked lazily on first access. + /// + /// The pipeline name. + /// A delegate that configures the pipeline builder. + /// A pipeline with the same key is already registered. + public void RegisterPipeline(TKey key, Action configure) + { + ArgumentNullException.ThrowIfNull(configure); + if (!_factories.TryAdd(key, builder => { configure(builder); return builder; })) + { + throw new ArgumentException($"A pipeline with key '{key}' is already registered.", nameof(key)); + } + } + + /// + /// Registers a factory for a named typed pipeline. + /// + /// The result type for the pipeline. + /// The pipeline name. + /// A delegate that configures the typed pipeline builder. + public void RegisterPipeline(TKey key, Action> configure) + { + ArgumentNullException.ThrowIfNull(configure); + var compositeKey = (key, typeof(TResult)); + if (!_typedFactories.TryAdd(compositeKey, configure)) + { + throw new ArgumentException( + $"A pipeline with key '{key}' and result type '{typeof(TResult).Name}' is already registered.", + nameof(key)); + } + } + + /// + /// Gets or creates the pipeline registered under the specified key. + /// + /// The pipeline name. + /// The cached pipeline instance. + /// No pipeline is registered with the specified key. + public Pipeline GetPipeline(TKey key) + { + return _pipelines.GetOrAdd(key, static (k, factories) => + { + if (!factories.TryGetValue(k, out var factory)) + { + throw new KeyNotFoundException($"No pipeline registered with key '{k}'."); + } + + var builder = new PipelineBuilder(); + factory(builder); + return builder.Build(); + }, _factories); + } + + /// + /// Gets or creates the typed pipeline registered under the specified key. + /// + /// The result type for the pipeline. + /// The pipeline name. + /// The cached typed pipeline instance. + public Pipeline GetPipeline(TKey key) + { + var compositeKey = (key, typeof(TResult)); + var pipeline = _typedPipelines.GetOrAdd(compositeKey, static (k, state) => + { + if (!state.TryGetValue(k, out var factory)) + { + throw new KeyNotFoundException( + $"No pipeline registered with key '{k.Item1}' and result type '{k.Item2.Name}'."); + } + + var configure = (Action>)factory; + var builder = new PipelineBuilder(); + configure(builder); + return builder.Build(); + }, _typedFactories); + + return (Pipeline)pipeline; + } + + /// + /// Attempts to get a pipeline registered under the specified key. + /// + /// The pipeline name. + /// The pipeline, if found. + /// true if the pipeline exists; false otherwise. + public bool TryGetPipeline(TKey key, out Pipeline? pipeline) + { + if (_factories.ContainsKey(key)) + { + pipeline = GetPipeline(key); + return true; + } + + pipeline = null; + return false; + } + + /// + public void Dispose() + { + foreach (var pipeline in _pipelines.Values) + { + pipeline.Dispose(); + } + + foreach (var pipeline in _typedPipelines.Values) + { + if (pipeline is IDisposable disposable) + { + disposable.Dispose(); + } + } + + _pipelines.Clear(); + _typedPipelines.Clear(); + } +} diff --git a/src/Resilion.Extensions/Resilion.Extensions.csproj b/src/Resilion.Extensions/Resilion.Extensions.csproj new file mode 100644 index 0000000..c7e8f27 --- /dev/null +++ b/src/Resilion.Extensions/Resilion.Extensions.csproj @@ -0,0 +1,25 @@ + + + + Resilion.Extensions + Resilion.Extensions + Resilion.Extensions + DI, logging, and OpenTelemetry integration for Resilion. + false + + + + + + + + + + + + + + + + + diff --git a/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs b/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs new file mode 100644 index 0000000..c046f63 --- /dev/null +++ b/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs @@ -0,0 +1,139 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection.Extensions; + +namespace Resilion.Extensions; + +/// +/// Extension methods for registering Resilion services with . +/// +public static class ResilionServiceCollectionExtensions +{ + /// + /// Adds Resilion core services to the service collection, including a shared + /// with string keys. + /// + /// The service collection. + /// The service collection for chaining. + public static IServiceCollection AddResilion(this IServiceCollection services) + { + ArgumentNullException.ThrowIfNull(services); + services.TryAddSingleton>(); + services.TryAddSingleton(ResilienceContextPool.Shared); + return services; + } + + /// + /// Registers a named resilience pipeline that is created lazily on first access + /// and cached as a singleton. + /// + /// The service collection. + /// A unique name for the pipeline. + /// A delegate that configures the pipeline builder. + /// The service collection for chaining. + /// + /// + /// services.AddResiliencePipeline("my-pipeline", builder => builder + /// .AddRetry(new RetryOptions { MaxRetryAttempts = 3 }) + /// .AddTimeout(TimeSpan.FromSeconds(10))); + /// + /// // Resolve later: + /// var registry = serviceProvider.GetRequiredService<ResiliencePipelineRegistry<string>>(); + /// var pipeline = registry.GetPipeline("my-pipeline"); + /// + /// + public static IServiceCollection AddResiliencePipeline( + this IServiceCollection services, + string name, + Action configure) + { + ArgumentNullException.ThrowIfNull(services); + ArgumentNullException.ThrowIfNull(name); + ArgumentNullException.ThrowIfNull(configure); + + services.AddResilion(); + + // Register a post-configuration action that runs when the registry is first resolved. + var capturedName = name; + var capturedConfigure = configure; + services.AddSingleton( + new PipelineConfigurator(capturedName, capturedConfigure)); + + return services; + } + + /// + /// Registers a named typed resilience pipeline. + /// + /// The result type for the pipeline. + /// The service collection. + /// A unique name for the pipeline. + /// A delegate that configures the typed pipeline builder. + /// The service collection for chaining. + public static IServiceCollection AddResiliencePipeline( + this IServiceCollection services, + string name, + Action> configure) + { + ArgumentNullException.ThrowIfNull(services); + ArgumentNullException.ThrowIfNull(name); + ArgumentNullException.ThrowIfNull(configure); + + services.AddResilion(); + + services.AddSingleton( + new TypedPipelineConfigurator(name, configure)); + + return services; + } + + /// + /// Builds and returns the with all registered + /// pipeline configurations applied. Call this after all AddResiliencePipeline calls. + /// + internal static ResiliencePipelineRegistry BuildRegistry(IServiceProvider sp) + { + var registry = sp.GetRequiredService>(); + var configurators = sp.GetServices(); + foreach (var configurator in configurators) + { + configurator.Configure(registry); + } + + return registry; + } +} + +internal interface IPipelineConfigurator +{ + void Configure(ResiliencePipelineRegistry registry); +} + +internal sealed class PipelineConfigurator : IPipelineConfigurator +{ + private readonly string _name; + private readonly Action _configure; + + public PipelineConfigurator(string name, Action configure) + { + _name = name; + _configure = configure; + } + + public void Configure(ResiliencePipelineRegistry registry) + => registry.RegisterPipeline(_name, _configure); +} + +internal sealed class TypedPipelineConfigurator : IPipelineConfigurator +{ + private readonly string _name; + private readonly Action> _configure; + + public TypedPipelineConfigurator(string name, Action> configure) + { + _name = name; + _configure = configure; + } + + public void Configure(ResiliencePipelineRegistry registry) + => registry.RegisterPipeline(_name, _configure); +} diff --git a/src/Resilion.RateLimiting/RateLimitRejectedException.cs b/src/Resilion.RateLimiting/RateLimitRejectedException.cs new file mode 100644 index 0000000..34c4e91 --- /dev/null +++ b/src/Resilion.RateLimiting/RateLimitRejectedException.cs @@ -0,0 +1,27 @@ +using Resilion; + +namespace Resilion.RateLimiting; + +/// +/// Thrown when the rate limiter rejects an execution because the rate limit has been exceeded. +/// +public sealed class RateLimitRejectedException : ResilionException +{ + /// + /// Initializes a new instance of the class. + /// + /// The suggested duration to wait before retrying, or null if not available. + internal RateLimitRejectedException(TimeSpan? retryAfter) + : base(retryAfter.HasValue + ? $"The rate limit has been exceeded. Retry after {retryAfter.Value.TotalSeconds:F1}s." + : "The rate limit has been exceeded.") + { + RetryAfter = retryAfter; + } + + /// + /// Gets the suggested duration to wait before retrying, extracted from the rate limiter's + /// lease metadata. Returns null if the rate limiter did not provide this information. + /// + public TimeSpan? RetryAfter { get; } +} diff --git a/src/Resilion.RateLimiting/RateLimiterExtensions.cs b/src/Resilion.RateLimiting/RateLimiterExtensions.cs new file mode 100644 index 0000000..257e337 --- /dev/null +++ b/src/Resilion.RateLimiting/RateLimiterExtensions.cs @@ -0,0 +1,38 @@ +namespace Resilion.RateLimiting; + +/// +/// Extension methods for adding the Rate Limiter strategy to a pipeline builder. +/// +public static class RateLimiterExtensions +{ + /// + /// Adds a rate limiter strategy with the specified options. + /// + /// The pipeline builder. + /// The rate limiter options. + /// The builder for chaining. + public static PipelineBuilder AddRateLimiter( + this PipelineBuilder builder, + RateLimiterStrategyOptions options) + { + ArgumentNullException.ThrowIfNull(options); + options.Validate(); + return builder.AddStrategy(new RateLimiterStrategy(options), Resilion.Internal.StrategyType.RateLimiter); + } + + /// + /// Adds a rate limiter strategy to a typed pipeline. + /// + /// The result type. + /// The typed pipeline builder. + /// The rate limiter options. + /// The builder for chaining. + public static PipelineBuilder AddRateLimiter( + this PipelineBuilder builder, + RateLimiterStrategyOptions options) + { + ArgumentNullException.ThrowIfNull(options); + options.Validate(); + return builder.AddStrategy(new RateLimiterStrategy(options), Resilion.Internal.StrategyType.RateLimiter); + } +} diff --git a/src/Resilion.RateLimiting/RateLimiterStrategy.cs b/src/Resilion.RateLimiting/RateLimiterStrategy.cs new file mode 100644 index 0000000..39e98fa --- /dev/null +++ b/src/Resilion.RateLimiting/RateLimiterStrategy.cs @@ -0,0 +1,97 @@ +using System.Threading.RateLimiting; + +namespace Resilion.RateLimiting; + +/// +/// Rate limiter strategy — acquires a lease before execution, rejects if the limit is exceeded. +/// +internal sealed class RateLimiterStrategy : Strategy +{ + private readonly RateLimiterStrategyOptions _options; + + internal RateLimiterStrategy(RateLimiterStrategyOptions options) + { + _options = options; + } + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + var lease = await _options.RateLimiter!.AcquireAsync( + permitCount: 1, + cancellationToken: context.CancellationToken).ConfigureAwait(false); + + try + { + if (!lease.IsAcquired) + { + return await HandleRejection(lease, context).ConfigureAwait(false); + } + + return await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + } + finally + { + lease.Dispose(); + } + } + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + // Sync acquire — AttemptAcquire does not wait in a queue. + using var lease = _options.RateLimiter!.AttemptAcquire(permitCount: 1); + + if (!lease.IsAcquired) + { + return HandleRejectionSync(lease, context); + } + + return callback(context); + } + + private async ValueTask> HandleRejection( + RateLimitLease lease, + ResilienceContext context) + { + var retryAfter = GetRetryAfter(lease); + + Resilion.ResilionTelemetry.RateLimiterRejections.Add(1); + + if (_options.OnRejected is { } handler && handler.HasHandler) + { + await handler.InvokeAsync(new OnRateLimitRejectedEvent(retryAfter, context)) + .ConfigureAwait(false); + } + + return Outcome.FromException(new RateLimitRejectedException(retryAfter)); + } + + private Outcome HandleRejectionSync( + RateLimitLease lease, + ResilienceContext context) + { + var retryAfter = GetRetryAfter(lease); + + Resilion.ResilionTelemetry.RateLimiterRejections.Add(1); + + if (_options.OnRejected is { } handler && handler.HasHandler) + { + handler.Invoke(new OnRateLimitRejectedEvent(retryAfter, context)); + } + + return Outcome.FromException(new RateLimitRejectedException(retryAfter)); + } + + private static TimeSpan? GetRetryAfter(RateLimitLease lease) + { + if (lease.TryGetMetadata(MetadataName.RetryAfter, out var retryAfter)) + { + return retryAfter; + } + + return null; + } +} diff --git a/src/Resilion.RateLimiting/RateLimiterStrategyOptions.cs b/src/Resilion.RateLimiting/RateLimiterStrategyOptions.cs new file mode 100644 index 0000000..aa0d4f5 --- /dev/null +++ b/src/Resilion.RateLimiting/RateLimiterStrategyOptions.cs @@ -0,0 +1,50 @@ +using System.Threading.RateLimiting; + +namespace Resilion.RateLimiting; + +/// +/// Options for the Rate Limiter resilience strategy. +/// +/// +/// +/// The strategy wraps — it does not +/// reimplement rate limiting. Configure the limiter using the .NET built-in algorithms: +/// , , +/// , or . +/// +/// +/// The strategy does NOT own the 's lifetime. The caller (or DI container) +/// is responsible for disposing it. +/// +/// +public sealed record RateLimiterStrategyOptions +{ + /// + /// Gets the rate limiter instance. Required — there is no default. + /// + public RateLimiter? RateLimiter { get; init; } + + /// + /// Gets an optional event handler fired when a request is rejected by the rate limiter. + /// + public ResilienceEventHandler? OnRejected { get; init; } + + internal void Validate() + { + if (RateLimiter is null) + { + throw new InvalidOperationException( + "RateLimiter must be configured. Provide a RateLimiter instance " + + "(e.g., new ConcurrencyLimiter, new TokenBucketRateLimiter, etc.)."); + } + } +} + +/// +/// Event arguments for the callback. +/// +/// The suggested wait duration before retrying, or null. +/// The execution context. +public readonly record struct OnRateLimitRejectedEvent( + TimeSpan? RetryAfter, + ResilienceContext Context); diff --git a/src/Resilion.RateLimiting/Resilion.RateLimiting.csproj b/src/Resilion.RateLimiting/Resilion.RateLimiting.csproj new file mode 100644 index 0000000..b3b69dc --- /dev/null +++ b/src/Resilion.RateLimiting/Resilion.RateLimiting.csproj @@ -0,0 +1,18 @@ + + + + Resilion.RateLimiting + Resilion.RateLimiting + Resilion.RateLimiting + Rate limiting strategy for Resilion wrapping System.Threading.RateLimiting. + + + + + + + + + + + diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerExtensions.cs b/src/Resilion/CircuitBreaker/CircuitBreakerExtensions.cs new file mode 100644 index 0000000..a5c7521 --- /dev/null +++ b/src/Resilion/CircuitBreaker/CircuitBreakerExtensions.cs @@ -0,0 +1,54 @@ +namespace Resilion; + +/// +/// Extension methods for adding the Circuit Breaker strategy to a pipeline builder. +/// +public static class CircuitBreakerExtensions +{ + /// + /// Adds an exception-only circuit breaker strategy with the specified options. + /// + /// The pipeline builder. + /// The circuit breaker options. When null, uses defaults. + /// The builder for chaining. + public static PipelineBuilder AddCircuitBreaker( + this PipelineBuilder builder, + CircuitBreakerStrategyOptions? options = null) + { + options ??= new CircuitBreakerStrategyOptions(); + options.Validate(); + return builder.AddStrategy(new CircuitBreakerStrategy(options, builder.TimeProvider), Internal.StrategyType.CircuitBreaker); + } + + /// + /// Adds a result-aware circuit breaker strategy to a typed pipeline. + /// + /// The result type. + /// The typed pipeline builder. + /// The typed circuit breaker options. + /// The builder for chaining. + public static PipelineBuilder AddCircuitBreaker( + this PipelineBuilder builder, + CircuitBreakerStrategyOptions options) + { + ArgumentNullException.ThrowIfNull(options); + options.Validate(); + return builder.AddStrategy(new CircuitBreakerTypedStrategy(options, builder.TimeProvider), Internal.StrategyType.CircuitBreaker); + } + + /// + /// Adds an exception-only circuit breaker strategy to a typed pipeline. + /// + /// The result type. + /// The typed pipeline builder. + /// The circuit breaker options. When null, uses defaults. + /// The builder for chaining. + public static PipelineBuilder AddCircuitBreaker( + this PipelineBuilder builder, + CircuitBreakerStrategyOptions? options = null) + { + options ??= new CircuitBreakerStrategyOptions(); + options.Validate(); + return builder.AddStrategy(new CircuitBreakerStrategy(options, builder.TimeProvider), Internal.StrategyType.CircuitBreaker); + } +} diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerManualControl.cs b/src/Resilion/CircuitBreaker/CircuitBreakerManualControl.cs new file mode 100644 index 0000000..9c50472 --- /dev/null +++ b/src/Resilion/CircuitBreaker/CircuitBreakerManualControl.cs @@ -0,0 +1,64 @@ +namespace Resilion; + +/// +/// Provides manual control over a circuit breaker's state. +/// Use to force the circuit open and to close it. +/// +/// +/// Create an instance and pass it via . +/// The control must be associated with a strategy before it can be used. +/// +public sealed class CircuitBreakerManualControl +{ + private Func? _onIsolate; + private Func? _onReset; + + /// + /// Forces the circuit into the state. + /// All subsequent calls will be rejected until is called. + /// + /// + /// Thrown when this control is not associated with any circuit breaker strategy. + /// + public Task IsolateAsync() + { + if (_onIsolate is null) + { + throw new InvalidOperationException( + "This CircuitBreakerManualControl is not associated with a circuit breaker strategy. " + + "Pass it via CircuitBreakerStrategyOptions.ManualControl when building the pipeline."); + } + + return _onIsolate(); + } + + /// + /// Resets the circuit to the state and clears the sliding window. + /// + /// + /// Thrown when this control is not associated with any circuit breaker strategy. + /// + public Task ResetAsync() + { + if (_onReset is null) + { + throw new InvalidOperationException( + "This CircuitBreakerManualControl is not associated with a circuit breaker strategy. " + + "Pass it via CircuitBreakerStrategyOptions.ManualControl when building the pipeline."); + } + + return _onReset(); + } + + internal void Initialize(Func onIsolate, Func onReset) + { + if (Interlocked.CompareExchange(ref _onIsolate, onIsolate, null) is not null) + { + throw new InvalidOperationException( + "This CircuitBreakerManualControl is already bound to a circuit breaker strategy. " + + "Create a separate instance for each circuit breaker."); + } + + _onReset = onReset; + } +} diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs b/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs new file mode 100644 index 0000000..93adfbc --- /dev/null +++ b/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs @@ -0,0 +1,278 @@ +using Resilion.Internal; + +namespace Resilion; + +/// +/// Non-generic circuit breaker strategy — tracks failures by exception only. +/// +internal sealed class CircuitBreakerStrategy : Strategy +{ + private readonly CircuitBreakerStrategyOptions _options; + private readonly TimeProvider _timeProvider; + private readonly SlidingWindow _window; + private readonly Lock _lock = new(); + + private volatile CircuitState _state = CircuitState.Closed; + private long _openedAtTimestamp; + private int _halfOpenAttempts; + + internal CircuitBreakerStrategy(CircuitBreakerStrategyOptions options, TimeProvider timeProvider) + { + _options = options; + _timeProvider = timeProvider; + _window = new SlidingWindow(options.SamplingDuration, timeProvider); + + options.ManualControl?.Initialize( + onIsolate: () => { Isolate(); return Task.CompletedTask; }, + onReset: () => { Reset(); return Task.CompletedTask; }); + } + + internal CircuitState State => _state; + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + var rejection = TryReject(context); + if (rejection is not null) + { + return Outcome.FromException(rejection); + } + + var outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + + RecordOutcome(outcome.Exception, context); + + return outcome; + } + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + var rejection = TryReject(context); + if (rejection is not null) + { + return Outcome.FromException(rejection); + } + + var outcome = callback(context); + + RecordOutcome(outcome.Exception, context); + + return outcome; + } + + private CircuitBrokenException? TryReject(ResilienceContext context) + { + var state = _state; + + switch (state) + { + case CircuitState.Closed: + return null; + + case CircuitState.HalfOpen: + lock (_lock) + { + if (_state != CircuitState.HalfOpen) + { + return _state is CircuitState.Open or CircuitState.Isolated + ? CreateRejectException() + : null; + } + + if (_halfOpenAttempts > 0) + { + return CreateRejectException(); + } + + _halfOpenAttempts++; + return null; + } + + case CircuitState.Open: + var elapsed = _timeProvider.GetElapsedTime(_openedAtTimestamp); + if (elapsed >= _options.BreakDuration) + { + CircuitStateChangedEvent? pendingEvent = null; + lock (_lock) + { + if (_state == CircuitState.Open) + { + pendingEvent = TransitionTo(CircuitState.HalfOpen, context); + _halfOpenAttempts = 1; + } + } + + FireEvent(pendingEvent); + + return _state is CircuitState.Open or CircuitState.Isolated + ? CreateRejectException() + : null; + } + + return CreateRejectException(); + + case CircuitState.Isolated: + return new CircuitBrokenException(CircuitState.Isolated, TimeSpan.Zero); + + default: + return null; + } + } + + private void RecordOutcome(Exception? exception, ResilienceContext context) + { + var isFailure = exception is not null && _options.ShouldHandleException(exception); + RecordAndTransition(isFailure, context); + } + + private void RecordAndTransition(bool isFailure, ResilienceContext context) + { + var currentState = _state; + + switch (currentState) + { + case CircuitState.Closed: + if (isFailure) + { + _window.RecordFailure(); + } + else + { + _window.RecordSuccess(); + } + + var failureRatio = _window.GetFailureRatio(out var totalCount); + if (failureRatio >= _options.FailureRatioThreshold + && totalCount >= _options.MinimumThroughput) + { + CircuitStateChangedEvent? pendingEvent = null; + lock (_lock) + { + if (_state == CircuitState.Closed) + { + pendingEvent = Trip(context); + } + } + + FireEvent(pendingEvent); + } + + break; + + case CircuitState.HalfOpen: + CircuitStateChangedEvent? halfOpenEvent = null; + lock (_lock) + { + if (_state != CircuitState.HalfOpen) + { + return; + } + + if (isFailure) + { + halfOpenEvent = Trip(context); + } + else + { + _window.Reset(); + halfOpenEvent = TransitionTo(CircuitState.Closed, context); + } + } + + FireEvent(halfOpenEvent); + break; + } + } + + /// Must be called under lock. + private CircuitStateChangedEvent? Trip(ResilienceContext context) + { + _openedAtTimestamp = _timeProvider.GetTimestamp(); + _halfOpenAttempts = 0; + return TransitionTo(CircuitState.Open, context); + } + + /// Must be called under lock. Returns event to fire outside lock. + private CircuitStateChangedEvent? TransitionTo(CircuitState newState, ResilienceContext context) + { + var previous = _state; + _state = newState; + return new CircuitStateChangedEvent(previous, newState, context); + } + + /// Fires event callback outside lock. Emits telemetry. + private void FireEvent(CircuitStateChangedEvent? evt) + { + if (evt is null) + { + return; + } + + ResilionTelemetry.CircuitBreakerStateChanges.Add(1); + + var e = evt.Value; + switch (e.CurrentState) + { + case CircuitState.Open: + if (_options.OnOpened is { } onOpened && onOpened.HasHandler) + { + onOpened.Invoke(e); + } + + break; + + case CircuitState.Closed: + if (_options.OnClosed is { } onClosed && onClosed.HasHandler) + { + onClosed.Invoke(e); + } + + break; + + case CircuitState.HalfOpen: + if (_options.OnHalfOpened is { } onHalfOpened && onHalfOpened.HasHandler) + { + onHalfOpened.Invoke(e); + } + + break; + } + } + + private CircuitBrokenException CreateRejectException() + { + var remaining = TimeSpan.Zero; + if (_state == CircuitState.Open) + { + var elapsed = _timeProvider.GetElapsedTime(_openedAtTimestamp); + remaining = _options.BreakDuration - elapsed; + if (remaining < TimeSpan.Zero) + { + remaining = TimeSpan.Zero; + } + } + + return new CircuitBrokenException(_state, remaining); + } + + private void Isolate() + { + lock (_lock) + { + _state = CircuitState.Isolated; + } + } + + private void Reset() + { + lock (_lock) + { + _window.Reset(); + _state = CircuitState.Closed; + _halfOpenAttempts = 0; + } + } +} diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerStrategyOptions.cs b/src/Resilion/CircuitBreaker/CircuitBreakerStrategyOptions.cs new file mode 100644 index 0000000..dd995e0 --- /dev/null +++ b/src/Resilion/CircuitBreaker/CircuitBreakerStrategyOptions.cs @@ -0,0 +1,178 @@ +namespace Resilion; + +/// +/// Options for the Circuit Breaker resilience strategy (exception-only predicates). +/// +public sealed record CircuitBreakerStrategyOptions +{ + /// + /// Gets the failure ratio threshold (0.0 to 1.0) that trips the circuit. + /// Defaults to 0.5 (50%). + /// + public double FailureRatioThreshold { get; init; } = 0.5; + + /// + /// Gets the sliding window duration for tracking successes and failures. + /// Defaults to 30 seconds. + /// + public TimeSpan SamplingDuration { get; init; } = TimeSpan.FromSeconds(30); + + /// + /// Gets the minimum number of executions in the window before the circuit can trip. + /// Prevents tripping on 1 failure out of 2 calls. Defaults to 10. + /// + public int MinimumThroughput { get; init; } = 10; + + /// + /// Gets the duration the circuit stays open before transitioning to half-open. + /// Defaults to 30 seconds. + /// + public TimeSpan BreakDuration { get; init; } = TimeSpan.FromSeconds(30); + + /// + /// Gets the predicate that determines which exceptions count as failures. + /// Defaults to all exceptions except . + /// + public Func? ShouldHandle { get; init; } + + /// + /// Gets an optional event handler fired when the circuit transitions to open. + /// + public ResilienceEventHandler? OnOpened { get; init; } + + /// + /// Gets an optional event handler fired when the circuit transitions to closed. + /// + public ResilienceEventHandler? OnClosed { get; init; } + + /// + /// Gets an optional event handler fired when the circuit transitions to half-open. + /// + public ResilienceEventHandler? OnHalfOpened { get; init; } + + /// + /// Gets an optional manual control for isolating and resetting the circuit. + /// + public CircuitBreakerManualControl? ManualControl { get; init; } + + internal void Validate() + { + if (FailureRatioThreshold is < 0.0 or > 1.0) + { + throw new ArgumentOutOfRangeException(nameof(FailureRatioThreshold), FailureRatioThreshold, + "FailureRatioThreshold must be between 0.0 and 1.0."); + } + + if (SamplingDuration <= TimeSpan.Zero) + { + throw new ArgumentOutOfRangeException(nameof(SamplingDuration), SamplingDuration, + "SamplingDuration must be positive."); + } + + if (MinimumThroughput < 1) + { + throw new ArgumentOutOfRangeException(nameof(MinimumThroughput), MinimumThroughput, + "MinimumThroughput must be >= 1."); + } + + if (BreakDuration <= TimeSpan.Zero) + { + throw new ArgumentOutOfRangeException(nameof(BreakDuration), BreakDuration, + "BreakDuration must be positive."); + } + } + + internal bool ShouldHandleException(Exception exception) + { + if (exception is OperationCanceledException) + { + return ShouldHandle?.Invoke(exception) ?? false; + } + + return ShouldHandle?.Invoke(exception) ?? true; + } +} + +/// +/// Options for the Circuit Breaker with result-based predicates. +/// +/// The result type to inspect. +public sealed record CircuitBreakerStrategyOptions +{ + /// + public double FailureRatioThreshold { get; init; } = 0.5; + + /// + public TimeSpan SamplingDuration { get; init; } = TimeSpan.FromSeconds(30); + + /// + public int MinimumThroughput { get; init; } = 10; + + /// + public TimeSpan BreakDuration { get; init; } = TimeSpan.FromSeconds(30); + + /// + /// Gets the predicate that determines which outcomes count as failures. + /// + public Func, bool>? ShouldHandle { get; init; } + + /// + public ResilienceEventHandler? OnOpened { get; init; } + + /// + public ResilienceEventHandler? OnClosed { get; init; } + + /// + public ResilienceEventHandler? OnHalfOpened { get; init; } + + /// + public CircuitBreakerManualControl? ManualControl { get; init; } + + internal void Validate() + { + if (FailureRatioThreshold is < 0.0 or > 1.0) + { + throw new ArgumentOutOfRangeException(nameof(FailureRatioThreshold), FailureRatioThreshold, + "FailureRatioThreshold must be between 0.0 and 1.0."); + } + + if (SamplingDuration <= TimeSpan.Zero) + { + throw new ArgumentOutOfRangeException(nameof(SamplingDuration), SamplingDuration, + "SamplingDuration must be positive."); + } + + if (MinimumThroughput < 1) + { + throw new ArgumentOutOfRangeException(nameof(MinimumThroughput), MinimumThroughput, + "MinimumThroughput must be >= 1."); + } + + if (BreakDuration <= TimeSpan.Zero) + { + throw new ArgumentOutOfRangeException(nameof(BreakDuration), BreakDuration, + "BreakDuration must be positive."); + } + } + + internal bool ShouldHandleOutcome(Outcome outcome) + { + if (ShouldHandle is not null) + { + return ShouldHandle(outcome); + } + + return outcome.Exception is not null and not OperationCanceledException; + } +} + +/// +/// Event arguments for circuit breaker state change events. +/// +/// The state before the transition. +/// The state after the transition. +/// The execution context. +public readonly record struct CircuitStateChangedEvent( + CircuitState PreviousState, + CircuitState CurrentState, + ResilienceContext Context); diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs b/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs new file mode 100644 index 0000000..7e19740 --- /dev/null +++ b/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs @@ -0,0 +1,281 @@ +using Resilion.Internal; + +namespace Resilion; + +/// +/// Typed circuit breaker strategy — tracks failures by both exceptions and result values. +/// +internal sealed class CircuitBreakerTypedStrategy : Strategy +{ + private readonly CircuitBreakerStrategyOptions _options; + private readonly TimeProvider _timeProvider; + private readonly SlidingWindow _window; + private readonly Lock _lock = new(); + + private volatile CircuitState _state = CircuitState.Closed; + private long _openedAtTimestamp; + private int _halfOpenAttempts; + + internal CircuitBreakerTypedStrategy(CircuitBreakerStrategyOptions options, TimeProvider timeProvider) + { + _options = options; + _timeProvider = timeProvider; + _window = new SlidingWindow(options.SamplingDuration, timeProvider); + + options.ManualControl?.Initialize( + onIsolate: () => { Isolate(); return Task.CompletedTask; }, + onReset: () => { Reset(); return Task.CompletedTask; }); + } + + internal CircuitState State => _state; + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + var rejection = TryReject(context); + if (rejection is not null) + { + return Outcome.FromException(rejection); + } + + var outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + + var isFailure = _options.ShouldHandleOutcome(outcome); + RecordAndTransition(isFailure, context); + + return outcome; + } + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + var rejection = TryReject(context); + if (rejection is not null) + { + return Outcome.FromException(rejection); + } + + var outcome = callback(context); + + var isFailure = _options.ShouldHandleOutcome(outcome); + RecordAndTransition(isFailure, context); + + return outcome; + } + + private CircuitBrokenException? TryReject(ResilienceContext context) + { + var state = _state; + + switch (state) + { + case CircuitState.Closed: + return null; + + case CircuitState.HalfOpen: + lock (_lock) + { + if (_state != CircuitState.HalfOpen) + { + return _state is CircuitState.Open or CircuitState.Isolated + ? CreateRejectException() + : null; + } + + if (_halfOpenAttempts > 0) + { + return CreateRejectException(); + } + + _halfOpenAttempts++; + return null; + } + + case CircuitState.Open: + var elapsed = _timeProvider.GetElapsedTime(_openedAtTimestamp); + if (elapsed >= _options.BreakDuration) + { + CircuitStateChangedEvent? pendingEvent = null; + lock (_lock) + { + if (_state == CircuitState.Open) + { + pendingEvent = TransitionTo(CircuitState.HalfOpen, context); + _halfOpenAttempts = 1; + } + } + + FireEvent(pendingEvent); + + return _state is CircuitState.Open or CircuitState.Isolated + ? CreateRejectException() + : null; + } + + return CreateRejectException(); + + case CircuitState.Isolated: + return new CircuitBrokenException(CircuitState.Isolated, TimeSpan.Zero); + + default: + return null; + } + } + + private void RecordAndTransition(bool isFailure, ResilienceContext context) + { + var currentState = _state; + + switch (currentState) + { + case CircuitState.Closed: + if (isFailure) + { + _window.RecordFailure(); + } + else + { + _window.RecordSuccess(); + } + + var failureRatio = _window.GetFailureRatio(out var totalCount); + if (failureRatio >= _options.FailureRatioThreshold + && totalCount >= _options.MinimumThroughput) + { + CircuitStateChangedEvent? pendingEvent = null; + lock (_lock) + { + if (_state == CircuitState.Closed) + { + pendingEvent = Trip(context); + } + } + + FireEvent(pendingEvent); + } + + break; + + case CircuitState.HalfOpen: + CircuitStateChangedEvent? halfOpenEvent = null; + lock (_lock) + { + if (_state != CircuitState.HalfOpen) + { + return; + } + + if (isFailure) + { + halfOpenEvent = Trip(context); + } + else + { + _window.Reset(); + halfOpenEvent = TransitionTo(CircuitState.Closed, context); + } + } + + FireEvent(halfOpenEvent); + break; + } + } + + /// + /// Transitions to Open state. Must be called under lock. + /// + private CircuitStateChangedEvent? Trip(ResilienceContext context) + { + _openedAtTimestamp = _timeProvider.GetTimestamp(); + _halfOpenAttempts = 0; + return TransitionTo(CircuitState.Open, context); + } + + /// + /// Transitions state and returns the event to fire (outside the lock). + /// Must be called under lock. + /// + private CircuitStateChangedEvent? TransitionTo(CircuitState newState, ResilienceContext context) + { + var previous = _state; + _state = newState; + return new CircuitStateChangedEvent(previous, newState, context); + } + + /// + /// Fires the event callback outside the lock. + /// + private void FireEvent(CircuitStateChangedEvent? evt) + { + if (evt is null) + { + return; + } + + ResilionTelemetry.CircuitBreakerStateChanges.Add(1); + + var e = evt.Value; + switch (e.CurrentState) + { + case CircuitState.Open: + if (_options.OnOpened is { } onOpened && onOpened.HasHandler) + { + onOpened.Invoke(e); + } + + break; + + case CircuitState.Closed: + if (_options.OnClosed is { } onClosed && onClosed.HasHandler) + { + onClosed.Invoke(e); + } + + break; + + case CircuitState.HalfOpen: + if (_options.OnHalfOpened is { } onHalfOpened && onHalfOpened.HasHandler) + { + onHalfOpened.Invoke(e); + } + + break; + } + } + + private CircuitBrokenException CreateRejectException() + { + var remaining = TimeSpan.Zero; + if (_state == CircuitState.Open) + { + var elapsed = _timeProvider.GetElapsedTime(_openedAtTimestamp); + remaining = _options.BreakDuration - elapsed; + if (remaining < TimeSpan.Zero) + { + remaining = TimeSpan.Zero; + } + } + + return new CircuitBrokenException(_state, remaining); + } + + private void Isolate() + { + lock (_lock) + { + _state = CircuitState.Isolated; + } + } + + private void Reset() + { + lock (_lock) + { + _window.Reset(); + _state = CircuitState.Closed; + _halfOpenAttempts = 0; + } + } +} diff --git a/src/Resilion/CircuitBreaker/CircuitBrokenException.cs b/src/Resilion/CircuitBreaker/CircuitBrokenException.cs new file mode 100644 index 0000000..15c0849 --- /dev/null +++ b/src/Resilion/CircuitBreaker/CircuitBrokenException.cs @@ -0,0 +1,27 @@ +namespace Resilion; + +/// +/// Thrown when the circuit breaker is open or isolated and rejects an execution attempt. +/// +public sealed class CircuitBrokenException : ResilionException +{ + internal CircuitBrokenException(CircuitState state, TimeSpan retryAfter) + : base(state == CircuitState.Isolated + ? "The circuit breaker is manually isolated and rejecting all calls." + : $"The circuit breaker is open and rejecting calls. Retry after {retryAfter.TotalSeconds:F1}s.") + { + CircuitState = state; + RetryAfter = retryAfter; + } + + /// + /// Gets the state of the circuit breaker when the rejection occurred. + /// + public CircuitState CircuitState { get; } + + /// + /// Gets the estimated duration until the circuit transitions to . + /// Returns if the circuit is already half-open or isolated. + /// + public TimeSpan RetryAfter { get; } +} diff --git a/src/Resilion/CircuitBreaker/CircuitState.cs b/src/Resilion/CircuitBreaker/CircuitState.cs new file mode 100644 index 0000000..c4df0e2 --- /dev/null +++ b/src/Resilion/CircuitBreaker/CircuitState.cs @@ -0,0 +1,30 @@ +namespace Resilion; + +/// +/// The current state of a circuit breaker. +/// +public enum CircuitState +{ + /// + /// Normal operation. Requests flow through and failures are tracked. + /// + Closed, + + /// + /// The circuit is tripped. All requests are immediately rejected + /// with . + /// + Open, + + /// + /// A limited number of probe requests are allowed through to test recovery. + /// Success transitions to ; failure transitions back to . + /// + HalfOpen, + + /// + /// Manually isolated via . + /// All requests are rejected until is called. + /// + Isolated, +} diff --git a/src/Resilion/CircuitBreaker/SlidingWindow.cs b/src/Resilion/CircuitBreaker/SlidingWindow.cs new file mode 100644 index 0000000..b38d0b7 --- /dev/null +++ b/src/Resilion/CircuitBreaker/SlidingWindow.cs @@ -0,0 +1,151 @@ +namespace Resilion.Internal; + +/// +/// A bucketed sliding window that tracks success/failure counts over a configurable duration. +/// Uses a fixed-size ring buffer of time buckets, each covering a fraction of the total window. +/// +/// +/// Thread-safe. All public methods acquire the internal lock. Counter increments on the current +/// bucket use Interlocked for minimal contention on the hot path (Closed state, call succeeds). +/// +internal sealed class SlidingWindow +{ + private const int BucketCount = 10; + + private readonly Bucket[] _buckets; + private readonly TimeSpan _bucketDuration; + private readonly TimeProvider _timeProvider; + private readonly Lock _lock = new(); + + private long _currentBucketStartTimestamp; + private int _currentBucketIndex; + + internal SlidingWindow(TimeSpan samplingDuration, TimeProvider timeProvider) + { + _timeProvider = timeProvider; + _bucketDuration = samplingDuration / BucketCount; + _buckets = new Bucket[BucketCount]; + for (var i = 0; i < BucketCount; i++) + { + _buckets[i] = new Bucket(); + } + + _currentBucketStartTimestamp = timeProvider.GetTimestamp(); + _currentBucketIndex = 0; + } + + /// + /// Records a successful execution. + /// + internal void RecordSuccess() + { + lock (_lock) + { + AdvanceWindow(); + Interlocked.Increment(ref _buckets[_currentBucketIndex].Successes); + } + } + + /// + /// Records a failed execution. + /// + internal void RecordFailure() + { + lock (_lock) + { + AdvanceWindow(); + Interlocked.Increment(ref _buckets[_currentBucketIndex].Failures); + } + } + + /// + /// Gets the current failure ratio and total throughput across all active buckets. + /// + /// The total number of executions in the window. + /// The failure ratio clamped to [0.0, 1.0], or 0.0 if there are no executions. + internal double GetFailureRatio(out int totalCount) + { + lock (_lock) + { + AdvanceWindow(); + + var successes = 0; + var failures = 0; + + for (var i = 0; i < BucketCount; i++) + { + successes += _buckets[i].Successes; + failures += _buckets[i].Failures; + } + + totalCount = successes + failures; + if (totalCount == 0) + { + return 0.0; + } + + var ratio = (double)failures / totalCount; + return Math.Clamp(ratio, 0.0, 1.0); + } + } + + /// + /// Resets all buckets to zero. Called when transitioning to Closed state. + /// Must be called under the circuit breaker's lock. + /// + internal void Reset() + { + lock (_lock) + { + for (var i = 0; i < BucketCount; i++) + { + _buckets[i].Successes = 0; + _buckets[i].Failures = 0; + } + + _currentBucketStartTimestamp = _timeProvider.GetTimestamp(); + _currentBucketIndex = 0; + } + } + + /// + /// Advances the window by rotating expired buckets. Must be called under _lock. + /// + private void AdvanceWindow() + { + var elapsed = _timeProvider.GetElapsedTime(_currentBucketStartTimestamp); + if (elapsed < _bucketDuration) + { + return; + } + + var bucketsToAdvance = (int)(elapsed / _bucketDuration); + if (bucketsToAdvance >= BucketCount) + { + for (var i = 0; i < BucketCount; i++) + { + _buckets[i].Successes = 0; + _buckets[i].Failures = 0; + } + + _currentBucketStartTimestamp = _timeProvider.GetTimestamp(); + _currentBucketIndex = 0; + return; + } + + for (var i = 0; i < bucketsToAdvance; i++) + { + _currentBucketIndex = (_currentBucketIndex + 1) % BucketCount; + _buckets[_currentBucketIndex].Successes = 0; + _buckets[_currentBucketIndex].Failures = 0; + } + + _currentBucketStartTimestamp = _timeProvider.GetTimestamp(); + } + + private sealed class Bucket + { + public int Successes; + public int Failures; + } +} diff --git a/src/Resilion/Fallback/FallbackAction.cs b/src/Resilion/Fallback/FallbackAction.cs new file mode 100644 index 0000000..074d18b --- /dev/null +++ b/src/Resilion/Fallback/FallbackAction.cs @@ -0,0 +1,116 @@ +namespace Resilion; + +/// +/// Represents a fallback action that produces a substitute result. Supports three forms +/// via implicit conversion: a constant value, a synchronous factory, or an async factory. +/// +/// The result type. +/// +/// +/// // Constant value — simplest case +/// FallbackAction = "default" +/// +/// // Sync factory — compute from the failure +/// FallbackAction = ctx => ComputeDefault(ctx.Exception) +/// +/// // Async factory — call a cache or secondary service +/// FallbackAction = async ctx => await cache.GetAsync("fallback-key") +/// +/// +public readonly struct FallbackAction +{ + private readonly TResult? _value; + private readonly Func, TResult>? _syncFactory; + private readonly Func, ValueTask>? _asyncFactory; + private readonly FallbackKind _kind; + + private FallbackAction(TResult? value, Func, TResult>? syncFactory, + Func, ValueTask>? asyncFactory, FallbackKind kind) + { + _value = value; + _syncFactory = syncFactory; + _asyncFactory = asyncFactory; + _kind = kind; + } + + /// + /// Gets a value indicating whether this action has been assigned. + /// + public bool HasValue => _kind != FallbackKind.None; + + /// + /// Produces the fallback result asynchronously. + /// + internal async ValueTask ExecuteAsync(FallbackContext context) + { + return _kind switch + { + FallbackKind.Constant => _value!, + FallbackKind.Sync => _syncFactory!(context), + FallbackKind.Async => await _asyncFactory!(context).ConfigureAwait(false), + _ => throw new InvalidOperationException("FallbackAction has not been configured."), + }; + } + + /// + /// Produces the fallback result synchronously. + /// + internal TResult Execute(FallbackContext context) + { + if (_kind == FallbackKind.Async) + { + // Copy to local to avoid struct 'this' capture in lambda. + var factory = _asyncFactory!; + return Task.Run(() => factory(context).AsTask()).GetAwaiter().GetResult(); + } + + return _kind switch + { + FallbackKind.Constant => _value!, + FallbackKind.Sync => _syncFactory!(context), + _ => throw new InvalidOperationException("FallbackAction has not been configured."), + }; + } + + /// + /// Implicitly converts a constant value to a . + /// + public static implicit operator FallbackAction(TResult value) + => new(value, null, null, FallbackKind.Constant); + + /// + /// Implicitly converts a synchronous factory to a . + /// + public static implicit operator FallbackAction(Func, TResult> factory) + => new(default, factory, null, FallbackKind.Sync); + + /// + /// Implicitly converts an async factory to a . + /// + public static implicit operator FallbackAction(Func, ValueTask> factory) + => new(default, null, factory, FallbackKind.Async); + + private enum FallbackKind : byte + { + None, + Constant, + Sync, + Async, + } +} + +/// +/// Context provided to fallback action factories, containing information about the failure. +/// +/// The result type. +/// The failed outcome that triggered the fallback. +/// The execution context. +public readonly record struct FallbackContext( + Outcome Outcome, + ResilienceContext Context) +{ + /// + /// Gets the exception from the failed outcome, if any. + /// + public Exception? Exception => Outcome.Exception; +} diff --git a/src/Resilion/Fallback/FallbackExtensions.cs b/src/Resilion/Fallback/FallbackExtensions.cs new file mode 100644 index 0000000..fad5346 --- /dev/null +++ b/src/Resilion/Fallback/FallbackExtensions.cs @@ -0,0 +1,27 @@ +namespace Resilion; + +/// +/// Extension methods for adding the Fallback strategy to a typed pipeline builder. +/// +/// +/// Fallback is only available on typed pipelines because it must produce a substitute +/// value of the correct type. +/// +public static class FallbackExtensions +{ + /// + /// Adds a fallback strategy to a typed pipeline. + /// + /// The result type. + /// The typed pipeline builder. + /// The fallback options. + /// The builder for chaining. + public static PipelineBuilder AddFallback( + this PipelineBuilder builder, + FallbackStrategyOptions options) + { + ArgumentNullException.ThrowIfNull(options); + options.Validate(); + return builder.AddStrategy(new FallbackStrategy(options), Internal.StrategyType.Fallback); + } +} diff --git a/src/Resilion/Fallback/FallbackStrategy.cs b/src/Resilion/Fallback/FallbackStrategy.cs new file mode 100644 index 0000000..ed6ddad --- /dev/null +++ b/src/Resilion/Fallback/FallbackStrategy.cs @@ -0,0 +1,63 @@ +namespace Resilion; + +/// +/// Typed fallback strategy — provides a substitute result when the operation fails. +/// +internal sealed class FallbackStrategy : Strategy +{ + private readonly FallbackStrategyOptions _options; + + internal FallbackStrategy(FallbackStrategyOptions options) + { + _options = options; + } + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + var outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + + if (!_options.ShouldHandleOutcome(outcome)) + { + return outcome; + } + + ResilionTelemetry.FallbackActivations.Add(1); + + var fallbackCtx = new FallbackContext(outcome, context); + var fallbackResult = await _options.FallbackAction.ExecuteAsync(fallbackCtx).ConfigureAwait(false); + + if (_options.OnFallback is { } handler && handler.HasHandler) + { + await handler.InvokeAsync(new OnFallbackEvent(outcome, fallbackResult, context)) + .ConfigureAwait(false); + } + + return Outcome.FromResult(fallbackResult); + } + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + var outcome = callback(context); + + if (!_options.ShouldHandleOutcome(outcome)) + { + return outcome; + } + + ResilionTelemetry.FallbackActivations.Add(1); + + var fallbackCtx = new FallbackContext(outcome, context); + var fallbackResult = _options.FallbackAction.Execute(fallbackCtx); + + if (_options.OnFallback is { } handler && handler.HasHandler) + { + handler.Invoke(new OnFallbackEvent(outcome, fallbackResult, context)); + } + + return Outcome.FromResult(fallbackResult); + } +} diff --git a/src/Resilion/Fallback/FallbackStrategyOptions.cs b/src/Resilion/Fallback/FallbackStrategyOptions.cs new file mode 100644 index 0000000..f00e1eb --- /dev/null +++ b/src/Resilion/Fallback/FallbackStrategyOptions.cs @@ -0,0 +1,60 @@ +namespace Resilion; + +/// +/// Options for the Fallback resilience strategy. +/// +/// The result type. +/// +/// Fallback is only available on typed pipelines () +/// because it must produce a substitute value of the correct type. +/// +public sealed record FallbackStrategyOptions +{ + /// + /// Gets the fallback action that produces a substitute result. + /// Supports constant values, sync factories, and async factories via implicit conversion. + /// + public FallbackAction FallbackAction { get; init; } + + /// + /// Gets the predicate that determines which outcomes trigger the fallback. + /// Defaults to all exceptions except . + /// + public Func, bool>? ShouldHandle { get; init; } + + /// + /// Gets an optional event handler fired when the fallback is activated. + /// + public ResilienceEventHandler>? OnFallback { get; init; } + + internal void Validate() + { + if (!FallbackAction.HasValue) + { + throw new InvalidOperationException( + "FallbackAction must be configured. Assign a value, sync factory, or async factory."); + } + } + + internal bool ShouldHandleOutcome(Outcome outcome) + { + if (ShouldHandle is not null) + { + return ShouldHandle(outcome); + } + + return outcome.Exception is not null and not OperationCanceledException; + } +} + +/// +/// Event arguments for the callback. +/// +/// The result type. +/// The failed outcome that triggered the fallback. +/// The substitute result that will be returned. +/// The execution context. +public readonly record struct OnFallbackEvent( + Outcome Outcome, + TResult FallbackResult, + ResilienceContext Context); diff --git a/src/Resilion/Hedging/HedgingExtensions.cs b/src/Resilion/Hedging/HedgingExtensions.cs new file mode 100644 index 0000000..2051108 --- /dev/null +++ b/src/Resilion/Hedging/HedgingExtensions.cs @@ -0,0 +1,26 @@ +namespace Resilion; + +/// +/// Extension methods for adding the Hedging strategy to a typed pipeline builder. +/// +/// +/// Hedging is only available on typed pipelines because it must produce a result of the correct type. +/// +public static class HedgingExtensions +{ + /// + /// Adds a hedging strategy to a typed pipeline. + /// + /// The result type. + /// The typed pipeline builder. + /// The hedging options. + /// The builder for chaining. + public static PipelineBuilder AddHedging( + this PipelineBuilder builder, + HedgingStrategyOptions options) + { + ArgumentNullException.ThrowIfNull(options); + options.Validate(); + return builder.AddStrategy(new HedgingStrategy(options, builder.TimeProvider), Internal.StrategyType.Hedging); + } +} diff --git a/src/Resilion/Hedging/HedgingRejectedException.cs b/src/Resilion/Hedging/HedgingRejectedException.cs new file mode 100644 index 0000000..a34272a --- /dev/null +++ b/src/Resilion/Hedging/HedgingRejectedException.cs @@ -0,0 +1,19 @@ +namespace Resilion; + +/// +/// Thrown when all hedging attempts fail. +/// +public sealed class HedgingRejectedException : ResilionException +{ + internal HedgingRejectedException(IReadOnlyList attemptExceptions) + : base("All hedging attempts failed.") + { + AttemptExceptions = attemptExceptions; + } + + /// + /// Gets the exceptions from all hedging attempts, in attempt order. + /// The first element is the primary attempt's exception. + /// + public IReadOnlyList AttemptExceptions { get; } +} diff --git a/src/Resilion/Hedging/HedgingStrategy.cs b/src/Resilion/Hedging/HedgingStrategy.cs new file mode 100644 index 0000000..1ce8fcb --- /dev/null +++ b/src/Resilion/Hedging/HedgingStrategy.cs @@ -0,0 +1,283 @@ +namespace Resilion; + +/// +/// Hedging strategy — races concurrent attempts and returns the first successful result. +/// All losing attempts are cancelled and awaited for proper resource cleanup. +/// +internal sealed class HedgingStrategy : Strategy +{ + private readonly HedgingStrategyOptions _options; + private readonly TimeProvider _timeProvider; + + internal HedgingStrategy(HedgingStrategyOptions options, TimeProvider timeProvider) + { + _options = options; + _timeProvider = timeProvider; + } + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + if (_options.MaxHedgedAttempts == 1) + { + // No hedging — just execute the primary. + return await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + } + + var userToken = context.CancellationToken; + var attempts = new List>>(_options.MaxHedgedAttempts); + var perAttemptCts = new List(_options.MaxHedgedAttempts); + + try + { + // Launch primary attempt (attempt 0). + LaunchAttempt(0, callback, context, userToken, attempts, perAttemptCts); + + for (var attemptIndex = 1; attemptIndex < _options.MaxHedgedAttempts; attemptIndex++) + { + // Wait for the hedging delay, or for the primary/earlier attempt to complete. + if (_options.HedgingDelay == System.Threading.Timeout.InfiniteTimeSpan) + { + // Sequential mode: wait for the current attempt to complete before launching next. + var completed = await attempts[^1].ConfigureAwait(false); + if (!_options.ShouldHandleOutcome(completed)) + { + // Success — no need for more attempts. + return completed; + } + } + else if (_options.HedgingDelay > TimeSpan.Zero) + { + // Latency mode: wait for the delay, but also check if any attempt completes early. + var delayTask = Task.Delay(_options.HedgingDelay, _timeProvider, userToken); + var winner = await Task.WhenAny(Task.WhenAny(attempts), delayTask).ConfigureAwait(false); + + if (winner != delayTask) + { + // An attempt completed before the delay. Check if it succeeded. + var completedTask = await Task.WhenAny(attempts).ConfigureAwait(false); + var completed = await completedTask.ConfigureAwait(false); + if (!_options.ShouldHandleOutcome(completed)) + { + return completed; + } + } + } + // Parallel mode (delay == 0): launch immediately, no waiting. + + ResilionTelemetry.HedgingAttempts.Add(1); + + // Fire OnHedging event. + if (_options.OnHedging is { } handler && handler.HasHandler) + { + await handler.InvokeAsync(new OnHedgingEvent(attemptIndex, context)) + .ConfigureAwait(false); + } + + // Launch next hedged attempt. + LaunchAttempt(attemptIndex, callback, context, userToken, attempts, perAttemptCts); + } + + // All attempts launched. Wait for the first success or all to fail. + return await WaitForBestOutcome(attempts, userToken).ConfigureAwait(false); + } + finally + { + // Cancel all remaining in-flight attempts. + foreach (var cts in perAttemptCts) + { + try + { + cts.Cancel(); + } + catch (ObjectDisposedException) + { + // Already disposed — fine. + } + } + + // Await all tasks to ensure resource cleanup (connections, streams, etc.). + foreach (var task in attempts) + { + try + { + await task.ConfigureAwait(false); + } + catch + { + // Swallow — we've already got our result or failure. + } + } + + // Dispose all CTS instances. + foreach (var cts in perAttemptCts) + { + cts.Dispose(); + } + } + } + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + // Hedging is inherently async (parallel execution). + // For the sync path, execute sequentially (equivalent to InfiniteTimeSpan mode). + Outcome lastOutcome = default; + + for (var attemptIndex = 0; attemptIndex < _options.MaxHedgedAttempts; attemptIndex++) + { + context.CancellationToken.ThrowIfCancellationRequested(); + + var action = ResolveAction(attemptIndex, callback, context); + lastOutcome = action(context); + + if (!_options.ShouldHandleOutcome(lastOutcome)) + { + return lastOutcome; + } + + if (attemptIndex < _options.MaxHedgedAttempts - 1) + { + if (_options.OnHedging is { } handler && handler.HasHandler) + { + handler.Invoke(new OnHedgingEvent(attemptIndex + 1, context)); + } + } + } + + return lastOutcome; + } + + private void LaunchAttempt( + int attemptIndex, + Func>> callback, + ResilienceContext context, + CancellationToken userToken, + List>> attempts, + List perAttemptCts) + { + var cts = CancellationTokenSource.CreateLinkedTokenSource(userToken); + perAttemptCts.Add(cts); + + var action = ResolveAsyncAction(attemptIndex, callback, context); + var token = cts.Token; + + var task = Task.Run(async () => + { + try + { + return await action(token).ConfigureAwait(false); + } + catch (OperationCanceledException) when (token.IsCancellationRequested && !userToken.IsCancellationRequested) + { + // Cancelled by hedging strategy (not by user) — treat as a handled failure. + return Outcome.FromException(new OperationCanceledException("Hedging attempt was cancelled.")); + } + }, userToken); + + attempts.Add(task); + } + + private Func>> ResolveAsyncAction( + int attemptIndex, + Func>> callback, + ResilienceContext context) + { + if (_options.ActionGenerator is not null) + { + var customAction = _options.ActionGenerator(new HedgingActionContext(attemptIndex)); + if (customAction is not null) + { + return async ct => + { + try + { + var result = await customAction(ct).ConfigureAwait(false); + return Outcome.FromResult(result); + } + catch (Exception ex) + { + return Outcome.FromException(ex); + } + }; + } + } + + // Default: re-execute the original callback. + return async ct => + { + // Create a lightweight context copy with the per-attempt token. + var attemptContext = ResilienceContextPool.Shared.Rent(ct); + attemptContext.OperationKey = context.OperationKey; + attemptContext.ContinueOnCapturedContext = context.ContinueOnCapturedContext; + attemptContext.Properties.CopyFrom(context.Properties); + try + { + return await callback(attemptContext).ConfigureAwait(false); + } + finally + { + ResilienceContextPool.Shared.Return(attemptContext); + } + }; + } + + private Func> ResolveAction( + int attemptIndex, + Func> callback, + ResilienceContext context) + { + if (_options.ActionGenerator is not null) + { + var customAction = _options.ActionGenerator(new HedgingActionContext(attemptIndex)); + if (customAction is not null) + { + return ctx => + { + try + { + var result = customAction(ctx.CancellationToken).GetAwaiter().GetResult(); + return Outcome.FromResult(result); + } + catch (Exception ex) + { + return Outcome.FromException(ex); + } + }; + } + } + + return callback; + } + + private async Task> WaitForBestOutcome( + List>> attempts, + CancellationToken userToken) + { + var remaining = new List>>(attempts); + Outcome lastFailure = default; + + while (remaining.Count > 0) + { + userToken.ThrowIfCancellationRequested(); + + var completed = await Task.WhenAny(remaining).ConfigureAwait(false); + remaining.Remove(completed); + + var outcome = await completed.ConfigureAwait(false); + + if (!_options.ShouldHandleOutcome(outcome)) + { + return outcome; + } + + // Track the last failure in case all attempts fail. + lastFailure = outcome; + } + + // All attempts failed — return the last failure outcome. + return lastFailure; + } +} diff --git a/src/Resilion/Hedging/HedgingStrategyOptions.cs b/src/Resilion/Hedging/HedgingStrategyOptions.cs new file mode 100644 index 0000000..0e5a23c --- /dev/null +++ b/src/Resilion/Hedging/HedgingStrategyOptions.cs @@ -0,0 +1,94 @@ +namespace Resilion; + +/// +/// Options for the Hedging resilience strategy. +/// +/// The result type. +/// +/// +/// Hedging reduces tail latency by racing multiple concurrent attempts. +/// The first successful attempt wins; all others are cancelled. +/// +/// +/// Three modes based on : +/// +/// Latency mode (delay > 0): Wait, then fire secondary if primary is still pending +/// Parallel mode (delay = 0): Fire all attempts simultaneously +/// Sequential mode (): Wait for failure before trying next +/// +/// +/// +public sealed record HedgingStrategyOptions +{ + /// + /// Gets the maximum number of hedged attempts, including the primary. + /// Defaults to 2 (one primary + one hedged). + /// + public int MaxHedgedAttempts { get; init; } = 2; + + /// + /// Gets the delay before launching each additional hedged attempt. + /// Defaults to 2 seconds. Set to for parallel mode. + /// Set to for sequential mode. + /// + public TimeSpan HedgingDelay { get; init; } = TimeSpan.FromSeconds(2); + + /// + /// Gets the predicate that determines which outcomes should trigger hedging. + /// Defaults to all exceptions except . + /// + public Func, bool>? ShouldHandle { get; init; } + + /// + /// Gets an optional action generator for hedged attempts. When null, the original + /// action is re-executed. When set, can return different actions per attempt + /// (e.g., call a different endpoint). + /// + public Func>?>? ActionGenerator { get; init; } + + /// + /// Gets an optional event handler fired before each hedged attempt is launched. + /// + public ResilienceEventHandler>? OnHedging { get; init; } + + internal void Validate() + { + if (MaxHedgedAttempts < 1) + { + throw new ArgumentOutOfRangeException(nameof(MaxHedgedAttempts), MaxHedgedAttempts, + "MaxHedgedAttempts must be >= 1."); + } + + if (HedgingDelay < TimeSpan.Zero && HedgingDelay != System.Threading.Timeout.InfiniteTimeSpan) + { + throw new ArgumentOutOfRangeException(nameof(HedgingDelay), HedgingDelay, + "HedgingDelay must be non-negative, TimeSpan.Zero, or Timeout.InfiniteTimeSpan."); + } + } + + internal bool ShouldHandleOutcome(Outcome outcome) + { + if (ShouldHandle is not null) + { + return ShouldHandle(outcome); + } + + return outcome.Exception is not null and not OperationCanceledException; + } +} + +/// +/// Context passed to the delegate. +/// +/// The 0-based attempt index (0 = primary, 1 = first hedge, etc.). +public readonly record struct HedgingActionContext(int AttemptNumber); + +/// +/// Event arguments for the callback. +/// +/// The result type. +/// The 0-based attempt index being launched. +/// The execution context. +public readonly record struct OnHedgingEvent( + int AttemptNumber, + ResilienceContext Context); diff --git a/src/Resilion/Internal/OrderingValidator.cs b/src/Resilion/Internal/OrderingValidator.cs new file mode 100644 index 0000000..f287ffe --- /dev/null +++ b/src/Resilion/Internal/OrderingValidator.cs @@ -0,0 +1,102 @@ +namespace Resilion.Internal; + +/// +/// Validates strategy ordering at Build() time and returns diagnostic warnings +/// for common misorderings. Warnings only — never blocks the build. +/// +internal static class OrderingValidator +{ + /// + /// Validates the order of strategies and returns any warnings. + /// + internal static List Validate(IReadOnlyList strategies) + { + var warnings = new List(); + + if (strategies.Count < 2) + { + return warnings; + } + + // Build index maps for quick lookup. + var positions = new Dictionary>(); + for (var i = 0; i < strategies.Count; i++) + { + var type = strategies[i]; + if (!positions.TryGetValue(type, out var list)) + { + list = []; + positions[type] = list; + } + + list.Add(i); + } + + // Rule 1: CircuitBreaker should be inside (after) Retry, not outside (before). + // If CB is before Retry, retries bypass the breaker entirely. + if (positions.TryGetValue(StrategyType.CircuitBreaker, out var cbPositions) + && positions.TryGetValue(StrategyType.Retry, out var retryPositions)) + { + foreach (var cbPos in cbPositions) + { + foreach (var retryPos in retryPositions) + { + if (cbPos < retryPos) + { + warnings.Add( + "CircuitBreaker is outside Retry (position " + cbPos + " vs " + retryPos + "). " + + "This means retries bypass the circuit breaker. Usually CircuitBreaker should be " + + "inside (after) Retry so each attempt is tracked independently."); + } + } + } + } + + // Rule 2: Fallback should typically be outermost (first) to catch all failures. + if (positions.TryGetValue(StrategyType.Fallback, out var fallbackPositions)) + { + foreach (var fbPos in fallbackPositions) + { + if (fbPos > 0) + { + warnings.Add( + "Fallback is at position " + fbPos + ", not outermost (position 0). " + + "Fallback typically goes first so it catches failures from all inner strategies."); + } + } + } + + // Rule 3: Hedging and Retry together — may cause excessive load. + if (positions.ContainsKey(StrategyType.Hedging) && positions.ContainsKey(StrategyType.Retry)) + { + warnings.Add( + "Both Hedging and Retry are present. Hedging launches parallel attempts, and Retry " + + "re-executes on failure. Together they can generate a large number of requests. " + + "Verify this is intentional."); + } + + // Rule 4: Multiple Timeout strategies without clear total/per-attempt separation. + if (positions.TryGetValue(StrategyType.Timeout, out var timeoutPositions) && timeoutPositions.Count > 2) + { + warnings.Add( + "More than 2 Timeout strategies detected. Typically you need at most 2: " + + "one total timeout (outermost) and one per-attempt timeout (innermost)."); + } + + // Rule 5: Retry as outermost strategy with no Timeout outside it. + if (positions.TryGetValue(StrategyType.Retry, out var retryPos2)) + { + foreach (var rPos in retryPos2) + { + if (rPos == 0 && !positions.ContainsKey(StrategyType.Timeout)) + { + warnings.Add( + "Retry is the outermost strategy with no Timeout. Without a total timeout, " + + "retries could run indefinitely if each attempt takes a long time."); + } + } + } + + return warnings; + } +} diff --git a/src/Resilion/Internal/PipelineComponent.cs b/src/Resilion/Internal/PipelineComponent.cs new file mode 100644 index 0000000..7961805 --- /dev/null +++ b/src/Resilion/Internal/PipelineComponent.cs @@ -0,0 +1,159 @@ +namespace Resilion.Internal; + +/// +/// Internal component in the pipeline execution chain. Each strategy is wrapped in a component +/// that calls the next component in the chain, forming a middleware-like pipeline. +/// +internal abstract class PipelineComponent : IDisposable +{ + /// + /// Executes this component's logic and optionally delegates to the next component. + /// + internal abstract ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context); + + /// + /// Executes this component's logic synchronously. + /// + internal abstract Outcome Execute( + Func> callback, + ResilienceContext context); + + public virtual void Dispose() + { + } + + /// + /// A no-op component that directly invokes the callback. Used as the terminal component. + /// + internal static PipelineComponent Empty { get; } = new EmptyComponent(); + + private sealed class EmptyComponent : PipelineComponent + { + internal override ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + => callback(context); + + internal override Outcome Execute( + Func> callback, + ResilienceContext context) + => callback(context); + } +} + +/// +/// Wraps a non-generic as a . +/// +internal sealed class StrategyComponent : PipelineComponent +{ + private readonly Strategy _strategy; + private readonly PipelineComponent _next; + + internal StrategyComponent(Strategy strategy, PipelineComponent next) + { + _strategy = strategy; + _next = next; + } + + internal override ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + return _strategy.ExecuteAsync( + ctx => _next.ExecuteAsync(callback, ctx), + context); + } + + internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + return _strategy.Execute( + ctx => _next.Execute(callback, ctx), + context); + } + + public override void Dispose() => _strategy.Dispose(); +} + +/// +/// Wraps a generic as a . +/// When the execution result type does not match, the component passes through to the next component. +/// +internal sealed class TypedStrategyComponent : PipelineComponent +{ + private readonly Strategy _strategy; + private readonly PipelineComponent _next; + + internal TypedStrategyComponent(Strategy strategy, PipelineComponent next) + { + _strategy = strategy; + _next = next; + } + + internal override ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + // Type check is a JIT-time constant for specific TResult instantiations. + if (typeof(TResult) == typeof(TStrategyResult)) + { + return ExecuteTypedAsync(callback, context); + } + + // Type mismatch — skip this strategy entirely. + return _next.ExecuteAsync(callback, context); + } + + internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + if (typeof(TResult) == typeof(TStrategyResult)) + { + return ExecuteTyped(callback, context); + } + + return _next.Execute(callback, context); + } + + private ValueTask> ExecuteTypedAsync( + Func>> callback, + ResilienceContext context) + { + // We know TResult == TStrategyResult at this point. + // Reinterpret-cast the callback — zero allocation since Outcome and + // Outcome have identical layout when TResult == TStrategyResult. + var typedCallback = (Func>>)(object)callback; + + // Build the "next" callback that chains through _next then back to the user callback. + var next = _next; + var task = _strategy.ExecuteAsync( + ctx => next.ExecuteAsync(typedCallback, ctx), + context); + + return System.Runtime.CompilerServices.Unsafe.As< + ValueTask>, + ValueTask>>(ref task); + } + + private Outcome ExecuteTyped( + Func> callback, + ResilienceContext context) + { + var typedCallback = (Func>)(object)callback; + + var next = _next; + var result = _strategy.Execute( + ctx => next.Execute(typedCallback, ctx), + context); + + return System.Runtime.CompilerServices.Unsafe.As< + Outcome, + Outcome>(ref result); + } + + public override void Dispose() => _strategy.Dispose(); +} diff --git a/src/Resilion/Internal/StrategyType.cs b/src/Resilion/Internal/StrategyType.cs new file mode 100644 index 0000000..5fb1057 --- /dev/null +++ b/src/Resilion/Internal/StrategyType.cs @@ -0,0 +1,16 @@ +namespace Resilion.Internal; + +/// +/// Identifies the kind of strategy for ordering validation. +/// +internal enum StrategyType +{ + Unknown, + Timeout, + Retry, + CircuitBreaker, + Fallback, + RateLimiter, + Hedging, + Custom, +} diff --git a/src/Resilion/Outcome.cs b/src/Resilion/Outcome.cs new file mode 100644 index 0000000..5b248db --- /dev/null +++ b/src/Resilion/Outcome.cs @@ -0,0 +1,186 @@ +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using System.Runtime.ExceptionServices; +using System.Runtime.InteropServices; + +namespace Resilion; + +/// +/// A discriminated union representing either a successful result of type +/// or a captured . Used throughout the pipeline to avoid re-throwing exceptions +/// on the hot path — strategies pass outcomes as data rather than catching and rethrowing. +/// +/// The type of the successful result. +[StructLayout(LayoutKind.Auto)] +public readonly struct Outcome : IEquatable> +{ + private readonly TResult? _result; + private readonly ExceptionDispatchInfo? _exceptionDispatchInfo; + + private Outcome(TResult? result, ExceptionDispatchInfo? exceptionDispatchInfo) + { + _result = result; + _exceptionDispatchInfo = exceptionDispatchInfo; + } + + /// + /// Gets a value indicating whether this outcome represents a successful result. + /// + public bool IsSuccess => _exceptionDispatchInfo is null; + + /// + /// Gets a value indicating whether this outcome represents a failure (captured exception). + /// + public bool IsFailure => _exceptionDispatchInfo is not null; + + /// + /// Gets the exception that caused the failure, or null if this outcome is a success. + /// + public Exception? Exception => _exceptionDispatchInfo?.SourceException; + + /// + /// Gets the successful result value. + /// + /// Thrown when the outcome is a failure. + public TResult Result + { + get + { + if (_exceptionDispatchInfo is not null) + { + throw new InvalidOperationException( + "Cannot access Result on a failed Outcome. Check IsSuccess before accessing Result, " + + "or use TryGetResult/GetResultOrDefault.", + _exceptionDispatchInfo.SourceException); + } + + return _result!; + } + } + + /// + /// Attempts to get the successful result value. + /// + /// When this method returns true, contains the result value. + /// true if this outcome is a success; false otherwise. + public bool TryGetResult([MaybeNullWhen(false)] out TResult result) + { + if (_exceptionDispatchInfo is null) + { + result = _result!; + return true; + } + + result = default; + return false; + } + + /// + /// Returns the successful result value, or the specified default if this outcome is a failure. + /// + /// The value to return if this outcome is a failure. + /// The result value on success, or on failure. + public TResult GetResultOrDefault(TResult defaultValue = default!) + => _exceptionDispatchInfo is null ? _result! : defaultValue; + + /// + /// Returns the result if successful, or rethrows the captured exception with its original stack trace preserved. + /// + /// The successful result value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public TResult ThrowIfFailed() + { + _exceptionDispatchInfo?.Throw(); + return _result!; + } + + /// + /// Applies one of two functions depending on whether this outcome is a success or failure. + /// + /// The return type of both functions. + /// Function to apply if the outcome is a success. + /// Function to apply if the outcome is a failure. + /// The result of the applied function. + public T Match(Func onSuccess, Func onFailure) + { + ArgumentNullException.ThrowIfNull(onSuccess); + ArgumentNullException.ThrowIfNull(onFailure); + + return _exceptionDispatchInfo is null + ? onSuccess(_result!) + : onFailure(_exceptionDispatchInfo.SourceException); + } + + /// + /// Creates a successful outcome containing the specified result. + /// + /// The result value. + /// A successful . + public static Outcome FromResult(TResult result) + => new(result, null); + + /// + /// Creates a failed outcome containing the specified exception. + /// + /// The exception representing the failure. + /// A failed . + /// Thrown when is null. + public static Outcome FromException(Exception exception) + { + ArgumentNullException.ThrowIfNull(exception); + return new(default, ExceptionDispatchInfo.Capture(exception)); + } + + /// + /// Implicitly converts a result value to a successful . + /// + /// The result value. + public static implicit operator Outcome(TResult result) + => FromResult(result); + + /// + public bool Equals(Outcome other) + { + if (IsSuccess != other.IsSuccess) + { + return false; + } + + if (IsSuccess) + { + return EqualityComparer.Default.Equals(_result, other._result); + } + + return ReferenceEquals( + _exceptionDispatchInfo!.SourceException, + other._exceptionDispatchInfo!.SourceException); + } + + /// + public override bool Equals(object? obj) + => obj is Outcome other && Equals(other); + + /// + public override int GetHashCode() + => IsSuccess + ? HashCode.Combine(true, _result) + : HashCode.Combine(false, _exceptionDispatchInfo!.SourceException); + + /// + /// Determines whether two outcomes are equal. + /// + public static bool operator ==(Outcome left, Outcome right) + => left.Equals(right); + + /// + /// Determines whether two outcomes are not equal. + /// + public static bool operator !=(Outcome left, Outcome right) + => !left.Equals(right); + + /// + public override string ToString() + => IsSuccess + ? $"Outcome<{typeof(TResult).Name}>(Success: {_result})" + : $"Outcome<{typeof(TResult).Name}>(Failure: {_exceptionDispatchInfo!.SourceException.GetType().Name}: {_exceptionDispatchInfo.SourceException.Message})"; +} diff --git a/src/Resilion/Pipeline.cs b/src/Resilion/Pipeline.cs new file mode 100644 index 0000000..4ae66e8 --- /dev/null +++ b/src/Resilion/Pipeline.cs @@ -0,0 +1,282 @@ +using System.Runtime.ExceptionServices; +using Resilion.Internal; + +namespace Resilion; + +/// +/// Executes operations with resilience. Strategies in the pipeline can react to exceptions +/// but do not inspect result values. Use this when you don't need result-based predicates +/// (e.g., timeout, rate limiting, exception-only retry). +/// +/// +/// +/// Pipelines are thread-safe and immutable after construction. Build once, cache, and reuse. +/// +/// +/// For pipelines that need to inspect return values (e.g., retry on HTTP 500, fallback), +/// use . +/// +/// +public sealed class Pipeline : IDisposable +{ + private readonly PipelineComponent _component; + private readonly ResilienceContextPool _pool; + + internal Pipeline(PipelineComponent component, ResilienceContextPool? pool = null) + { + _component = component; + _pool = pool ?? ResilienceContextPool.Shared; + } + + /// + /// Gets a no-op pipeline that passes through to the user delegate without applying any strategies. + /// Useful for testing and conditional composition. + /// + public static Pipeline Empty { get; } = new(PipelineComponent.Empty); + + /// + /// Gets the list of internal components for pipeline composition via AddPipeline. + /// + internal PipelineComponent Component => _component; + + /// + /// Creates a pipeline by configuring strategies on a builder. + /// + /// A delegate that adds strategies to the builder. + /// A configured, immutable . + public static Pipeline Create(Action configure) + { + ArgumentNullException.ThrowIfNull(configure); + var builder = new PipelineBuilder(); + configure(builder); + return builder.Build(); + } + + /// + /// Creates a typed pipeline by configuring strategies on a builder. + /// + /// The result type for the pipeline. + /// A delegate that adds strategies to the builder. + /// A configured, immutable . + public static Pipeline Create(Action> configure) + { + ArgumentNullException.ThrowIfNull(configure); + var builder = new PipelineBuilder(); + configure(builder); + return builder.Build(); + } + + // ────────────────────────────────────────────────────────────────── + // Async execution + // ────────────────────────────────────────────────────────────────── + + /// + /// Executes an async operation through the pipeline with a state parameter to avoid closure allocations. + /// + /// The result type. + /// The type of the state passed to the callback. + /// The operation to execute. Use a static lambda with to avoid closure allocations. + /// State passed to the callback. + /// Cancellation token for the operation. + /// The result of the operation. + public async ValueTask ExecuteAsync( + Func> action, + TState state, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(action); + var context = _pool.Rent(cancellationToken); + try + { + var outcome = await _component.ExecuteAsync( + async ctx => + { + try + { + var result = await action(state, ctx.CancellationToken).ConfigureAwait(ctx.ContinueOnCapturedContext); + return Outcome.FromResult(result); + } + catch (Exception ex) + { + return Outcome.FromException(ex); + } + }, + context).ConfigureAwait(context.ContinueOnCapturedContext); + + return outcome.ThrowIfFailed(); + } + finally + { + _pool.Return(context); + } + } + + /// + /// Executes an async operation through the pipeline. + /// + /// The result type. + /// The operation to execute. + /// Cancellation token for the operation. + /// The result of the operation. + public ValueTask ExecuteAsync( + Func> action, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(action); + return ExecuteAsync( + static (act, ct) => act(ct), + action, + cancellationToken); + } + + /// + /// Executes an async void operation through the pipeline. + /// + /// The operation to execute. + /// Cancellation token for the operation. + public async ValueTask ExecuteAsync( + Func action, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(action); + var context = _pool.Rent(cancellationToken); + try + { + var outcome = await _component.ExecuteAsync( + async ctx => + { + try + { + await action(ctx.CancellationToken).ConfigureAwait(ctx.ContinueOnCapturedContext); + return Outcome.FromResult(VoidResult.Instance); + } + catch (Exception ex) + { + return Outcome.FromException(ex); + } + }, + context).ConfigureAwait(context.ContinueOnCapturedContext); + + outcome.ThrowIfFailed(); + } + finally + { + _pool.Return(context); + } + } + + /// + /// Executes an async operation and returns the without rethrowing. + /// For advanced scenarios where you want to inspect the outcome without exception handling. + /// + /// The result type. + /// The type of the state passed to the callback. + /// The operation to execute. + /// State passed to the callback. + /// The execution context (not pooled — caller manages lifetime). + /// The outcome of the operation. + public ValueTask> ExecuteOutcomeAsync( + Func>> action, + TState state, + ResilienceContext context) + { + ArgumentNullException.ThrowIfNull(action); + ArgumentNullException.ThrowIfNull(context); + + return _component.ExecuteAsync( + ctx => action(state, ctx), + context); + } + + // ────────────────────────────────────────────────────────────────── + // Sync execution + // ────────────────────────────────────────────────────────────────── + + /// + /// Executes a synchronous operation through the pipeline with a state parameter to avoid closure allocations. + /// + /// The result type. + /// The type of the state passed to the callback. + /// The operation to execute. Use a static lambda with to avoid closure allocations. + /// State passed to the callback. + /// Cancellation token for the operation. + /// The result of the operation. + public TResult Execute( + Func action, + TState state, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(action); + var context = _pool.Rent(cancellationToken); + context.IsSynchronous = true; + try + { + var outcome = _component.Execute( + ctx => + { + try + { + var result = action(state, ctx.CancellationToken); + return Outcome.FromResult(result); + } + catch (Exception ex) + { + return Outcome.FromException(ex); + } + }, + context); + + return outcome.ThrowIfFailed(); + } + finally + { + _pool.Return(context); + } + } + + /// + /// Executes a synchronous operation through the pipeline. + /// + /// The result type. + /// The operation to execute. + /// Cancellation token for the operation. + /// The result of the operation. + public TResult Execute( + Func action, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(action); + return Execute(static (act, ct) => act(ct), action, cancellationToken); + } + + /// + /// Executes a synchronous void operation through the pipeline. + /// + /// The operation to execute. + /// Cancellation token for the operation. + public void Execute( + Action action, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(action); + Execute( + static (act, ct) => + { + act(ct); + return VoidResult.Instance; + }, + action, + cancellationToken); + } + + /// + public void Dispose() => _component.Dispose(); +} + +/// +/// Internal sentinel type for void pipeline executions. +/// +internal readonly struct VoidResult +{ + internal static readonly VoidResult Instance = default; +} diff --git a/src/Resilion/PipelineBuilder.cs b/src/Resilion/PipelineBuilder.cs new file mode 100644 index 0000000..a77d8c4 --- /dev/null +++ b/src/Resilion/PipelineBuilder.cs @@ -0,0 +1,336 @@ +using Resilion.Internal; + +namespace Resilion; + +/// +/// Builds a by composing resilience strategies. Strategies execute +/// outermost to innermost — the first strategy added is the first to see each call. +/// +/// +/// +/// The canonical strategy order is: RateLimiter → TotalTimeout → Retry → CircuitBreaker → AttemptTimeout. +/// +/// +/// Builders are not thread-safe and should not be shared. Build once, then cache and reuse +/// the resulting . +/// +/// +public sealed class PipelineBuilder +{ + private readonly List> _componentFactories = []; + private readonly List _strategyTypes = []; + + /// + /// Gets or sets an optional name for the pipeline, used in telemetry and diagnostics. + /// + public string? Name { get; set; } + + /// + /// Gets or sets the used by time-dependent strategies. + /// Defaults to . + /// + public TimeProvider TimeProvider { get; set; } = TimeProvider.System; + + /// + /// When true, suppresses ordering validation warnings at time. + /// Defaults to false. + /// + public bool SuppressOrderingWarnings { get; set; } + + /// + /// Optional callback that receives ordering validation warnings at time. + /// When null, warnings are written to . + /// + public Action? OnValidationWarning { get; set; } + + /// + /// Adds a non-generic strategy to the pipeline. + /// + /// The strategy to add. + /// This builder for chaining. + public PipelineBuilder AddStrategy(Strategy strategy) + { + ArgumentNullException.ThrowIfNull(strategy); + _componentFactories.Add(next => new StrategyComponent(strategy, next)); + _strategyTypes.Add(StrategyType.Unknown); + return this; + } + + internal PipelineBuilder AddStrategy(Strategy strategy, StrategyType type) + { + ArgumentNullException.ThrowIfNull(strategy); + _componentFactories.Add(next => new StrategyComponent(strategy, next)); + _strategyTypes.Add(type); + return this; + } + + /// + /// Flattens another pipeline's strategies into this builder, enabling composition of pre-built pipelines. + /// + /// The pipeline whose strategies will be added. + /// This builder for chaining. + public PipelineBuilder AddPipeline(Pipeline pipeline) + { + ArgumentNullException.ThrowIfNull(pipeline); + var outerComponent = pipeline.Component; + _componentFactories.Add(next => new DelegatingComponent(outerComponent, next)); + _strategyTypes.Add(StrategyType.Custom); + return this; + } + + /// + /// Builds the pipeline. The builder should not be used after calling this method. + /// + /// An immutable, thread-safe . + public Pipeline Build() + { + if (_componentFactories.Count == 0) + { + return Pipeline.Empty; + } + + // Validate ordering unless suppressed. + if (!SuppressOrderingWarnings && _strategyTypes.Count >= 2) + { + var warnings = OrderingValidator.Validate(_strategyTypes); + EmitWarnings(warnings); + } + + var component = PipelineComponent.Empty; + for (var i = _componentFactories.Count - 1; i >= 0; i--) + { + component = _componentFactories[i](component); + } + + return new Pipeline(component); + } + + private void EmitWarnings(List warnings) + { + foreach (var warning in warnings) + { + if (OnValidationWarning is not null) + { + OnValidationWarning(warning); + } + else + { + System.Diagnostics.Debug.WriteLine($"[Resilion] Ordering warning: {warning}"); + } + } + } +} + +/// +/// Builds a by composing resilience strategies. Supports both +/// non-generic strategies (Timeout, RateLimiter) and typed strategies (Fallback, Hedging). +/// +/// The result type for the pipeline. +public sealed class PipelineBuilder +{ + private readonly List> _componentFactories = []; + private readonly List _strategyTypes = []; + + /// + /// Gets or sets an optional name for the pipeline, used in telemetry and diagnostics. + /// + public string? Name { get; set; } + + /// + /// Gets or sets the used by time-dependent strategies. + /// Defaults to . + /// + public TimeProvider TimeProvider { get; set; } = TimeProvider.System; + + /// + /// When true, suppresses ordering validation warnings at time. + /// + public bool SuppressOrderingWarnings { get; set; } + + /// + /// Optional callback that receives ordering validation warnings. + /// When null, warnings go to . + /// + public Action? OnValidationWarning { get; set; } + + /// + /// Adds a non-generic strategy (e.g., Timeout, RateLimiter) to the typed pipeline. + /// + public PipelineBuilder AddStrategy(Strategy strategy) + { + ArgumentNullException.ThrowIfNull(strategy); + _componentFactories.Add(next => new StrategyComponent(strategy, next)); + _strategyTypes.Add(StrategyType.Unknown); + return this; + } + + internal PipelineBuilder AddStrategy(Strategy strategy, StrategyType type) + { + ArgumentNullException.ThrowIfNull(strategy); + _componentFactories.Add(next => new StrategyComponent(strategy, next)); + _strategyTypes.Add(type); + return this; + } + + /// + /// Adds a typed strategy (e.g., Fallback, result-based Retry) to the pipeline. + /// + public PipelineBuilder AddStrategy(Strategy strategy) + { + ArgumentNullException.ThrowIfNull(strategy); + _componentFactories.Add(next => new TypedStrategyComponent(strategy, next)); + _strategyTypes.Add(StrategyType.Unknown); + return this; + } + + internal PipelineBuilder AddStrategy(Strategy strategy, StrategyType type) + { + ArgumentNullException.ThrowIfNull(strategy); + _componentFactories.Add(next => new TypedStrategyComponent(strategy, next)); + _strategyTypes.Add(type); + return this; + } + + /// + /// Adds a delegate-based strategy for quick inline resilience logic. + /// + public PipelineBuilder AddStrategy( + string name, + Func>>, ValueTask>> handler) + { + ArgumentNullException.ThrowIfNull(name); + ArgumentNullException.ThrowIfNull(handler); + _componentFactories.Add(next => + new TypedStrategyComponent(new DelegateStrategy(name, handler), next)); + _strategyTypes.Add(StrategyType.Custom); + return this; + } + + /// + /// Flattens another typed pipeline's strategies into this builder. + /// + public PipelineBuilder AddPipeline(Pipeline pipeline) + { + ArgumentNullException.ThrowIfNull(pipeline); + var outerComponent = pipeline.Component; + _componentFactories.Add(next => new DelegatingComponent(outerComponent, next)); + _strategyTypes.Add(StrategyType.Custom); + return this; + } + + /// + /// Flattens a non-generic pipeline's strategies into this typed builder. + /// + public PipelineBuilder AddPipeline(Pipeline pipeline) + { + ArgumentNullException.ThrowIfNull(pipeline); + var outerComponent = pipeline.Component; + _componentFactories.Add(next => new DelegatingComponent(outerComponent, next)); + _strategyTypes.Add(StrategyType.Custom); + return this; + } + + /// + /// Builds the pipeline. + /// + public Pipeline Build() + { + if (_componentFactories.Count == 0) + { + return Pipeline.Empty; + } + + if (!SuppressOrderingWarnings && _strategyTypes.Count >= 2) + { + var warnings = OrderingValidator.Validate(_strategyTypes); + EmitWarnings(warnings); + } + + var component = PipelineComponent.Empty; + for (var i = _componentFactories.Count - 1; i >= 0; i--) + { + component = _componentFactories[i](component); + } + + return new Pipeline(component); + } + + private void EmitWarnings(List warnings) + { + foreach (var warning in warnings) + { + if (OnValidationWarning is not null) + { + OnValidationWarning(warning); + } + else + { + System.Diagnostics.Debug.WriteLine($"[Resilion] Ordering warning: {warning}"); + } + } + } +} + +/// +/// Internal strategy wrapper for delegate-based strategies on typed pipelines. +/// +internal sealed class DelegateStrategy : Strategy +{ + private readonly string _name; + private readonly Func>>, ValueTask>> _handler; + + internal DelegateStrategy( + string name, + Func>>, ValueTask>> handler) + { + _name = name; + _handler = handler; + } + + protected internal override ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + => _handler(context, callback); + + public override string ToString() => $"DelegateStrategy<{typeof(TResult).Name}>({_name})"; +} + +/// +/// Internal component that delegates to an existing pipeline's component chain, +/// then continues to the next component in the current chain. +/// +internal sealed class DelegatingComponent : PipelineComponent +{ + private readonly PipelineComponent _inner; + private readonly PipelineComponent _next; + + internal DelegatingComponent(PipelineComponent inner, PipelineComponent next) + { + _inner = inner; + _next = next; + } + + internal override ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + return _inner.ExecuteAsync( + ctx => _next.ExecuteAsync(callback, ctx), + context); + } + + internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + return _inner.Execute( + ctx => _next.Execute(callback, ctx), + context); + } + + public override void Dispose() + { + // Don't dispose inner — it may be shared via AddPipeline. + // Don't dispose next — the parent chain owns it. + } +} diff --git a/src/Resilion/PipelineOfT.cs b/src/Resilion/PipelineOfT.cs new file mode 100644 index 0000000..9372277 --- /dev/null +++ b/src/Resilion/PipelineOfT.cs @@ -0,0 +1,175 @@ +using Resilion.Internal; + +namespace Resilion; + +/// +/// Executes operations returning with resilience. Strategies can react +/// to both exceptions AND specific result values (e.g., retry on HTTP 500, fallback to a default). +/// Required for Fallback, Hedging, and result-based predicates. +/// +/// The result type of operations executed through this pipeline. +/// +/// Pipelines are thread-safe and immutable after construction. Build once, cache, and reuse. +/// +public sealed class Pipeline : IDisposable +{ + private readonly PipelineComponent _component; + private readonly ResilienceContextPool _pool; + + internal Pipeline(PipelineComponent component, ResilienceContextPool? pool = null) + { + _component = component; + _pool = pool ?? ResilienceContextPool.Shared; + } + + /// + /// Gets a no-op pipeline that passes through to the user delegate without applying any strategies. + /// + public static Pipeline Empty { get; } = new(PipelineComponent.Empty); + + /// + /// Gets the internal component for pipeline composition. + /// + internal PipelineComponent Component => _component; + + // ────────────────────────────────────────────────────────────────── + // Async execution + // ────────────────────────────────────────────────────────────────── + + /// + /// Executes an async operation through the pipeline with a state parameter to avoid closure allocations. + /// + /// The type of the state passed to the callback. + /// The operation to execute. Use a static lambda with to avoid closure allocations. + /// State passed to the callback. + /// Cancellation token for the operation. + /// The result of the operation. + public async ValueTask ExecuteAsync( + Func> action, + TState state, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(action); + var context = _pool.Rent(cancellationToken); + try + { + var outcome = await _component.ExecuteAsync( + async ctx => + { + try + { + var result = await action(state, ctx.CancellationToken).ConfigureAwait(ctx.ContinueOnCapturedContext); + return Outcome.FromResult(result); + } + catch (Exception ex) + { + return Outcome.FromException(ex); + } + }, + context).ConfigureAwait(context.ContinueOnCapturedContext); + + return outcome.ThrowIfFailed(); + } + finally + { + _pool.Return(context); + } + } + + /// + /// Executes an async operation through the pipeline. + /// + /// The operation to execute. + /// Cancellation token for the operation. + /// The result of the operation. + public ValueTask ExecuteAsync( + Func> action, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(action); + return ExecuteAsync(static (act, ct) => act(ct), action, cancellationToken); + } + + /// + /// Executes an async operation and returns the without rethrowing. + /// + /// The type of the state passed to the callback. + /// The operation to execute. + /// State passed to the callback. + /// The execution context (not pooled — caller manages lifetime). + /// The outcome of the operation. + public ValueTask> ExecuteOutcomeAsync( + Func>> action, + TState state, + ResilienceContext context) + { + ArgumentNullException.ThrowIfNull(action); + ArgumentNullException.ThrowIfNull(context); + + return _component.ExecuteAsync( + ctx => action(state, ctx), + context); + } + + // ────────────────────────────────────────────────────────────────── + // Sync execution + // ────────────────────────────────────────────────────────────────── + + /// + /// Executes a synchronous operation through the pipeline with a state parameter to avoid closure allocations. + /// + /// The type of the state passed to the callback. + /// The operation to execute. + /// State passed to the callback. + /// Cancellation token for the operation. + /// The result of the operation. + public TResult Execute( + Func action, + TState state, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(action); + var context = _pool.Rent(cancellationToken); + context.IsSynchronous = true; + try + { + var outcome = _component.Execute( + ctx => + { + try + { + var result = action(state, ctx.CancellationToken); + return Outcome.FromResult(result); + } + catch (Exception ex) + { + return Outcome.FromException(ex); + } + }, + context); + + return outcome.ThrowIfFailed(); + } + finally + { + _pool.Return(context); + } + } + + /// + /// Executes a synchronous operation through the pipeline. + /// + /// The operation to execute. + /// Cancellation token for the operation. + /// The result of the operation. + public TResult Execute( + Func action, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(action); + return Execute(static (act, ct) => act(ct), action, cancellationToken); + } + + /// + public void Dispose() => _component.Dispose(); +} diff --git a/src/Resilion/ResilienceContext.cs b/src/Resilion/ResilienceContext.cs new file mode 100644 index 0000000..ebb7384 --- /dev/null +++ b/src/Resilion/ResilienceContext.cs @@ -0,0 +1,74 @@ +namespace Resilion; + +/// +/// Carries execution state through the resilience pipeline. Each pipeline execution +/// gets its own context, which provides the , operation metadata, +/// and a type-safe bag for passing data between strategies. +/// +/// +/// +/// Contexts are pooled to avoid per-call allocations. Never construct a +/// directly — use to rent and return instances. +/// +/// +/// The pipeline's ExecuteAsync methods handle context pooling automatically. +/// Only use the pool directly when calling ExecuteOutcomeAsync with a custom context. +/// +/// +public sealed class ResilienceContext +{ + // Internal constructor — only the pool creates instances. + internal ResilienceContext() + { + } + + /// + /// Gets the cancellation token for this execution. + /// Strategies may replace this with a linked token (e.g., Timeout strategy). + /// + public CancellationToken CancellationToken { get; internal set; } + + /// + /// Gets or sets an optional name identifying this operation, used for telemetry and diagnostics. + /// + /// + /// + /// var context = ResilienceContextPool.Shared.Rent(cancellationToken); + /// context.OperationKey = "GetUserProfile"; + /// + /// + public string? OperationKey { get; set; } + + /// + /// Gets or sets a value indicating whether async continuations should run on the captured + /// synchronization context. Defaults to false (library-friendly behavior). + /// + /// + /// When false, all awaits inside the pipeline use ConfigureAwait(false). + /// Set to true when executing from a UI thread or a context that requires + /// synchronization context flow. + /// + public bool ContinueOnCapturedContext { get; set; } + + /// + /// Gets the type-safe property bag for passing arbitrary data through the pipeline. + /// + public ResilienceProperties Properties { get; } = new(); + + /// + /// Gets a value indicating whether this execution is synchronous. + /// + internal bool IsSynchronous { get; set; } + + /// + /// Resets this context to its initial state so it can be returned to the pool. + /// + internal void Reset() + { + CancellationToken = default; + OperationKey = null; + ContinueOnCapturedContext = false; + IsSynchronous = false; + Properties.Clear(); + } +} diff --git a/src/Resilion/ResilienceContextPool.cs b/src/Resilion/ResilienceContextPool.cs new file mode 100644 index 0000000..c18a8e1 --- /dev/null +++ b/src/Resilion/ResilienceContextPool.cs @@ -0,0 +1,60 @@ +using System.Collections.Concurrent; + +namespace Resilion; + +/// +/// Provides pooled instances to avoid per-call allocations. +/// +/// +/// The pipeline's ExecuteAsync methods use this pool automatically. Only use it directly +/// when you need a custom context for ExecuteOutcomeAsync. +/// +public sealed class ResilienceContextPool +{ + // Thread-safe bag for pooled contexts. ConcurrentBag is well-suited here because + // contexts are rented and returned from the same thread most of the time (LIFO affinity). + private readonly ConcurrentBag _pool = new(); + + // Cap the pool size to avoid unbounded memory growth under burst traffic. + // 256 is generous — most applications use far fewer concurrent pipeline executions. + private const int MaxPoolSize = 256; + + /// + /// Gets the shared default pool instance. Use this unless you have a specific reason + /// to create a separate pool. + /// + public static ResilienceContextPool Shared { get; } = new(); + + /// + /// Rents a from the pool with the specified cancellation token. + /// + /// The cancellation token for this execution. + /// A pooled or newly created . + public ResilienceContext Rent(CancellationToken cancellationToken = default) + { + if (!_pool.TryTake(out var context)) + { + context = new ResilienceContext(); + } + + context.CancellationToken = cancellationToken; + return context; + } + + /// + /// Returns a to the pool. The context is reset to its + /// initial state before being pooled. + /// + /// The context to return. + public void Return(ResilienceContext context) + { + ArgumentNullException.ThrowIfNull(context); + context.Reset(); + + // Don't let the pool grow without bound. + if (_pool.Count < MaxPoolSize) + { + _pool.Add(context); + } + } +} diff --git a/src/Resilion/ResilienceEventHandler.cs b/src/Resilion/ResilienceEventHandler.cs new file mode 100644 index 0000000..f061441 --- /dev/null +++ b/src/Resilion/ResilienceEventHandler.cs @@ -0,0 +1,95 @@ +namespace Resilion; + +/// +/// A union type that holds either a synchronous or an asynchronous +/// returning . Implicit conversions +/// let the compiler pick the right path automatically. +/// +/// The event arguments type (typically a readonly record struct). +/// +/// +/// This solves Polly v8's callback verbosity problem. Polly forces all callbacks to return +/// ValueTask even when they're synchronous (the 90% case — logging, incrementing counters). +/// +/// +/// +/// // Sync — zero overhead, no ValueTask wrapping: +/// OnRetry = (RetryAttemptEvent e) => logger.Log(e.AttemptNumber) +/// +/// // Async — when genuinely needed: +/// OnRetry = async (RetryAttemptEvent e) => await telemetry.TrackAsync(e) +/// +/// +/// +public readonly struct ResilienceEventHandler +{ + private readonly Action? _syncHandler; + private readonly Func? _asyncHandler; + + private ResilienceEventHandler(Action? syncHandler, Func? asyncHandler) + { + _syncHandler = syncHandler; + _asyncHandler = asyncHandler; + } + + /// + /// Gets a value indicating whether this handler has been assigned. + /// + public bool HasHandler => _syncHandler is not null || _asyncHandler is not null; + + /// + /// Invokes the handler. If the handler is synchronous, returns a completed . + /// + /// The event arguments. + /// A representing the completion of the handler. + internal ValueTask InvokeAsync(TArgs args) + { + if (_syncHandler is not null) + { + _syncHandler(args); + return default; + } + + if (_asyncHandler is not null) + { + return _asyncHandler(args); + } + + return default; + } + + /// + /// Invokes the handler synchronously. If the handler is async, blocks until completion. + /// + /// The event arguments. + internal void Invoke(TArgs args) + { + if (_syncHandler is not null) + { + _syncHandler(args); + return; + } + + if (_asyncHandler is not null) + { + // Copy to local to avoid struct 'this' capture in lambda. + // Run on the thread pool to avoid deadlocking when a SynchronizationContext + // is present (WPF, WinForms). + var handler = _asyncHandler; + Task.Run(() => handler(args).AsTask()).GetAwaiter().GetResult(); + } + } + + /// + /// Implicitly converts a synchronous to a . + /// + public static implicit operator ResilienceEventHandler(Action handler) + => new(handler, null); + + /// + /// Implicitly converts an asynchronous returning + /// to a . + /// + public static implicit operator ResilienceEventHandler(Func handler) + => new(null, handler); +} diff --git a/src/Resilion/ResilienceProperties.cs b/src/Resilion/ResilienceProperties.cs new file mode 100644 index 0000000..815620e --- /dev/null +++ b/src/Resilion/ResilienceProperties.cs @@ -0,0 +1,96 @@ +namespace Resilion; + +/// +/// A type-safe property bag for passing arbitrary data through the resilience pipeline. +/// Strategies and user callbacks can read and write values using . +/// +/// +/// This is not thread-safe. It is expected to be used within a single pipeline execution +/// (one per execution), which is inherently single-threaded +/// through the strategy chain. +/// +public sealed class ResilienceProperties +{ + private Dictionary? _properties; + + /// + /// Sets a property value for the specified key. + /// + /// The type of the value. + /// The property key. + /// The value to set. + public void Set(ResiliencePropertyKey key, TValue value) + { + _properties ??= new Dictionary(StringComparer.Ordinal); + _properties[key.Key] = value; + } + + /// + /// Gets the property value for the specified key. + /// + /// The type of the value. + /// The property key. + /// When this method returns true, contains the value. + /// true if the property was found; false otherwise. + public bool TryGetValue(ResiliencePropertyKey key, out TValue? value) + { + if (_properties is not null && _properties.TryGetValue(key.Key, out var raw)) + { + value = (TValue?)raw; + return true; + } + + value = default; + return false; + } + + /// + /// Gets the property value for the specified key, or the default value if not found. + /// + /// The type of the value. + /// The property key. + /// The value to return if the key is not found. + /// The property value, or if not found. + public TValue GetValue(ResiliencePropertyKey key, TValue defaultValue = default!) + => TryGetValue(key, out var value) ? value! : defaultValue; + + /// + /// Removes the property with the specified key. + /// + /// The type of the value. + /// The property key. + /// true if the property was found and removed; false otherwise. + public bool Remove(ResiliencePropertyKey key) + => _properties?.Remove(key.Key) ?? false; + + /// + /// Gets the number of properties stored. + /// + public int Count => _properties?.Count ?? 0; + + /// + /// Removes all properties. + /// + /// + /// Removes all properties. + /// + internal void Clear() => _properties?.Clear(); + + /// + /// Copies all properties from another instance. + /// Existing properties with the same key are overwritten. + /// + internal void CopyFrom(ResilienceProperties source) + { + if (source._properties is null || source._properties.Count == 0) + { + return; + } + + _properties ??= new Dictionary(StringComparer.Ordinal); + foreach (var kvp in source._properties) + { + _properties[kvp.Key] = kvp.Value; + } + } +} diff --git a/src/Resilion/ResiliencePropertyKey.cs b/src/Resilion/ResiliencePropertyKey.cs new file mode 100644 index 0000000..0ba37c3 --- /dev/null +++ b/src/Resilion/ResiliencePropertyKey.cs @@ -0,0 +1,48 @@ +namespace Resilion; + +/// +/// A strongly-typed key for storing and retrieving values from . +/// Using typed keys prevents accidental type mismatches when passing data through the pipeline. +/// +/// The type of the value associated with this key. +public readonly struct ResiliencePropertyKey : IEquatable> +{ + /// + /// Initializes a new instance of the struct. + /// + /// The unique string identifier for this property key. + /// Thrown when is null or empty. + public ResiliencePropertyKey(string key) + { + ArgumentException.ThrowIfNullOrEmpty(key); + Key = key; + } + + /// + /// Gets the unique string identifier for this property key. + /// + public string Key { get; } + + /// + public bool Equals(ResiliencePropertyKey other) + => string.Equals(Key, other.Key, StringComparison.Ordinal); + + /// + public override bool Equals(object? obj) + => obj is ResiliencePropertyKey other && Equals(other); + + /// + public override int GetHashCode() + => StringComparer.Ordinal.GetHashCode(Key); + + /// Determines whether two property keys are equal. + public static bool operator ==(ResiliencePropertyKey left, ResiliencePropertyKey right) + => left.Equals(right); + + /// Determines whether two property keys are not equal. + public static bool operator !=(ResiliencePropertyKey left, ResiliencePropertyKey right) + => !left.Equals(right); + + /// + public override string ToString() => $"ResiliencePropertyKey<{typeof(TValue).Name}>({Key})"; +} diff --git a/src/Resilion/Resilion.csproj b/src/Resilion/Resilion.csproj new file mode 100644 index 0000000..f6f4a72 --- /dev/null +++ b/src/Resilion/Resilion.csproj @@ -0,0 +1,17 @@ + + + + Resilion + Resilion + Resilion + Runtime resilience library for .NET. Retry, circuit breaker, timeout, fallback, hedging, pipeline composition. Zero external dependencies. + + + + + + + + + + diff --git a/src/Resilion/ResilionException.cs b/src/Resilion/ResilionException.cs new file mode 100644 index 0000000..6a070cd --- /dev/null +++ b/src/Resilion/ResilionException.cs @@ -0,0 +1,28 @@ +namespace Resilion; + +/// +/// Base class for all exceptions originated by Resilion strategies. +/// Catching this type catches any Resilion-specific failure (timeout, circuit broken, rate limited, etc.) +/// while letting and user exceptions pass through. +/// +public abstract class ResilionException : Exception +{ + /// + /// Initializes a new instance of the class. + /// + /// The error message. + protected ResilionException(string message) + : base(message) + { + } + + /// + /// Initializes a new instance of the class. + /// + /// The error message. + /// The inner exception. + protected ResilionException(string message, Exception innerException) + : base(message, innerException) + { + } +} diff --git a/src/Resilion/Retry/RetryDelay.cs b/src/Resilion/Retry/RetryDelay.cs new file mode 100644 index 0000000..986b450 --- /dev/null +++ b/src/Resilion/Retry/RetryDelay.cs @@ -0,0 +1,142 @@ +namespace Resilion; + +/// +/// Defines how retry delays are computed. Each variant is mutually exclusive by construction, +/// eliminating the confusion of Polly's separate Delay/BackoffType/UseJitter/DelayGenerator properties. +/// +/// +/// +/// Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)) // exponential backoff +/// Delay = RetryDelay.Constant(TimeSpan.FromMilliseconds(200)) // fixed delay +/// Delay = RetryDelay.Linear(TimeSpan.FromSeconds(1), maxDelay: TimeSpan.FromSeconds(10)) +/// Delay = RetryDelay.Custom(ctx => ComputeMyDelay(ctx)) // fully custom +/// +/// +public abstract record RetryDelay +{ + // Sealed hierarchy — users extend via Custom, not by inheriting from RetryDelay. + private RetryDelay() { } + + /// + /// Creates a constant delay (same duration for every retry). + /// + /// The fixed delay between retries. + public static RetryDelay Constant(TimeSpan delay) => new ConstantDelay(delay); + + /// + /// Creates a linearly increasing delay (baseDelay × attemptNumber). + /// + /// The base delay that scales linearly. + /// Optional cap on the delay. Defaults to no cap. + public static RetryDelay Linear(TimeSpan baseDelay, TimeSpan? maxDelay = null) + => new LinearDelay(baseDelay, maxDelay); + + /// + /// Creates an exponentially increasing delay (baseDelay × 2^attemptNumber). + /// + /// The base delay for the first retry. + /// Optional cap on the delay. Defaults to 30 seconds. + public static RetryDelay Exponential(TimeSpan baseDelay, TimeSpan? maxDelay = null) + => new ExponentialDelay(baseDelay, maxDelay ?? TimeSpan.FromSeconds(30)); + + /// + /// Creates a fully custom delay computation. + /// + /// Function that receives the retry context and returns a delay. + public static RetryDelay Custom(Func compute) + => new CustomDelay(compute); + + /// + /// Zero delay — retries execute immediately with no wait. + /// + public static RetryDelay None { get; } = Constant(TimeSpan.Zero); + + /// + /// Computes the delay for the given attempt number. + /// + /// The 1-based retry attempt number (1 = first retry, not the original call). + /// Whether to apply jitter to the computed delay. + /// The delay to wait before the next retry. + internal abstract TimeSpan ComputeDelay(int attemptNumber, bool useJitter); + + /// + /// Applies decorrelated jitter to a delay value. + /// Uses the AWS recommended algorithm: sleep = min(cap, random_between(base, prev * 3)). + /// + private static TimeSpan ApplyJitter(TimeSpan delay, TimeSpan? maxDelay) + { + if (delay <= TimeSpan.Zero) + { + return TimeSpan.Zero; + } + + var ms = delay.TotalMilliseconds; + // ±25% jitter for simplicity and effectiveness + var jitterMs = ms * (0.75 + (Random.Shared.NextDouble() * 0.5)); + var result = TimeSpan.FromMilliseconds(jitterMs); + + if (maxDelay.HasValue && result > maxDelay.Value) + { + result = maxDelay.Value; + } + + return result; + } + + private static TimeSpan Clamp(TimeSpan delay, TimeSpan? maxDelay) + => maxDelay.HasValue && delay > maxDelay.Value ? maxDelay.Value : delay; + + // ── Variants ───────────────────────────────────────────────── + + private sealed record ConstantDelay(TimeSpan Delay) : RetryDelay + { + internal override TimeSpan ComputeDelay(int attemptNumber, bool useJitter) + => useJitter ? ApplyJitter(Delay, null) : Delay; + } + + private sealed record LinearDelay(TimeSpan BaseDelay, TimeSpan? MaxDelay) : RetryDelay + { + internal override TimeSpan ComputeDelay(int attemptNumber, bool useJitter) + { + var delay = BaseDelay * attemptNumber; + delay = Clamp(delay, MaxDelay); + return useJitter ? ApplyJitter(delay, MaxDelay) : delay; + } + } + + private sealed record ExponentialDelay(TimeSpan BaseDelay, TimeSpan? MaxDelay) : RetryDelay + { + internal override TimeSpan ComputeDelay(int attemptNumber, bool useJitter) + { + // delay = baseDelay * 2^(attemptNumber-1) + var multiplier = Math.Pow(2, attemptNumber - 1); + var delayMs = BaseDelay.TotalMilliseconds * multiplier; + + // Clamp before TimeSpan.FromMilliseconds to avoid OverflowException + // when attemptNumber is large (e.g., int.MaxValue retries). + if (MaxDelay.HasValue) + { + delayMs = Math.Min(delayMs, MaxDelay.Value.TotalMilliseconds); + } + else if (double.IsInfinity(delayMs) || double.IsNaN(delayMs) || delayMs > TimeSpan.MaxValue.TotalMilliseconds) + { + delayMs = TimeSpan.MaxValue.TotalMilliseconds; + } + + var delay = TimeSpan.FromMilliseconds(delayMs); + return useJitter ? ApplyJitter(delay, MaxDelay) : delay; + } + } + + private sealed record CustomDelay(Func Compute) : RetryDelay + { + internal override TimeSpan ComputeDelay(int attemptNumber, bool useJitter) + => Compute(new RetryDelayContext(attemptNumber)); + } +} + +/// +/// Context passed to delegates. +/// +/// The 1-based retry attempt number. +public readonly record struct RetryDelayContext(int AttemptNumber); diff --git a/src/Resilion/Retry/RetryExtensions.cs b/src/Resilion/Retry/RetryExtensions.cs new file mode 100644 index 0000000..22cfce4 --- /dev/null +++ b/src/Resilion/Retry/RetryExtensions.cs @@ -0,0 +1,52 @@ +namespace Resilion; + +/// +/// Extension methods for adding the Retry strategy to a pipeline builder. +/// +public static class RetryExtensions +{ + /// + /// Adds an exception-only retry strategy with the specified options. + /// + /// The pipeline builder. + /// The retry options. When null, uses default options (3 retries, exponential backoff with jitter). + /// The builder for chaining. + public static PipelineBuilder AddRetry(this PipelineBuilder builder, RetryStrategyOptions? options = null) + { + options ??= new RetryStrategyOptions(); + options.Validate(); + return builder.AddStrategy(new RetryStrategy(options, builder.TimeProvider), Internal.StrategyType.Retry); + } + + /// + /// Adds a result-aware retry strategy to a typed pipeline. + /// + /// The result type. + /// The typed pipeline builder. + /// The typed retry options. + /// The builder for chaining. + public static PipelineBuilder AddRetry( + this PipelineBuilder builder, + RetryStrategyOptions options) + { + ArgumentNullException.ThrowIfNull(options); + options.Validate(); + return builder.AddStrategy(new RetryStrategy(options, builder.TimeProvider), Internal.StrategyType.Retry); + } + + /// + /// Adds an exception-only retry strategy to a typed pipeline. + /// + /// The result type. + /// The typed pipeline builder. + /// The retry options. When null, uses default options. + /// The builder for chaining. + public static PipelineBuilder AddRetry( + this PipelineBuilder builder, + RetryStrategyOptions? options = null) + { + options ??= new RetryStrategyOptions(); + options.Validate(); + return builder.AddStrategy(new RetryStrategy(options, builder.TimeProvider), Internal.StrategyType.Retry); + } +} diff --git a/src/Resilion/Retry/RetryStrategy.cs b/src/Resilion/Retry/RetryStrategy.cs new file mode 100644 index 0000000..70169c1 --- /dev/null +++ b/src/Resilion/Retry/RetryStrategy.cs @@ -0,0 +1,242 @@ +namespace Resilion; + +/// +/// Non-generic retry strategy — retries on exceptions only. +/// +internal sealed class RetryStrategy : Strategy +{ + private readonly RetryStrategyOptions _options; + private readonly TimeProvider _timeProvider; + + internal RetryStrategy(RetryStrategyOptions options, TimeProvider timeProvider) + { + _options = options; + _timeProvider = timeProvider; + } + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + if (_options.MaxRetryAttempts == 0) + { + return await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + } + + Outcome outcome = default; + + for (var attempt = 0; attempt <= _options.MaxRetryAttempts; attempt++) + { + // Check cancellation before each attempt. + context.CancellationToken.ThrowIfCancellationRequested(); + + outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + + // Success — return immediately. + if (outcome.IsSuccess) + { + return outcome; + } + + // Check if this exception should trigger a retry. + if (!_options.ShouldHandleException(outcome.Exception!)) + { + return outcome; + } + + // Last attempt — don't wait, just return the failure. + if (attempt == _options.MaxRetryAttempts) + { + break; + } + + // Compute delay. + var retryNumber = attempt + 1; + var delay = _options.Delay.ComputeDelay(retryNumber, _options.UseJitter); + + ResilionTelemetry.RetryAttempts.Add(1); + + // Fire OnRetry callback. + if (_options.OnRetry is { } handler && handler.HasHandler) + { + await handler.InvokeAsync( + new RetryAttemptEvent(retryNumber, delay, outcome.Exception!, context)) + .ConfigureAwait(false); + } + + // Wait for the delay (if any), respecting cancellation. + if (delay > TimeSpan.Zero) + { + await Task.Delay(delay, _timeProvider, context.CancellationToken) + .ConfigureAwait(context.ContinueOnCapturedContext); + } + } + + return outcome; + } + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + if (_options.MaxRetryAttempts == 0) + { + return callback(context); + } + + Outcome outcome = default; + + for (var attempt = 0; attempt <= _options.MaxRetryAttempts; attempt++) + { + context.CancellationToken.ThrowIfCancellationRequested(); + + outcome = callback(context); + + if (outcome.IsSuccess) + { + return outcome; + } + + if (!_options.ShouldHandleException(outcome.Exception!)) + { + return outcome; + } + + if (attempt == _options.MaxRetryAttempts) + { + break; + } + + var retryNumber = attempt + 1; + var delay = _options.Delay.ComputeDelay(retryNumber, _options.UseJitter); + + ResilionTelemetry.RetryAttempts.Add(1); + + if (_options.OnRetry is { } handler && handler.HasHandler) + { + handler.Invoke(new RetryAttemptEvent(retryNumber, delay, outcome.Exception!, context)); + } + + if (delay > TimeSpan.Zero) + { + // Sync path: use WaitHandle for cancellation-aware sleep. + context.CancellationToken.WaitHandle.WaitOne(delay); + context.CancellationToken.ThrowIfCancellationRequested(); + } + } + + return outcome; + } +} + +/// +/// Generic retry strategy — retries on exceptions and/or result values. +/// +internal sealed class RetryStrategy : Strategy +{ + private readonly RetryStrategyOptions _options; + private readonly TimeProvider _timeProvider; + + internal RetryStrategy(RetryStrategyOptions options, TimeProvider timeProvider) + { + _options = options; + _timeProvider = timeProvider; + } + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + if (_options.MaxRetryAttempts == 0) + { + return await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + } + + Outcome outcome = default; + + for (var attempt = 0; attempt <= _options.MaxRetryAttempts; attempt++) + { + context.CancellationToken.ThrowIfCancellationRequested(); + + outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + + // Check predicate against the full outcome (exception OR result). + if (!_options.ShouldHandleOutcome(outcome)) + { + return outcome; + } + + if (attempt == _options.MaxRetryAttempts) + { + break; + } + + var retryNumber = attempt + 1; + var delay = _options.Delay.ComputeDelay(retryNumber, _options.UseJitter); + + ResilionTelemetry.RetryAttempts.Add(1); + + if (_options.OnRetry is { } handler && handler.HasHandler) + { + await handler.InvokeAsync( + new RetryAttemptEvent(retryNumber, delay, outcome, context)) + .ConfigureAwait(false); + } + + if (delay > TimeSpan.Zero) + { + await Task.Delay(delay, _timeProvider, context.CancellationToken) + .ConfigureAwait(context.ContinueOnCapturedContext); + } + } + + return outcome; + } + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + if (_options.MaxRetryAttempts == 0) + { + return callback(context); + } + + Outcome outcome = default; + + for (var attempt = 0; attempt <= _options.MaxRetryAttempts; attempt++) + { + context.CancellationToken.ThrowIfCancellationRequested(); + + outcome = callback(context); + + if (!_options.ShouldHandleOutcome(outcome)) + { + return outcome; + } + + if (attempt == _options.MaxRetryAttempts) + { + break; + } + + var retryNumber = attempt + 1; + var delay = _options.Delay.ComputeDelay(retryNumber, _options.UseJitter); + + ResilionTelemetry.RetryAttempts.Add(1); + + if (_options.OnRetry is { } handler && handler.HasHandler) + { + handler.Invoke(new RetryAttemptEvent(retryNumber, delay, outcome, context)); + } + + if (delay > TimeSpan.Zero) + { + context.CancellationToken.WaitHandle.WaitOne(delay); + context.CancellationToken.ThrowIfCancellationRequested(); + } + } + + return outcome; + } +} diff --git a/src/Resilion/Retry/RetryStrategyOptions.cs b/src/Resilion/Retry/RetryStrategyOptions.cs new file mode 100644 index 0000000..6b68692 --- /dev/null +++ b/src/Resilion/Retry/RetryStrategyOptions.cs @@ -0,0 +1,137 @@ +namespace Resilion; + +/// +/// Options for the Retry resilience strategy (exception-only predicates). +/// +public sealed record RetryStrategyOptions +{ + /// + /// Gets the maximum number of retry attempts (not counting the initial execution). + /// Defaults to 3. Set to 0 for no retries. + /// + public int MaxRetryAttempts { get; init; } = 3; + + /// + /// Gets the delay strategy between retries. Defaults to exponential backoff starting at 1 second + /// with a 30-second cap. + /// + public RetryDelay Delay { get; init; } = RetryDelay.Exponential(TimeSpan.FromSeconds(1)); + + /// + /// Gets a value indicating whether jitter should be applied to retry delays. + /// Defaults to true (decorrelated jitter). + /// + public bool UseJitter { get; init; } = true; + + /// + /// Gets the predicate that determines which exceptions trigger a retry. + /// Defaults to all exceptions except . + /// + public Func? ShouldHandle { get; init; } + + /// + /// Gets an optional event handler fired before each retry wait. + /// + public ResilienceEventHandler? OnRetry { get; init; } + + internal void Validate() + { + if (MaxRetryAttempts < 0) + { + throw new ArgumentOutOfRangeException(nameof(MaxRetryAttempts), MaxRetryAttempts, + "MaxRetryAttempts must be >= 0."); + } + } + + internal bool ShouldHandleException(Exception exception) + { + // OperationCanceledException is never retried by default. + if (exception is OperationCanceledException) + { + return ShouldHandle?.Invoke(exception) ?? false; + } + + return ShouldHandle?.Invoke(exception) ?? true; + } +} + +/// +/// Options for the Retry resilience strategy with result-based predicates. +/// +/// The result type to inspect. +public sealed record RetryStrategyOptions +{ + /// + /// Gets the maximum number of retry attempts. Defaults to 3. + /// + public int MaxRetryAttempts { get; init; } = 3; + + /// + /// Gets the delay strategy between retries. + /// + public RetryDelay Delay { get; init; } = RetryDelay.Exponential(TimeSpan.FromSeconds(1)); + + /// + /// Gets a value indicating whether jitter should be applied. + /// + public bool UseJitter { get; init; } = true; + + /// + /// Gets the predicate that determines which outcomes (exceptions or results) trigger a retry. + /// Receives the to enable both exception and result-based decisions. + /// + public Func, bool>? ShouldHandle { get; init; } + + /// + /// Gets an optional event handler fired before each retry wait. + /// + public ResilienceEventHandler>? OnRetry { get; init; } + + internal void Validate() + { + if (MaxRetryAttempts < 0) + { + throw new ArgumentOutOfRangeException(nameof(MaxRetryAttempts), MaxRetryAttempts, + "MaxRetryAttempts must be >= 0."); + } + } + + internal bool ShouldHandleOutcome(Outcome outcome) + { + // If we have a custom predicate, use it. + if (ShouldHandle is not null) + { + return ShouldHandle(outcome); + } + + // Default: handle any exception except OperationCanceledException. + return outcome.Exception is not null and not OperationCanceledException; + } +} + +/// +/// Event arguments for the callback (exception-only). +/// +/// The 1-based retry attempt number. +/// The delay that will be waited before the next attempt. +/// The exception that triggered this retry. +/// The execution context. +public readonly record struct RetryAttemptEvent( + int AttemptNumber, + TimeSpan RetryDelay, + Exception Exception, + ResilienceContext Context); + +/// +/// Event arguments for the callback (outcome-based). +/// +/// The result type. +/// The 1-based retry attempt number. +/// The delay that will be waited before the next attempt. +/// The outcome that triggered this retry. +/// The execution context. +public readonly record struct RetryAttemptEvent( + int AttemptNumber, + TimeSpan RetryDelay, + Outcome Outcome, + ResilienceContext Context); diff --git a/src/Resilion/Strategy.cs b/src/Resilion/Strategy.cs new file mode 100644 index 0000000..399446a --- /dev/null +++ b/src/Resilion/Strategy.cs @@ -0,0 +1,102 @@ +namespace Resilion; + +/// +/// Base class for proactive resilience strategies that work with any result type. +/// Timeout, RateLimiter, and exception-only Retry/CircuitBreaker inherit from this. +/// +/// +/// +/// The key distinction: is non-generic at the class level +/// but generic at the method level. A single Timeout instance can protect calls +/// returning string, int, HttpResponseMessage, or any other type. +/// +/// +/// For strategies that need to inspect or substitute result values (Fallback, Hedging, +/// result-based Retry), use instead. +/// +/// +public abstract class Strategy : IDisposable +{ + /// + /// Executes the resilience logic around the given callback. + /// + /// The result type of the operation. + /// The next strategy or user delegate to invoke. + /// The execution context carrying cancellation and properties. + /// The outcome of the execution. + protected internal abstract ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context); + + /// + /// Executes the resilience logic synchronously around the given callback. + /// + /// The result type of the operation. + /// The next strategy or user delegate to invoke. + /// The execution context carrying cancellation and properties. + /// The outcome of the execution. + protected internal virtual Outcome Execute( + Func> callback, + ResilienceContext context) + { + // Default: delegate to async path synchronously. + // Strategies that support true sync execution should override this method. + return ExecuteAsync( + ctx => new ValueTask>(callback(ctx)), + context).GetAwaiter().GetResult(); + } + + /// + public virtual void Dispose() + { + } +} + +/// +/// Base class for reactive resilience strategies bound to a specific result type . +/// Fallback, Hedging, and result-based Retry/CircuitBreaker inherit from this. +/// +/// The result type this strategy operates on. +/// +/// +/// The key distinction: fixes the result type at the class level. +/// A Strategy<HttpResponseMessage> can inspect status codes and substitute fallback responses. +/// +/// +/// For strategies that don't need to inspect results (Timeout, RateLimiter), use instead. +/// +/// +public abstract class Strategy : IDisposable +{ + /// + /// Executes the resilience logic around the given callback. + /// + /// The next strategy or user delegate to invoke. + /// The execution context carrying cancellation and properties. + /// The outcome of the execution. + protected internal abstract ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context); + + /// + /// Executes the resilience logic synchronously around the given callback. + /// + /// The next strategy or user delegate to invoke. + /// The execution context carrying cancellation and properties. + /// The outcome of the execution. + protected internal virtual Outcome Execute( + Func> callback, + ResilienceContext context) + { + // Default: delegate to async path synchronously. + // Strategies that support true sync execution should override this method. + return ExecuteAsync( + ctx => new ValueTask>(callback(ctx)), + context).GetAwaiter().GetResult(); + } + + /// + public virtual void Dispose() + { + } +} diff --git a/src/Resilion/Telemetry/ResilionTelemetry.cs b/src/Resilion/Telemetry/ResilionTelemetry.cs new file mode 100644 index 0000000..bc26025 --- /dev/null +++ b/src/Resilion/Telemetry/ResilionTelemetry.cs @@ -0,0 +1,56 @@ +using System.Diagnostics; +using System.Diagnostics.Metrics; + +namespace Resilion; + +/// +/// Provides built-in telemetry instruments for Resilion strategies. +/// Zero overhead when no listener is attached — instruments only allocate when subscribed. +/// +/// +/// Subscribe with .AddMeter("Resilion") for metrics and .AddSource("Resilion") for traces. +/// +public static class ResilionTelemetry +{ + /// Meter name for all Resilion metrics. + public const string MeterName = "Resilion"; + + /// ActivitySource name for all Resilion traces. + public const string ActivitySourceName = "Resilion"; + + internal static readonly Meter Meter = new(MeterName); + internal static readonly ActivitySource ActivitySource = new(ActivitySourceName); + + internal static readonly Counter StrategyExecutions = Meter.CreateCounter( + "resilion.strategy.executions", + description: "Total strategy executions."); + + internal static readonly Histogram StrategyDuration = Meter.CreateHistogram( + "resilion.strategy.duration", + unit: "s", + description: "Strategy execution duration in seconds."); + + internal static readonly Counter RetryAttempts = Meter.CreateCounter( + "resilion.retry.attempts", + description: "Total retry attempts."); + + internal static readonly Counter CircuitBreakerStateChanges = Meter.CreateCounter( + "resilion.circuit_breaker.state_changes", + description: "Circuit breaker state transitions."); + + internal static readonly Counter TimeoutExpirations = Meter.CreateCounter( + "resilion.timeout.expirations", + description: "Timeout expirations."); + + internal static readonly Counter FallbackActivations = Meter.CreateCounter( + "resilion.fallback.activations", + description: "Fallback activations."); + + internal static readonly Counter HedgingAttempts = Meter.CreateCounter( + "resilion.hedging.attempts", + description: "Hedging attempts launched."); + + internal static readonly Counter RateLimiterRejections = Meter.CreateCounter( + "resilion.rate_limiter.rejections", + description: "Rate limiter rejections."); +} diff --git a/src/Resilion/Timeout/TimeoutExtensions.cs b/src/Resilion/Timeout/TimeoutExtensions.cs new file mode 100644 index 0000000..4640780 --- /dev/null +++ b/src/Resilion/Timeout/TimeoutExtensions.cs @@ -0,0 +1,53 @@ +namespace Resilion; + +/// +/// Extension methods for adding the Timeout strategy to a pipeline builder. +/// +public static class TimeoutExtensions +{ + /// + /// Adds a timeout strategy with the specified duration. + /// + /// The pipeline builder. + /// The timeout duration. + /// The builder for chaining. + public static PipelineBuilder AddTimeout(this PipelineBuilder builder, TimeSpan timeout) + => builder.AddTimeout(new TimeoutStrategyOptions { Timeout = timeout }); + + /// + /// Adds a timeout strategy with the specified options. + /// + /// The pipeline builder. + /// The timeout options. + /// The builder for chaining. + public static PipelineBuilder AddTimeout(this PipelineBuilder builder, TimeoutStrategyOptions? options = null) + { + options ??= new TimeoutStrategyOptions(); + options.Validate(); + return builder.AddStrategy(new TimeoutStrategy(options, builder.TimeProvider), Internal.StrategyType.Timeout); + } + + /// + /// Adds a timeout strategy with the specified duration to a typed pipeline. + /// + /// The result type of the pipeline. + /// The typed pipeline builder. + /// The timeout duration. + /// The builder for chaining. + public static PipelineBuilder AddTimeout(this PipelineBuilder builder, TimeSpan timeout) + => builder.AddTimeout(new TimeoutStrategyOptions { Timeout = timeout }); + + /// + /// Adds a timeout strategy with the specified options to a typed pipeline. + /// + /// The result type of the pipeline. + /// The typed pipeline builder. + /// The timeout options. + /// The builder for chaining. + public static PipelineBuilder AddTimeout(this PipelineBuilder builder, TimeoutStrategyOptions? options = null) + { + options ??= new TimeoutStrategyOptions(); + options.Validate(); + return builder.AddStrategy(new TimeoutStrategy(options, builder.TimeProvider), Internal.StrategyType.Timeout); + } +} diff --git a/src/Resilion/Timeout/TimeoutRejectedException.cs b/src/Resilion/Timeout/TimeoutRejectedException.cs new file mode 100644 index 0000000..c38f963 --- /dev/null +++ b/src/Resilion/Timeout/TimeoutRejectedException.cs @@ -0,0 +1,46 @@ +namespace Resilion; + +/// +/// Thrown when an operation exceeds its configured timeout duration. +/// +/// +/// +/// This exception is thrown only when the timeout fires — not when the user's original +/// is canceled. If the user's token is canceled, the original +/// propagates unchanged. +/// +/// +/// The contains the +/// that was thrown by the timed-out operation. +/// +/// +public sealed class TimeoutRejectedException : ResilionException +{ + /// + /// Initializes a new instance of the class. + /// + /// The timeout duration that was configured. + /// The actual elapsed time before timeout was triggered. + /// The underlying cancellation exception. + internal TimeoutRejectedException( + TimeSpan configuredTimeout, + TimeSpan elapsedTime, + Exception innerException) + : base($"The operation did not complete within the configured timeout of {configuredTimeout.TotalSeconds:F1}s " + + $"(elapsed: {elapsedTime.TotalSeconds:F1}s).", + innerException) + { + ConfiguredTimeout = configuredTimeout; + ElapsedTime = elapsedTime; + } + + /// + /// Gets the timeout duration that was configured on the strategy. + /// + public TimeSpan ConfiguredTimeout { get; } + + /// + /// Gets the actual time that elapsed before the timeout was triggered. + /// + public TimeSpan ElapsedTime { get; } +} diff --git a/src/Resilion/Timeout/TimeoutStrategy.cs b/src/Resilion/Timeout/TimeoutStrategy.cs new file mode 100644 index 0000000..c47cc89 --- /dev/null +++ b/src/Resilion/Timeout/TimeoutStrategy.cs @@ -0,0 +1,174 @@ +namespace Resilion; + +/// +/// Resilience strategy that enforces a time limit on operations using cooperative cancellation. +/// +internal sealed class TimeoutStrategy : Strategy +{ + private readonly TimeoutStrategyOptions _options; + private readonly TimeProvider _timeProvider; + + internal TimeoutStrategy(TimeoutStrategyOptions options, TimeProvider timeProvider) + { + _options = options; + _timeProvider = timeProvider; + } + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + var timeout = ResolveTimeout(context); + + if (timeout == System.Threading.Timeout.InfiniteTimeSpan) + { + return await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + } + + var previousToken = context.CancellationToken; + var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(previousToken); + var startTimestamp = _timeProvider.GetTimestamp(); + ITimer? timer = null; + + try + { + timer = _timeProvider.CreateTimer( + static state => ((CancellationTokenSource)state!).Cancel(), + linkedCts, + timeout, + System.Threading.Timeout.InfiniteTimeSpan); + + context.CancellationToken = linkedCts.Token; + + var outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + + if (outcome.Exception is OperationCanceledException oce + && WasCancelledByTimeout(linkedCts, previousToken)) + { + var elapsed = _timeProvider.GetElapsedTime(startTimestamp); + return await HandleTimeout(context, timeout, elapsed, oce).ConfigureAwait(false); + } + + return outcome; + } + finally + { + context.CancellationToken = previousToken; + + if (timer is not null) + { + await timer.DisposeAsync().ConfigureAwait(false); + } + + linkedCts.Dispose(); + } + } + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + var timeout = ResolveTimeout(context); + + if (timeout == System.Threading.Timeout.InfiniteTimeSpan) + { + return callback(context); + } + + var previousToken = context.CancellationToken; + var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(previousToken); + var startTimestamp = _timeProvider.GetTimestamp(); + ITimer? timer = null; + + try + { + timer = _timeProvider.CreateTimer( + static state => ((CancellationTokenSource)state!).Cancel(), + linkedCts, + timeout, + System.Threading.Timeout.InfiniteTimeSpan); + + context.CancellationToken = linkedCts.Token; + var outcome = callback(context); + + if (outcome.Exception is OperationCanceledException oce + && WasCancelledByTimeout(linkedCts, previousToken)) + { + var elapsed = _timeProvider.GetElapsedTime(startTimestamp); + HandleTimeoutSync(context, timeout, elapsed); + return Outcome.FromException( + new TimeoutRejectedException(timeout, elapsed, oce)); + } + + return outcome; + } + catch (OperationCanceledException oce) when (WasCancelledByTimeout(linkedCts, previousToken)) + { + var elapsed = _timeProvider.GetElapsedTime(startTimestamp); + HandleTimeoutSync(context, timeout, elapsed); + return Outcome.FromException( + new TimeoutRejectedException(timeout, elapsed, oce)); + } + finally + { + context.CancellationToken = previousToken; + timer?.Dispose(); + linkedCts.Dispose(); + } + } + + private TimeSpan ResolveTimeout(ResilienceContext context) + { + if (_options.TimeoutGenerator is not null) + { + return _options.TimeoutGenerator(new TimeoutGeneratorArgs(context)); + } + + return _options.Timeout; + } + + /// + /// Determines whether the cancellation was caused by our timeout rather than the user's token. + /// In rare cases where user cancellation races with timeout, this may misclassify. + /// + private static bool WasCancelledByTimeout( + CancellationTokenSource linkedCts, + CancellationToken userToken) + { + // Check both atomically as possible: if linked CTS fired AND user token didn't. + return linkedCts.IsCancellationRequested && !userToken.IsCancellationRequested; + } + + /// + /// Handles timeout on the async path. Preserves the original OCE as inner exception. + /// + private async ValueTask> HandleTimeout( + ResilienceContext context, + TimeSpan timeout, + TimeSpan elapsed, + Exception originalException) + { + ResilionTelemetry.TimeoutExpirations.Add(1); + + if (_options.OnTimeout is { } handler && handler.HasHandler) + { + await handler.InvokeAsync(new OnTimeoutArgs(context, timeout, elapsed)).ConfigureAwait(false); + } + + return Outcome.FromException( + new TimeoutRejectedException(timeout, elapsed, originalException)); + } + + private void HandleTimeoutSync( + ResilienceContext context, + TimeSpan timeout, + TimeSpan elapsed) + { + ResilionTelemetry.TimeoutExpirations.Add(1); + + if (_options.OnTimeout is { } handler && handler.HasHandler) + { + handler.Invoke(new OnTimeoutArgs(context, timeout, elapsed)); + } + } +} diff --git a/src/Resilion/Timeout/TimeoutStrategyOptions.cs b/src/Resilion/Timeout/TimeoutStrategyOptions.cs new file mode 100644 index 0000000..d76eda9 --- /dev/null +++ b/src/Resilion/Timeout/TimeoutStrategyOptions.cs @@ -0,0 +1,67 @@ +namespace Resilion; + +/// +/// Options for the Timeout resilience strategy. +/// +/// +/// +/// Timeout relies on cooperative cancellation. The operation must observe the +/// passed through the execution context. If the operation +/// ignores the token, the timeout has no effect — the strategy cannot forcibly abort it. +/// +/// +/// To apply a per-attempt timeout inside retry, place the Timeout strategy after +/// the Retry strategy in the pipeline. To apply a total timeout across all retries, +/// place it before the Retry strategy. +/// +/// +public sealed record TimeoutStrategyOptions +{ + /// + /// Gets the timeout duration. Defaults to 30 seconds. + /// + /// + /// Set to to disable the timeout (passthrough). + /// Set to to immediately timeout (useful for testing). + /// + public TimeSpan Timeout { get; init; } = TimeSpan.FromSeconds(30); + + /// + /// Gets an optional delegate that computes the timeout duration dynamically per execution. + /// When set, is ignored. + /// + public Func? TimeoutGenerator { get; init; } + + /// + /// Gets an optional event handler that fires when a timeout occurs. + /// + public ResilienceEventHandler? OnTimeout { get; init; } + + internal void Validate() + { + if (TimeoutGenerator is null && Timeout < TimeSpan.Zero && Timeout != System.Threading.Timeout.InfiniteTimeSpan) + { + throw new ArgumentOutOfRangeException( + nameof(Timeout), + Timeout, + "Timeout must be a non-negative TimeSpan, TimeSpan.Zero, or Timeout.InfiniteTimeSpan."); + } + } +} + +/// +/// Arguments passed to the delegate. +/// +/// The execution context for the current operation. +public readonly record struct TimeoutGeneratorArgs(ResilienceContext Context); + +/// +/// Arguments passed to the event handler. +/// +/// The execution context for the timed-out operation. +/// The timeout duration that was applied. +/// The actual elapsed time before timeout was triggered. +public readonly record struct OnTimeoutArgs( + ResilienceContext Context, + TimeSpan Timeout, + TimeSpan ElapsedTime); diff --git a/tests/Directory.Build.props b/tests/Directory.Build.props new file mode 100644 index 0000000..69043c9 --- /dev/null +++ b/tests/Directory.Build.props @@ -0,0 +1,30 @@ + + + + net9.0 + Exe + latest + enable + enable + false + true + true + + $(NoWarn);xUnit1051 + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + diff --git a/tests/Resilion.Extensions.Tests/ExtensionsTests.cs b/tests/Resilion.Extensions.Tests/ExtensionsTests.cs new file mode 100644 index 0000000..2debf9d --- /dev/null +++ b/tests/Resilion.Extensions.Tests/ExtensionsTests.cs @@ -0,0 +1,197 @@ +using Microsoft.Extensions.DependencyInjection; +using Resilion.Extensions; +using Xunit; + +namespace Resilion.Extensions.Tests; + +public class ResiliencePipelineRegistryTests +{ + [Fact] + public void RegisterAndGet_ReturnsSamePipeline() + { + using var registry = new ResiliencePipelineRegistry(); + registry.RegisterPipeline("test", b => b.AddRetry()); + + var p1 = registry.GetPipeline("test"); + var p2 = registry.GetPipeline("test"); + + Assert.NotNull(p1); + Assert.Same(p1, p2); + } + + [Fact] + public void GetPipeline_UnregisteredKey_Throws() + { + using var registry = new ResiliencePipelineRegistry(); + + Assert.Throws(() => registry.GetPipeline("missing")); + } + + [Fact] + public void RegisterDuplicateKey_Throws() + { + using var registry = new ResiliencePipelineRegistry(); + registry.RegisterPipeline("dup", b => b.AddTimeout(TimeSpan.FromSeconds(5))); + + Assert.Throws(() => + registry.RegisterPipeline("dup", b => b.AddRetry())); + } + + [Fact] + public void TryGetPipeline_Registered_ReturnsTrue() + { + using var registry = new ResiliencePipelineRegistry(); + registry.RegisterPipeline("exists", b => b.AddRetry()); + + Assert.True(registry.TryGetPipeline("exists", out var pipeline)); + Assert.NotNull(pipeline); + } + + [Fact] + public void TryGetPipeline_NotRegistered_ReturnsFalse() + { + using var registry = new ResiliencePipelineRegistry(); + + Assert.False(registry.TryGetPipeline("missing", out var pipeline)); + Assert.Null(pipeline); + } + + [Fact] + public async Task RegisteredPipeline_ExecutesCorrectly() + { + using var registry = new ResiliencePipelineRegistry(); + registry.RegisterPipeline("retry-3", b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 2, + Delay = RetryDelay.None, + })); + + var pipeline = registry.GetPipeline("retry-3"); + var callCount = 0; + + var result = await pipeline.ExecuteAsync(ct => + { + callCount++; + if (callCount < 3) + { + throw new InvalidOperationException("transient"); + } + + return new ValueTask("recovered"); + }); + + Assert.Equal("recovered", result); + Assert.Equal(3, callCount); + } + + [Fact] + public async Task TypedPipeline_RegisterAndResolve() + { + using var registry = new ResiliencePipelineRegistry(); + registry.RegisterPipeline("typed", b => b.AddFallback( + new FallbackStrategyOptions { FallbackAction = -1 })); + + var pipeline = registry.GetPipeline("typed"); + var result = await pipeline.ExecuteAsync(ct => + { + throw new Exception("fail"); + return new ValueTask(0); + }); + + Assert.Equal(-1, result); + } + + [Fact] + public void Dispose_DisposesCreatedPipelines() + { + var registry = new ResiliencePipelineRegistry(); + registry.RegisterPipeline("x", b => b.AddTimeout(TimeSpan.FromSeconds(1))); + _ = registry.GetPipeline("x"); // Force creation + + // Dispose should not throw. + registry.Dispose(); + } +} + +public class ServiceCollectionExtensionsTests +{ + [Fact] + public void AddResilion_RegistersRegistry() + { + var services = new ServiceCollection(); + services.AddResilion(); + + var sp = services.BuildServiceProvider(); + var registry = sp.GetService>(); + + Assert.NotNull(registry); + } + + [Fact] + public void AddResilion_RegistersContextPool() + { + var services = new ServiceCollection(); + services.AddResilion(); + + var sp = services.BuildServiceProvider(); + var pool = sp.GetService(); + + Assert.NotNull(pool); + Assert.Same(ResilienceContextPool.Shared, pool); + } + + [Fact] + public async Task AddResiliencePipeline_ResolvesViaRegistry() + { + var services = new ServiceCollection(); + services.AddResiliencePipeline("http-retry", b => b + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 1, + Delay = RetryDelay.None, + }) + .AddTimeout(TimeSpan.FromSeconds(30))); + + var sp = services.BuildServiceProvider(); + + // Apply configurators to the registry (simulating what a hosted service would do). + var registry = ResilionServiceCollectionExtensions.BuildRegistry(sp); + var pipeline = registry.GetPipeline("http-retry"); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask("ok")); + Assert.Equal("ok", result); + } + + [Fact] + public async Task AddResiliencePipeline_Typed_ResolvesViaRegistry() + { + var services = new ServiceCollection(); + services.AddResiliencePipeline("fallback-pipeline", b => b + .AddFallback(new FallbackStrategyOptions { FallbackAction = 42 })); + + var sp = services.BuildServiceProvider(); + var registry = ResilionServiceCollectionExtensions.BuildRegistry(sp); + var pipeline = registry.GetPipeline("fallback-pipeline"); + + var result = await pipeline.ExecuteAsync(ct => + { + throw new Exception("fail"); + return new ValueTask(0); + }); + Assert.Equal(42, result); + } + + [Fact] + public void AddResilion_Idempotent() + { + var services = new ServiceCollection(); + services.AddResilion(); + services.AddResilion(); + services.AddResilion(); + + var sp = services.BuildServiceProvider(); + var registries = sp.GetServices>().ToList(); + + Assert.Single(registries); + } +} diff --git a/tests/Resilion.Extensions.Tests/Resilion.Extensions.Tests.csproj b/tests/Resilion.Extensions.Tests/Resilion.Extensions.Tests.csproj new file mode 100644 index 0000000..049ef1c --- /dev/null +++ b/tests/Resilion.Extensions.Tests/Resilion.Extensions.Tests.csproj @@ -0,0 +1,18 @@ + + + + Resilion.Extensions.Tests + Resilion.Extensions.Tests + + + + + + + + + + + + + diff --git a/tests/Resilion.Tests/CircuitBreaker/CircuitBreakerStrategyTests.cs b/tests/Resilion.Tests/CircuitBreaker/CircuitBreakerStrategyTests.cs new file mode 100644 index 0000000..c44c341 --- /dev/null +++ b/tests/Resilion.Tests/CircuitBreaker/CircuitBreakerStrategyTests.cs @@ -0,0 +1,431 @@ +using Microsoft.Extensions.Time.Testing; +using Xunit; + +namespace Resilion.Tests; + +public class CircuitBreakerStrategyTests +{ + private static CircuitBreakerStrategyOptions LowThresholdOptions( + FakeTimeProvider? fakeTime = null) => + new() + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 4, + SamplingDuration = TimeSpan.FromSeconds(30), + BreakDuration = TimeSpan.FromSeconds(5), + }; + + // ────────────────────────────────────────────────────────────────── + // Closed state — happy path + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Closed_SuccessfulCalls_StayClosed() + { + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(LowThresholdOptions())); + + for (var i = 0; i < 20; i++) + { + var result = await pipeline.ExecuteAsync(ct => new ValueTask(42)); + Assert.Equal(42, result); + } + } + + [Fact] + public void Sync_Closed_SuccessfulCalls_StayClosed() + { + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(LowThresholdOptions())); + + for (var i = 0; i < 20; i++) + { + var result = pipeline.Execute(ct => 42); + Assert.Equal(42, result); + } + } + + // ────────────────────────────────────────────────────────────────── + // Closed → Open transition + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Closed_ExceedsFailureRatio_TripsToOpen() + { + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(LowThresholdOptions())); + + // Generate enough failures to trip: 4 failures out of 4 calls = 100% > 50% + for (var i = 0; i < 4; i++) + { + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + throw new InvalidOperationException("fail")).AsTask()); + } + + // Next call should be rejected + var ex = await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask(42)).AsTask()); + + Assert.Equal(CircuitState.Open, ex.CircuitState); + Assert.True(ex.RetryAfter > TimeSpan.Zero); + } + + [Fact] + public async Task Closed_BelowMinimumThroughput_DoesNotTrip() + { + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(LowThresholdOptions())); + + // 3 failures — below MinimumThroughput of 4 + for (var i = 0; i < 3; i++) + { + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + throw new InvalidOperationException("fail")).AsTask()); + } + + // Should still be closed — not enough throughput to evaluate ratio + var result = await pipeline.ExecuteAsync(ct => new ValueTask(42)); + Assert.Equal(42, result); + } + + [Fact] + public async Task Closed_BelowFailureRatio_DoesNotTrip() + { + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(LowThresholdOptions())); + + // 1 failure + 3 successes = 25% < 50% threshold + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => throw new InvalidOperationException("fail")).AsTask()); + + for (var i = 0; i < 3; i++) + { + await pipeline.ExecuteAsync(ct => new ValueTask(42)); + } + + // Should still be closed + var result = await pipeline.ExecuteAsync(ct => new ValueTask(99)); + Assert.Equal(99, result); + } + + // ────────────────────────────────────────────────────────────────── + // Open → HalfOpen → Closed recovery + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Open_AfterBreakDuration_TransitionsToHalfOpen_ThenClosed() + { + var fakeTime = new FakeTimeProvider(); + var stateChanges = new List<(CircuitState From, CircuitState To)>(); + Action onState = e => + stateChanges.Add((e.PreviousState, e.CurrentState)); + + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 2, + SamplingDuration = TimeSpan.FromSeconds(30), + BreakDuration = TimeSpan.FromSeconds(5), + OnOpened = onState, + OnHalfOpened = onState, + OnClosed = onState, + }); + }); + + // Trip the circuit: 2 failures + for (var i = 0; i < 2; i++) + { + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + throw new InvalidOperationException("fail")).AsTask()); + } + + // Should be open + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask(1)).AsTask()); + + // Advance past break duration + fakeTime.Advance(TimeSpan.FromSeconds(6)); + + // Next call should succeed (probe in half-open) + var result = await pipeline.ExecuteAsync(ct => new ValueTask(42)); + Assert.Equal(42, result); + + // State transitions should include: Closed→Open, Open→HalfOpen, HalfOpen→Closed + Assert.Contains(stateChanges, s => s.From == CircuitState.Closed && s.To == CircuitState.Open); + Assert.Contains(stateChanges, s => s.From == CircuitState.Open && s.To == CircuitState.HalfOpen); + Assert.Contains(stateChanges, s => s.From == CircuitState.HalfOpen && s.To == CircuitState.Closed); + } + + // ────────────────────────────────────────────────────────────────── + // HalfOpen — probe fails → back to Open + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task HalfOpen_ProbeFails_TransitionsBackToOpen() + { + var fakeTime = new FakeTimeProvider(); + + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 2, + BreakDuration = TimeSpan.FromSeconds(5), + }); + }); + + // Trip the circuit + for (var i = 0; i < 2; i++) + { + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + throw new InvalidOperationException("fail")).AsTask()); + } + + // Advance past break duration + fakeTime.Advance(TimeSpan.FromSeconds(6)); + + // Probe fails + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + throw new InvalidOperationException("still failing")).AsTask()); + + // Should be Open again — next call is rejected + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask(1)).AsTask()); + } + + // ────────────────────────────────────────────────────────────────── + // OperationCanceledException — not counted as failure + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task OCE_NotCountedAsFailure() + { + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 2, + })); + + // 2 cancellations should NOT trip the circuit + for (var i = 0; i < 2; i++) + { + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + throw new OperationCanceledException()).AsTask()); + } + + // Circuit should still be closed + var result = await pipeline.ExecuteAsync(ct => new ValueTask(42)); + Assert.Equal(42, result); + } + + // ────────────────────────────────────────────────────────────────── + // Manual control + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task ManualControl_Isolate_RejectsAllCalls() + { + var control = new CircuitBreakerManualControl(); + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + ManualControl = control, + })); + + // Should work before isolation + var result = await pipeline.ExecuteAsync(ct => new ValueTask(1)); + Assert.Equal(1, result); + + // Isolate + await control.IsolateAsync(); + + // Should be rejected + var ex = await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask(1)).AsTask()); + Assert.Equal(CircuitState.Isolated, ex.CircuitState); + } + + [Fact] + public async Task ManualControl_Reset_AllowsCalls() + { + var control = new CircuitBreakerManualControl(); + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + ManualControl = control, + })); + + await control.IsolateAsync(); + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask(1)).AsTask()); + + await control.ResetAsync(); + + // Should work again + var result = await pipeline.ExecuteAsync(ct => new ValueTask(42)); + Assert.Equal(42, result); + } + + [Fact] + public async Task ManualControl_WithoutStrategy_ThrowsInvalidOperation() + { + var control = new CircuitBreakerManualControl(); + + await Assert.ThrowsAsync(() => control.IsolateAsync()); + await Assert.ThrowsAsync(() => control.ResetAsync()); + } + + // ────────────────────────────────────────────────────────────────── + // Custom ShouldHandle predicate + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task ShouldHandle_OnlyCountsMatchingExceptions() + { + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 2, + ShouldHandle = ex => ex is TimeoutException, // Only count TimeoutException + })); + + // InvalidOperationException should NOT count as failure + for (var i = 0; i < 4; i++) + { + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + throw new InvalidOperationException("not counted")).AsTask()); + } + + // Circuit should still be closed + var result = await pipeline.ExecuteAsync(ct => new ValueTask(42)); + Assert.Equal(42, result); + } + + // ────────────────────────────────────────────────────────────────── + // Options validation + // ────────────────────────────────────────────────────────────────── + + [Theory] + [InlineData(-0.1)] + [InlineData(1.1)] + public void InvalidFailureRatio_ThrowsAtBuildTime(double ratio) + { + Assert.Throws(() => + Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = ratio, + }))); + } + + [Fact] + public void ZeroMinimumThroughput_ThrowsAtBuildTime() + { + Assert.Throws(() => + Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + MinimumThroughput = 0, + }))); + } + + // ────────────────────────────────────────────────────────────────── + // Concurrent access (basic thread safety) + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task ConcurrentAccess_NoExceptionsOrCorruption() + { + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.8, + MinimumThroughput = 100, + SamplingDuration = TimeSpan.FromSeconds(60), + BreakDuration = TimeSpan.FromSeconds(1), + })); + + var successCount = 0; + var failureCount = 0; + var rejectionCount = 0; + + var tasks = Enumerable.Range(0, 500).Select(async i => + { + try + { + await pipeline.ExecuteAsync(ct => + { + if (i % 5 == 0) // 20% failure rate — below 80% threshold + { + throw new InvalidOperationException("fail"); + } + + return new ValueTask(i); + }); + + Interlocked.Increment(ref successCount); + } + catch (InvalidOperationException) + { + Interlocked.Increment(ref failureCount); + } + catch (CircuitBrokenException) + { + Interlocked.Increment(ref rejectionCount); + } + }); + + await Task.WhenAll(tasks); + + // With 20% failure rate and 80% threshold, the circuit should NOT trip. + Assert.Equal(0, rejectionCount); + Assert.True(successCount > 0); + Assert.True(failureCount > 0); + Assert.Equal(500, successCount + failureCount); + } + + // ────────────────────────────────────────────────────────────────── + // Typed pipeline — result-based circuit breaker + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task TypedPipeline_TripsOnBadResults() + { + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker( + new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.5, + MinimumThroughput = 2, + BreakDuration = TimeSpan.FromSeconds(5), + ShouldHandle = outcome => + outcome.TryGetResult(out var val) && val == -1, // -1 is a "failure" + })); + + // 2 "bad" results should trip + await pipeline.ExecuteAsync(ct => new ValueTask(-1)); + await pipeline.ExecuteAsync(ct => new ValueTask(-1)); + + // Should be tripped + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask(42)).AsTask()); + } + + // ────────────────────────────────────────────────────────────────── + // Exception propagation — exceptions still propagate even when counted + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Exception_StillPropagates_WhenCountedAsFailure() + { + var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(LowThresholdOptions())); + + // The exception should propagate, AND be counted as a failure + var ex = await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + throw new InvalidOperationException("should propagate")).AsTask()); + + Assert.Equal("should propagate", ex.Message); + } +} diff --git a/tests/Resilion.Tests/Fallback/FallbackStrategyTests.cs b/tests/Resilion.Tests/Fallback/FallbackStrategyTests.cs new file mode 100644 index 0000000..50ff14c --- /dev/null +++ b/tests/Resilion.Tests/Fallback/FallbackStrategyTests.cs @@ -0,0 +1,269 @@ +using Xunit; + +namespace Resilion.Tests; + +public class FallbackStrategyTests +{ + // ────────────────────────────────────────────────────────────────── + // Happy path — no fallback triggered + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_Success_NoFallback() + { + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = "default", + })); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask("ok")); + Assert.Equal("ok", result); + } + + [Fact] + public void Sync_Success_NoFallback() + { + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = "default", + })); + + var result = pipeline.Execute(ct => "ok"); + Assert.Equal("ok", result); + } + + // ────────────────────────────────────────────────────────────────── + // Constant value fallback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_ConstantFallback_ReturnedOnException() + { + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = "fallback-value", + })); + + var result = await pipeline.ExecuteAsync(ct => + { + throw new InvalidOperationException("fail"); + return new ValueTask("unreachable"); + }); + + Assert.Equal("fallback-value", result); + } + + [Fact] + public void Sync_ConstantFallback_ReturnedOnException() + { + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = "fallback-value", + })); + + var result = pipeline.Execute(ct => + { + throw new InvalidOperationException("fail"); + return "unreachable"; + }); + + Assert.Equal("fallback-value", result); + } + + // ────────────────────────────────────────────────────────────────── + // Sync factory fallback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_SyncFactory_ComputesFallback() + { + Func, string> factory = + ctx => $"fallback-for-{ctx.Exception?.GetType().Name}"; + + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = factory, + })); + + var result = await pipeline.ExecuteAsync(ct => + { + throw new TimeoutException("timed out"); + return new ValueTask("unreachable"); + }); + + Assert.Equal("fallback-for-TimeoutException", result); + } + + // ────────────────────────────────────────────────────────────────── + // Async factory fallback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_AsyncFactory_ComputesFallback() + { + Func, ValueTask> factory = + async ctx => + { + await Task.Yield(); + return "async-fallback"; + }; + + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = factory, + })); + + var result = await pipeline.ExecuteAsync(ct => + { + throw new InvalidOperationException("fail"); + return new ValueTask("unreachable"); + }); + + Assert.Equal("async-fallback", result); + } + + // ────────────────────────────────────────────────────────────────── + // Result-based fallback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_FallbackOnBadResult() + { + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = 0, + ShouldHandle = outcome => + outcome.TryGetResult(out var val) && val < 0, + })); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask(-1)); + Assert.Equal(0, result); + + result = await pipeline.ExecuteAsync(ct => new ValueTask(42)); + Assert.Equal(42, result); + } + + // ────────────────────────────────────────────────────────────────── + // OperationCanceledException — not handled by default + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_OCE_NotHandledByDefault() + { + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = "fallback", + })); + + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + { + throw new OperationCanceledException(); + return new ValueTask("unreachable"); + }).AsTask()); + } + + // ────────────────────────────────────────────────────────────────── + // OnFallback callback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_OnFallback_IsFired() + { + OnFallbackEvent? capturedEvent = null; + Action> onFallback = e => capturedEvent = e; + + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = "replacement", + OnFallback = onFallback, + })); + + var result = await pipeline.ExecuteAsync(ct => + { + throw new InvalidOperationException("fail"); + return new ValueTask("unreachable"); + }); + + Assert.Equal("replacement", result); + Assert.NotNull(capturedEvent); + Assert.Equal("replacement", capturedEvent.Value.FallbackResult); + Assert.IsType(capturedEvent.Value.Outcome.Exception); + } + + // ────────────────────────────────────────────────────────────────── + // Composition — Fallback wrapping Retry + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task FallbackWrappingRetry_FallbackCatchesExhaustedRetries() + { + var callCount = 0; + + var pipeline = Pipeline.Create(b => b + .AddFallback(new FallbackStrategyOptions + { + FallbackAction = "exhausted-fallback", + }) + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 2, + Delay = RetryDelay.None, + })); + + var result = await pipeline.ExecuteAsync(ct => + { + callCount++; + throw new InvalidOperationException("always fail"); + return new ValueTask("unreachable"); + }); + + Assert.Equal("exhausted-fallback", result); + Assert.Equal(3, callCount); + } + + // ────────────────────────────────────────────────────────────────── + // Options validation + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void MissingFallbackAction_ThrowsAtBuildTime() + { + Assert.Throws(() => + Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions()))); + } + + // ────────────────────────────────────────────────────────────────── + // Fallback factory that throws — exception propagates + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_FallbackFactoryThrows_ExceptionPropagates() + { + Func, string> factory = + _ => throw new NotImplementedException("factory broke"); + + var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = factory, + })); + + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + { + throw new InvalidOperationException("trigger"); + return new ValueTask("unreachable"); + }).AsTask()); + } +} diff --git a/tests/Resilion.Tests/Hedging/HedgingStrategyTests.cs b/tests/Resilion.Tests/Hedging/HedgingStrategyTests.cs new file mode 100644 index 0000000..6317713 --- /dev/null +++ b/tests/Resilion.Tests/Hedging/HedgingStrategyTests.cs @@ -0,0 +1,352 @@ +using Microsoft.Extensions.Time.Testing; +using Xunit; + +namespace Resilion.Tests; + +public class HedgingStrategyTests +{ + // ────────────────────────────────────────────────────────────────── + // Single attempt — no hedging + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task MaxHedgedAttempts1_NoHedging() + { + var callCount = 0; + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions { MaxHedgedAttempts = 1 })); + + var result = await pipeline.ExecuteAsync(ct => + { + Interlocked.Increment(ref callCount); + return new ValueTask("ok"); + }); + + Assert.Equal("ok", result); + Assert.Equal(1, callCount); + } + + // ────────────────────────────────────────────────────────────────── + // Primary succeeds — no hedging needed + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_PrimarySucceeds_ReturnsImmediately() + { + var callCount = 0; + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = TimeSpan.FromSeconds(2), + })); + + var result = await pipeline.ExecuteAsync(ct => + { + Interlocked.Increment(ref callCount); + return new ValueTask("fast"); + }); + + Assert.Equal("fast", result); + // Primary succeeds immediately, hedged attempts may or may not launch + // depending on timing, but the result should always be "fast". + } + + // ────────────────────────────────────────────────────────────────── + // Parallel mode (delay = 0) — all attempts launch simultaneously + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task ParallelMode_AllAttemptsLaunch() + { + var callCount = 0; + var barrier = new TaskCompletionSource(); + + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = TimeSpan.Zero, // Parallel mode + ShouldHandle = outcome => outcome.Exception is not null, + })); + + var result = await pipeline.ExecuteAsync(ct => + { + var attempt = Interlocked.Increment(ref callCount); + // All attempts return the same result immediately. + return new ValueTask($"attempt-{attempt}"); + }); + + // At least one attempt should have completed. + Assert.StartsWith("attempt-", result); + } + + // ────────────────────────────────────────────────────────────────── + // Sequential mode (InfiniteTimeSpan) — waits for failure before next + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task SequentialMode_TriesOneAtATime() + { + var callCount = 0; + + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = System.Threading.Timeout.InfiniteTimeSpan, + })); + + var result = await pipeline.ExecuteAsync(ct => + { + var attempt = Interlocked.Increment(ref callCount); + if (attempt < 3) + { + throw new InvalidOperationException($"fail-{attempt}"); + } + + return new ValueTask("success"); + }); + + Assert.Equal("success", result); + Assert.Equal(3, callCount); + } + + // ────────────────────────────────────────────────────────────────── + // All attempts fail + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task AllAttemptsFail_ThrowsLastException() + { + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = TimeSpan.Zero, + })); + + var ex = await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + { + throw new InvalidOperationException("always fail"); + return new ValueTask("unreachable"); + }).AsTask()); + + Assert.Equal("always fail", ex.Message); + } + + // ────────────────────────────────────────────────────────────────── + // Custom ActionGenerator + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task ActionGenerator_CustomActionsPerAttempt() + { + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = System.Threading.Timeout.InfiniteTimeSpan, + ActionGenerator = ctx => ctx.AttemptNumber switch + { + 0 => ct => throw new InvalidOperationException("primary fails"), + 1 => ct => throw new InvalidOperationException("secondary fails"), + 2 => ct => new ValueTask("tertiary wins"), + _ => null, + }, + })); + + var result = await pipeline.ExecuteAsync(ct => + { + // This shouldn't be called because ActionGenerator provides all actions. + throw new InvalidOperationException("should not reach"); + return new ValueTask("unreachable"); + }); + + Assert.Equal("tertiary wins", result); + } + + // ────────────────────────────────────────────────────────────────── + // OnHedging callback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task OnHedging_FiredForEachHedgedAttempt() + { + var hedgingEvents = new List(); + Action> onHedging = e => + hedgingEvents.Add(e.AttemptNumber); + + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = TimeSpan.Zero, + OnHedging = onHedging, + })); + + await pipeline.ExecuteAsync(ct => new ValueTask("ok")); + + // OnHedging should have been called for attempts 1 and 2 (not 0, the primary). + Assert.Contains(1, hedgingEvents); + Assert.Contains(2, hedgingEvents); + } + + // ────────────────────────────────────────────────────────────────── + // Sync execution — sequential fallback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void Sync_ExecutesSequentially() + { + var callCount = 0; + + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = TimeSpan.FromSeconds(1), // Ignored in sync — always sequential + })); + + var result = pipeline.Execute(ct => + { + callCount++; + if (callCount < 3) + { + throw new InvalidOperationException("fail"); + } + + return "success"; + }); + + Assert.Equal("success", result); + Assert.Equal(3, callCount); + } + + // ────────────────────────────────────────────────────────────────── + // User cancellation + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task UserCancellation_PropagatesOCE() + { + using var cts = new CancellationTokenSource(); + cts.Cancel(); + + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = TimeSpan.Zero, + })); + + await Assert.ThrowsAnyAsync(() => + pipeline.ExecuteAsync(ct => + { + ct.ThrowIfCancellationRequested(); + return new ValueTask("unreachable"); + }, cts.Token).AsTask()); + } + + // ────────────────────────────────────────────────────────────────── + // Result-based hedging + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task ResultBasedHedging_RetriesOnBadResult() + { + var callCount = 0; + + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 3, + HedgingDelay = System.Threading.Timeout.InfiniteTimeSpan, + ShouldHandle = outcome => + outcome.TryGetResult(out var val) && val < 0, + })); + + var result = await pipeline.ExecuteAsync(ct => + { + var attempt = Interlocked.Increment(ref callCount); + return new ValueTask(attempt < 3 ? -1 : 42); + }); + + Assert.Equal(42, result); + } + + // ────────────────────────────────────────────────────────────────── + // Options validation + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void ZeroMaxAttempts_ThrowsAtBuildTime() + { + Assert.Throws(() => + Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions { MaxHedgedAttempts = 0 }))); + } + + [Fact] + public void NegativeDelay_ThrowsAtBuildTime() + { + Assert.Throws(() => + Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions { HedgingDelay = TimeSpan.FromSeconds(-1) }))); + } + + // ────────────────────────────────────────────────────────────────── + // Properties propagation to hedged attempts + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Properties_PropagatedToHedgedAttempts() + { + var propertyKey = new ResiliencePropertyKey("test-key"); + string? capturedValue = null; + + var pipeline = Pipeline.Create(b => b.AddHedging( + new HedgingStrategyOptions + { + MaxHedgedAttempts = 2, + HedgingDelay = System.Threading.Timeout.InfiniteTimeSpan, + })); + + // Use ExecuteOutcomeAsync so we can set properties on the context. + var context = ResilienceContextPool.Shared.Rent(); + context.Properties.Set(propertyKey, "propagated-value"); + + try + { + var callCount = 0; + var outcome = await pipeline.ExecuteOutcomeAsync( + static (state, ctx) => + { + var attempt = Interlocked.Increment(ref state.callCount); + if (attempt == 1) + { + return new ValueTask>( + Outcome.FromException(new InvalidOperationException("fail"))); + } + + // Second attempt — check if properties were propagated. + state.ctx.Properties.TryGetValue(state.key, out var val); + state.captured = val; + return new ValueTask>(Outcome.FromResult("ok")); + }, + (callCount: 0, ctx: context, key: propertyKey, captured: (string?)null), + context); + + // The captured value should reflect what was set on the original context. + // Note: the hedging strategy creates a new context per attempt and copies properties. + // With ExecuteOutcomeAsync the user-provided context IS the original context, + // so the first attempt sees it directly. For the second (hedged) attempt, + // properties are copied. + } + finally + { + ResilienceContextPool.Shared.Return(context); + } + } +} diff --git a/tests/Resilion.Tests/OrderingValidatorTests.cs b/tests/Resilion.Tests/OrderingValidatorTests.cs new file mode 100644 index 0000000..226b404 --- /dev/null +++ b/tests/Resilion.Tests/OrderingValidatorTests.cs @@ -0,0 +1,234 @@ +using Resilion.Internal; +using Xunit; + +namespace Resilion.Tests; + +public class OrderingValidatorTests +{ + // ────────────────────────────────────────────────────────────────── + // No warnings for correct ordering + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void CanonicalOrder_NoWarnings() + { + var strategies = new List + { + StrategyType.RateLimiter, + StrategyType.Timeout, // total + StrategyType.Retry, + StrategyType.CircuitBreaker, + StrategyType.Timeout, // per-attempt + }; + + var warnings = OrderingValidator.Validate(strategies); + Assert.Empty(warnings); + } + + [Fact] + public void SingleStrategy_NoWarnings() + { + var warnings = OrderingValidator.Validate([StrategyType.Retry]); + Assert.Empty(warnings); + } + + // ────────────────────────────────────────────────────────────────── + // CircuitBreaker outside Retry + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void CircuitBreakerBeforeRetry_Warns() + { + var strategies = new List + { + StrategyType.CircuitBreaker, // pos 0 + StrategyType.Retry, // pos 1 + }; + + var warnings = OrderingValidator.Validate(strategies); + Assert.Single(warnings); + Assert.Contains("CircuitBreaker is outside Retry", warnings[0]); + } + + [Fact] + public void CircuitBreakerAfterRetry_NoWarning() + { + var strategies = new List + { + StrategyType.Retry, + StrategyType.CircuitBreaker, + }; + + var warnings = OrderingValidator.Validate(strategies); + Assert.DoesNotContain(warnings, w => w.Contains("CircuitBreaker is outside Retry")); + } + + // ────────────────────────────────────────────────────────────────── + // Fallback not outermost + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void FallbackNotFirst_Warns() + { + var strategies = new List + { + StrategyType.Retry, + StrategyType.Fallback, // pos 1, not 0 + }; + + var warnings = OrderingValidator.Validate(strategies); + Assert.Contains(warnings, w => w.Contains("Fallback is at position")); + } + + [Fact] + public void FallbackFirst_NoWarning() + { + var strategies = new List + { + StrategyType.Fallback, + StrategyType.Retry, + }; + + var warnings = OrderingValidator.Validate(strategies); + Assert.DoesNotContain(warnings, w => w.Contains("Fallback is at position")); + } + + // ────────────────────────────────────────────────────────────────── + // Hedging + Retry together + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void HedgingAndRetry_Warns() + { + var strategies = new List + { + StrategyType.Hedging, + StrategyType.Retry, + }; + + var warnings = OrderingValidator.Validate(strategies); + Assert.Contains(warnings, w => w.Contains("Both Hedging and Retry")); + } + + // ────────────────────────────────────────────────────────────────── + // Too many timeouts + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void ThreeTimeouts_Warns() + { + var strategies = new List + { + StrategyType.Timeout, + StrategyType.Timeout, + StrategyType.Timeout, + }; + + var warnings = OrderingValidator.Validate(strategies); + Assert.Contains(warnings, w => w.Contains("More than 2 Timeout")); + } + + [Fact] + public void TwoTimeouts_NoWarning() + { + var strategies = new List + { + StrategyType.Timeout, + StrategyType.Retry, + StrategyType.Timeout, + }; + + var warnings = OrderingValidator.Validate(strategies); + Assert.DoesNotContain(warnings, w => w.Contains("More than 2 Timeout")); + } + + // ────────────────────────────────────────────────────────────────── + // Retry outermost with no timeout + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void RetryOutermostNoTimeout_Warns() + { + var strategies = new List + { + StrategyType.Retry, + StrategyType.CircuitBreaker, + }; + + var warnings = OrderingValidator.Validate(strategies); + Assert.Contains(warnings, w => w.Contains("Retry is the outermost strategy with no Timeout")); + } + + [Fact] + public void RetryWithTimeoutPresent_NoWarning() + { + var strategies = new List + { + StrategyType.Timeout, + StrategyType.Retry, + }; + + var warnings = OrderingValidator.Validate(strategies); + Assert.DoesNotContain(warnings, w => w.Contains("Retry is the outermost")); + } + + // ────────────────────────────────────────────────────────────────── + // SuppressOrderingWarnings on builder + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void SuppressWarnings_NoWarningsEmitted() + { + var captured = new List(); + + var pipeline = Pipeline.Create(b => + { + b.SuppressOrderingWarnings = true; + b.OnValidationWarning = w => captured.Add(w); + b.AddCircuitBreaker(); + b.AddRetry(); + }); + + Assert.Empty(captured); + } + + // ────────────────────────────────────────────────────────────────── + // OnValidationWarning callback receives warnings + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void OnValidationWarning_ReceivesWarnings() + { + var captured = new List(); + + var pipeline = Pipeline.Create(b => + { + b.OnValidationWarning = w => captured.Add(w); + b.AddCircuitBreaker(); + b.AddRetry(); + }); + + Assert.NotEmpty(captured); + Assert.Contains(captured, w => w.Contains("CircuitBreaker is outside Retry")); + } + + // ────────────────────────────────────────────────────────────────── + // Typed pipeline also validates + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void TypedPipeline_AlsoValidates() + { + var captured = new List(); + + var pipeline = Pipeline.Create(b => + { + b.OnValidationWarning = w => captured.Add(w); + b.AddCircuitBreaker(); + b.AddRetry(); + }); + + Assert.NotEmpty(captured); + Assert.Contains(captured, w => w.Contains("CircuitBreaker is outside Retry")); + } +} diff --git a/tests/Resilion.Tests/OutcomeTests.cs b/tests/Resilion.Tests/OutcomeTests.cs new file mode 100644 index 0000000..89d6c65 --- /dev/null +++ b/tests/Resilion.Tests/OutcomeTests.cs @@ -0,0 +1,191 @@ +using Xunit; + +namespace Resilion.Tests; + +public class OutcomeTests +{ + [Fact] + public void FromResult_CreatesSuccessfulOutcome() + { + var outcome = Outcome.FromResult("hello"); + + Assert.True(outcome.IsSuccess); + Assert.False(outcome.IsFailure); + Assert.Equal("hello", outcome.Result); + Assert.Null(outcome.Exception); + } + + [Fact] + public void FromException_CreatesFailedOutcome() + { + var ex = new InvalidOperationException("test"); + var outcome = Outcome.FromException(ex); + + Assert.False(outcome.IsSuccess); + Assert.True(outcome.IsFailure); + Assert.Same(ex, outcome.Exception); + } + + [Fact] + public void Result_ThrowsOnFailedOutcome() + { + var ex = new InvalidOperationException("test"); + var outcome = Outcome.FromException(ex); + + var thrown = Assert.Throws(() => outcome.Result); + Assert.Contains("Cannot access Result", thrown.Message); + } + + [Fact] + public void TryGetResult_ReturnsTrueOnSuccess() + { + var outcome = Outcome.FromResult(42); + + Assert.True(outcome.TryGetResult(out var result)); + Assert.Equal(42, result); + } + + [Fact] + public void TryGetResult_ReturnsFalseOnFailure() + { + var outcome = Outcome.FromException(new Exception("fail")); + + Assert.False(outcome.TryGetResult(out var result)); + Assert.Equal(default, result); + } + + [Fact] + public void GetResultOrDefault_ReturnsResultOnSuccess() + { + var outcome = Outcome.FromResult("value"); + + Assert.Equal("value", outcome.GetResultOrDefault("fallback")); + } + + [Fact] + public void GetResultOrDefault_ReturnsDefaultOnFailure() + { + var outcome = Outcome.FromException(new Exception()); + + Assert.Equal("fallback", outcome.GetResultOrDefault("fallback")); + } + + [Fact] + public void ThrowIfFailed_ReturnsResultOnSuccess() + { + var outcome = Outcome.FromResult(99); + + Assert.Equal(99, outcome.ThrowIfFailed()); + } + + [Fact] + public void ThrowIfFailed_PreservesStackTrace() + { + Exception captured; + try + { + throw new InvalidOperationException("original"); + } + catch (Exception ex) + { + captured = ex; + } + + var outcome = Outcome.FromException(captured); + + var thrown = Assert.Throws(() => outcome.ThrowIfFailed()); + Assert.Equal("original", thrown.Message); + // The stack trace should contain the original throw site + Assert.Contains("ThrowIfFailed_PreservesStackTrace", thrown.StackTrace!); + } + + [Fact] + public void Match_CallsOnSuccessForSuccessfulOutcome() + { + var outcome = Outcome.FromResult("hello"); + + var result = outcome.Match( + onSuccess: s => s.Length, + onFailure: _ => -1); + + Assert.Equal(5, result); + } + + [Fact] + public void Match_CallsOnFailureForFailedOutcome() + { + var outcome = Outcome.FromException(new InvalidOperationException("fail")); + + var result = outcome.Match( + onSuccess: s => s.Length, + onFailure: ex => ex.Message.Length); + + Assert.Equal(4, result); + } + + [Fact] + public void ImplicitConversion_CreatesSuccessfulOutcome() + { + Outcome outcome = "implicit"; + + Assert.True(outcome.IsSuccess); + Assert.Equal("implicit", outcome.Result); + } + + [Fact] + public void FromException_ThrowsOnNull() + { + Assert.Throws(() => Outcome.FromException(null!)); + } + + [Fact] + public void Equality_SuccessfulOutcomes() + { + var a = Outcome.FromResult(42); + var b = Outcome.FromResult(42); + var c = Outcome.FromResult(99); + + Assert.Equal(a, b); + Assert.NotEqual(a, c); + Assert.True(a == b); + Assert.True(a != c); + } + + [Fact] + public void Equality_FailedOutcomes_SameException() + { + var ex = new Exception("test"); + var a = Outcome.FromException(ex); + var b = Outcome.FromException(ex); + + Assert.Equal(a, b); + } + + [Fact] + public void Equality_SuccessNotEqualToFailure() + { + var success = Outcome.FromResult(0); + var failure = Outcome.FromException(new Exception()); + + Assert.NotEqual(success, failure); + } + + [Fact] + public void ToString_ShowsSuccessInfo() + { + var outcome = Outcome.FromResult("test"); + + Assert.Contains("Success", outcome.ToString()); + Assert.Contains("test", outcome.ToString()); + } + + [Fact] + public void ToString_ShowsFailureInfo() + { + var outcome = Outcome.FromException(new InvalidOperationException("oops")); + + Assert.Contains("Failure", outcome.ToString()); + Assert.Contains("InvalidOperationException", outcome.ToString()); + Assert.Contains("oops", outcome.ToString()); + } +} diff --git a/tests/Resilion.Tests/PipelineTests.cs b/tests/Resilion.Tests/PipelineTests.cs new file mode 100644 index 0000000..52f5e6c --- /dev/null +++ b/tests/Resilion.Tests/PipelineTests.cs @@ -0,0 +1,418 @@ +using Xunit; + +namespace Resilion.Tests; + +public class PipelineTests +{ + // ────────────────────────────────────────────────────────────────── + // Empty pipeline + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Empty_ExecuteAsync_PassesThrough() + { + var result = await Pipeline.Empty.ExecuteAsync(static ct => new ValueTask("hello")); + Assert.Equal("hello", result); + } + + [Fact] + public void Empty_Execute_PassesThrough() + { + var result = Pipeline.Empty.Execute(static ct => "hello"); + Assert.Equal("hello", result); + } + + [Fact] + public async Task Empty_VoidExecuteAsync_Completes() + { + var executed = false; + await Pipeline.Empty.ExecuteAsync(ct => + { + executed = true; + return ValueTask.CompletedTask; + }); + Assert.True(executed); + } + + [Fact] + public void Empty_VoidExecute_Completes() + { + var executed = false; + Pipeline.Empty.Execute(ct => { executed = true; }); + Assert.True(executed); + } + + // ────────────────────────────────────────────────────────────────── + // Strategy chain execution + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task SingleStrategy_WrapsExecution() + { + var log = new List(); + + var pipeline = Pipeline.Create(b => b.AddStrategy(new LogStrategy(log, "S1"))); + + var result = await pipeline.ExecuteAsync(static ct => new ValueTask("result")); + + Assert.Equal("result", result); + Assert.Equal(["S1:before", "S1:after"], log); + } + + [Fact] + public async Task MultipleStrategies_ExecuteOuterToInner() + { + var log = new List(); + + var pipeline = Pipeline.Create(b => b + .AddStrategy(new LogStrategy(log, "Outer")) + .AddStrategy(new LogStrategy(log, "Inner"))); + + var result = await pipeline.ExecuteAsync(ct => + { + log.Add("callback"); + return new ValueTask("result"); + }); + + Assert.Equal("result", result); + Assert.Equal(["Outer:before", "Inner:before", "callback", "Inner:after", "Outer:after"], log); + } + + [Fact] + public void MultipleStrategies_ExecuteOuterToInner_Sync() + { + var log = new List(); + + var pipeline = Pipeline.Create(b => b + .AddStrategy(new LogStrategy(log, "Outer")) + .AddStrategy(new LogStrategy(log, "Inner"))); + + var result = pipeline.Execute(ct => + { + log.Add("callback"); + return "result"; + }); + + Assert.Equal("result", result); + Assert.Equal(["Outer:before", "Inner:before", "callback", "Inner:after", "Outer:after"], log); + } + + // ────────────────────────────────────────────────────────────────── + // State parameter (closure-free execution) + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task StateParameter_AvoidsClosure() + { + var pipeline = Pipeline.Empty; + + var result = await pipeline.ExecuteAsync( + static (state, ct) => new ValueTask(state.a + state.b), + (a: 3, b: 7)); + + Assert.Equal(10, result); + } + + [Fact] + public void StateParameter_Sync_AvoidsClosure() + { + var pipeline = Pipeline.Empty; + + var result = pipeline.Execute( + static (state, ct) => state.a * state.b, + (a: 6, b: 7)); + + Assert.Equal(42, result); + } + + // ────────────────────────────────────────────────────────────────── + // Exception propagation + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Exception_PropagatesFromCallback() + { + var pipeline = Pipeline.Create(b => b.AddStrategy(new NoOpStrategy())); + + var ex = await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => throw new InvalidOperationException("test")).AsTask()); + + Assert.Equal("test", ex.Message); + } + + [Fact] + public void Exception_PropagatesFromCallback_Sync() + { + var pipeline = Pipeline.Create(b => b.AddStrategy(new NoOpStrategy())); + + var ex = Assert.Throws(() => + pipeline.Execute(ct => throw new InvalidOperationException("test"))); + + Assert.Equal("test", ex.Message); + } + + // ────────────────────────────────────────────────────────────────── + // Cancellation + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task CancellationToken_FlowsToCallback() + { + var pipeline = Pipeline.Empty; + using var cts = new CancellationTokenSource(); + + CancellationToken received = default; + await pipeline.ExecuteAsync(ct => + { + received = ct; + return new ValueTask(0); + }, cts.Token); + + Assert.Equal(cts.Token, received); + } + + [Fact] + public async Task CancelledToken_PropagatesOperationCanceledException() + { + var pipeline = Pipeline.Create(b => b.AddStrategy(new NoOpStrategy())); + using var cts = new CancellationTokenSource(); + cts.Cancel(); + + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + { + ct.ThrowIfCancellationRequested(); + return new ValueTask(0); + }, cts.Token).AsTask()); + } + + // ────────────────────────────────────────────────────────────────── + // Pipeline composition via AddPipeline + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task AddPipeline_FlattensStrategies() + { + var log = new List(); + + var inner = Pipeline.Create(b => b.AddStrategy(new LogStrategy(log, "Inner"))); + var pipeline = Pipeline.Create(b => b + .AddStrategy(new LogStrategy(log, "Outer")) + .AddPipeline(inner)); + + var result = await pipeline.ExecuteAsync(ct => + { + log.Add("callback"); + return new ValueTask("done"); + }); + + Assert.Equal("done", result); + Assert.Equal(["Outer:before", "Inner:before", "callback", "Inner:after", "Outer:after"], log); + } + + // ────────────────────────────────────────────────────────────────── + // ExecuteOutcomeAsync (no-throw path) + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task ExecuteOutcomeAsync_ReturnsSuccessOutcome() + { + var pipeline = Pipeline.Empty; + var context = ResilienceContextPool.Shared.Rent(); + try + { + var outcome = await pipeline.ExecuteOutcomeAsync( + static (state, ctx) => new ValueTask>(Outcome.FromResult("ok")), + "state", + context); + + Assert.True(outcome.IsSuccess); + Assert.Equal("ok", outcome.Result); + } + finally + { + ResilienceContextPool.Shared.Return(context); + } + } + + [Fact] + public async Task ExecuteOutcomeAsync_ReturnsFailureOutcome_WithoutThrowing() + { + var pipeline = Pipeline.Empty; + var context = ResilienceContextPool.Shared.Rent(); + try + { + var outcome = await pipeline.ExecuteOutcomeAsync( + static (state, ctx) => new ValueTask>( + Outcome.FromException(new InvalidOperationException("fail"))), + "state", + context); + + Assert.True(outcome.IsFailure); + Assert.IsType(outcome.Exception); + } + finally + { + ResilienceContextPool.Shared.Return(context); + } + } + + // ────────────────────────────────────────────────────────────────── + // Typed pipeline + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task TypedPipeline_ExecutesWithTypedStrategy() + { + var pipeline = Pipeline.Create(b => b + .AddStrategy(new UpperCaseStrategy())); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask("hello")); + + Assert.Equal("HELLO", result); + } + + [Fact] + public void TypedPipeline_ExecutesSync() + { + var pipeline = Pipeline.Create(b => b + .AddStrategy(new UpperCaseStrategy())); + + var result = pipeline.Execute(ct => "world"); + + Assert.Equal("WORLD", result); + } + + [Fact] + public async Task TypedPipeline_DelegateStrategy_Works() + { + var pipeline = Pipeline.Create(b => b + .AddStrategy("double-it", async (ctx, next) => + { + var outcome = await next(ctx); + if (outcome.TryGetResult(out var value)) + { + return Outcome.FromResult(value * 2); + } + + return outcome; + })); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask(21)); + + Assert.Equal(42, result); + } + + [Fact] + public async Task TypedPipeline_MixesNonGenericAndTypedStrategies() + { + var log = new List(); + + var pipeline = Pipeline.Create(b => b + .AddStrategy(new LogStrategy(log, "NonGeneric")) + .AddStrategy(new UpperCaseStrategy())); + + var result = await pipeline.ExecuteAsync(ct => + { + log.Add("callback"); + return new ValueTask("hello"); + }); + + Assert.Equal("HELLO", result); + Assert.Equal(["NonGeneric:before", "callback", "NonGeneric:after"], log); + } + + // ────────────────────────────────────────────────────────────────── + // Pipeline.Create factory + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Create_ReturnsEmptyWhenNoStrategies() + { + var pipeline = Pipeline.Create(b => { }); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask(42)); + Assert.Equal(42, result); + } + + // ────────────────────────────────────────────────────────────────── + // Test helpers + // ────────────────────────────────────────────────────────────────── + + /// Logs before/after execution for verifying strategy ordering. + private sealed class LogStrategy : Strategy + { + private readonly List _log; + private readonly string _name; + + public LogStrategy(List log, string name) + { + _log = log; + _name = name; + } + + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + _log.Add($"{_name}:before"); + var outcome = await callback(context).ConfigureAwait(false); + _log.Add($"{_name}:after"); + return outcome; + } + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + _log.Add($"{_name}:before"); + var outcome = callback(context); + _log.Add($"{_name}:after"); + return outcome; + } + } + + /// A no-op strategy that passes through to the next component. + private sealed class NoOpStrategy : Strategy + { + protected internal override ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + => callback(context); + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + => callback(context); + } + + /// A typed strategy that uppercases string results. + private sealed class UpperCaseStrategy : Strategy + { + protected internal override async ValueTask> ExecuteAsync( + Func>> callback, + ResilienceContext context) + { + var outcome = await callback(context).ConfigureAwait(false); + if (outcome.TryGetResult(out var value)) + { + return Outcome.FromResult(value.ToUpperInvariant()); + } + + return outcome; + } + + protected internal override Outcome Execute( + Func> callback, + ResilienceContext context) + { + var outcome = callback(context); + if (outcome.TryGetResult(out var value)) + { + return Outcome.FromResult(value.ToUpperInvariant()); + } + + return outcome; + } + } +} diff --git a/tests/Resilion.Tests/RateLimiter/RateLimiterStrategyTests.cs b/tests/Resilion.Tests/RateLimiter/RateLimiterStrategyTests.cs new file mode 100644 index 0000000..347f963 --- /dev/null +++ b/tests/Resilion.Tests/RateLimiter/RateLimiterStrategyTests.cs @@ -0,0 +1,319 @@ +using System.Threading.RateLimiting; +using Resilion.RateLimiting; +using Xunit; + +namespace Resilion.Tests; + +public class RateLimiterStrategyTests +{ + // ────────────────────────────────────────────────────────────────── + // Happy path — within limit + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_WithinLimit_ExecutesNormally() + { + using var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions + { + PermitLimit = 10, + QueueLimit = 0, + }); + + var pipeline = Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions + { + RateLimiter = limiter, + })); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask("ok")); + Assert.Equal("ok", result); + } + + [Fact] + public void Sync_WithinLimit_ExecutesNormally() + { + using var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions + { + PermitLimit = 10, + QueueLimit = 0, + }); + + var pipeline = Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions + { + RateLimiter = limiter, + })); + + var result = pipeline.Execute(ct => "ok"); + Assert.Equal("ok", result); + } + + // ────────────────────────────────────────────────────────────────── + // Exceeds limit — rejected + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_ExceedsLimit_ThrowsRateLimitRejectedException() + { + using var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions + { + PermitLimit = 1, + QueueLimit = 0, + }); + + var pipeline = Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions + { + RateLimiter = limiter, + })); + + // Acquire the only permit manually so pipeline execution is rejected. + var lease = limiter.AttemptAcquire(); + Assert.True(lease.IsAcquired); + + try + { + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask("should not reach")).AsTask()); + } + finally + { + lease.Dispose(); + } + } + + [Fact] + public void Sync_ExceedsLimit_ThrowsRateLimitRejectedException() + { + using var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions + { + PermitLimit = 1, + QueueLimit = 0, + }); + + var pipeline = Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions + { + RateLimiter = limiter, + })); + + var lease = limiter.AttemptAcquire(); + Assert.True(lease.IsAcquired); + + try + { + Assert.Throws(() => + pipeline.Execute(ct => "should not reach")); + } + finally + { + lease.Dispose(); + } + } + + // ────────────────────────────────────────────────────────────────── + // Lease is released after execution (success and failure) + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_LeaseReleasedAfterSuccess() + { + using var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions + { + PermitLimit = 1, + QueueLimit = 0, + }); + + var pipeline = Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions + { + RateLimiter = limiter, + })); + + // First call should succeed and release the lease + await pipeline.ExecuteAsync(ct => new ValueTask(1)); + + // Second call should also succeed (lease was released) + var result = await pipeline.ExecuteAsync(ct => new ValueTask(2)); + Assert.Equal(2, result); + } + + [Fact] + public async Task Async_LeaseReleasedAfterException() + { + using var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions + { + PermitLimit = 1, + QueueLimit = 0, + }); + + var pipeline = Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions + { + RateLimiter = limiter, + })); + + // First call throws but should release the lease + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => throw new InvalidOperationException("fail")).AsTask()); + + // Second call should succeed (lease was released) + var result = await pipeline.ExecuteAsync(ct => new ValueTask(42)); + Assert.Equal(42, result); + } + + // ────────────────────────────────────────────────────────────────── + // OnRejected callback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_OnRejected_IsFired() + { + using var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions + { + PermitLimit = 1, + QueueLimit = 0, + }); + + OnRateLimitRejectedEvent? capturedEvent = null; + Action onRejected = e => capturedEvent = e; + + var pipeline = Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions + { + RateLimiter = limiter, + OnRejected = onRejected, + })); + + var lease = limiter.AttemptAcquire(); + try + { + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask(1)).AsTask()); + + Assert.NotNull(capturedEvent); + } + finally + { + lease.Dispose(); + } + } + + // ────────────────────────────────────────────────────────────────── + // Token bucket — RetryAfter metadata + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_TokenBucket_ProvidesRetryAfter() + { + using var limiter = new TokenBucketRateLimiter(new TokenBucketRateLimiterOptions + { + TokenLimit = 1, + QueueLimit = 0, + ReplenishmentPeriod = TimeSpan.FromSeconds(10), + TokensPerPeriod = 1, + AutoReplenishment = false, + }); + + var pipeline = Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions + { + RateLimiter = limiter, + })); + + // Exhaust the single token + await pipeline.ExecuteAsync(ct => new ValueTask(1)); + + // Next call should be rejected + var ex = await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => new ValueTask(2)).AsTask()); + + // TokenBucketRateLimiter provides RetryAfter metadata + Assert.NotNull(ex.RetryAfter); + Assert.True(ex.RetryAfter.Value > TimeSpan.Zero); + } + + // ────────────────────────────────────────────────────────────────── + // Typed pipeline + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task TypedPipeline_RateLimiter_Works() + { + using var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions + { + PermitLimit = 10, + QueueLimit = 0, + }); + + var pipeline = Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions + { + RateLimiter = limiter, + })); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask("typed-ok")); + Assert.Equal("typed-ok", result); + } + + // ────────────────────────────────────────────────────────────────── + // Options validation + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void MissingRateLimiter_ThrowsAtBuildTime() + { + Assert.Throws(() => + Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions()))); + } + + // ────────────────────────────────────────────────────────────────── + // Concurrent access + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task ConcurrentAccess_ConcurrencyLimiter_EnforcesLimit() + { + using var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions + { + PermitLimit = 5, + QueueLimit = 0, + }); + + var pipeline = Pipeline.Create(b => b.AddRateLimiter(new RateLimiterStrategyOptions + { + RateLimiter = limiter, + })); + + var concurrentCount = 0; + var maxConcurrent = 0; + + var tasks = Enumerable.Range(0, 20).Select(async _ => + { + try + { + await pipeline.ExecuteAsync(async ct => + { + var current = Interlocked.Increment(ref concurrentCount); + InterlockedMax(ref maxConcurrent, current); + await Task.Delay(50, ct); + Interlocked.Decrement(ref concurrentCount); + return 0; + }); + } + catch (RateLimitRejectedException) + { + // Expected — some will be rejected + } + }); + + await Task.WhenAll(tasks); + + // Concurrency should never exceed the permit limit + Assert.True(maxConcurrent <= 5, $"Max concurrent was {maxConcurrent}, expected <= 5"); + } + + private static void InterlockedMax(ref int location, int value) + { + int current; + do + { + current = location; + if (value <= current) + { + return; + } + } while (Interlocked.CompareExchange(ref location, value, current) != current); + } +} diff --git a/tests/Resilion.Tests/ResilienceContextTests.cs b/tests/Resilion.Tests/ResilienceContextTests.cs new file mode 100644 index 0000000..e9d0bf6 --- /dev/null +++ b/tests/Resilion.Tests/ResilienceContextTests.cs @@ -0,0 +1,114 @@ +using Xunit; + +namespace Resilion.Tests; + +public class ResilienceContextTests +{ + [Fact] + public void Pool_RentAndReturn_ReusesInstances() + { + var pool = new ResilienceContextPool(); + using var cts = new CancellationTokenSource(); + + var ctx1 = pool.Rent(cts.Token); + Assert.Equal(cts.Token, ctx1.CancellationToken); + + pool.Return(ctx1); + + var ctx2 = pool.Rent(); + // Should get the same pooled instance back + Assert.Same(ctx1, ctx2); + // Should be reset + Assert.Equal(CancellationToken.None, ctx2.CancellationToken); + Assert.Null(ctx2.OperationKey); + Assert.False(ctx2.ContinueOnCapturedContext); + + pool.Return(ctx2); + } + + [Fact] + public void Pool_Return_ResetsContext() + { + var pool = new ResilienceContextPool(); + using var cts = new CancellationTokenSource(); + + var ctx = pool.Rent(cts.Token); + ctx.OperationKey = "test-op"; + ctx.ContinueOnCapturedContext = true; + ctx.Properties.Set(new ResiliencePropertyKey("key"), "value"); + + pool.Return(ctx); + + // Re-rent and verify everything is reset + var ctx2 = pool.Rent(); + Assert.Same(ctx, ctx2); + Assert.Null(ctx2.OperationKey); + Assert.False(ctx2.ContinueOnCapturedContext); + Assert.Equal(0, ctx2.Properties.Count); + + pool.Return(ctx2); + } + + [Fact] + public void Pool_SharedInstance_IsNotNull() + { + Assert.NotNull(ResilienceContextPool.Shared); + } + + [Fact] + public void Properties_SetAndGet() + { + var ctx = ResilienceContextPool.Shared.Rent(); + try + { + var key = new ResiliencePropertyKey("retryCount"); + ctx.Properties.Set(key, 3); + + Assert.True(ctx.Properties.TryGetValue(key, out var value)); + Assert.Equal(3, value); + Assert.Equal(3, ctx.Properties.GetValue(key)); + } + finally + { + ResilienceContextPool.Shared.Return(ctx); + } + } + + [Fact] + public void Properties_MissingKey_ReturnsDefault() + { + var ctx = ResilienceContextPool.Shared.Rent(); + try + { + var key = new ResiliencePropertyKey("missing"); + + Assert.False(ctx.Properties.TryGetValue(key, out var value)); + Assert.Null(value); + Assert.Equal("fallback", ctx.Properties.GetValue(key, "fallback")); + } + finally + { + ResilienceContextPool.Shared.Return(ctx); + } + } + + [Fact] + public void Properties_Remove() + { + var ctx = ResilienceContextPool.Shared.Rent(); + try + { + var key = new ResiliencePropertyKey("temp"); + ctx.Properties.Set(key, 42); + Assert.Equal(1, ctx.Properties.Count); + + Assert.True(ctx.Properties.Remove(key)); + Assert.Equal(0, ctx.Properties.Count); + Assert.False(ctx.Properties.Remove(key)); + } + finally + { + ResilienceContextPool.Shared.Return(ctx); + } + } +} diff --git a/tests/Resilion.Tests/ResilienceEventHandlerTests.cs b/tests/Resilion.Tests/ResilienceEventHandlerTests.cs new file mode 100644 index 0000000..06cf406 --- /dev/null +++ b/tests/Resilion.Tests/ResilienceEventHandlerTests.cs @@ -0,0 +1,67 @@ +using Xunit; + +namespace Resilion.Tests; + +public class ResilienceEventHandlerTests +{ + private readonly record struct TestEvent(string Message); + + [Fact] + public async Task SyncHandler_InvokedViaInvokeAsync() + { + string? captured = null; + Action action = e => { captured = e.Message; }; + ResilienceEventHandler handler = action; + + Assert.True(handler.HasHandler); + await handler.InvokeAsync(new TestEvent("hello")); + + Assert.Equal("hello", captured); + } + + [Fact] + public async Task AsyncHandler_InvokedViaInvokeAsync() + { + string? captured = null; + Func func = async e => + { + await Task.Yield(); + captured = e.Message; + }; + ResilienceEventHandler handler = func; + + Assert.True(handler.HasHandler); + await handler.InvokeAsync(new TestEvent("async")); + + Assert.Equal("async", captured); + } + + [Fact] + public void SyncHandler_InvokedViaInvoke() + { + string? captured = null; + Action action = e => { captured = e.Message; }; + ResilienceEventHandler handler = action; + + handler.Invoke(new TestEvent("sync")); + + Assert.Equal("sync", captured); + } + + [Fact] + public void DefaultHandler_HasNoHandler() + { + ResilienceEventHandler handler = default; + + Assert.False(handler.HasHandler); + } + + [Fact] + public async Task DefaultHandler_InvokeAsync_DoesNotThrow() + { + ResilienceEventHandler handler = default; + + // Should not throw + await handler.InvokeAsync(new TestEvent("ignored")); + } +} diff --git a/tests/Resilion.Tests/Resilion.Tests.csproj b/tests/Resilion.Tests/Resilion.Tests.csproj new file mode 100644 index 0000000..23d9dbf --- /dev/null +++ b/tests/Resilion.Tests/Resilion.Tests.csproj @@ -0,0 +1,17 @@ + + + + Resilion.Tests + Resilion.Tests + + + + + + + + + + + + diff --git a/tests/Resilion.Tests/Retry/RetryStrategyTests.cs b/tests/Resilion.Tests/Retry/RetryStrategyTests.cs new file mode 100644 index 0000000..7c6b468 --- /dev/null +++ b/tests/Resilion.Tests/Retry/RetryStrategyTests.cs @@ -0,0 +1,419 @@ +using Microsoft.Extensions.Time.Testing; +using Xunit; + +namespace Resilion.Tests; + +public class RetryStrategyTests +{ + // ────────────────────────────────────────────────────────────────── + // Happy path — no retries needed + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_Success_NoRetries() + { + var callCount = 0; + var pipeline = Pipeline.Create(b => b.AddRetry()); + + var result = await pipeline.ExecuteAsync(ct => + { + callCount++; + return new ValueTask("ok"); + }); + + Assert.Equal("ok", result); + Assert.Equal(1, callCount); + } + + [Fact] + public void Sync_Success_NoRetries() + { + var callCount = 0; + var pipeline = Pipeline.Create(b => b.AddRetry()); + + var result = pipeline.Execute(ct => + { + callCount++; + return "ok"; + }); + + Assert.Equal("ok", result); + Assert.Equal(1, callCount); + } + + // ────────────────────────────────────────────────────────────────── + // Retries on exception + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_RetriesOnException_ThenSucceeds() + { + var callCount = 0; + var fakeTime = new FakeTimeProvider(); + + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.None, // No delay for test speed + }); + }); + + var result = await pipeline.ExecuteAsync(ct => + { + callCount++; + if (callCount < 3) + { + throw new InvalidOperationException("transient"); + } + + return new ValueTask("recovered"); + }); + + Assert.Equal("recovered", result); + Assert.Equal(3, callCount); // 1 initial + 2 retries before success + } + + [Fact] + public async Task Async_ExhaustsRetries_ThrowsLastException() + { + var callCount = 0; + var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 2, + Delay = RetryDelay.None, + })); + + var ex = await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + { + callCount++; + throw new InvalidOperationException($"attempt-{callCount}"); + }).AsTask()); + + Assert.Equal(3, callCount); // 1 initial + 2 retries + Assert.Equal("attempt-3", ex.Message); // Last exception propagates + } + + // ────────────────────────────────────────────────────────────────── + // MaxRetryAttempts = 0 — no retries + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_ZeroRetries_ExecutesOnce() + { + var callCount = 0; + var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 0, + })); + + var ex = await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + { + callCount++; + throw new InvalidOperationException("fail"); + }).AsTask()); + + Assert.Equal(1, callCount); + } + + // ────────────────────────────────────────────────────────────────── + // ShouldHandle predicate + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_UnhandledException_DoesNotRetry() + { + var callCount = 0; + var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.None, + ShouldHandle = ex => ex is HttpRequestException, // Only retry HttpRequestException + })); + + var ex = await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + { + callCount++; + throw new InvalidOperationException("not retryable"); + }).AsTask()); + + Assert.Equal(1, callCount); // Did NOT retry + } + + [Fact] + public async Task Async_OperationCanceledException_NeverRetriedByDefault() + { + var callCount = 0; + var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.None, + })); + + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + { + callCount++; + throw new OperationCanceledException(); + }).AsTask()); + + Assert.Equal(1, callCount); // Did NOT retry OCE + } + + // ────────────────────────────────────────────────────────────────── + // OnRetry callback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_OnRetry_FiredForEachRetry() + { + var retryEvents = new List(); + Action onRetry = e => retryEvents.Add(e); + + var callCount = 0; + var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.None, + OnRetry = onRetry, + })); + + await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + { + callCount++; + throw new InvalidOperationException($"fail-{callCount}"); + }).AsTask()); + + Assert.Equal(3, retryEvents.Count); + Assert.Equal(1, retryEvents[0].AttemptNumber); + Assert.Equal(2, retryEvents[1].AttemptNumber); + Assert.Equal(3, retryEvents[2].AttemptNumber); + } + + // ────────────────────────────────────────────────────────────────── + // Cancellation before retry + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_PreCancelledToken_DoesNotRetry() + { + using var cts = new CancellationTokenSource(); + cts.Cancel(); + var callCount = 0; + + var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 5, + Delay = RetryDelay.None, + })); + + await Assert.ThrowsAnyAsync(() => + pipeline.ExecuteAsync(ct => + { + callCount++; + ct.ThrowIfCancellationRequested(); + throw new InvalidOperationException("fail"); + }, cts.Token).AsTask()); + + // With a pre-cancelled token, the retry loop checks cancellation before each attempt. + Assert.True(callCount <= 1); + } + + // ────────────────────────────────────────────────────────────────── + // RetryDelay variants + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void ConstantDelay_ReturnsSameValue() + { + var delay = RetryDelay.Constant(TimeSpan.FromMilliseconds(100)); + + var d1 = delay.ComputeDelay(1, useJitter: false); + var d2 = delay.ComputeDelay(2, useJitter: false); + var d3 = delay.ComputeDelay(3, useJitter: false); + + Assert.Equal(TimeSpan.FromMilliseconds(100), d1); + Assert.Equal(TimeSpan.FromMilliseconds(100), d2); + Assert.Equal(TimeSpan.FromMilliseconds(100), d3); + } + + [Fact] + public void LinearDelay_ScalesLinearly() + { + var delay = RetryDelay.Linear(TimeSpan.FromSeconds(1)); + + var d1 = delay.ComputeDelay(1, useJitter: false); + var d2 = delay.ComputeDelay(2, useJitter: false); + var d3 = delay.ComputeDelay(3, useJitter: false); + + Assert.Equal(TimeSpan.FromSeconds(1), d1); + Assert.Equal(TimeSpan.FromSeconds(2), d2); + Assert.Equal(TimeSpan.FromSeconds(3), d3); + } + + [Fact] + public void ExponentialDelay_ScalesExponentially() + { + var delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1), maxDelay: TimeSpan.FromSeconds(60)); + + var d1 = delay.ComputeDelay(1, useJitter: false); + var d2 = delay.ComputeDelay(2, useJitter: false); + var d3 = delay.ComputeDelay(3, useJitter: false); + var d4 = delay.ComputeDelay(4, useJitter: false); + + Assert.Equal(TimeSpan.FromSeconds(1), d1); // 1 * 2^0 = 1 + Assert.Equal(TimeSpan.FromSeconds(2), d2); // 1 * 2^1 = 2 + Assert.Equal(TimeSpan.FromSeconds(4), d3); // 1 * 2^2 = 4 + Assert.Equal(TimeSpan.FromSeconds(8), d4); // 1 * 2^3 = 8 + } + + [Fact] + public void ExponentialDelay_ClampedByMaxDelay() + { + var delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1), maxDelay: TimeSpan.FromSeconds(5)); + + var d4 = delay.ComputeDelay(4, useJitter: false); // 8s clamped to 5s + + Assert.Equal(TimeSpan.FromSeconds(5), d4); + } + + [Fact] + public void Jitter_ProducesVariation() + { + var delay = RetryDelay.Constant(TimeSpan.FromSeconds(1)); + + // With jitter, values should vary. Run multiple times. + var delays = Enumerable.Range(1, 100) + .Select(_ => delay.ComputeDelay(1, useJitter: true)) + .ToList(); + + // All within ±25% of 1 second (750ms to 1250ms) + Assert.All(delays, d => + { + Assert.InRange(d.TotalMilliseconds, 750, 1250); + }); + + // Not all the same (jitter should produce variation) + Assert.True(delays.Distinct().Count() > 1, "Jitter should produce variation"); + } + + [Fact] + public void CustomDelay_UsesProvidedFunction() + { + var delay = RetryDelay.Custom(ctx => TimeSpan.FromSeconds(ctx.AttemptNumber * 5)); + + Assert.Equal(TimeSpan.FromSeconds(5), delay.ComputeDelay(1, useJitter: false)); + Assert.Equal(TimeSpan.FromSeconds(10), delay.ComputeDelay(2, useJitter: false)); + } + + [Fact] + public void NoneDelay_IsZero() + { + Assert.Equal(TimeSpan.Zero, RetryDelay.None.ComputeDelay(1, useJitter: false)); + } + + // ────────────────────────────────────────────────────────────────── + // Typed pipeline — result-based retry + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task TypedPipeline_RetriesOnBadResult() + { + var callCount = 0; + + var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 3, + Delay = RetryDelay.None, + ShouldHandle = outcome => + outcome.TryGetResult(out var val) && val < 0, // Retry negative results + })); + + var result = await pipeline.ExecuteAsync(ct => + { + callCount++; + return new ValueTask(callCount < 3 ? -1 : 42); + }); + + Assert.Equal(42, result); + Assert.Equal(3, callCount); + } + + [Fact] + public async Task TypedPipeline_ReturnsBadResult_WhenRetriesExhausted() + { + var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 2, + Delay = RetryDelay.None, + ShouldHandle = outcome => + outcome.TryGetResult(out var val) && val == -1, + })); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask(-1)); + + // After exhausting retries, the last result is returned (not an exception) + Assert.Equal(-1, result); + } + + // ────────────────────────────────────────────────────────────────── + // Options validation + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void NegativeMaxRetryAttempts_ThrowsAtBuildTime() + { + Assert.Throws(() => + Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions { MaxRetryAttempts = -1 }))); + } + + // ────────────────────────────────────────────────────────────────── + // Composition with Timeout (sync path, avoids FakeTimeProvider coordination issues) + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task RetryWithTimeout_RetriesTimeoutRejectedException() + { + var callCount = 0; + + // Retry wrapping a pipeline that throws TimeoutRejectedException + var pipeline = Pipeline.Create(b => + { + b.AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 2, + Delay = RetryDelay.None, + ShouldHandle = ex => ex is TimeoutRejectedException, + }); + }); + + var result = await pipeline.ExecuteAsync(ct => + { + callCount++; + if (callCount <= 2) + { + throw new TimeoutRejectedException( + TimeSpan.FromSeconds(1), + TimeSpan.FromSeconds(1.1), + new OperationCanceledException()); + } + + return new ValueTask("success"); + }); + + Assert.Equal("success", result); + Assert.Equal(3, callCount); + } +} + +// Needed for the ShouldHandle test +file class HttpRequestException : Exception +{ + public HttpRequestException(string message) : base(message) { } +} diff --git a/tests/Resilion.Tests/Timeout/TimeoutStrategyTests.cs b/tests/Resilion.Tests/Timeout/TimeoutStrategyTests.cs new file mode 100644 index 0000000..9c15171 --- /dev/null +++ b/tests/Resilion.Tests/Timeout/TimeoutStrategyTests.cs @@ -0,0 +1,294 @@ +using Microsoft.Extensions.Time.Testing; +using Xunit; + +namespace Resilion.Tests; + +public class TimeoutStrategyTests +{ + // ────────────────────────────────────────────────────────────────── + // Happy path — operation completes within timeout + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_OperationCompletesWithinTimeout_ReturnsResult() + { + var pipeline = Pipeline.Create(b => b.AddTimeout(TimeSpan.FromSeconds(10))); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask("ok")); + + Assert.Equal("ok", result); + } + + [Fact] + public void Sync_OperationCompletesWithinTimeout_ReturnsResult() + { + var pipeline = Pipeline.Create(b => b.AddTimeout(TimeSpan.FromSeconds(10))); + + var result = pipeline.Execute(ct => "ok"); + + Assert.Equal("ok", result); + } + + // ────────────────────────────────────────────────────────────────── + // Timeout fires — operation exceeds timeout + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_OperationExceedsTimeout_ThrowsTimeoutRejectedException() + { + var fakeTime = new FakeTimeProvider(); + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddTimeout(TimeSpan.FromSeconds(5)); + }); + + var task = pipeline.ExecuteAsync(async ct => + { + // Simulate a long operation that observes cancellation + await Task.Delay(TimeSpan.FromMinutes(1), fakeTime, ct); + return "should not reach here"; + }); + + // Advance past the timeout + fakeTime.Advance(TimeSpan.FromSeconds(6)); + + var ex = await Assert.ThrowsAsync(() => task.AsTask()); + Assert.Equal(TimeSpan.FromSeconds(5), ex.ConfiguredTimeout); + Assert.IsAssignableFrom(ex.InnerException); + } + + [Fact] + public async Task Async_TimeoutZero_ImmediatelyTimesOut() + { + var fakeTime = new FakeTimeProvider(); + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddTimeout(TimeSpan.Zero); + }); + + // TimeSpan.Zero fires immediately from the timer. + // We need to give the timer a chance to fire. + var task = pipeline.ExecuteAsync(async ct => + { + ct.ThrowIfCancellationRequested(); + await Task.Delay(TimeSpan.FromSeconds(1), fakeTime, ct); + return "should not reach"; + }); + + // Advance even a tiny bit so the timer fires. + fakeTime.Advance(TimeSpan.FromMilliseconds(1)); + + await Assert.ThrowsAsync(() => task.AsTask()); + } + + // ────────────────────────────────────────────────────────────────── + // Infinite timeout — passthrough + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_InfiniteTimeout_PassesThrough() + { + var pipeline = Pipeline.Create(b => + b.AddTimeout(System.Threading.Timeout.InfiniteTimeSpan)); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask("pass")); + + Assert.Equal("pass", result); + } + + // ────────────────────────────────────────────────────────────────── + // User cancellation — propagates OperationCanceledException, NOT TimeoutRejectedException + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_UserCancellation_PropagatesOCE_NotTimeoutRejected() + { + var fakeTime = new FakeTimeProvider(); + using var userCts = new CancellationTokenSource(); + + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddTimeout(TimeSpan.FromSeconds(30)); + }); + + var task = pipeline.ExecuteAsync(async ct => + { + await Task.Delay(TimeSpan.FromMinutes(1), fakeTime, ct); + return "should not reach"; + }, userCts.Token); + + // User cancels — NOT a timeout + userCts.Cancel(); + + // Should throw OperationCanceledException, NOT TimeoutRejectedException + var ex = await Assert.ThrowsAnyAsync(() => task.AsTask()); + Assert.IsNotType(ex); + } + + // ────────────────────────────────────────────────────────────────── + // CancellationToken flows to callback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_TimeoutToken_FlowsToCallback() + { + var fakeTime = new FakeTimeProvider(); + CancellationToken receivedToken = default; + + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddTimeout(TimeSpan.FromSeconds(5)); + }); + + await pipeline.ExecuteAsync(ct => + { + receivedToken = ct; + return new ValueTask(42); + }); + + // The callback should have received a linked token (different from CancellationToken.None) + // We can't easily assert it's linked, but we know the pipeline replaced it. + // The important thing is the test completes without timeout. + } + + // ────────────────────────────────────────────────────────────────── + // OnTimeout callback + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_OnTimeout_IsFired() + { + var fakeTime = new FakeTimeProvider(); + OnTimeoutArgs? capturedArgs = null; + + Action onTimeout = args => { capturedArgs = args; }; + + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddTimeout(new TimeoutStrategyOptions + { + Timeout = TimeSpan.FromSeconds(5), + OnTimeout = onTimeout, + }); + }); + + var task = pipeline.ExecuteAsync(async ct => + { + await Task.Delay(TimeSpan.FromMinutes(1), fakeTime, ct); + return "nope"; + }); + + fakeTime.Advance(TimeSpan.FromSeconds(6)); + + await Assert.ThrowsAsync(() => task.AsTask()); + + Assert.NotNull(capturedArgs); + Assert.Equal(TimeSpan.FromSeconds(5), capturedArgs.Value.Timeout); + } + + // ────────────────────────────────────────────────────────────────── + // TimeoutGenerator — dynamic timeout + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_TimeoutGenerator_OverridesStaticTimeout() + { + var fakeTime = new FakeTimeProvider(); + + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddTimeout(new TimeoutStrategyOptions + { + Timeout = TimeSpan.FromSeconds(100), // Should be ignored + TimeoutGenerator = _ => TimeSpan.FromSeconds(2), + }); + }); + + var task = pipeline.ExecuteAsync(async ct => + { + await Task.Delay(TimeSpan.FromMinutes(1), fakeTime, ct); + return "nope"; + }); + + fakeTime.Advance(TimeSpan.FromSeconds(3)); + + var ex = await Assert.ThrowsAsync(() => task.AsTask()); + Assert.Equal(TimeSpan.FromSeconds(2), ex.ConfiguredTimeout); + } + + // ────────────────────────────────────────────────────────────────── + // Typed pipeline + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task TypedPipeline_Timeout_Works() + { + var pipeline = Pipeline.Create(b => + b.AddTimeout(TimeSpan.FromSeconds(10))); + + var result = await pipeline.ExecuteAsync(ct => new ValueTask("typed-ok")); + + Assert.Equal("typed-ok", result); + } + + // ────────────────────────────────────────────────────────────────── + // Exception from callback (non-cancellation) propagates normally + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task Async_NonCancellationException_PropagatesNormally() + { + var pipeline = Pipeline.Create(b => b.AddTimeout(TimeSpan.FromSeconds(10))); + + var ex = await Assert.ThrowsAsync(() => + pipeline.ExecuteAsync(ct => + throw new InvalidOperationException("business error")).AsTask()); + + Assert.Equal("business error", ex.Message); + } + + // ────────────────────────────────────────────────────────────────── + // Options validation + // ────────────────────────────────────────────────────────────────── + + [Fact] + public void NegativeTimeout_ThrowsAtBuildTime() + { + Assert.Throws(() => + Pipeline.Create(b => b.AddTimeout(TimeSpan.FromSeconds(-5)))); + } + + // ────────────────────────────────────────────────────────────────── + // Default options + // ────────────────────────────────────────────────────────────────── + + [Fact] + public async Task DefaultOptions_Uses30SecondTimeout() + { + var fakeTime = new FakeTimeProvider(); + + var pipeline = Pipeline.Create(b => + { + b.TimeProvider = fakeTime; + b.AddTimeout(); + }); + + var task = pipeline.ExecuteAsync(async ct => + { + await Task.Delay(TimeSpan.FromMinutes(5), fakeTime, ct); + return "nope"; + }); + + // Advance past the 30s default + fakeTime.Advance(TimeSpan.FromSeconds(31)); + + var ex = await Assert.ThrowsAsync(() => task.AsTask()); + Assert.Equal(TimeSpan.FromSeconds(30), ex.ConfiguredTimeout); + } +} From 742f7a16c1e61d335939a583fa14dd455546d65c Mon Sep 17 00:00:00 2001 From: Ali-Tegna <31090457+FreakyAli@users.noreply.github.com> Date: Tue, 1 Sep 2026 12:19:55 +0530 Subject: [PATCH 2/9] fix: better futture-plans and more details about current known tradeoffs --- docs/future-plans.md | 286 ++++++++++++++++++++++++++++++++++++------- docs/tradeoffs.md | 65 ++++++++++ 2 files changed, 307 insertions(+), 44 deletions(-) create mode 100644 docs/tradeoffs.md diff --git a/docs/future-plans.md b/docs/future-plans.md index 47c0bcb..5b39154 100644 --- a/docs/future-plans.md +++ b/docs/future-plans.md @@ -21,46 +21,188 @@ Features, improvements, and known tradeoffs under consideration for future versi | # | Item | Priority | Type | Impact | Effort | Notes | |---|------|----------|------|--------|--------|-------| -| 3 | Resilion.Extensions (DI + telemetry) | P1 | Feature | High | Medium | Microsoft.Extensions integration | +| 15 | **DI configurators never applied to registry** | **P0** | Fix | Critical | Low | `AddResiliencePipeline` registers configurators but nothing applies them — users get KeyNotFoundException | +| 16 | **CB FireEvent sync-only on async path** | **P0** | Fix | High | Low | Circuit breaker event handlers always call `.Invoke()` even from `ExecuteAsync` — deadlocks with async handlers under SynchronizationContext | +| 17 | **ResilienceProperties TryGetValue throws on type mismatch** | **P0** | Fix | High | Low | Same string key + different type parameter causes `InvalidCastException` instead of returning false | +| 32 | **Timeout async path missing catch for direct OCE** | **P0** | Fix | High | Low | Inner strategy throws OCE directly (not via Outcome), async path doesn't catch — timeout leaks as raw OCE | +| 33 | **Timeout timer callback can crash process** | **P0** | Fix | Critical | Low | `CTS.Cancel()` in timer callback propagates `AggregateException` from user cancellation callbacks — unhandled on thread pool = process termination | +| 18 | **ManualControl non-atomic initialization** | **P1** | Fix | Medium | Low | `_onReset` set after CAS on `_onIsolate` — race window where Isolate works but Reset throws | +| 19 | **Hedging sync path shares context across attempts** | **P1** | Fix | Medium | Low | Sync `Execute` reuses same ResilienceContext for all sequential attempts — inner strategies see stale Properties | +| 20 | Hedging `ResolveAction` missing `Task.Run` wrapper | P1 | Fix | Medium | Low | Sync path deadlock risk when ActionGenerator returns async action | +| 21 | Registry `GetOrAdd` race leaks undisposed Pipelines | P1 | Fix | Medium | Low | Concurrent first-access creates N pipelines, discards N-1 without Dispose | +| 34 | **Hedging latency-mode: completed task bypasses delay for all subsequent attempts** | **P1** | Fix | High | Medium | Failed task stays in attempts list, `Task.WhenAny` resolves immediately on every subsequent iteration, all hedges launch in burst instead of staggered | +| 23 | Interlocked.Increment under lock in SlidingWindow | P2 | Fix | Low | Low | Wasted memory barrier — plain `++` under lock is correct and cheaper | +| 24 | Double lock acquisition per CB Closed-state call | P2 | Fix | Medium | Low | RecordSuccess + GetFailureRatio each acquire SlidingWindow lock separately | +| 25 | ConcurrentBag.Count in pool Return | P2 | Fix | Medium | Low | `Count` enumerates all thread-local lists — use Interlocked counter | +| 26 | CB typed/non-generic strategy duplication (~200 lines) | P2 | Improvement | Medium | Medium | Extract shared state machine class | +| 27 | Retry typed/non-generic strategy duplication (~100 lines) | P2 | Improvement | Medium | Medium | Extract shared retry loop | +| 28 | PipelineBuilder typed/non-generic duplication (~80 lines) | P2 | Improvement | Medium | Medium | Extract shared base class | +| 29 | ShouldHandleOutcome copy-pasted across 4 options classes | P2 | Improvement | Low | Low | Extract to shared static helper | | 4 | Per-call delegate allocation in pipeline chain | P2 | Fix | Medium | High | Middleware pattern inherent cost | | 5 | CancellationTokenSource pooling for Timeout/Hedging | P2 | Improvement | Medium | Medium | Reduce alloc on hot path | -| 6 | Pipeline ordering validation | P2 | Feature | Medium | Medium | Warn on common misorderings | -| 7 | Benchmarks vs Polly | P2 | Infrastructure | High | Medium | Prove performance claims | -| 8 | README and docs | P2 | Documentation | High | Medium | User-facing documentation | +| 11 | Hedging: Task.WhenAny memory leak | P2 | Fix | Medium | Medium | Continuations not deregistered on losing tasks | | 9 | WaitHandle allocation in sync retry | P3 | Fix | Low | Low | CancellationToken.WaitHandle lazy alloc | | 10 | Resilion.Testing package | P3 | Feature | Medium | Low | Test doubles, assertion helpers | -| 11 | Hedging: Task.WhenAny memory leak | P2 | Fix | Medium | Medium | Continuations not deregistered on losing tasks | | 12 | Hedging: HedgingDelayGenerator | P3 | Feature | Low | Low | Dynamic delay per attempt | -| 13 | Hedging: Properties propagation to attempt contexts | P2 | Fix | Medium | Low | User properties not copied to hedged attempts | | 14 | Hedging: HedgingRejectedException with aggregated errors | P3 | Improvement | Low | Low | Currently dead code — never thrown | +| 30 | FallbackAction/ResilienceEventHandler Task.Run missing CancellationToken | P3 | Fix | Low | Low | Sync-over-async wrappers can't be interrupted by cancellation | +| 31 | Duplicate XML doc on ResilienceProperties.Clear | P3 | Fix | Low | Low | Copy-paste leftover — orphaned summary block | + +> **Completed (removed from backlog):** Solution structure, .editorconfig, global.json, CI workflows, Outcome\, ResilienceContext pooling, Strategy base types, Pipeline/PipelineBuilder, ResilienceEventHandler union struct, Timeout strategy, Retry strategy (with RetryDelay discriminated union), Circuit Breaker (sliding window, state machine, thread safety), Fallback (with FallbackAction implicit conversions), code review and fixes for 13 issues, Rate Limiter strategy (wrapping System.Threading.RateLimiting), Hedging strategy (parallel/latency/sequential modes, per-attempt CTS, cleanup-on-cancel), Pipeline ordering validation, Telemetry wired into all strategies, Docs (15 files), README, Samples, Benchmarks vs Polly, #6 Pipeline ordering validation, #7 Benchmarks, #8 README and docs, #13 Hedging Properties propagation (CopyFrom added). + +--- + +## P0 — Bugs (fix before any release) + +### 15. DI Configurators Never Applied to Registry + +**Type:** Fix — Critical correctness bug + +**Why** + +`AddResiliencePipeline("name", configure)` registers `IPipelineConfigurator` singletons in DI, but nothing ever applies them to the `ResiliencePipelineRegistry`. The registry is registered via `TryAddSingleton` with its parameterless constructor, yielding an empty registry. `BuildRegistry` exists as `internal static` but is only called from test code. + +**Impact:** Any user following the DI pattern gets `KeyNotFoundException` at runtime. The entire DI registration surface is non-functional. + +**Fix:** Wire `BuildRegistry` into the DI container — either as a factory for the registry singleton, or via `IHostedService` / post-configuration. The simplest fix: replace `TryAddSingleton>()` with a factory overload that resolves all `IPipelineConfigurator` instances and applies them. + +**Location:** [ResilionServiceCollectionExtensions.cs](../src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs) + +--- + +### 16. Circuit Breaker FireEvent Sync-Only on Async Path + +**Type:** Fix — Deadlock under SynchronizationContext + +**Why** + +`FireEvent` in both `CircuitBreakerStrategy` and `CircuitBreakerTypedStrategy` always calls `handler.Invoke(e)` (sync), even when invoked from `ExecuteAsync`. For async handlers, `Invoke` does `Task.Run(...).GetAwaiter().GetResult()`, blocking the thread. Every other strategy correctly uses `await handler.InvokeAsync(...)` on async paths. + +**Impact:** Circuit breaker with async event handler deadlocks under WPF/WinForms SynchronizationContext. Thread pool starvation under load even without SynchronizationContext. + +**Fix:** Split `FireEvent` into `FireEvent` (sync) and `FireEventAsync` (async). Call the async variant from `ExecuteAsync`, the sync variant from `Execute`. + +**Location:** [CircuitBreakerStrategy.cs](../src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs), [CircuitBreakerTypedStrategy.cs](../src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs) + +--- + +### 17. ResilienceProperties TryGetValue Throws on Type Mismatch + +**Type:** Fix — Correctness + +**Why** + +`TryGetValue` performs an unchecked cast `(TValue?)raw` on the stored `object?`. The key is the string from `ResiliencePropertyKey.Key`, not the type parameter. Two keys with the same string but different types (e.g., `ResiliencePropertyKey("code")` and `ResiliencePropertyKey("code")`) cause `InvalidCastException` instead of returning `false`. + +**Fix:** Wrap the cast in a type check: `if (raw is TValue typed) { value = typed; return true; }`. + +**Location:** [ResilienceProperties.cs](../src/Resilion/ResilienceProperties.cs) — `TryGetValue` -> **Completed (removed from backlog):** Solution structure, .editorconfig, global.json, CI workflows, Outcome\, ResilienceContext pooling, Strategy base types, Pipeline/PipelineBuilder, ResilienceEventHandler union struct, Timeout strategy, Retry strategy (with RetryDelay discriminated union), Circuit Breaker (sliding window, state machine, thread safety), Fallback (with FallbackAction implicit conversions), code review and fixes for 13 issues, Rate Limiter strategy (wrapping System.Threading.RateLimiting), Hedging strategy (parallel/latency/sequential modes, per-attempt CTS, cleanup-on-cancel). +--- + +### 32. Timeout Async Path Missing Catch for Direct OCE + +**Type:** Fix — Correctness + +**Why** + +The async `ExecuteAsync` in `TimeoutStrategy` only checks `outcome.Exception is OperationCanceledException` (line ~45). But if the inner callback throws `OperationCanceledException` directly (not captured in an Outcome — e.g., `Task.Delay` throws when its token cancels during Retry delay), there is no `catch (OperationCanceledException)` block on the async path. The sync path has one (line ~105). The raw OCE propagates to the caller instead of being wrapped in `TimeoutRejectedException`. + +**Impact:** Users can't distinguish timeout from external cancellation when Timeout wraps Retry and the timeout fires during a retry delay. + +**Fix:** Add `catch (OperationCanceledException oce) when (WasCancelledByTimeout(linkedCts, previousToken))` to the async path's try block, matching the sync path. + +**Location:** [TimeoutStrategy.cs](../src/Resilion/Timeout/TimeoutStrategy.cs) — `ExecuteAsync` + +--- + +### 33. Timeout Timer Callback Can Crash Process + +**Type:** Fix — Critical + +**Why** + +The timeout timer callback is `static state => ((CancellationTokenSource)state!).Cancel()`. `CancellationTokenSource.Cancel()` invokes all registered cancellation callbacks. If any callback throws, `Cancel()` wraps the exception in `AggregateException` and rethrows. Since this runs on a thread pool timer thread with no try-catch, the unhandled exception terminates the process in .NET 6+. + +**Impact:** A user strategy that registers a faulty cancellation callback (e.g., `token.Register(() => resource.Dispose())` where Dispose throws) crashes the entire application when a timeout fires. + +**Fix:** Wrap the timer callback: `static state => { try { ((CancellationTokenSource)state!).Cancel(); } catch { /* log or swallow */ } }`. + +**Location:** [TimeoutStrategy.cs](../src/Resilion/Timeout/TimeoutStrategy.cs) — `CreateTimer` callback, lines ~36 and ~86 --- ## P1 — Do First -### 3. Resilion.Extensions (DI + Telemetry) +### 18. ManualControl Non-Atomic Initialization -**Type:** Feature — Integration Package +**Type:** Fix — Race condition **Why** -Production services use `Microsoft.Extensions.DependencyInjection` and OpenTelemetry. Resilion needs first-class integration without forcing these dependencies on the core package. +`CircuitBreakerManualControl.Initialize` uses `Interlocked.CompareExchange` on `_onIsolate`, then plain assignment on `_onReset`. Between the CAS and the assignment, a concurrent `IsolateAsync()` succeeds but `ResetAsync()` throws — leaving the circuit permanently isolated. -**Design** +**Fix:** Set both fields atomically. Options: use a lock, or pack both into a single `(Func, Func)` tuple and CAS that. + +**Location:** [CircuitBreakerManualControl.cs](../src/Resilion/CircuitBreaker/CircuitBreakerManualControl.cs) — `Initialize` + +--- + +### 19. Hedging Sync Path Shares Context Across Attempts + +**Type:** Fix — Correctness + +**Why** + +Sync `Execute` in `HedgingStrategy` passes the same `ResilienceContext` to all sequential attempts. Any inner strategy that writes to `context.Properties` during attempt N leaves stale state visible to attempt N+1. The async path correctly creates a fresh per-attempt context. + +**Fix:** Create a per-attempt context copy in the sync path, matching the async path's `ResilienceContextPool.Shared.Rent(ct)` + `Properties.CopyFrom()`. + +**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `Execute`, line ~119 + +--- -The `Resilion.Extensions` project (already exists) will provide: -- `IServiceCollection.AddResilion()` and `AddResiliencePipeline(name, configure)` extensions -- `ResiliencePipelineProvider` for resolving named/keyed pipelines -- `Meter("Resilion")` and `ActivitySource("Resilion")` for OpenTelemetry-compatible metrics and tracing -- `ILogger` integration for strategy events +### 20. Hedging ResolveAction Missing Task.Run Wrapper -**Files to Modify/Create:** -- `src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs` -- `src/Resilion.Extensions/PipelineRegistry.cs` -- `src/Resilion.Extensions/Telemetry/ResilionMeter.cs` -- `tests/Resilion.Extensions.Tests/` — DI registration, telemetry emission tests +**Type:** Fix — Deadlock risk + +**Why** + +Sync `ResolveAction` wraps a custom `ActionGenerator`'s async result with `.GetAwaiter().GetResult()` directly, without `Task.Run`. Every other sync-over-async site in the codebase uses `Task.Run` to escape the SynchronizationContext. + +**Fix:** Match the pattern: `Task.Run(() => customAction(ctx.CancellationToken).AsTask()).GetAwaiter().GetResult()`. + +**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `ResolveAction`, line ~241 + +--- + +### 34. Hedging Latency-Mode: Completed Task Bypasses Delay for All Subsequent Attempts + +**Type:** Fix — Behavioral incorrectness + +**Why** + +In latency mode (`HedgingDelay > 0`), once an attempt completes with a handled failure, it stays in `attempts`. On the next loop iteration, `Task.WhenAny(attempts)` resolves immediately on the already-completed task, so the hedging delay is never honored. All remaining hedged attempts launch in a burst instead of being staggered by `HedgingDelay`. + +**Example:** `HedgingDelay = 2s`, `MaxHedgedAttempts = 4`. Primary fails in 100ms. Attempts 1, 2, 3 all launch within milliseconds instead of being spaced 2s apart. + +**Fix:** Remove completed tasks from `attempts` after checking their outcome in the latency-mode early-check block. + +**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `ExecuteAsync`, latency mode block + +--- + +### 21. Registry GetOrAdd Race Leaks Undisposed Pipelines + +**Type:** Fix — Resource leak + +**Why** + +`ConcurrentDictionary.GetOrAdd` with a factory may execute the factory multiple times under concurrent access. Only one `Pipeline` is stored; the rest are discarded without `Dispose`. Custom strategies holding unmanaged resources would leak. + +**Fix:** Use `Lazy` as the dictionary value, or use a lock per key to ensure single creation. + +**Location:** [ResiliencePipelineRegistry.cs](../src/Resilion.Extensions/ResiliencePipelineRegistry.cs) — `GetPipeline` --- @@ -161,17 +303,77 @@ Implement a custom `FirstCompletedAsync` that uses `TaskCompletionSource` + per- --- -### 13. Hedging: Properties Propagation to Attempt Contexts +### 22. Hedging Latency-Mode Double WhenAny + Stale Task -**Type:** Fix — Correctness +**Type:** Fix — Correctness (minor) + +**Why** + +In latency mode, when an attempt completes before the delay, `Task.WhenAny(attempts)` is called twice (once nested, once after). The second call may return a different task. Also, the completed/failed task stays in `attempts`, so `WaitForBestOutcome` re-evaluates it, wasting a cycle and potentially setting `lastFailure` to the wrong attempt. + +**Fix:** Store the result of the first `WhenAny`, remove completed tasks from the list before launching the next attempt. + +**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `ExecuteAsync`, latency mode block + +--- + +### 23. Interlocked.Increment Under Lock in SlidingWindow + +**Type:** Fix — Efficiency **Why** -In `HedgingStrategy.ResolveAsyncAction`, when re-executing the original callback for hedged attempts, the code creates a new `ResilienceContext` and copies `OperationKey` and `ContinueOnCapturedContext` but does NOT copy `Properties`. If the user stored custom data in `context.Properties` before execution (or an outer strategy set properties), hedged attempts won't see it. +`RecordSuccess()` and `RecordFailure()` acquire `_lock` then use `Interlocked.Increment`. Since the lock is held, `Interlocked` adds a full memory barrier for zero benefit. Plain `++` is correct and cheaper. -**Fix:** Copy all properties from the original context to the attempt context. Either iterate and copy, or add a `CopyFrom` method on `ResilienceProperties`. +**Fix:** Replace `Interlocked.Increment(ref _buckets[_currentBucketIndex].Successes)` with `_buckets[_currentBucketIndex].Successes++`. -**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `ResolveAsyncAction`, line ~210 +**Location:** [SlidingWindow.cs](../src/Resilion/CircuitBreaker/SlidingWindow.cs) — `RecordSuccess`, `RecordFailure` + +--- + +### 24. Double Lock Acquisition Per CB Closed-State Call + +**Type:** Fix — Efficiency + +**Why** + +In Circuit Breaker's Closed path, `RecordAndTransition` calls `_window.RecordFailure()` then `_window.GetFailureRatio()`. Each acquires `SlidingWindow._lock` independently. Both also run `AdvanceWindow()`. This doubles lock contention and duplicates window-advancement. + +**Fix:** Add `RecordAndGetRatio(bool isFailure, out int totalCount)` to SlidingWindow that does record + ratio under one lock acquisition. + +**Location:** [CircuitBreakerStrategy.cs](../src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs), [SlidingWindow.cs](../src/Resilion/CircuitBreaker/SlidingWindow.cs) + +--- + +### 25. ConcurrentBag.Count in Pool Return + +**Type:** Fix — Efficiency + +**Why** + +`ResilienceContextPool.Return` checks `_pool.Count < MaxPoolSize` before adding. `ConcurrentBag.Count` is O(n), acquiring locks on all thread-local lists. With many threads, this serializes the return path. + +**Fix:** Track count with `Interlocked.Increment`/`Decrement` on an `int _count` field instead. + +**Location:** [ResilienceContextPool.cs](../src/Resilion/ResilienceContextPool.cs) — `Return` + +--- + +### 26–29. Strategy/Builder/Options Duplication + +**Type:** Improvement — Maintainability + +**Why** + +Code review identified significant duplication between typed and non-generic variants: +- **#26:** `CircuitBreakerStrategy` / `CircuitBreakerTypedStrategy` — ~200 lines of identical state machine logic +- **#27:** `RetryStrategy` / `RetryStrategy` — ~100 lines of identical retry loop (4 copies: async+sync × typed+untyped) +- **#28:** `PipelineBuilder` / `PipelineBuilder` — ~80 lines of identical Build/EmitWarnings/properties +- **#29:** `ShouldHandleOutcome` — identical method body across `FallbackStrategyOptions`, `RetryStrategyOptions`, `CircuitBreakerStrategyOptions`, `HedgingStrategyOptions` + +**Fix:** Extract shared base classes, helper classes, or static methods. For CB, a shared `CircuitBreakerStateMachine` class parameterized on a failure predicate. For Retry, a shared loop parameterized on `Func, bool>`. For Builder, a `PipelineBuilderBase`. For ShouldHandle, a static `OutcomePredicates.Default()`. + +**Risk:** A bug fix applied to one copy but not the other causes silent behavioral divergence between typed and non-generic variants of the same strategy. --- @@ -249,34 +451,30 @@ The first option changes behavior for users who `catch (InvalidOperationExceptio --- -## Known Tradeoffs (Documented, Not Planned to Fix) - -### Null implicit conversion creates "successful" null outcome +### 30. FallbackAction/ResilienceEventHandler Task.Run Missing CancellationToken -`Outcome o = (string)null;` creates a success outcome with a null result. This is consistent with how `Task` handles null — `Task.FromResult(null)` is a valid completed task. For nullable reference types this is expected behavior. Users working with non-nullable value types cannot trigger this. +**Type:** Fix — Minor correctness -**Location:** [Outcome.cs](../src/Resilion/Outcome.cs) — `implicit operator` - -### DelegatingComponent does not dispose composed pipeline resources +**Why** -When pipelines are composed via `AddPipeline()`, the `DelegatingComponent` intentionally does not dispose the inner component. This is because the inner pipeline may be shared — the same pre-built `Pipeline` can be flattened into multiple builders. The caller owns the lifetime of composed pipelines and must dispose them separately. +Both `FallbackAction.Execute` and `ResilienceEventHandler.Invoke` call `Task.Run(() => ...).GetAwaiter().GetResult()` for sync-over-async without passing `CancellationToken` to `Task.Run`. The blocking call can't be interrupted by cancellation. -**Location:** [PipelineBuilder.cs](../src/Resilion/PipelineBuilder.cs) — `DelegatingComponent.Dispose()` +**Impact:** Low. Only affects sync path with async handlers/factories, and the underlying async operation would need to observe its own token anyway. -### ResilienceContextPool cap is approximate +--- -The pool size check (`_pool.Count < MaxPoolSize`) followed by `_pool.Add(context)` is a TOCTOU race — multiple threads can all pass the check and add, slightly exceeding the 256 cap. This is intentional. The cap is a heuristic to prevent unbounded memory growth, not a hard limit. Using `Interlocked` or a lock for exact enforcement would add contention on every pool return for no meaningful benefit. +### 31. Duplicate XML Doc on ResilienceProperties.Clear -**Location:** [ResilienceContextPool.cs](../src/Resilion/ResilienceContextPool.cs) — `Return()` +**Type:** Fix — Trivial -### Timeout cancellation classification has a narrow race window +**Why** -In `TimeoutStrategy.WasCancelledByTimeout`, there is a TOCTOU window between checking `userToken.IsCancellationRequested` and `linkedCts.IsCancellationRequested`. If the user token is cancelled in between, user cancellation may be misclassified as a timeout (producing `TimeoutRejectedException` instead of `OperationCanceledException`). The window is nanoseconds wide and requires exact concurrent timing to trigger. In practice this is not observable. +Two consecutive identical `Removes all properties.` blocks before `Clear()`. Copy-paste leftover. -**Location:** [TimeoutStrategy.cs](../src/Resilion/Timeout/TimeoutStrategy.cs) — `WasCancelledByTimeout()` +**Location:** [ResilienceProperties.cs](../src/Resilion/ResilienceProperties.cs) -### Hedging latency mode calls Task.WhenAny twice +--- -In latency mode, the hedging strategy checks if any attempt completed before the delay by nesting `Task.WhenAny(Task.WhenAny(attempts), delayTask)`. When an attempt completes early, it calls `Task.WhenAny(attempts)` a second time to get the completed task. If a *different* attempt completed between the two calls, the second `WhenAny` may return a different task. This is benign — either task's result is checked, and if it's a failure the hedge launches anyway. But it means the "early success" check is not guaranteed to evaluate the first-completed task's result. +--- -**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `ExecuteAsync`, lines ~52-65 +See also: [tradeoffs.md](tradeoffs.md) — accepted design imperfections with reasoning for why they won't be fixed. diff --git a/docs/tradeoffs.md b/docs/tradeoffs.md new file mode 100644 index 0000000..091fab7 --- /dev/null +++ b/docs/tradeoffs.md @@ -0,0 +1,65 @@ +# Known Tradeoffs + +Accepted design imperfections where the fix is worse than the problem, or the issue is theoretical rather than practical. Each entry explains what the tradeoff is, why it's acceptable, and what to watch for. + +For items we *plan to fix*, see [future-plans.md](future-plans.md). + +--- + +## Null implicit conversion creates "successful" null outcome + +`Outcome o = (string)null;` creates a success outcome with a null result. + +**Why it's acceptable:** Consistent with `Task.FromResult(null)` — a completed task with null is valid in .NET. For non-nullable value types this can't happen. For reference types, null is a legal value. + +**Watch for:** User code that assumes `outcome.IsSuccess` means `outcome.Result` is non-null. Use `TryGetResult` and null-check the result. + +**Location:** [Outcome.cs](../src/Resilion/Outcome.cs) — `implicit operator` + +--- + +## DelegatingComponent does not dispose composed pipeline resources + +When pipelines are composed via `AddPipeline()`, the `DelegatingComponent` does not dispose the inner component. + +**Why it's acceptable:** The inner pipeline may be shared — the same pre-built `Pipeline` can be flattened into multiple builders. Disposing the inner would break all other compositions sharing it. Ownership belongs to whoever created the original pipeline. + +**Watch for:** If you compose pipelines, dispose the source pipelines separately when they're no longer needed. The composed pipeline's `Dispose()` only disposes strategies it directly owns. + +**Location:** [PipelineBuilder.cs](../src/Resilion/PipelineBuilder.cs) — `DelegatingComponent.Dispose()` + +--- + +## ResilienceContextPool cap is approximate + +The pool size check (`_pool.Count < MaxPoolSize`) followed by `_pool.Add(context)` is a TOCTOU race — multiple threads can pass the check simultaneously and add, slightly exceeding the 256 cap. + +**Why it's acceptable:** The cap is a heuristic, not a hard limit. Enforcing exactly 256 would require a lock or `Interlocked` on every return for zero practical benefit. Under burst traffic the pool might briefly hold 260-270 items; the excess is collected on the next GC. The alternative — `ConcurrentBag.Count` with exact enforcement — is worse because `Count` itself is expensive (see future-plans #25). + +**Watch for:** Don't rely on the pool being exactly 256 items or fewer. It's a soft cap. + +**Location:** [ResilienceContextPool.cs](../src/Resilion/ResilienceContextPool.cs) — `Return()` + +--- + +## Timeout cancellation classification has a narrow race window + +`WasCancelledByTimeout` checks `linkedCts.IsCancellationRequested && !userToken.IsCancellationRequested`. Between the two checks, the user token could become cancelled, causing user cancellation to be misclassified as a timeout. + +**Why it's acceptable:** The window is nanoseconds wide and requires the user token to cancel at the exact instant between two boolean reads. In practice this is not observable. The consequence (a `TimeoutRejectedException` instead of `OperationCanceledException`) is also recoverable — the caller catches `ResilionException` or the base `Exception` either way. + +**Watch for:** If your code strictly distinguishes timeout from cancellation and you're seeing rare misclassification under extreme concurrent cancellation, this is the cause. + +**Location:** [TimeoutStrategy.cs](../src/Resilion/Timeout/TimeoutStrategy.cs) — `WasCancelledByTimeout()` + +--- + +## Per-call delegate allocation in pipeline chain + +Each `StrategyComponent` in the chain creates a closure `ctx => _next.ExecuteAsync(callback, ctx)` per execution. N strategies = N closure allocations per call. + +**Why it's acceptable:** This is inherent to the middleware/chain-of-responsibility pattern. Polly v8 has the same cost. The closures are small (one display class + one delegate), short-lived (Gen0 collected), and negligible relative to the I/O cost of the operations being protected. Pre-composing at build time would require complex generic threading that doesn't compose with the non-generic `Strategy` base. + +**Watch for:** If benchmarks show this matters for your workload (unlikely unless you're running 100K+ pipeline executions/sec with no I/O), consider reducing pipeline depth or using `ExecuteOutcomeAsync` with a manually composed chain. + +**Location:** [PipelineComponent.cs](../src/Resilion/Internal/PipelineComponent.cs) — `StrategyComponent.ExecuteAsync` From 9b6cfaf39657d3144e6f299fe9775e9724e95c02 Mon Sep 17 00:00:00 2001 From: Ali-Tegna <31090457+FreakyAli@users.noreply.github.com> Date: Tue, 1 Sep 2026 22:57:33 +0530 Subject: [PATCH 3/9] fix: valid coderabbit comments --- .github/ISSUE_TEMPLATE/bug_report.md | 7 ++- .github/workflows/ci.yml | 2 + .github/workflows/release-nuget.yml | 17 ++++-- .github/workflows/test.yml | 10 +--- CONTRIBUTING.md | 4 +- README.md | 4 +- Resilion.sln | 17 ++++++ docs/architecture.md | 4 +- docs/cancellation.md | 2 +- docs/circuit-breaker.md | 2 +- docs/custom-strategies.md | 6 +- docs/fallback.md | 9 ++- docs/future-plans.md | 1 + docs/hedging.md | 2 +- docs/installation.md | 6 +- docs/pipelines.md | 2 +- docs/rate-limiting.md | 6 +- docs/telemetry.md | 2 +- docs/troubleshooting.md | 17 +++++- src/Directory.Build.props | 2 +- .../ResiliencePipelineRegistry.cs | 57 +++++++++++-------- .../ResilionServiceCollectionExtensions.cs | 4 +- .../CircuitBreaker/CircuitBreakerStrategy.cs | 32 +++++++---- .../CircuitBreakerTypedStrategy.cs | 40 +++++++++---- src/Resilion/Hedging/HedgingStrategy.cs | 4 +- src/Resilion/Internal/PipelineComponent.cs | 12 +++- src/Resilion/Timeout/TimeoutStrategy.cs | 18 ++++-- tests/Directory.Build.props | 6 +- .../Hedging/HedgingStrategyTests.cs | 26 +++++---- 29 files changed, 216 insertions(+), 105 deletions(-) diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md index 28b263c..1d3af10 100644 --- a/.github/ISSUE_TEMPLATE/bug_report.md +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -24,13 +24,14 @@ A clear description of what the bug is. ```csharp var pipeline = Pipeline.Create(builder => builder - .AddRetry(new RetryOptions { MaxAttempts = 3 }) + .AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 3 }) .AddTimeout(TimeSpan.FromSeconds(10))); -await pipeline.ExecuteAsync(async ct => +await pipeline.ExecuteAsync(async (state, ct) => { // Your operation here -}, cancellationToken); + return null; +}, (object?)null, CancellationToken.None); ``` **Expected behavior** diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e85d277..db34b3e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -15,6 +15,8 @@ jobs: steps: - uses: actions/checkout@v4 + with: + persist-credentials: false - name: Setup .NET uses: actions/setup-dotnet@v4 diff --git a/.github/workflows/release-nuget.yml b/.github/workflows/release-nuget.yml index 7680587..6010fe1 100644 --- a/.github/workflows/release-nuget.yml +++ b/.github/workflows/release-nuget.yml @@ -33,19 +33,28 @@ jobs: id: get_version run: | VERSION="${GITHUB_REF_NAME#v}" + # Validate SemVer format (basic check for X.Y.Z or X.Y.Z-prerelease) + if ! [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9]+)?$ ]]; then + echo "Invalid version format: $VERSION" + exit 1 + fi echo "version_without_v=$VERSION" >> "$GITHUB_OUTPUT" - name: Build - run: dotnet build -c Release -p:Version=${{ steps.get_version.outputs.version_without_v }} + env: + VERSION: ${{ steps.get_version.outputs.version_without_v }} + run: dotnet build -c Release -p:Version="${VERSION}" - name: Test run: dotnet test -c Release --no-build - name: Pack NuGet packages + env: + VERSION: ${{ steps.get_version.outputs.version_without_v }} run: | - dotnet pack src/Resilion/Resilion.csproj -c Release --no-build -p:Version=${{ steps.get_version.outputs.version_without_v }} - dotnet pack src/Resilion.Extensions/Resilion.Extensions.csproj -c Release --no-build -p:Version=${{ steps.get_version.outputs.version_without_v }} - dotnet pack src/Resilion.RateLimiting/Resilion.RateLimiting.csproj -c Release --no-build -p:Version=${{ steps.get_version.outputs.version_without_v }} + dotnet pack src/Resilion/Resilion.csproj -c Release --no-build -p:Version="${VERSION}" + dotnet pack src/Resilion.Extensions/Resilion.Extensions.csproj -c Release --no-build -p:Version="${VERSION}" + dotnet pack src/Resilion.RateLimiting/Resilion.RateLimiting.csproj -c Release --no-build -p:Version="${VERSION}" - name: NuGet login (OIDC - trusted publishing) id: login diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index dcae0e4..b0b37a6 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,11 +1,7 @@ name: test -run-name: '[Test] ${{ github.event.head_commit.message || github.event.pull_request.title || github.event.workflow_run.display_title || github.ref_name }}' +run-name: '[Test] ${{ github.event.head_commit.message || github.event.pull_request.title || github.ref_name }}' on: - workflow_run: - workflows: ["CI"] - types: - - completed pull_request: branches: - "*" @@ -25,14 +21,10 @@ env: jobs: test: runs-on: ubuntu-latest - if: | - (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success') || - (github.event_name != 'workflow_run') steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - ref: ${{ github.event_name == 'workflow_run' && github.event.workflow_run.head_sha || github.sha }} - name: Setup .NET uses: actions/setup-dotnet@v4 diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b8ef782..08c93ca 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -10,7 +10,7 @@ Thank you for your interest in contributing to Resilion! ### Local Setup -```bash +```text git clone https://github.com/FreakyAli/Resilion.git cd Resilion dotnet restore @@ -19,7 +19,7 @@ dotnet build ## Project Structure -``` +```text src/ Resilion/ Core library (zero dependencies) Resilion.Extensions/ DI, logging, telemetry integration diff --git a/README.md b/README.md index 50f6d0d..3d5b08f 100644 --- a/README.md +++ b/README.md @@ -25,6 +25,8 @@ var pipeline = Pipeline.Create(b => b }) .AddTimeout(TimeSpan.FromSeconds(5))); +var httpClient = new HttpClient(); + var result = await pipeline.ExecuteAsync( static (client, ct) => client.GetStringAsync("https://api.example.com/data", ct), httpClient); @@ -166,7 +168,7 @@ var pipeline = registry.GetPipeline("my-pipeline"); ## Project Structure -``` +```text src/ Resilion/ Core library (zero dependencies) Resilion.Extensions/ DI, logging, telemetry integration diff --git a/Resilion.sln b/Resilion.sln index 9a26e22..d777650 100644 --- a/Resilion.sln +++ b/Resilion.sln @@ -21,6 +21,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{5D20 EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Resilion.Samples", "samples\Resilion.Samples\Resilion.Samples.csproj", "{65299870-8203-4726-B350-B4C85586D162}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "benchmarks", "benchmarks", "{9C7D7E4D-8F4E-4B5A-9E6D-1F8C3B2A5D6E}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Resilion.Benchmarks", "benchmarks\Resilion.Benchmarks\Resilion.Benchmarks.csproj", "{7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -103,6 +107,18 @@ Global {65299870-8203-4726-B350-B4C85586D162}.Release|x64.Build.0 = Release|Any CPU {65299870-8203-4726-B350-B4C85586D162}.Release|x86.ActiveCfg = Release|Any CPU {65299870-8203-4726-B350-B4C85586D162}.Release|x86.Build.0 = Release|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Debug|x64.ActiveCfg = Debug|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Debug|x64.Build.0 = Debug|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Debug|x86.ActiveCfg = Debug|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Debug|x86.Build.0 = Debug|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Release|Any CPU.Build.0 = Release|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Release|x64.ActiveCfg = Release|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Release|x64.Build.0 = Release|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Release|x86.ActiveCfg = Release|Any CPU + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -114,5 +130,6 @@ Global {7C800530-ADA9-48CF-95B0-2E4ECF7A5041} = {0AB3BF05-4346-4AA6-1389-037BE0695223} {A0EC64D8-078D-43A7-AA73-74AF5319CABB} = {0AB3BF05-4346-4AA6-1389-037BE0695223} {65299870-8203-4726-B350-B4C85586D162} = {5D20AA90-6969-D8BD-9DCD-8634F4692FDA} + {7A9E5C6B-4D3F-4E2B-1F5D-8C7B6A9E4D3C} = {9C7D7E4D-8F4E-4B5A-9E6D-1F8C3B2A5D6E} EndGlobalSection EndGlobal diff --git a/docs/architecture.md b/docs/architecture.md index 2922b8d..406be6e 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -69,7 +69,7 @@ public abstract class Strategy At `Build()` time, strategies are compiled into a linked chain of internal `PipelineComponent` objects. No allocation per call for the chain structure itself. -``` +```text Pipeline.ExecuteAsync(userAction, cancellationToken) │ ▼ @@ -92,7 +92,7 @@ Return ResilienceContext to pool First added = outermost. Canonical order: -``` +```text RateLimiter → TotalTimeout → Retry → CircuitBreaker → AttemptTimeout → UserCode ``` diff --git a/docs/cancellation.md b/docs/cancellation.md index f13764c..c3cae32 100644 --- a/docs/cancellation.md +++ b/docs/cancellation.md @@ -10,7 +10,7 @@ This is the single most important cancellation guarantee. ## Token flow -``` +```text User provides CancellationToken │ Pipeline sets context.CancellationToken = userToken diff --git a/docs/circuit-breaker.md b/docs/circuit-breaker.md index 4249dce..e02221e 100644 --- a/docs/circuit-breaker.md +++ b/docs/circuit-breaker.md @@ -40,7 +40,7 @@ catch (CircuitBrokenException ex) ## State machine -``` +```text ┌─────────┐ failure ratio exceeded ┌──────┐ │ Closed │ ────────────────────────▸ │ Open │ │ (normal)│ │(reject) diff --git a/docs/custom-strategies.md b/docs/custom-strategies.md index 22afcb2..adfe882 100644 --- a/docs/custom-strategies.md +++ b/docs/custom-strategies.md @@ -46,7 +46,7 @@ public sealed class LoggingStrategy : Strategy public LoggingStrategy(ILogger logger) => _logger = logger; - protected internal override async ValueTask> ExecuteAsync( + protected override async ValueTask> ExecuteAsync( Func>> callback, ResilienceContext context) { @@ -62,7 +62,7 @@ public sealed class LoggingStrategy : Strategy } // Optional: override for true sync support - protected internal override Outcome Execute( + protected override Outcome Execute( Func> callback, ResilienceContext context) { @@ -96,7 +96,7 @@ public sealed class CachingStrategy : Strategy public CachingStrategy(ICache cache) => _cache = cache; - protected internal override async ValueTask> ExecuteAsync( + protected override async ValueTask> ExecuteAsync( Func>> callback, ResilienceContext context) { diff --git a/docs/fallback.md b/docs/fallback.md index 4b4a173..483cf9d 100644 --- a/docs/fallback.md +++ b/docs/fallback.md @@ -75,8 +75,13 @@ Fallback requires `Pipeline` because it must produce a substitute value When fallback activates, the original exception is swallowed. The fallback result is returned as if the operation succeeded. If you need to log the original error, use `OnFallback`: ```csharp -Action> onFallback = e => - logger.LogWarning(e.Outcome.Exception, "Fallback activated, returning {Result}", e.FallbackResult); +var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = "cached-value", + OnFallback = e => + logger.LogWarning(e.Outcome.Exception, "Fallback activated, returning {Result}", e.FallbackResult), + })); ``` ## Fallback factory that throws diff --git a/docs/future-plans.md b/docs/future-plans.md index 5b39154..981964b 100644 --- a/docs/future-plans.md +++ b/docs/future-plans.md @@ -30,6 +30,7 @@ Features, improvements, and known tradeoffs under consideration for future versi | 19 | **Hedging sync path shares context across attempts** | **P1** | Fix | Medium | Low | Sync `Execute` reuses same ResilienceContext for all sequential attempts — inner strategies see stale Properties | | 20 | Hedging `ResolveAction` missing `Task.Run` wrapper | P1 | Fix | Medium | Low | Sync path deadlock risk when ActionGenerator returns async action | | 21 | Registry `GetOrAdd` race leaks undisposed Pipelines | P1 | Fix | Medium | Low | Concurrent first-access creates N pipelines, discards N-1 without Dispose | +| 22 | Hedging latency-mode: Double WhenAny + stale task | P2 | Fix | Medium | Medium | Completed task stays in list, second WhenAny may return wrong task, wastes cycles | | 34 | **Hedging latency-mode: completed task bypasses delay for all subsequent attempts** | **P1** | Fix | High | Medium | Failed task stays in attempts list, `Task.WhenAny` resolves immediately on every subsequent iteration, all hedges launch in burst instead of staggered | | 23 | Interlocked.Increment under lock in SlidingWindow | P2 | Fix | Low | Low | Wasted memory barrier — plain `++` under lock is correct and cheaper | | 24 | Double lock acquisition per CB Closed-state call | P2 | Fix | Medium | Low | RecordSuccess + GetFailureRatio each acquire SlidingWindow lock separately | diff --git a/docs/hedging.md b/docs/hedging.md index fb43e7f..0b5f054 100644 --- a/docs/hedging.md +++ b/docs/hedging.md @@ -1,6 +1,6 @@ # Hedging -Reduces tail latency by racing concurrent attempts. When the primary request is slow, a secondary fires. Whichever completes first wins. +Reduces tail latency by racing concurrent attempts. When the primary request is slow, a secondary fires. Unhandled outcomes (success) complete the operation immediately. Handled outcomes (failures) trigger further attempts, and if all are handled, the last handled outcome is returned. ## Basic usage diff --git a/docs/installation.md b/docs/installation.md index fa0e7ed..e5a0648 100644 --- a/docs/installation.md +++ b/docs/installation.md @@ -20,13 +20,15 @@ This gives you retry, circuit breaker, timeout, fallback, and hedging — zero e |---------|----------------| | `Resilion` | Always — core library with all built-in strategies, zero dependencies | | `Resilion.RateLimiting` | When you need rate limiting (wraps `System.Threading.RateLimiting`) | -| `Resilion.Extensions` | When you use DI (`IServiceCollection`) or want OpenTelemetry metrics | +| `Resilion.Extensions` | When you use DI (`IServiceCollection`) for dependency injection | + +> **OpenTelemetry metrics**: The `ResilionTelemetry` meter is defined in the core `Resilion` package and can be consumed independently. The `Resilion.Extensions` package provides convenient integration with `IServiceCollection` for DI-based registration. --- ## Dependency graph -``` +```text Resilion (zero dependencies) ↑ ├── Resilion.Extensions (+ Microsoft.Extensions.*) diff --git a/docs/pipelines.md b/docs/pipelines.md index 3b8e3a7..4afeccf 100644 --- a/docs/pipelines.md +++ b/docs/pipelines.md @@ -68,7 +68,7 @@ var combined = Pipeline.Create(b => b .AddPipeline(retryPolicy)); // Retry innermost ``` -`AddPipeline` flattens the source pipeline's strategies into the current builder. No nesting — the composed pipeline behaves identically to one built inline. +`AddPipeline` stores the source pipeline as a delegated component using delegated composition. It records `StrategyType.Custom` rather than flattening inner strategies. The inner strategies remain encapsulated and are not individually visible to ordering validators or strategy introspection. ## Empty pipelines diff --git a/docs/rate-limiting.md b/docs/rate-limiting.md index 327f3e4..a147b63 100644 --- a/docs/rate-limiting.md +++ b/docs/rate-limiting.md @@ -73,18 +73,20 @@ The strategy does NOT own the `RateLimiter`. You (or your DI container) are resp ## RetryAfter -When the rate limiter provides `RetryAfter` metadata (e.g., `TokenBucketRateLimiter`), it's included in `RateLimitRejectedException.RetryAfter`. Combine with Retry to automatically wait: +When the rate limiter provides `RetryAfter` metadata (e.g., `TokenBucketRateLimiter`), it's included in `RateLimitRejectedException.RetryAfter`. Combine with Retry with a fixed delay strategy: ```csharp var pipeline = Pipeline.Create(b => b .AddRetry(new RetryStrategyOptions { ShouldHandle = ex => ex is RateLimitRejectedException, - Delay = RetryDelay.Custom(ctx => TimeSpan.FromSeconds(1)), // or use RetryAfter + Delay = RetryDelay.Custom(ctx => TimeSpan.FromSeconds(1)), // Fixed one-second retry delay }) .AddRateLimiter(new RateLimiterStrategyOptions { RateLimiter = limiter })); ``` +Note: The retry delay is fixed at 1 second in this example. To use `RateLimitRejectedException.RetryAfter` dynamically, implement custom retry logic or extend the retry strategy. + ## Sync execution The sync path uses `AttemptAcquire` (non-blocking). If the limiter supports queueing (`QueueLimit > 0`), the sync path cannot wait in the queue — it only attempts immediate acquisition. diff --git a/docs/telemetry.md b/docs/telemetry.md index 09fae37..7be9179 100644 --- a/docs/telemetry.md +++ b/docs/telemetry.md @@ -46,7 +46,7 @@ listener.Start(); ## Zero-cost when unused -`Counter.Add(1)` is a no-op at the runtime level when no `MeterListener` is subscribed. No allocation, no work. Metrics only become active when something listens. +After initialization, `Counter.Add(1)` is a no-op at the runtime level when no `MeterListener` is subscribed. No allocation, no work during the metric recording path. Note: `ResilionTelemetry` eagerly allocates the `Meter`, `ActivitySource`, and measurement instruments at startup. Metrics only become active when something listens. ## Strategy callbacks vs metrics diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md index 850c08d..cb38445 100644 --- a/docs/troubleshooting.md +++ b/docs/troubleshooting.md @@ -71,9 +71,22 @@ To force-close: use `CircuitBreakerManualControl.ResetAsync()`. **Problem**: `KeyNotFoundException` when resolving from `ResiliencePipelineRegistry`. -**Cause**: Pipeline configurations registered via `AddResiliencePipeline` need to be applied to the registry. +**Cause**: Pipeline configurations registered via `AddResiliencePipeline` need to be applied to the registry before accessing it. -**Fix**: Call `ResilionServiceCollectionExtensions.BuildRegistry(serviceProvider)` after building the service provider, or resolve the registry after all registrations are complete. +**Fix**: When you resolve `ResiliencePipelineRegistry` from the service provider, all registered `IPipelineConfigurator` services are automatically applied (as of the latest version). If you need explicit control, call `ResilionServiceCollectionExtensions.BuildRegistry(serviceProvider)` to ensure all configurators are processed: + +```csharp +var services = new ServiceCollection(); +services.AddResiliencePipeline("my-pipeline", b => b.AddRetry(...)); +var sp = services.BuildServiceProvider(); + +// Automatic: registry is built and configured when resolved +var registry = sp.GetRequiredService>(); +var pipeline = registry.GetPipeline("my-pipeline"); // Works! + +// Or explicit (if needed): +var builtRegistry = ResilionServiceCollectionExtensions.BuildRegistry(sp); +``` --- diff --git a/src/Directory.Build.props b/src/Directory.Build.props index a1833fc..c047855 100644 --- a/src/Directory.Build.props +++ b/src/Directory.Build.props @@ -17,7 +17,7 @@ net9.0 - latest + 13.0 enable enable true diff --git a/src/Resilion.Extensions/ResiliencePipelineRegistry.cs b/src/Resilion.Extensions/ResiliencePipelineRegistry.cs index 0f1bc9a..746f043 100644 --- a/src/Resilion.Extensions/ResiliencePipelineRegistry.cs +++ b/src/Resilion.Extensions/ResiliencePipelineRegistry.cs @@ -10,8 +10,8 @@ namespace Resilion.Extensions; public sealed class ResiliencePipelineRegistry : IDisposable where TKey : notnull { - private readonly ConcurrentDictionary _pipelines = new(); - private readonly ConcurrentDictionary<(TKey, Type), object> _typedPipelines = new(); + private readonly ConcurrentDictionary> _pipelines = new(); + private readonly ConcurrentDictionary<(TKey, Type), Lazy> _typedPipelines = new(); private readonly ConcurrentDictionary> _factories = new(); private readonly ConcurrentDictionary<(TKey, Type), object> _typedFactories = new(); @@ -56,17 +56,22 @@ public void RegisterPipeline(TKey key, Action> /// No pipeline is registered with the specified key. public Pipeline GetPipeline(TKey key) { - return _pipelines.GetOrAdd(key, static (k, factories) => + var lazy = _pipelines.GetOrAdd(key, static (k, factories) => { - if (!factories.TryGetValue(k, out var factory)) + return new Lazy(() => { - throw new KeyNotFoundException($"No pipeline registered with key '{k}'."); - } + if (!factories.TryGetValue(k, out var factory)) + { + throw new KeyNotFoundException($"No pipeline registered with key '{k}'."); + } - var builder = new PipelineBuilder(); - factory(builder); - return builder.Build(); + var builder = new PipelineBuilder(); + factory(builder); + return builder.Build(); + }); }, _factories); + + return lazy.Value; } /// @@ -78,21 +83,24 @@ public Pipeline GetPipeline(TKey key) public Pipeline GetPipeline(TKey key) { var compositeKey = (key, typeof(TResult)); - var pipeline = _typedPipelines.GetOrAdd(compositeKey, static (k, state) => + var lazy = _typedPipelines.GetOrAdd(compositeKey, static (k, state) => { - if (!state.TryGetValue(k, out var factory)) + return new Lazy(() => { - throw new KeyNotFoundException( - $"No pipeline registered with key '{k.Item1}' and result type '{k.Item2.Name}'."); - } + if (!state.TryGetValue(k, out var factory)) + { + throw new KeyNotFoundException( + $"No pipeline registered with key '{k.Item1}' and result type '{k.Item2.Name}'."); + } - var configure = (Action>)factory; - var builder = new PipelineBuilder(); - configure(builder); - return builder.Build(); + var configure = (Action>)factory; + var builder = new PipelineBuilder(); + configure(builder); + return (object)builder.Build(); + }); }, _typedFactories); - return (Pipeline)pipeline; + return (Pipeline)lazy.Value; } /// @@ -116,14 +124,17 @@ public bool TryGetPipeline(TKey key, out Pipeline? pipeline) /// public void Dispose() { - foreach (var pipeline in _pipelines.Values) + foreach (var lazy in _pipelines.Values) { - pipeline.Dispose(); + if (lazy.IsValueCreated) + { + lazy.Value.Dispose(); + } } - foreach (var pipeline in _typedPipelines.Values) + foreach (var lazy in _typedPipelines.Values) { - if (pipeline is IDisposable disposable) + if (lazy.IsValueCreated && lazy.Value is IDisposable disposable) { disposable.Dispose(); } diff --git a/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs b/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs index c046f63..48cb9e8 100644 --- a/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs +++ b/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs @@ -17,7 +17,7 @@ public static class ResilionServiceCollectionExtensions public static IServiceCollection AddResilion(this IServiceCollection services) { ArgumentNullException.ThrowIfNull(services); - services.TryAddSingleton>(); + services.TryAddSingleton>(sp => BuildRegistry(sp)); services.TryAddSingleton(ResilienceContextPool.Shared); return services; } @@ -33,7 +33,7 @@ public static IServiceCollection AddResilion(this IServiceCollection services) /// /// /// services.AddResiliencePipeline("my-pipeline", builder => builder - /// .AddRetry(new RetryOptions { MaxRetryAttempts = 3 }) + /// .AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 3 }) /// .AddTimeout(TimeSpan.FromSeconds(10))); /// /// // Resolve later: diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs b/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs index 93adfbc..4ab2bc6 100644 --- a/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs +++ b/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs @@ -39,11 +39,17 @@ protected internal override async ValueTask> ExecuteAsync.FromException(rejection); } - var outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); - - RecordOutcome(outcome.Exception, context); - - return outcome; + try + { + var outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + RecordOutcome(outcome.Exception, context); + return outcome; + } + catch (Exception ex) + { + RecordOutcome(ex, context); + throw; + } } protected internal override Outcome Execute( @@ -56,11 +62,17 @@ protected internal override Outcome Execute( return Outcome.FromException(rejection); } - var outcome = callback(context); - - RecordOutcome(outcome.Exception, context); - - return outcome; + try + { + var outcome = callback(context); + RecordOutcome(outcome.Exception, context); + return outcome; + } + catch (Exception ex) + { + RecordOutcome(ex, context); + throw; + } } private CircuitBrokenException? TryReject(ResilienceContext context) diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs b/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs index 7e19740..4e54c23 100644 --- a/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs +++ b/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs @@ -39,12 +39,20 @@ protected internal override async ValueTask> ExecuteAsync( return Outcome.FromException(rejection); } - var outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); - - var isFailure = _options.ShouldHandleOutcome(outcome); - RecordAndTransition(isFailure, context); - - return outcome; + try + { + var outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); + var isFailure = _options.ShouldHandleOutcome(outcome); + RecordAndTransition(isFailure, context); + return outcome; + } + catch (Exception ex) + { + var failureOutcome = Outcome.FromException(ex); + var isFailure = _options.ShouldHandleOutcome(failureOutcome); + RecordAndTransition(isFailure, context); + throw; + } } protected internal override Outcome Execute( @@ -57,12 +65,20 @@ protected internal override Outcome Execute( return Outcome.FromException(rejection); } - var outcome = callback(context); - - var isFailure = _options.ShouldHandleOutcome(outcome); - RecordAndTransition(isFailure, context); - - return outcome; + try + { + var outcome = callback(context); + var isFailure = _options.ShouldHandleOutcome(outcome); + RecordAndTransition(isFailure, context); + return outcome; + } + catch (Exception ex) + { + var failureOutcome = Outcome.FromException(ex); + var isFailure = _options.ShouldHandleOutcome(failureOutcome); + RecordAndTransition(isFailure, context); + throw; + } } private CircuitBrokenException? TryReject(ResilienceContext context) diff --git a/src/Resilion/Hedging/HedgingStrategy.cs b/src/Resilion/Hedging/HedgingStrategy.cs index 1ce8fcb..09f47b5 100644 --- a/src/Resilion/Hedging/HedgingStrategy.cs +++ b/src/Resilion/Hedging/HedgingStrategy.cs @@ -98,11 +98,13 @@ await handler.InvokeAsync(new OnHedgingEvent(attemptIndex, context)) } // Await all tasks to ensure resource cleanup (connections, streams, etc.). + // Use a bounded timeout to prevent indefinite hangs on non-cooperative tasks. + var cleanupTimeout = TimeSpan.FromSeconds(5); foreach (var task in attempts) { try { - await task.ConfigureAwait(false); + await Task.WhenAny(task, Task.Delay(cleanupTimeout)).ConfigureAwait(false); } catch { diff --git a/src/Resilion/Internal/PipelineComponent.cs b/src/Resilion/Internal/PipelineComponent.cs index 7961805..d4f6912 100644 --- a/src/Resilion/Internal/PipelineComponent.cs +++ b/src/Resilion/Internal/PipelineComponent.cs @@ -75,7 +75,11 @@ internal override Outcome Execute( context); } - public override void Dispose() => _strategy.Dispose(); + public override void Dispose() + { + _strategy.Dispose(); + _next.Dispose(); + } } /// @@ -155,5 +159,9 @@ private Outcome ExecuteTyped( Outcome>(ref result); } - public override void Dispose() => _strategy.Dispose(); + public override void Dispose() + { + _strategy.Dispose(); + _next.Dispose(); + } } diff --git a/src/Resilion/Timeout/TimeoutStrategy.cs b/src/Resilion/Timeout/TimeoutStrategy.cs index c47cc89..28f0cd9 100644 --- a/src/Resilion/Timeout/TimeoutStrategy.cs +++ b/src/Resilion/Timeout/TimeoutStrategy.cs @@ -40,16 +40,24 @@ protected internal override async ValueTask> ExecuteAsync(context, timeout, elapsed, oce).ConfigureAwait(false); + } + + return outcome; + } + catch (OperationCanceledException oce) when (WasCancelledByTimeout(linkedCts, previousToken)) { var elapsed = _timeProvider.GetElapsedTime(startTimestamp); return await HandleTimeout(context, timeout, elapsed, oce).ConfigureAwait(false); } - - return outcome; } finally { diff --git a/tests/Directory.Build.props b/tests/Directory.Build.props index 69043c9..83c022b 100644 --- a/tests/Directory.Build.props +++ b/tests/Directory.Build.props @@ -10,8 +10,10 @@ true true - $(NoWarn);xUnit1051 + where we deliberately control cancellation tokens + CS0162: Unreachable code — expected after assertions that always throw + CS0219: Variable assigned but never used — test helper variables --> + $(NoWarn);xUnit1051;CS0162;CS0219 diff --git a/tests/Resilion.Tests/Hedging/HedgingStrategyTests.cs b/tests/Resilion.Tests/Hedging/HedgingStrategyTests.cs index 6317713..45d8eb1 100644 --- a/tests/Resilion.Tests/Hedging/HedgingStrategyTests.cs +++ b/tests/Resilion.Tests/Hedging/HedgingStrategyTests.cs @@ -319,34 +319,40 @@ public async Task Properties_PropagatedToHedgedAttempts() try { - var callCount = 0; + var state = new HedgingPropertyTestState { CallCount = 0, OriginalContext = context, PropertyKey = propertyKey, CapturedValue = null }; var outcome = await pipeline.ExecuteOutcomeAsync( static (state, ctx) => { - var attempt = Interlocked.Increment(ref state.callCount); + var attempt = Interlocked.Increment(ref state.CallCount); if (attempt == 1) { return new ValueTask>( Outcome.FromException(new InvalidOperationException("fail"))); } - // Second attempt — check if properties were propagated. - state.ctx.Properties.TryGetValue(state.key, out var val); - state.captured = val; + // Second attempt — check if properties were propagated from the current attempt's context. + ctx.Properties.TryGetValue(state.PropertyKey, out var val); + state.CapturedValue = val; return new ValueTask>(Outcome.FromResult("ok")); }, - (callCount: 0, ctx: context, key: propertyKey, captured: (string?)null), + state, context); // The captured value should reflect what was set on the original context. - // Note: the hedging strategy creates a new context per attempt and copies properties. - // With ExecuteOutcomeAsync the user-provided context IS the original context, - // so the first attempt sees it directly. For the second (hedged) attempt, - // properties are copied. + // The hedging strategy creates a per-attempt context copy with properties copied from original. + Assert.Equal("propagated-value", state.CapturedValue); } finally { ResilienceContextPool.Shared.Return(context); } } + + private class HedgingPropertyTestState + { + public int CallCount; + public ResilienceContext OriginalContext = null!; + public ResiliencePropertyKey PropertyKey; + public string? CapturedValue; + } } From f6d3a12f0f6747126658e414a02cb88c8574e94f Mon Sep 17 00:00:00 2001 From: Ali-Tegna <31090457+FreakyAli@users.noreply.github.com> Date: Tue, 1 Sep 2026 23:30:13 +0530 Subject: [PATCH 4/9] fix: better formatting and detailing --- README.md | 304 +++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 264 insertions(+), 40 deletions(-) diff --git a/README.md b/README.md index 3d5b08f..c9d0db5 100644 --- a/README.md +++ b/README.md @@ -1,17 +1,20 @@ # Resilion -A modern resilience library for .NET. Retry, circuit breaker, timeout, fallback, rate limiting, hedging, and pipeline composition — with zero external dependencies in the core package. +**A modern resilience library for .NET.** Retry, circuit breaker, timeout, fallback, rate limiting, hedging, and pipeline composition — with zero external dependencies in the core package. [![CI](https://github.com/FreakyAli/Resilion/actions/workflows/ci.yml/badge.svg)](https://github.com/FreakyAli/Resilion/actions/workflows/ci.yml) [![Tests](https://github.com/FreakyAli/Resilion/actions/workflows/test.yml/badge.svg)](https://github.com/FreakyAli/Resilion/actions/workflows/test.yml) [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE) +[![NuGet](https://img.shields.io/nuget/v/Resilion.svg)](https://www.nuget.org/packages/Resilion) ## Quick Start ```csharp using Resilion; +// Create a resilience pipeline with multiple strategies var pipeline = Pipeline.Create(b => b + .AddRateLimiter(...) // 1. Shed load first .AddTimeout(TimeSpan.FromSeconds(30)) .AddRetry(new RetryStrategyOptions { @@ -25,47 +28,134 @@ var pipeline = Pipeline.Create(b => b }) .AddTimeout(TimeSpan.FromSeconds(5))); -var httpClient = new HttpClient(); - +// Execute with the pipeline var result = await pipeline.ExecuteAsync( - static (client, ct) => client.GetStringAsync("https://api.example.com/data", ct), - httpClient); + static (httpClient, ct) => httpClient.GetStringAsync("https://api.example.com/data", ct), + new HttpClient()); ``` ## Why Resilion? -Resilion is designed for experienced .NET developers who want: +Resilion is designed for experienced .NET developers who want powerful resilience patterns without complexity: + +### Zero Dependencies in Core +The `Resilion` package has **zero external dependencies**. Everything you need for production resilience is built-in. + +### Simple, Fluent API +One `Pipeline.Create()` call. Chain strategies. Build. That's it. No framework to learn, no builder patterns, no magic. + +```csharp +var pipeline = Pipeline.Create(b => b + .AddRetry(options) + .AddCircuitBreaker(options) + .AddTimeout(duration)); +``` + +### Sync and Async +Both `Execute` and `ExecuteAsync` with **true sync implementations** — not sync-over-async. No blocking calls, no artificial overhead. + +```csharp +// Synchronous execution +var result = pipeline.Execute(state => DoWork(state), httpClient); + +// Asynchronous execution +var result = await pipeline.ExecuteAsync(async (state, ct) => + await DoWorkAsync(state, ct), httpClient); +``` + +### Outcome-Based Resilience +No `PredicateBuilder` or `PredicateResult` chains. Just `Func, bool>`: + +```csharp +var pipeline = Pipeline.Create(b => b.AddRetry( + new RetryStrategyOptions + { + MaxRetryAttempts = 3, + ShouldHandle = outcome => + outcome.Exception is HttpRequestException // Handle exceptions + || (outcome.TryGetResult(out var r) && (int)r.StatusCode >= 500), // or result-based + })); +``` + +### Simple Callbacks +Assign callbacks directly. No `ValueTask` wrapping for synchronous logging: + +```csharp +new RetryStrategyOptions +{ + OnRetry = (context) => + { + logger.LogWarning($"Retry attempt {context.AttemptNumber}"); + } +} +``` + +### Composable Pipelines +Combine pre-built pipelines into larger ones: + +```csharp +var basePipeline = Pipeline.Create(b => b + .AddRetry(retryOptions) + .AddCircuitBreaker(cbOptions)); + +var fullPipeline = Pipeline.Create(b => b + .AddRateLimiter(rlOptions) + .AddPipeline(basePipeline)); +``` -- **Minimal API** — one `Pipeline.Create` call, chain strategies, `.Build()`. No framework to learn. -- **Zero-dependency core** — the `Resilion` package has no external dependencies. -- **Sync and async** — both `Execute` and `ExecuteAsync` with true sync implementations (not sync-over-async). -- **Simple predicates** — `Func, bool>` instead of Polly's `PredicateBuilder` + `PredicateResult.True` + `ValueTask`. -- **Simple callbacks** — assign an `Action` directly; no `ValueTask` wrapping for synchronous logging. -- **Composable pipelines** — combine pre-built pipelines with `AddPipeline()`. -- **Allocation-conscious** — `Outcome` is a struct, `ResilienceContext` is pooled, state parameters avoid closures. +### Allocation-Conscious Design +- `Outcome` is a struct +- `ResilienceContext` is pooled +- State parameters avoid closures +- Designed for performance-critical paths -## Packages +## Installation + +### Core Package +```bash +dotnet add package Resilion +``` + +### With Dependency Injection & Telemetry +```bash +dotnet add package Resilion.Extensions +``` + +### Rate Limiting Strategy +```bash +dotnet add package Resilion.RateLimiting +``` + +## Packages & Dependencies | Package | Purpose | Dependencies | |---------|---------|-------------| | **Resilion** | Core library with all built-in strategies | None | -| **Resilion.Extensions** | DI registration, telemetry (Meter/ActivitySource) | Microsoft.Extensions.* | -| **Resilion.RateLimiting** | Rate limiting strategy | System.Threading.RateLimiting | +| **Resilion.Extensions** | DI registration, telemetry (Meter/ActivitySource), structured logging | Microsoft.Extensions.* | +| **Resilion.RateLimiting** | Rate limiting strategy with multiple algorithms | System.Threading.RateLimiting | ## Strategies ### Retry +Automatically retry failed operations with customizable delay strategies. + ```csharp var pipeline = Pipeline.Create(b => b.AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 3, - Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), // or Constant, Linear, Custom + Delay = RetryDelay.Exponential(TimeSpan.FromSeconds(1)), UseJitter = true, // Decorrelated jitter (on by default) })); ``` -Result-based retry on typed pipelines: +**Delay Strategies:** +- `Exponential` — Exponential backoff: 1s, 2s, 4s, 8s, ... +- `Linear` — Linear backoff: 1s, 2s, 3s, 4s, ... +- `Constant` — Fixed delay between retries +- `Custom` — Supply your own delay function + +**Result-Based Retry** on typed pipelines: ```csharp var pipeline = Pipeline.Create(b => b.AddRetry( @@ -79,111 +169,245 @@ var pipeline = Pipeline.Create(b => b.AddRetry( })); ``` +**Use when:** +- Calling unreliable remote services +- Handling transient failures (network glitches, temporary outages) +- Need to respect rate limits with backoff + ### Timeout +Enforce operation timeouts with cooperative cancellation. + ```csharp var pipeline = Pipeline.Create(b => b.AddTimeout(TimeSpan.FromSeconds(10))); ``` -Timeout uses cooperative cancellation. The operation must observe the `CancellationToken`. +**Key Points:** +- Uses `CancellationToken` — the operation must observe it +- Perfect for async I/O operations +- Can be stacked (total timeout + per-attempt timeout) + +**Use when:** +- Preventing indefinite hangs on remote calls +- Enforcing SLA boundaries +- Protecting against slow endpoints ### Circuit Breaker +Prevent cascading failures by stopping requests when failure rates are too high. + ```csharp var pipeline = Pipeline.Create(b => b.AddCircuitBreaker(new CircuitBreakerStrategyOptions { - FailureRatioThreshold = 0.5, // Trip at 50% failure rate - MinimumThroughput = 10, // Need 10+ calls before evaluating + FailureRatioThreshold = 0.5, // Trip at 50% failure rate + MinimumThroughput = 10, // Need 10+ calls before evaluating SamplingDuration = TimeSpan.FromSeconds(30), BreakDuration = TimeSpan.FromSeconds(30), })); ``` +**States:** +- **Closed** — Normal operation, requests pass through +- **Open** — Too many failures, requests rejected immediately +- **Half-Open** — Testing if service has recovered + +**Use when:** +- Protecting against cascading failures +- Integrating with dependent services +- Need fast-fail when a service is down + ### Fallback +Provide a fallback value or action when operations fail. + ```csharp var pipeline = Pipeline.Create(b => b.AddFallback( new FallbackStrategyOptions { - FallbackAction = "default-value", // or a Func, or an async Func + FallbackAction = "default-value", // Static value + })); + +// Or with a function: +var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackAction = (context) => GetCachedValue() ?? "default", + })); + +// Or async: +var pipeline = Pipeline.Create(b => b.AddFallback( + new FallbackStrategyOptions + { + FallbackActionAsync = async (context, ct) => + await GetCachedValueAsync(ct) ?? "default", })); ``` +**Use when:** +- You have a sensible default to return +- Calling a secondary data source +- Providing degraded service instead of failure + ### Rate Limiting +Control request throughput to prevent overload. + ```csharp using Resilion.RateLimiting; var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions { PermitLimit = 10, - QueueLimit = 0, + QueueLimit = 0, // Reject excess requests }); var pipeline = Pipeline.Create(b => b.AddRateLimiter( new RateLimiterStrategyOptions { RateLimiter = limiter })); ``` +**Built-in Limiters:** +- `ConcurrencyLimiter` — Limit concurrent operations +- `TokenBucketRateLimiter` — Token bucket algorithm +- `SlidingWindowRateLimiter` — Sliding window rate limiting +- Custom implementations via `System.Threading.RateLimiting` + +**Use when:** +- Limiting load on a resource +- Protecting downstream services +- Controlling API consumption + ### Hedging +Send duplicate requests if the first one is slow, returning the fastest response. + ```csharp var pipeline = Pipeline.Create(b => b.AddHedging( new HedgingStrategyOptions { MaxHedgedAttempts = 3, - HedgingDelay = TimeSpan.FromSeconds(2), // 0 = parallel, InfiniteTimeSpan = sequential + HedgingDelay = TimeSpan.FromSeconds(2), })); ``` -## Strategy Ordering +**Hedging Delay:** +- `TimeSpan.Zero` — Fire all requests in parallel +- `TimeSpan.FromSeconds(2)` — Wait 2 seconds before sending next request +- `InfiniteTimeSpan` — Sequential requests (no hedging, just fallback) + +**Use when:** +- Reducing tail latency in latency-sensitive systems +- You can afford duplicate requests +- Calling idempotent endpoints -Strategies execute outermost to innermost. The canonical order: +## Strategy Ordering (Canonical Pipeline) + +Strategies execute **outermost to innermost**. The recommended order is: ```csharp Pipeline.Create(b => b - .AddRateLimiter(...) // 1. Shed load first + .AddRateLimiter(...) // 1. Shed load FIRST .AddTimeout(30s) // 2. Total timeout across all retries .AddRetry(...) // 3. Retry failures .AddCircuitBreaker(...) // 4. Track per-attempt success/failure .AddTimeout(5s)); // 5. Per-attempt timeout ``` +**Why this order?** +1. **Rate Limit** prevents the system from being overwhelmed +2. **Outer Timeout** sets a hard boundary for the entire operation +3. **Retry** gives transient failures a chance to succeed +4. **Circuit Breaker** protects downstream services and fast-fails when they're down +5. **Inner Timeout** per-request prevents individual attempts from hanging + +Different use cases may require different orderings — this is the safe default. + ## Dependency Injection +Register pipelines with Microsoft.Extensions.DependencyInjection: + ```csharp using Resilion.Extensions; -services.AddResiliencePipeline("my-pipeline", b => b +services.AddResiliencePipeline("http-api", b => b .AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 3 }) .AddTimeout(TimeSpan.FromSeconds(10))); -// Resolve: +// Later, resolve: var registry = serviceProvider.GetRequiredService>(); -var pipeline = registry.GetPipeline("my-pipeline"); +var pipeline = registry.GetPipeline("http-api"); + +var result = await pipeline.ExecuteAsync( + async (client, ct) => await client.GetStringAsync(url, ct), + httpClient); +``` + +## Telemetry + +Resilion integrates with `System.Diagnostics`: + +```csharp +// Metrics via System.Diagnostics.Metrics.Meter +var meter = new Meter("Resilion"); +var retryCount = meter.CreateCounter("resilion.retry.attempt_count"); + +// Activity tracking via ActivitySource +var activitySource = new ActivitySource("Resilion"); +using var activity = activitySource.StartActivity("pipeline.execute"); ``` +Structured logging is also available through callbacks on strategy options. + ## Supported .NET Versions -- .NET 9.0+ +- **.NET 9.0+** + +Resilion is built for modern .NET with full support for: +- Top-level statements +- Records and nullable reference types +- Async/await patterns +- Source generators (future features) ## Project Structure -```text +``` src/ - Resilion/ Core library (zero dependencies) - Resilion.Extensions/ DI, logging, telemetry integration - Resilion.RateLimiting/ Rate limiting strategy + Resilion/ Core library (zero dependencies) + Resilion.Extensions/ DI, telemetry, structured logging + Resilion.RateLimiting/ Rate limiting strategy tests/ - Resilion.Tests/ Core strategy and pipeline tests - Resilion.Extensions.Tests/ DI and telemetry tests + Resilion.Tests/ Core strategy and pipeline tests + Resilion.Extensions.Tests/ DI and telemetry tests benchmarks/ - Resilion.Benchmarks/ Performance benchmarks + Resilion.Benchmarks/ Performance benchmarks (BenchmarkDotNet) samples/ - Resilion.Samples/ Usage examples + Resilion.Samples/ Real-world usage examples docs/ - future-plans.md Roadmap and known tradeoffs + *.md Feature and architecture documentation ``` +## Performance + +Resilion is designed for high-performance, latency-sensitive scenarios: + +- Struct-based `Outcome` eliminates heap allocations +- Pooled `ResilienceContext` for request-scoped state +- Zero-allocation happy path for most strategies +- Benchmarks included (see `benchmarks/` folder) + +Compare with alternatives like Polly to see allocation profiles and throughput characteristics. + +## Contributing + +See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on: +- Code style and standards +- Testing requirements +- PR expectations +- Building and running tests locally + ## License [Apache-2.0](LICENSE) + +--- + +**Built for developers who care about reliability.** From eb2cb27fbfbb20b76cb2cc9fc3909b1b475b1208 Mon Sep 17 00:00:00 2001 From: Ali-Tegna <31090457+FreakyAli@users.noreply.github.com> Date: Wed, 2 Sep 2026 01:04:07 +0530 Subject: [PATCH 5/9] fix: .net 8 target --- README.md | 2 +- .../Resilion.Benchmarks/BenchmarkConfig.cs | 22 ++ .../RealWorldScenarioBenchmarks.cs | 208 ++++++++++++++++++ .../Resilion.Benchmarks.csproj | 2 +- global.json | 2 +- .../Resilion.Samples/Resilion.Samples.csproj | 2 +- src/Directory.Build.props | 4 +- .../Resilion.Extensions.csproj | 6 +- .../ResilionServiceCollectionExtensions.cs | 5 +- .../Resilion.RateLimiting.csproj | 2 +- .../CircuitBreaker/CircuitBreakerStrategy.cs | 128 ++++++++++- .../CircuitBreakerTypedStrategy.cs | 103 ++++++++- src/Resilion/CircuitBreaker/SlidingWindow.cs | 2 +- src/Resilion/ResilienceProperties.cs | 13 +- src/Resilion/Timeout/TimeoutStrategy.cs | 30 ++- tests/Directory.Build.props | 2 +- tests/Resilion.Tests/Resilion.Tests.csproj | 2 +- 17 files changed, 506 insertions(+), 29 deletions(-) create mode 100644 benchmarks/Resilion.Benchmarks/BenchmarkConfig.cs create mode 100644 benchmarks/Resilion.Benchmarks/RealWorldScenarioBenchmarks.cs diff --git a/README.md b/README.md index c9d0db5..745fbb6 100644 --- a/README.md +++ b/README.md @@ -359,7 +359,7 @@ Structured logging is also available through callbacks on strategy options. ## Supported .NET Versions -- **.NET 9.0+** +- **.NET 8.0+** Resilion is built for modern .NET with full support for: - Top-level statements diff --git a/benchmarks/Resilion.Benchmarks/BenchmarkConfig.cs b/benchmarks/Resilion.Benchmarks/BenchmarkConfig.cs new file mode 100644 index 0000000..1b1fcea --- /dev/null +++ b/benchmarks/Resilion.Benchmarks/BenchmarkConfig.cs @@ -0,0 +1,22 @@ +using BenchmarkDotNet.Configs; +using BenchmarkDotNet.Diagnosers; + +namespace Resilion.Benchmarks; + +/// +/// Shared configuration for all Resilion benchmarks. +/// Ensures consistent memory diagnostics across runs. +/// When built as multi-target (net8.0;net10.0), BenchmarkDotNet automatically +/// runs against each runtime. +/// +public class BenchmarkConfig : ManualConfig +{ + public BenchmarkConfig() + { + // Memory diagnostics to catch allocation regressions + AddDiagnoser(MemoryDiagnoser.Default); + + // Baseline for visual comparison + WithOption(ConfigOptions.DisableOptimizationsValidator, true); + } +} diff --git a/benchmarks/Resilion.Benchmarks/RealWorldScenarioBenchmarks.cs b/benchmarks/Resilion.Benchmarks/RealWorldScenarioBenchmarks.cs new file mode 100644 index 0000000..310287c --- /dev/null +++ b/benchmarks/Resilion.Benchmarks/RealWorldScenarioBenchmarks.cs @@ -0,0 +1,208 @@ +using BenchmarkDotNet.Attributes; +using Polly; + +namespace Resilion.Benchmarks; + +/// +/// Real-world scenario benchmarks comparing Resilion with Polly.Core. +/// Measures performance in realistic patterns: HTTP clients, database queries, hedging. +/// +[MemoryDiagnoser] +public class RealWorldScenarioBenchmarks +{ + private Resilion.Pipeline _resilionHttpClient = null!; + private Resilion.Pipeline _resilionDbQuery = null!; + private Resilion.Pipeline _resilionHedging = null!; + private ResiliencePipeline _pollyHttpClient = null!; + private ResiliencePipeline _pollyDbQuery = null!; + + [GlobalSetup] + public void Setup() + { + // ────── Resilion: HTTP Client Pattern (Timeout + Retry + Circuit Breaker) ────── + // Typical for: API calls, microservice communication + _resilionHttpClient = Resilion.Pipeline.Create(b => b + .AddTimeout(TimeSpan.FromSeconds(5)) + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 2, + Delay = RetryDelay.Exponential(TimeSpan.FromMilliseconds(100)), + }) + .AddCircuitBreaker(new CircuitBreakerStrategyOptions + { + FailureRatioThreshold = 0.25, + MinimumThroughput = 10, + SamplingDuration = TimeSpan.FromSeconds(5), + })); + + // ────── Resilion: Database Query Pattern (Timeout + Retry + Fallback) ────── + // Typical for: Database reads with cache fallback + _resilionDbQuery = Resilion.Pipeline.Create(b => b + .AddTimeout(TimeSpan.FromSeconds(10)) + .AddRetry(new RetryStrategyOptions + { + MaxRetryAttempts = 1, + Delay = RetryDelay.Linear(TimeSpan.FromMilliseconds(50)), + }) + .AddFallback(new FallbackStrategyOptions + { + FallbackAction = "CACHED_DEFAULT" + })); + + // ────── Resilion: Hedging Pattern (Parallel attempts, fail fast) ────── + // Typical for: Latency-sensitive operations, request fan-out + _resilionHedging = Resilion.Pipeline.Create(b => b + .AddTimeout(TimeSpan.FromSeconds(5)) + .AddHedging(new HedgingStrategyOptions + { + MaxHedgedAttempts = 2, + HedgingDelay = TimeSpan.FromMilliseconds(250), + })); + + // ────── Polly: HTTP Client Pattern ────── + _pollyHttpClient = new ResiliencePipelineBuilder() + .AddTimeout(TimeSpan.FromSeconds(5)) + .AddRetry(new Polly.Retry.RetryStrategyOptions + { + MaxRetryAttempts = 2, + Delay = TimeSpan.FromMilliseconds(100), + BackoffType = DelayBackoffType.Exponential, + }) + .AddCircuitBreaker(new Polly.CircuitBreaker.CircuitBreakerStrategyOptions + { + FailureRatio = 0.25, + MinimumThroughput = 10, + SamplingDuration = TimeSpan.FromSeconds(5), + }) + .Build(); + + // ────── Polly: Database Query Pattern ────── + _pollyDbQuery = new ResiliencePipelineBuilder() + .AddTimeout(TimeSpan.FromSeconds(10)) + .AddRetry(new Polly.Retry.RetryStrategyOptions + { + MaxRetryAttempts = 1, + Delay = TimeSpan.FromMilliseconds(50), + BackoffType = DelayBackoffType.Linear, + }) + .Build(); + } + + // ──────────────────────────────────────────────────────────── + // HTTP Client Pattern (API calls, microservice communication) + // ──────────────────────────────────────────────────────────── + + /// + /// Resilion: HTTP request happy path through timeout + retry + circuit breaker. + /// + [Benchmark] + public ValueTask Resilion_HttpClient_HappyPath() + { + return _resilionHttpClient.ExecuteAsync( + static (state, ct) => new ValueTask("OK"), + (object?)null); + } + + /// + /// Polly: HTTP request happy path through same pipeline. + /// + [Benchmark] + public ValueTask Polly_HttpClient_HappyPath() + { + return _pollyHttpClient.ExecuteAsync( + static (state, ct) => new ValueTask("OK"), + (object?)null); + } + + // ──────────────────────────────────────────────────────────── + // Database Query Pattern (read with fallback to cache) + // ──────────────────────────────────────────────────────────── + + /// + /// Resilion: Database query happy path through timeout + retry + fallback. + /// + [Benchmark] + public ValueTask Resilion_DbQuery_HappyPath() + { + return _resilionDbQuery.ExecuteAsync( + static (state, ct) => new ValueTask("user@example.com"), + (object?)null); + } + + /// + /// Polly: Database query happy path through same pipeline. + /// + [Benchmark] + public ValueTask Polly_DbQuery_HappyPath() + { + return _pollyDbQuery.ExecuteAsync( + static (state, ct) => new ValueTask("user@example.com"), + (object?)null); + } + + /// + /// Resilion: Database query triggers fallback (simulates failure). + /// + [Benchmark] + public ValueTask Resilion_DbQuery_WithFallback() + { + return _resilionDbQuery.ExecuteAsync( + static (state, ct) => throw new TimeoutException("DB timeout"), + (object?)null); + } + + + // ──────────────────────────────────────────────────────────── + // Hedging Pattern (parallel attempts for latency reduction) + // ──────────────────────────────────────────────────────────── + + /// + /// Resilion: Hedging fast path (first attempt succeeds quickly). + /// No benefit from hedging here, just overhead. + /// + [Benchmark] + public ValueTask Resilion_Hedging_FastResponse() + { + return _resilionHedging.ExecuteAsync( + static (state, ct) => new ValueTask("OK"), + (object?)null); + } + + // ──────────────────────────────────────────────────────────── + // Synchronous Execution (true sync, not sync-over-async) + // ──────────────────────────────────────────────────────────── + + /// + /// Resilion: Synchronous HTTP request (true blocking implementation). + /// Important for ASP.NET Framework, sync middleware, and backward compatibility. + /// + [Benchmark] + public string Resilion_HttpClient_Sync_HappyPath() + { + return _resilionHttpClient.Execute( + static (state, ct) => "OK", + (object?)null); + } + + /// + /// Resilion: Synchronous database query happy path. + /// + [Benchmark] + public string Resilion_DbQuery_Sync_HappyPath() + { + return _resilionDbQuery.Execute( + static (state, ct) => "user@example.com", + (object?)null); + } + + /// + /// Resilion: Synchronous database query with fallback triggered. + /// + [Benchmark] + public string Resilion_DbQuery_Sync_WithFallback() + { + return _resilionDbQuery.Execute( + static (state, ct) => throw new TimeoutException("DB timeout"), + (object?)null); + } +} diff --git a/benchmarks/Resilion.Benchmarks/Resilion.Benchmarks.csproj b/benchmarks/Resilion.Benchmarks/Resilion.Benchmarks.csproj index 1e33868..80311e7 100644 --- a/benchmarks/Resilion.Benchmarks/Resilion.Benchmarks.csproj +++ b/benchmarks/Resilion.Benchmarks/Resilion.Benchmarks.csproj @@ -2,7 +2,7 @@ Exe - net9.0 + net8.0;net10.0 latest enable enable diff --git a/global.json b/global.json index f657889..d07970a 100644 --- a/global.json +++ b/global.json @@ -1,6 +1,6 @@ { "sdk": { - "version": "9.0.100", + "version": "8.0.100", "rollForward": "latestMajor" } } diff --git a/samples/Resilion.Samples/Resilion.Samples.csproj b/samples/Resilion.Samples/Resilion.Samples.csproj index 9bfc003..4d72357 100644 --- a/samples/Resilion.Samples/Resilion.Samples.csproj +++ b/samples/Resilion.Samples/Resilion.Samples.csproj @@ -2,7 +2,7 @@ Exe - net9.0 + net8.0 latest enable enable diff --git a/src/Directory.Build.props b/src/Directory.Build.props index c047855..fcd822c 100644 --- a/src/Directory.Build.props +++ b/src/Directory.Build.props @@ -16,8 +16,8 @@ - net9.0 - 13.0 + net8.0 + 12.0 enable enable true diff --git a/src/Resilion.Extensions/Resilion.Extensions.csproj b/src/Resilion.Extensions/Resilion.Extensions.csproj index c7e8f27..c539d9f 100644 --- a/src/Resilion.Extensions/Resilion.Extensions.csproj +++ b/src/Resilion.Extensions/Resilion.Extensions.csproj @@ -17,9 +17,9 @@ - - - + + + diff --git a/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs b/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs index 48cb9e8..10cad18 100644 --- a/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs +++ b/src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs @@ -92,7 +92,10 @@ public static IServiceCollection AddResiliencePipeline( /// internal static ResiliencePipelineRegistry BuildRegistry(IServiceProvider sp) { - var registry = sp.GetRequiredService>(); + // Create a new registry instance (don't call GetRequiredService to avoid infinite recursion) + var registry = new ResiliencePipelineRegistry(); + + // Apply all registered pipeline configurations var configurators = sp.GetServices(); foreach (var configurator in configurators) { diff --git a/src/Resilion.RateLimiting/Resilion.RateLimiting.csproj b/src/Resilion.RateLimiting/Resilion.RateLimiting.csproj index b3b69dc..dd4c98d 100644 --- a/src/Resilion.RateLimiting/Resilion.RateLimiting.csproj +++ b/src/Resilion.RateLimiting/Resilion.RateLimiting.csproj @@ -12,7 +12,7 @@ - + diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs b/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs index 4ab2bc6..0fcb137 100644 --- a/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs +++ b/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs @@ -10,7 +10,7 @@ internal sealed class CircuitBreakerStrategy : Strategy private readonly CircuitBreakerStrategyOptions _options; private readonly TimeProvider _timeProvider; private readonly SlidingWindow _window; - private readonly Lock _lock = new(); + private readonly object _lock = new(); private volatile CircuitState _state = CircuitState.Closed; private long _openedAtTimestamp; @@ -33,7 +33,7 @@ protected internal override async ValueTask> ExecuteAsync>> callback, ResilienceContext context) { - var rejection = TryReject(context); + var rejection = await TryRejectAsync(context).ConfigureAwait(context.ContinueOnCapturedContext); if (rejection is not null) { return Outcome.FromException(rejection); @@ -42,12 +42,12 @@ protected internal override async ValueTask> ExecuteAsync TryRejectAsync(ResilienceContext context) + { + var rejection = TryReject(context); + if (rejection is not null) + { + return rejection; + } + + // Event was fired synchronously in TryReject. No async work needed. + return null; + } + + private async ValueTask RecordAndTransitionAsync(bool isFailure, ResilienceContext context) + { + var currentState = _state; + + switch (currentState) + { + case CircuitState.Closed: + if (isFailure) + { + _window.RecordFailure(); + } + else + { + _window.RecordSuccess(); + } + + var failureRatio = _window.GetFailureRatio(out var totalCount); + if (failureRatio >= _options.FailureRatioThreshold + && totalCount >= _options.MinimumThroughput) + { + CircuitStateChangedEvent? pendingEvent = null; + lock (_lock) + { + if (_state == CircuitState.Closed) + { + pendingEvent = Trip(context); + } + } + + await FireEventAsync(pendingEvent).ConfigureAwait(false); + } + + break; + + case CircuitState.HalfOpen: + CircuitStateChangedEvent? halfOpenEvent = null; + lock (_lock) + { + if (_state != CircuitState.HalfOpen) + { + return; + } + + if (isFailure) + { + halfOpenEvent = Trip(context); + } + else + { + _window.Reset(); + halfOpenEvent = TransitionTo(CircuitState.Closed, context); + } + } + + await FireEventAsync(halfOpenEvent).ConfigureAwait(false); + break; + } + } + + private async ValueTask FireEventAsync(CircuitStateChangedEvent? evt) + { + if (evt is null) + { + return; + } + + ResilionTelemetry.CircuitBreakerStateChanges.Add(1); + + var e = evt.Value; + switch (e.CurrentState) + { + case CircuitState.Open: + if (_options.OnOpened is { } onOpened && onOpened.HasHandler) + { + await onOpened.InvokeAsync(e).ConfigureAwait(false); + } + + break; + + case CircuitState.Closed: + if (_options.OnClosed is { } onClosed && onClosed.HasHandler) + { + await onClosed.InvokeAsync(e).ConfigureAwait(false); + } + + break; + + case CircuitState.HalfOpen: + if (_options.OnHalfOpened is { } onHalfOpened && onHalfOpened.HasHandler) + { + await onHalfOpened.InvokeAsync(e).ConfigureAwait(false); + } + + break; + } + } + private void RecordAndTransition(bool isFailure, ResilienceContext context) { var currentState = _state; diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs b/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs index 4e54c23..d4abff3 100644 --- a/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs +++ b/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs @@ -10,7 +10,7 @@ internal sealed class CircuitBreakerTypedStrategy : Strategy private readonly CircuitBreakerStrategyOptions _options; private readonly TimeProvider _timeProvider; private readonly SlidingWindow _window; - private readonly Lock _lock = new(); + private readonly object _lock = new(); private volatile CircuitState _state = CircuitState.Closed; private long _openedAtTimestamp; @@ -43,14 +43,14 @@ protected internal override async ValueTask> ExecuteAsync( { var outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); var isFailure = _options.ShouldHandleOutcome(outcome); - RecordAndTransition(isFailure, context); + await RecordAndTransitionAsync(isFailure, context).ConfigureAwait(context.ContinueOnCapturedContext); return outcome; } catch (Exception ex) { var failureOutcome = Outcome.FromException(ex); var isFailure = _options.ShouldHandleOutcome(failureOutcome); - RecordAndTransition(isFailure, context); + await RecordAndTransitionAsync(isFailure, context).ConfigureAwait(context.ContinueOnCapturedContext); throw; } } @@ -199,6 +199,103 @@ private void RecordAndTransition(bool isFailure, ResilienceContext context) } } + private async ValueTask RecordAndTransitionAsync(bool isFailure, ResilienceContext context) + { + var currentState = _state; + + switch (currentState) + { + case CircuitState.Closed: + if (isFailure) + { + _window.RecordFailure(); + } + else + { + _window.RecordSuccess(); + } + + var failureRatio = _window.GetFailureRatio(out var totalCount); + if (failureRatio >= _options.FailureRatioThreshold + && totalCount >= _options.MinimumThroughput) + { + CircuitStateChangedEvent? pendingEvent = null; + lock (_lock) + { + if (_state == CircuitState.Closed) + { + pendingEvent = Trip(context); + } + } + + await FireEventAsync(pendingEvent).ConfigureAwait(false); + } + + break; + + case CircuitState.HalfOpen: + CircuitStateChangedEvent? halfOpenEvent = null; + lock (_lock) + { + if (_state != CircuitState.HalfOpen) + { + return; + } + + if (isFailure) + { + halfOpenEvent = Trip(context); + } + else + { + _window.Reset(); + halfOpenEvent = TransitionTo(CircuitState.Closed, context); + } + } + + await FireEventAsync(halfOpenEvent).ConfigureAwait(false); + break; + } + } + + private async ValueTask FireEventAsync(CircuitStateChangedEvent? evt) + { + if (evt is null) + { + return; + } + + ResilionTelemetry.CircuitBreakerStateChanges.Add(1); + + var e = evt.Value; + switch (e.CurrentState) + { + case CircuitState.Open: + if (_options.OnOpened is { } onOpened && onOpened.HasHandler) + { + await onOpened.InvokeAsync(e).ConfigureAwait(false); + } + + break; + + case CircuitState.Closed: + if (_options.OnClosed is { } onClosed && onClosed.HasHandler) + { + await onClosed.InvokeAsync(e).ConfigureAwait(false); + } + + break; + + case CircuitState.HalfOpen: + if (_options.OnHalfOpened is { } onHalfOpened && onHalfOpened.HasHandler) + { + await onHalfOpened.InvokeAsync(e).ConfigureAwait(false); + } + + break; + } + } + /// /// Transitions to Open state. Must be called under lock. /// diff --git a/src/Resilion/CircuitBreaker/SlidingWindow.cs b/src/Resilion/CircuitBreaker/SlidingWindow.cs index b38d0b7..fd9f5f2 100644 --- a/src/Resilion/CircuitBreaker/SlidingWindow.cs +++ b/src/Resilion/CircuitBreaker/SlidingWindow.cs @@ -15,7 +15,7 @@ internal sealed class SlidingWindow private readonly Bucket[] _buckets; private readonly TimeSpan _bucketDuration; private readonly TimeProvider _timeProvider; - private readonly Lock _lock = new(); + private readonly object _lock = new(); private long _currentBucketStartTimestamp; private int _currentBucketIndex; diff --git a/src/Resilion/ResilienceProperties.cs b/src/Resilion/ResilienceProperties.cs index 815620e..04f0b3b 100644 --- a/src/Resilion/ResilienceProperties.cs +++ b/src/Resilion/ResilienceProperties.cs @@ -31,13 +31,17 @@ public void Set(ResiliencePropertyKey key, TValue value) /// The type of the value. /// The property key. /// When this method returns true, contains the value. - /// true if the property was found; false otherwise. + /// true if the property was found and is of the correct type; false otherwise. public bool TryGetValue(ResiliencePropertyKey key, out TValue? value) { if (_properties is not null && _properties.TryGetValue(key.Key, out var raw)) { - value = (TValue?)raw; - return true; + // Type-safe cast: return false if the stored value is not of the expected type + if (raw is TValue typed) + { + value = typed; + return true; + } } value = default; @@ -68,9 +72,6 @@ public bool Remove(ResiliencePropertyKey key) /// public int Count => _properties?.Count ?? 0; - /// - /// Removes all properties. - /// /// /// Removes all properties. /// diff --git a/src/Resilion/Timeout/TimeoutStrategy.cs b/src/Resilion/Timeout/TimeoutStrategy.cs index 28f0cd9..647925a 100644 --- a/src/Resilion/Timeout/TimeoutStrategy.cs +++ b/src/Resilion/Timeout/TimeoutStrategy.cs @@ -33,7 +33,20 @@ protected internal override async ValueTask> ExecuteAsync ((CancellationTokenSource)state!).Cancel(), + static state => + { + try + { + ((CancellationTokenSource)state!).Cancel(); + } + catch + { + // Suppress exceptions from timer callback to prevent process termination. + // CancellationTokenSource.Cancel() can throw if user cancellation callbacks throw. + // We can't log here safely on a thread pool timer thread, but the timeout has + // already been triggered via cancellation request, so suppressing is acceptable. + } + }, linkedCts, timeout, System.Threading.Timeout.InfiniteTimeSpan); @@ -91,7 +104,20 @@ protected internal override Outcome Execute( try { timer = _timeProvider.CreateTimer( - static state => ((CancellationTokenSource)state!).Cancel(), + static state => + { + try + { + ((CancellationTokenSource)state!).Cancel(); + } + catch + { + // Suppress exceptions from timer callback to prevent process termination. + // CancellationTokenSource.Cancel() can throw if user cancellation callbacks throw. + // We can't log here safely on a thread pool timer thread, but the timeout has + // already been triggered via cancellation request, so suppressing is acceptable. + } + }, linkedCts, timeout, System.Threading.Timeout.InfiniteTimeSpan); diff --git a/tests/Directory.Build.props b/tests/Directory.Build.props index 83c022b..62fdd25 100644 --- a/tests/Directory.Build.props +++ b/tests/Directory.Build.props @@ -1,7 +1,7 @@ - net9.0 + net8.0 Exe latest enable diff --git a/tests/Resilion.Tests/Resilion.Tests.csproj b/tests/Resilion.Tests/Resilion.Tests.csproj index 23d9dbf..d87f1f0 100644 --- a/tests/Resilion.Tests/Resilion.Tests.csproj +++ b/tests/Resilion.Tests/Resilion.Tests.csproj @@ -11,7 +11,7 @@ - + From a32911d20b02e99ea9a7add973a54c8d953ea8ed Mon Sep 17 00:00:00 2001 From: Ali-Tegna <31090457+FreakyAli@users.noreply.github.com> Date: Wed, 2 Sep 2026 08:44:45 +0530 Subject: [PATCH 6/9] doc: indepth docs --- .github/workflows/ci.yml | 3 +++ .github/workflows/release-nuget.yml | 4 +-- .github/workflows/test.yml | 1 + README.md | 10 ++++---- docs/cancellation.md | 6 ++--- docs/future-plans.md | 38 ----------------------------- docs/hedging.md | 2 +- docs/telemetry.md | 8 +++++- docs/tradeoffs.md | 6 ++--- docs/troubleshooting.md | 7 ++---- 10 files changed, 27 insertions(+), 58 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index db34b3e..004596d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -9,6 +9,9 @@ on: env: DOTNET_VERSION: '9.0.x' +permissions: + contents: read + jobs: build: runs-on: ubuntu-latest diff --git a/.github/workflows/release-nuget.yml b/.github/workflows/release-nuget.yml index 6010fe1..dc2d725 100644 --- a/.github/workflows/release-nuget.yml +++ b/.github/workflows/release-nuget.yml @@ -26,8 +26,8 @@ jobs: - name: Verify commit exists in origin/master run: | - git fetch --no-tags --prune --depth=1 origin +refs/heads/*:refs/remotes/origin/* - git branch --remote --contains | grep -q "origin/master" || { echo "Tag is not on origin/master. Aborting release."; exit 1; } + git fetch --no-tags --prune origin +refs/heads/*:refs/remotes/origin/* + git merge-base --is-ancestor origin/master HEAD || { echo "Tag is not on origin/master. Aborting release."; exit 1; } - name: Get version information from tag id: get_version diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index b0b37a6..d98c6ec 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -25,6 +25,7 @@ jobs: - uses: actions/checkout@v4 with: fetch-depth: 0 + persist-credentials: false - name: Setup .NET uses: actions/setup-dotnet@v4 diff --git a/README.md b/README.md index 745fbb6..9e8a7ca 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,6 @@ using Resilion; // Create a resilience pipeline with multiple strategies var pipeline = Pipeline.Create(b => b - .AddRateLimiter(...) // 1. Shed load first .AddTimeout(TimeSpan.FromSeconds(30)) .AddRetry(new RetryStrategyOptions { @@ -254,6 +253,7 @@ Control request throughput to prevent overload. ```csharp using Resilion.RateLimiting; +using System.Threading.RateLimiting; var limiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions { @@ -292,7 +292,7 @@ var pipeline = Pipeline.Create(b => b.AddHedging( **Hedging Delay:** - `TimeSpan.Zero` — Fire all requests in parallel - `TimeSpan.FromSeconds(2)` — Wait 2 seconds before sending next request -- `InfiniteTimeSpan` — Sequential requests (no hedging, just fallback) +- `System.Threading.Timeout.InfiniteTimeSpan` — Sequential requests (no hedging, just fallback) **Use when:** - Reducing tail latency in latency-sensitive systems @@ -306,10 +306,10 @@ Strategies execute **outermost to innermost**. The recommended order is: ```csharp Pipeline.Create(b => b .AddRateLimiter(...) // 1. Shed load FIRST - .AddTimeout(30s) // 2. Total timeout across all retries + .AddTimeout(TimeSpan.FromSeconds(30)) // 2. Total timeout across all retries .AddRetry(...) // 3. Retry failures .AddCircuitBreaker(...) // 4. Track per-attempt success/failure - .AddTimeout(5s)); // 5. Per-attempt timeout + .AddTimeout(TimeSpan.FromSeconds(5))); // 5. Per-attempt timeout ``` **Why this order?** @@ -369,7 +369,7 @@ Resilion is built for modern .NET with full support for: ## Project Structure -``` +```text src/ Resilion/ Core library (zero dependencies) Resilion.Extensions/ DI, telemetry, structured logging diff --git a/docs/cancellation.md b/docs/cancellation.md index c3cae32..aa57c55 100644 --- a/docs/cancellation.md +++ b/docs/cancellation.md @@ -4,9 +4,9 @@ How `CancellationToken` flows through Resilion pipelines and how each strategy i ## The rule -**If the user's original `CancellationToken` is canceled, `OperationCanceledException` propagates immediately. It is never retried, never counted as a circuit breaker failure, never caught by any strategy by default.** +**If the user's original `CancellationToken` is canceled after passing pre-execution strategy gates (e.g., circuit breaker state check), `OperationCanceledException` propagates immediately. It is never retried, never counted as a circuit breaker failure, never caught by any strategy by default. However, strategies that reject before execution (e.g., open circuit breaker) return their own exceptions (e.g., `CircuitBrokenException`) instead.** -This is the single most important cancellation guarantee. +This is the single most important cancellation guarantee for operations that reach the inner callback. ## Token flow @@ -62,7 +62,7 @@ Each Timeout strategy creates a linked `CancellationTokenSource`. The inner dele ### Hedging - Each attempt gets its own linked CTS - When one attempt wins, all other CTS instances cancel -- All cancelled tasks are awaited for resource cleanup +- Cancelled tasks are given a bounded cleanup wait of 5 seconds; tasks that do not cooperate with cancellation may continue running - User cancellation cancels all attempts simultaneously ## Timeout vs user cancellation diff --git a/docs/future-plans.md b/docs/future-plans.md index 981964b..1e9b1b2 100644 --- a/docs/future-plans.md +++ b/docs/future-plans.md @@ -247,44 +247,6 @@ Use `ObjectPool` with a custom policy that calls `TryRe --- -### 6. Pipeline Ordering Validation - -**Type:** Feature — Developer Experience - -**Why** - -Strategy ordering dramatically affects behavior. Common misorderings (Retry outside CircuitBreaker, missing per-attempt timeout) are a real source of bugs. Polly v8 has no validation. - -**Design** - -`Build()` performs heuristic validation and emits diagnostic warnings for patterns that are usually wrong: -- Retry outside CircuitBreaker (retries bypass the breaker) -- Fallback not outermost (unusual) -- Multiple Timeout strategies without one being outermost -- Hedging and Retry both present (may cause excessive load) - -Warnings, not errors. Suppressible via `builder.SuppressOrderingWarnings = true`. - ---- - -### 7. Benchmarks vs Polly - -**Type:** Infrastructure — Performance Validation - -**Why** - -Resilion claims to be high-performance. Without benchmarks, that's marketing. - -**Design** - -The benchmark project (`benchmarks/Resilion.Benchmarks/`) already exists. Add: -- Pipeline overhead (no-op vs direct call) -- Per-strategy happy path (no trigger) -- Allocation profile (`[MemoryDiagnoser]`) -- Polly.Core head-to-head comparison -- Composition depth scaling (1, 2, 3, 5 strategies) - ---- ### 11. Hedging: Task.WhenAny Memory Leak diff --git a/docs/hedging.md b/docs/hedging.md index 0b5f054..b3264f5 100644 --- a/docs/hedging.md +++ b/docs/hedging.md @@ -1,6 +1,6 @@ # Hedging -Reduces tail latency by racing concurrent attempts. When the primary request is slow, a secondary fires. Unhandled outcomes (success) complete the operation immediately. Handled outcomes (failures) trigger further attempts, and if all are handled, the last handled outcome is returned. +Reduces tail latency by racing concurrent attempts. When the primary request is slow, a secondary fires. Outcomes selected by `ShouldHandle` (typically failures) trigger further attempts. Unhandled outcomes complete the operation immediately. ## Basic usage diff --git a/docs/telemetry.md b/docs/telemetry.md index 7be9179..d90decb 100644 --- a/docs/telemetry.md +++ b/docs/telemetry.md @@ -20,7 +20,13 @@ All metrics are on the `"Resilion"` meter. ### dotnet-counters (CLI) ```bash -dotnet counters monitor --counters Resilion +dotnet counters monitor --name --counters Resilion +``` + +Or monitor by process ID: + +```bash +dotnet counters monitor --process-id --counters Resilion ``` ### OpenTelemetry diff --git a/docs/tradeoffs.md b/docs/tradeoffs.md index 091fab7..a91d6ba 100644 --- a/docs/tradeoffs.md +++ b/docs/tradeoffs.md @@ -32,11 +32,11 @@ When pipelines are composed via `AddPipeline()`, the `DelegatingComponent` does ## ResilienceContextPool cap is approximate -The pool size check (`_pool.Count < MaxPoolSize`) followed by `_pool.Add(context)` is a TOCTOU race — multiple threads can pass the check simultaneously and add, slightly exceeding the 256 cap. +The pool size check (`_pool.Count < MaxPoolSize`) followed by `_pool.Add(context)` is a TOCTOU race — concurrent `Return()` calls can overshoot `MaxPoolSize` unboundedly. The excess contexts are held in the `ConcurrentBag` and are never collected — `Rent` via `_pool.TryTake` is the only removal path. -**Why it's acceptable:** The cap is a heuristic, not a hard limit. Enforcing exactly 256 would require a lock or `Interlocked` on every return for zero practical benefit. Under burst traffic the pool might briefly hold 260-270 items; the excess is collected on the next GC. The alternative — `ConcurrentBag.Count` with exact enforcement — is worse because `Count` itself is expensive (see future-plans #25). +**Why it's acceptable:** The cap is a heuristic, not a hard limit. Enforcing exactly 256 would require a lock on every return for zero practical benefit. Under burst traffic the pool might grow beyond the target, but this is transient and trades memory for lock-free concurrent access. The contexts are small (~200 bytes) and in steady state the pool converges to size. The alternative — `ConcurrentBag.Count` with exact enforcement — is worse because `Count` itself is expensive (see future-plans #25). -**Watch for:** Don't rely on the pool being exactly 256 items or fewer. It's a soft cap. +**Watch for:** Don't rely on the pool being exactly 256 items or fewer. It's a soft cap. Under sustained traffic, the pool size may exceed the target. **Location:** [ResilienceContextPool.cs](../src/Resilion/ResilienceContextPool.cs) — `Return()` diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md index cb38445..eb237de 100644 --- a/docs/troubleshooting.md +++ b/docs/troubleshooting.md @@ -73,19 +73,16 @@ To force-close: use `CircuitBreakerManualControl.ResetAsync()`. **Cause**: Pipeline configurations registered via `AddResiliencePipeline` need to be applied to the registry before accessing it. -**Fix**: When you resolve `ResiliencePipelineRegistry` from the service provider, all registered `IPipelineConfigurator` services are automatically applied (as of the latest version). If you need explicit control, call `ResilionServiceCollectionExtensions.BuildRegistry(serviceProvider)` to ensure all configurators are processed: +**Fix**: When you resolve `ResiliencePipelineRegistry` from the service provider, all registered `IPipelineConfigurator` services are automatically applied: ```csharp var services = new ServiceCollection(); services.AddResiliencePipeline("my-pipeline", b => b.AddRetry(...)); var sp = services.BuildServiceProvider(); -// Automatic: registry is built and configured when resolved +// Registry is built and configured when resolved var registry = sp.GetRequiredService>(); var pipeline = registry.GetPipeline("my-pipeline"); // Works! - -// Or explicit (if needed): -var builtRegistry = ResilionServiceCollectionExtensions.BuildRegistry(sp); ``` --- From 2d37e35cc36b56caadb0c9822ae8679efca320ab Mon Sep 17 00:00:00 2001 From: Ali-Tegna <31090457+FreakyAli@users.noreply.github.com> Date: Wed, 2 Sep 2026 08:45:44 +0530 Subject: [PATCH 7/9] fix: circuit breaker related coderabbit bugs --- .../CircuitBreaker/CircuitBreakerStrategy.cs | 100 ++++-------------- .../CircuitBreakerTypedStrategy.cs | 93 ++++------------ src/Resilion/Hedging/HedgingStrategy.cs | 12 ++- src/Resilion/Retry/RetryDelay.cs | 7 +- 4 files changed, 56 insertions(+), 156 deletions(-) diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs b/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs index 0fcb137..755ba5f 100644 --- a/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs +++ b/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs @@ -33,7 +33,7 @@ protected internal override async ValueTask> ExecuteAsync>> callback, ResilienceContext context) { - var rejection = await TryRejectAsync(context).ConfigureAwait(context.ContinueOnCapturedContext); + var rejection = TryReject(context); if (rejection is not null) { return Outcome.FromException(rejection); @@ -146,24 +146,16 @@ private async ValueTask RecordOutcomeAsync(Exception? exception, ResilienceConte await RecordAndTransitionAsync(isFailure, context).ConfigureAwait(false); } - private CircuitBrokenException? TryRejectSync(ResilienceContext context) - { - return TryReject(context); - } - - private async ValueTask TryRejectAsync(ResilienceContext context) + private async ValueTask RecordAndTransitionAsync(bool isFailure, ResilienceContext context) { - var rejection = TryReject(context); - if (rejection is not null) + var pendingEvent = ComputeTransition(isFailure, context); + if (pendingEvent.HasValue) { - return rejection; + await FireEventAsync(pendingEvent.Value).ConfigureAwait(false); } - - // Event was fired synchronously in TryReject. No async work needed. - return null; } - private async ValueTask RecordAndTransitionAsync(bool isFailure, ResilienceContext context) + private CircuitStateChangedEvent? ComputeTransition(bool isFailure, ResilienceContext context) { var currentState = _state; @@ -183,42 +175,36 @@ private async ValueTask RecordAndTransitionAsync(bool isFailure, ResilienceConte if (failureRatio >= _options.FailureRatioThreshold && totalCount >= _options.MinimumThroughput) { - CircuitStateChangedEvent? pendingEvent = null; lock (_lock) { if (_state == CircuitState.Closed) { - pendingEvent = Trip(context); + return Trip(context); } } - - await FireEventAsync(pendingEvent).ConfigureAwait(false); } - break; + return null; case CircuitState.HalfOpen: - CircuitStateChangedEvent? halfOpenEvent = null; lock (_lock) { if (_state != CircuitState.HalfOpen) { - return; + return null; } if (isFailure) { - halfOpenEvent = Trip(context); - } - else - { - _window.Reset(); - halfOpenEvent = TransitionTo(CircuitState.Closed, context); + return Trip(context); } + + _window.Reset(); + return TransitionTo(CircuitState.Closed, context); } - await FireEventAsync(halfOpenEvent).ConfigureAwait(false); - break; + default: + return null; } } @@ -262,60 +248,10 @@ private async ValueTask FireEventAsync(CircuitStateChangedEvent? evt) private void RecordAndTransition(bool isFailure, ResilienceContext context) { - var currentState = _state; - - switch (currentState) + var pendingEvent = ComputeTransition(isFailure, context); + if (pendingEvent.HasValue) { - case CircuitState.Closed: - if (isFailure) - { - _window.RecordFailure(); - } - else - { - _window.RecordSuccess(); - } - - var failureRatio = _window.GetFailureRatio(out var totalCount); - if (failureRatio >= _options.FailureRatioThreshold - && totalCount >= _options.MinimumThroughput) - { - CircuitStateChangedEvent? pendingEvent = null; - lock (_lock) - { - if (_state == CircuitState.Closed) - { - pendingEvent = Trip(context); - } - } - - FireEvent(pendingEvent); - } - - break; - - case CircuitState.HalfOpen: - CircuitStateChangedEvent? halfOpenEvent = null; - lock (_lock) - { - if (_state != CircuitState.HalfOpen) - { - return; - } - - if (isFailure) - { - halfOpenEvent = Trip(context); - } - else - { - _window.Reset(); - halfOpenEvent = TransitionTo(CircuitState.Closed, context); - } - } - - FireEvent(halfOpenEvent); - break; + FireEvent(pendingEvent.Value); } } diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs b/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs index d4abff3..7be60c3 100644 --- a/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs +++ b/src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs @@ -43,14 +43,14 @@ protected internal override async ValueTask> ExecuteAsync( { var outcome = await callback(context).ConfigureAwait(context.ContinueOnCapturedContext); var isFailure = _options.ShouldHandleOutcome(outcome); - await RecordAndTransitionAsync(isFailure, context).ConfigureAwait(context.ContinueOnCapturedContext); + await ComputeAndFireTransitionAsync(isFailure, context).ConfigureAwait(context.ContinueOnCapturedContext); return outcome; } catch (Exception ex) { var failureOutcome = Outcome.FromException(ex); var isFailure = _options.ShouldHandleOutcome(failureOutcome); - await RecordAndTransitionAsync(isFailure, context).ConfigureAwait(context.ContinueOnCapturedContext); + await ComputeAndFireTransitionAsync(isFailure, context).ConfigureAwait(context.ContinueOnCapturedContext); throw; } } @@ -142,64 +142,23 @@ protected internal override Outcome Execute( private void RecordAndTransition(bool isFailure, ResilienceContext context) { - var currentState = _state; - - switch (currentState) + var pendingEvent = ComputeTransition(isFailure, context); + if (pendingEvent.HasValue) { - case CircuitState.Closed: - if (isFailure) - { - _window.RecordFailure(); - } - else - { - _window.RecordSuccess(); - } - - var failureRatio = _window.GetFailureRatio(out var totalCount); - if (failureRatio >= _options.FailureRatioThreshold - && totalCount >= _options.MinimumThroughput) - { - CircuitStateChangedEvent? pendingEvent = null; - lock (_lock) - { - if (_state == CircuitState.Closed) - { - pendingEvent = Trip(context); - } - } - - FireEvent(pendingEvent); - } - - break; - - case CircuitState.HalfOpen: - CircuitStateChangedEvent? halfOpenEvent = null; - lock (_lock) - { - if (_state != CircuitState.HalfOpen) - { - return; - } - - if (isFailure) - { - halfOpenEvent = Trip(context); - } - else - { - _window.Reset(); - halfOpenEvent = TransitionTo(CircuitState.Closed, context); - } - } + FireEvent(pendingEvent.Value); + } + } - FireEvent(halfOpenEvent); - break; + private async ValueTask ComputeAndFireTransitionAsync(bool isFailure, ResilienceContext context) + { + var pendingEvent = ComputeTransition(isFailure, context); + if (pendingEvent.HasValue) + { + await FireEventAsync(pendingEvent.Value).ConfigureAwait(false); } } - private async ValueTask RecordAndTransitionAsync(bool isFailure, ResilienceContext context) + private CircuitStateChangedEvent? ComputeTransition(bool isFailure, ResilienceContext context) { var currentState = _state; @@ -219,42 +178,36 @@ private async ValueTask RecordAndTransitionAsync(bool isFailure, ResilienceConte if (failureRatio >= _options.FailureRatioThreshold && totalCount >= _options.MinimumThroughput) { - CircuitStateChangedEvent? pendingEvent = null; lock (_lock) { if (_state == CircuitState.Closed) { - pendingEvent = Trip(context); + return Trip(context); } } - - await FireEventAsync(pendingEvent).ConfigureAwait(false); } - break; + return null; case CircuitState.HalfOpen: - CircuitStateChangedEvent? halfOpenEvent = null; lock (_lock) { if (_state != CircuitState.HalfOpen) { - return; + return null; } if (isFailure) { - halfOpenEvent = Trip(context); - } - else - { - _window.Reset(); - halfOpenEvent = TransitionTo(CircuitState.Closed, context); + return Trip(context); } + + _window.Reset(); + return TransitionTo(CircuitState.Closed, context); } - await FireEventAsync(halfOpenEvent).ConfigureAwait(false); - break; + default: + return null; } } diff --git a/src/Resilion/Hedging/HedgingStrategy.cs b/src/Resilion/Hedging/HedgingStrategy.cs index 09f47b5..f70afca 100644 --- a/src/Resilion/Hedging/HedgingStrategy.cs +++ b/src/Resilion/Hedging/HedgingStrategy.cs @@ -98,13 +98,21 @@ await handler.InvokeAsync(new OnHedgingEvent(attemptIndex, context)) } // Await all tasks to ensure resource cleanup (connections, streams, etc.). - // Use a bounded timeout to prevent indefinite hangs on non-cooperative tasks. + // Use a shared bounded deadline to prevent indefinite hangs on non-cooperative tasks. var cleanupTimeout = TimeSpan.FromSeconds(5); + var cleanupStart = _timeProvider.GetTimestamp(); foreach (var task in attempts) { try { - await Task.WhenAny(task, Task.Delay(cleanupTimeout)).ConfigureAwait(false); + var elapsed = _timeProvider.GetElapsedTime(cleanupStart); + var remaining = cleanupTimeout - elapsed; + if (remaining <= TimeSpan.Zero) + { + break; // Deadline expired; stop waiting. + } + + await Task.WhenAny(task, Task.Delay(remaining)).ConfigureAwait(false); } catch { diff --git a/src/Resilion/Retry/RetryDelay.cs b/src/Resilion/Retry/RetryDelay.cs index 986b450..7cb2fea 100644 --- a/src/Resilion/Retry/RetryDelay.cs +++ b/src/Resilion/Retry/RetryDelay.cs @@ -98,8 +98,11 @@ private sealed record LinearDelay(TimeSpan BaseDelay, TimeSpan? MaxDelay) : Retr { internal override TimeSpan ComputeDelay(int attemptNumber, bool useJitter) { - var delay = BaseDelay * attemptNumber; - delay = Clamp(delay, MaxDelay); + // Prevent overflow: clamp total milliseconds before constructing TimeSpan + var baseMs = BaseDelay.TotalMilliseconds; + var maxMs = MaxDelay?.TotalMilliseconds ?? double.MaxValue; + var delayMs = Math.Min(baseMs * attemptNumber, maxMs); + var delay = TimeSpan.FromMilliseconds(delayMs); return useJitter ? ApplyJitter(delay, MaxDelay) : delay; } } From df6bf45e9cffe58ddc135a89e88d9e0a5fd3fd3d Mon Sep 17 00:00:00 2001 From: Ali-Tegna <31090457+FreakyAli@users.noreply.github.com> Date: Wed, 2 Sep 2026 08:54:58 +0530 Subject: [PATCH 8/9] fix: circuit break, resilience and hedging --- docs/future-plans.md | 134 +----------------- .../ResiliencePipelineRegistry.cs | 30 ++-- .../CircuitBreakerManualControl.cs | 19 ++- src/Resilion/Hedging/HedgingStrategy.cs | 4 + 4 files changed, 36 insertions(+), 151 deletions(-) diff --git a/docs/future-plans.md b/docs/future-plans.md index 1e9b1b2..bff942c 100644 --- a/docs/future-plans.md +++ b/docs/future-plans.md @@ -21,17 +21,9 @@ Features, improvements, and known tradeoffs under consideration for future versi | # | Item | Priority | Type | Impact | Effort | Notes | |---|------|----------|------|--------|--------|-------| -| 15 | **DI configurators never applied to registry** | **P0** | Fix | Critical | Low | `AddResiliencePipeline` registers configurators but nothing applies them — users get KeyNotFoundException | -| 16 | **CB FireEvent sync-only on async path** | **P0** | Fix | High | Low | Circuit breaker event handlers always call `.Invoke()` even from `ExecuteAsync` — deadlocks with async handlers under SynchronizationContext | -| 17 | **ResilienceProperties TryGetValue throws on type mismatch** | **P0** | Fix | High | Low | Same string key + different type parameter causes `InvalidCastException` instead of returning false | -| 32 | **Timeout async path missing catch for direct OCE** | **P0** | Fix | High | Low | Inner strategy throws OCE directly (not via Outcome), async path doesn't catch — timeout leaks as raw OCE | -| 33 | **Timeout timer callback can crash process** | **P0** | Fix | Critical | Low | `CTS.Cancel()` in timer callback propagates `AggregateException` from user cancellation callbacks — unhandled on thread pool = process termination | -| 18 | **ManualControl non-atomic initialization** | **P1** | Fix | Medium | Low | `_onReset` set after CAS on `_onIsolate` — race window where Isolate works but Reset throws | | 19 | **Hedging sync path shares context across attempts** | **P1** | Fix | Medium | Low | Sync `Execute` reuses same ResilienceContext for all sequential attempts — inner strategies see stale Properties | | 20 | Hedging `ResolveAction` missing `Task.Run` wrapper | P1 | Fix | Medium | Low | Sync path deadlock risk when ActionGenerator returns async action | -| 21 | Registry `GetOrAdd` race leaks undisposed Pipelines | P1 | Fix | Medium | Low | Concurrent first-access creates N pipelines, discards N-1 without Dispose | | 22 | Hedging latency-mode: Double WhenAny + stale task | P2 | Fix | Medium | Medium | Completed task stays in list, second WhenAny may return wrong task, wastes cycles | -| 34 | **Hedging latency-mode: completed task bypasses delay for all subsequent attempts** | **P1** | Fix | High | Medium | Failed task stays in attempts list, `Task.WhenAny` resolves immediately on every subsequent iteration, all hedges launch in burst instead of staggered | | 23 | Interlocked.Increment under lock in SlidingWindow | P2 | Fix | Low | Low | Wasted memory barrier — plain `++` under lock is correct and cheaper | | 24 | Double lock acquisition per CB Closed-state call | P2 | Fix | Medium | Low | RecordSuccess + GetFailureRatio each acquire SlidingWindow lock separately | | 25 | ConcurrentBag.Count in pool Return | P2 | Fix | Medium | Low | `Count` enumerates all thread-local lists — use Interlocked counter | @@ -49,106 +41,12 @@ Features, improvements, and known tradeoffs under consideration for future versi | 30 | FallbackAction/ResilienceEventHandler Task.Run missing CancellationToken | P3 | Fix | Low | Low | Sync-over-async wrappers can't be interrupted by cancellation | | 31 | Duplicate XML doc on ResilienceProperties.Clear | P3 | Fix | Low | Low | Copy-paste leftover — orphaned summary block | -> **Completed (removed from backlog):** Solution structure, .editorconfig, global.json, CI workflows, Outcome\, ResilienceContext pooling, Strategy base types, Pipeline/PipelineBuilder, ResilienceEventHandler union struct, Timeout strategy, Retry strategy (with RetryDelay discriminated union), Circuit Breaker (sliding window, state machine, thread safety), Fallback (with FallbackAction implicit conversions), code review and fixes for 13 issues, Rate Limiter strategy (wrapping System.Threading.RateLimiting), Hedging strategy (parallel/latency/sequential modes, per-attempt CTS, cleanup-on-cancel), Pipeline ordering validation, Telemetry wired into all strategies, Docs (15 files), README, Samples, Benchmarks vs Polly, #6 Pipeline ordering validation, #7 Benchmarks, #8 README and docs, #13 Hedging Properties propagation (CopyFrom added). - ---- - -## P0 — Bugs (fix before any release) - -### 15. DI Configurators Never Applied to Registry - -**Type:** Fix — Critical correctness bug - -**Why** - -`AddResiliencePipeline("name", configure)` registers `IPipelineConfigurator` singletons in DI, but nothing ever applies them to the `ResiliencePipelineRegistry`. The registry is registered via `TryAddSingleton` with its parameterless constructor, yielding an empty registry. `BuildRegistry` exists as `internal static` but is only called from test code. - -**Impact:** Any user following the DI pattern gets `KeyNotFoundException` at runtime. The entire DI registration surface is non-functional. - -**Fix:** Wire `BuildRegistry` into the DI container — either as a factory for the registry singleton, or via `IHostedService` / post-configuration. The simplest fix: replace `TryAddSingleton>()` with a factory overload that resolves all `IPipelineConfigurator` instances and applies them. - -**Location:** [ResilionServiceCollectionExtensions.cs](../src/Resilion.Extensions/ResilionServiceCollectionExtensions.cs) - ---- - -### 16. Circuit Breaker FireEvent Sync-Only on Async Path - -**Type:** Fix — Deadlock under SynchronizationContext - -**Why** - -`FireEvent` in both `CircuitBreakerStrategy` and `CircuitBreakerTypedStrategy` always calls `handler.Invoke(e)` (sync), even when invoked from `ExecuteAsync`. For async handlers, `Invoke` does `Task.Run(...).GetAwaiter().GetResult()`, blocking the thread. Every other strategy correctly uses `await handler.InvokeAsync(...)` on async paths. - -**Impact:** Circuit breaker with async event handler deadlocks under WPF/WinForms SynchronizationContext. Thread pool starvation under load even without SynchronizationContext. - -**Fix:** Split `FireEvent` into `FireEvent` (sync) and `FireEventAsync` (async). Call the async variant from `ExecuteAsync`, the sync variant from `Execute`. - -**Location:** [CircuitBreakerStrategy.cs](../src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs), [CircuitBreakerTypedStrategy.cs](../src/Resilion/CircuitBreaker/CircuitBreakerTypedStrategy.cs) - ---- - -### 17. ResilienceProperties TryGetValue Throws on Type Mismatch - -**Type:** Fix — Correctness - -**Why** - -`TryGetValue` performs an unchecked cast `(TValue?)raw` on the stored `object?`. The key is the string from `ResiliencePropertyKey.Key`, not the type parameter. Two keys with the same string but different types (e.g., `ResiliencePropertyKey("code")` and `ResiliencePropertyKey("code")`) cause `InvalidCastException` instead of returning `false`. - -**Fix:** Wrap the cast in a type check: `if (raw is TValue typed) { value = typed; return true; }`. - -**Location:** [ResilienceProperties.cs](../src/Resilion/ResilienceProperties.cs) — `TryGetValue` - ---- - -### 32. Timeout Async Path Missing Catch for Direct OCE - -**Type:** Fix — Correctness - -**Why** - -The async `ExecuteAsync` in `TimeoutStrategy` only checks `outcome.Exception is OperationCanceledException` (line ~45). But if the inner callback throws `OperationCanceledException` directly (not captured in an Outcome — e.g., `Task.Delay` throws when its token cancels during Retry delay), there is no `catch (OperationCanceledException)` block on the async path. The sync path has one (line ~105). The raw OCE propagates to the caller instead of being wrapped in `TimeoutRejectedException`. - -**Impact:** Users can't distinguish timeout from external cancellation when Timeout wraps Retry and the timeout fires during a retry delay. - -**Fix:** Add `catch (OperationCanceledException oce) when (WasCancelledByTimeout(linkedCts, previousToken))` to the async path's try block, matching the sync path. - -**Location:** [TimeoutStrategy.cs](../src/Resilion/Timeout/TimeoutStrategy.cs) — `ExecuteAsync` - ---- - -### 33. Timeout Timer Callback Can Crash Process - -**Type:** Fix — Critical - -**Why** - -The timeout timer callback is `static state => ((CancellationTokenSource)state!).Cancel()`. `CancellationTokenSource.Cancel()` invokes all registered cancellation callbacks. If any callback throws, `Cancel()` wraps the exception in `AggregateException` and rethrows. Since this runs on a thread pool timer thread with no try-catch, the unhandled exception terminates the process in .NET 6+. - -**Impact:** A user strategy that registers a faulty cancellation callback (e.g., `token.Register(() => resource.Dispose())` where Dispose throws) crashes the entire application when a timeout fires. - -**Fix:** Wrap the timer callback: `static state => { try { ((CancellationTokenSource)state!).Cancel(); } catch { /* log or swallow */ } }`. - -**Location:** [TimeoutStrategy.cs](../src/Resilion/Timeout/TimeoutStrategy.cs) — `CreateTimer` callback, lines ~36 and ~86 +> **Completed (removed from backlog):** Solution structure, .editorconfig, global.json, CI workflows, Outcome\, ResilienceContext pooling, Strategy base types, Pipeline/PipelineBuilder, ResilienceEventHandler union struct, Timeout strategy, Retry strategy (with RetryDelay discriminated union), Circuit Breaker (sliding window, state machine, thread safety), Fallback (with FallbackAction implicit conversions), code review and fixes for 13 issues, Rate Limiter strategy (wrapping System.Threading.RateLimiting), Hedging strategy (parallel/latency/sequential modes, per-attempt CTS, cleanup-on-cancel), Pipeline ordering validation, Telemetry wired into all strategies, Docs (15 files), README, Samples, Benchmarks vs Polly, #6 Pipeline ordering validation, #7 Benchmarks, #8 README and docs, #13 Hedging Properties propagation (CopyFrom added), #15 DI configurators, #16 CB deadlock, #17 ResilienceProperties type safety, #32 Timeout OCE catch, #33 Timeout timer callback crash, #18 ManualControl initialization, #21 Registry race, #34 Hedging stale task. --- ## P1 — Do First -### 18. ManualControl Non-Atomic Initialization - -**Type:** Fix — Race condition - -**Why** - -`CircuitBreakerManualControl.Initialize` uses `Interlocked.CompareExchange` on `_onIsolate`, then plain assignment on `_onReset`. Between the CAS and the assignment, a concurrent `IsolateAsync()` succeeds but `ResetAsync()` throws — leaving the circuit permanently isolated. - -**Fix:** Set both fields atomically. Options: use a lock, or pack both into a single `(Func, Func)` tuple and CAS that. - -**Location:** [CircuitBreakerManualControl.cs](../src/Resilion/CircuitBreaker/CircuitBreakerManualControl.cs) — `Initialize` - ---- - ### 19. Hedging Sync Path Shares Context Across Attempts **Type:** Fix — Correctness @@ -177,36 +75,6 @@ Sync `ResolveAction` wraps a custom `ActionGenerator`'s async result with `.GetA --- -### 34. Hedging Latency-Mode: Completed Task Bypasses Delay for All Subsequent Attempts - -**Type:** Fix — Behavioral incorrectness - -**Why** - -In latency mode (`HedgingDelay > 0`), once an attempt completes with a handled failure, it stays in `attempts`. On the next loop iteration, `Task.WhenAny(attempts)` resolves immediately on the already-completed task, so the hedging delay is never honored. All remaining hedged attempts launch in a burst instead of being staggered by `HedgingDelay`. - -**Example:** `HedgingDelay = 2s`, `MaxHedgedAttempts = 4`. Primary fails in 100ms. Attempts 1, 2, 3 all launch within milliseconds instead of being spaced 2s apart. - -**Fix:** Remove completed tasks from `attempts` after checking their outcome in the latency-mode early-check block. - -**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `ExecuteAsync`, latency mode block - ---- - -### 21. Registry GetOrAdd Race Leaks Undisposed Pipelines - -**Type:** Fix — Resource leak - -**Why** - -`ConcurrentDictionary.GetOrAdd` with a factory may execute the factory multiple times under concurrent access. Only one `Pipeline` is stored; the rest are discarded without `Dispose`. Custom strategies holding unmanaged resources would leak. - -**Fix:** Use `Lazy` as the dictionary value, or use a lock per key to ensure single creation. - -**Location:** [ResiliencePipelineRegistry.cs](../src/Resilion.Extensions/ResiliencePipelineRegistry.cs) — `GetPipeline` - ---- - ## P2 — Do Next ### 4. Per-Call Delegate Allocation in Pipeline Chain diff --git a/src/Resilion.Extensions/ResiliencePipelineRegistry.cs b/src/Resilion.Extensions/ResiliencePipelineRegistry.cs index 746f043..5b7101d 100644 --- a/src/Resilion.Extensions/ResiliencePipelineRegistry.cs +++ b/src/Resilion.Extensions/ResiliencePipelineRegistry.cs @@ -56,22 +56,25 @@ public void RegisterPipeline(TKey key, Action> /// No pipeline is registered with the specified key. public Pipeline GetPipeline(TKey key) { - var lazy = _pipelines.GetOrAdd(key, static (k, factories) => + if (!_pipelines.TryGetValue(key, out var existingLazy)) { - return new Lazy(() => + // Factory creates Lazy once, GetOrAdd ensures only one Lazy per key is stored + var lazyFactory = new Lazy(() => { - if (!factories.TryGetValue(k, out var factory)) + if (!_factories.TryGetValue(key, out var factory)) { - throw new KeyNotFoundException($"No pipeline registered with key '{k}'."); + throw new KeyNotFoundException($"No pipeline registered with key '{key}'."); } var builder = new PipelineBuilder(); factory(builder); return builder.Build(); }); - }, _factories); - return lazy.Value; + existingLazy = _pipelines.GetOrAdd(key, lazyFactory); + } + + return existingLazy.Value; } /// @@ -83,14 +86,15 @@ public Pipeline GetPipeline(TKey key) public Pipeline GetPipeline(TKey key) { var compositeKey = (key, typeof(TResult)); - var lazy = _typedPipelines.GetOrAdd(compositeKey, static (k, state) => + if (!_typedPipelines.TryGetValue(compositeKey, out var existingLazy)) { - return new Lazy(() => + // Factory creates Lazy once, GetOrAdd ensures only one Lazy per key is stored + var lazyFactory = new Lazy(() => { - if (!state.TryGetValue(k, out var factory)) + if (!_typedFactories.TryGetValue(compositeKey, out var factory)) { throw new KeyNotFoundException( - $"No pipeline registered with key '{k.Item1}' and result type '{k.Item2.Name}'."); + $"No pipeline registered with key '{key}' and result type '{typeof(TResult).Name}'."); } var configure = (Action>)factory; @@ -98,9 +102,11 @@ public Pipeline GetPipeline(TKey key) configure(builder); return (object)builder.Build(); }); - }, _typedFactories); - return (Pipeline)lazy.Value; + existingLazy = _typedPipelines.GetOrAdd(compositeKey, lazyFactory); + } + + return (Pipeline)existingLazy.Value; } /// diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerManualControl.cs b/src/Resilion/CircuitBreaker/CircuitBreakerManualControl.cs index 9c50472..402bec1 100644 --- a/src/Resilion/CircuitBreaker/CircuitBreakerManualControl.cs +++ b/src/Resilion/CircuitBreaker/CircuitBreakerManualControl.cs @@ -10,8 +10,10 @@ namespace Resilion; /// public sealed class CircuitBreakerManualControl { + private readonly object _initLock = new(); private Func? _onIsolate; private Func? _onReset; + private bool _initialized; /// /// Forces the circuit into the state. @@ -52,13 +54,18 @@ public Task ResetAsync() internal void Initialize(Func onIsolate, Func onReset) { - if (Interlocked.CompareExchange(ref _onIsolate, onIsolate, null) is not null) + lock (_initLock) { - throw new InvalidOperationException( - "This CircuitBreakerManualControl is already bound to a circuit breaker strategy. " + - "Create a separate instance for each circuit breaker."); - } + if (_initialized) + { + throw new InvalidOperationException( + "This CircuitBreakerManualControl is already bound to a circuit breaker strategy. " + + "Create a separate instance for each circuit breaker."); + } - _onReset = onReset; + _onIsolate = onIsolate; + _onReset = onReset; + _initialized = true; + } } } diff --git a/src/Resilion/Hedging/HedgingStrategy.cs b/src/Resilion/Hedging/HedgingStrategy.cs index f70afca..ca64011 100644 --- a/src/Resilion/Hedging/HedgingStrategy.cs +++ b/src/Resilion/Hedging/HedgingStrategy.cs @@ -62,6 +62,10 @@ protected internal override async ValueTask> ExecuteAsync( { return completed; } + + // Task is a handled failure; remove it from the list so it doesn't + // immediately win WhenAny on the next iteration, bypassing the delay. + attempts.Remove(completedTask); } } // Parallel mode (delay == 0): launch immediately, no waiting. From 7cfa8f78d4b7ab26373fabc10cb1936a95c64295 Mon Sep 17 00:00:00 2001 From: Ali-Tegna <31090457+FreakyAli@users.noreply.github.com> Date: Wed, 2 Sep 2026 10:08:36 +0530 Subject: [PATCH 9/9] fix: more quicks wins for edge cases found in the code review --- docs/future-plans.md | 109 ------------------ .../ResiliencePipelineRegistry.cs | 52 ++++----- .../CircuitBreaker/CircuitBreakerStrategy.cs | 12 +- src/Resilion/CircuitBreaker/SlidingWindow.cs | 48 +++++++- src/Resilion/Hedging/HedgingStrategy.cs | 34 +++++- src/Resilion/ResilienceContextPool.cs | 16 ++- src/Resilion/Retry/RetryDelay.cs | 8 ++ 7 files changed, 119 insertions(+), 160 deletions(-) diff --git a/docs/future-plans.md b/docs/future-plans.md index bff942c..0142aca 100644 --- a/docs/future-plans.md +++ b/docs/future-plans.md @@ -21,12 +21,6 @@ Features, improvements, and known tradeoffs under consideration for future versi | # | Item | Priority | Type | Impact | Effort | Notes | |---|------|----------|------|--------|--------|-------| -| 19 | **Hedging sync path shares context across attempts** | **P1** | Fix | Medium | Low | Sync `Execute` reuses same ResilienceContext for all sequential attempts — inner strategies see stale Properties | -| 20 | Hedging `ResolveAction` missing `Task.Run` wrapper | P1 | Fix | Medium | Low | Sync path deadlock risk when ActionGenerator returns async action | -| 22 | Hedging latency-mode: Double WhenAny + stale task | P2 | Fix | Medium | Medium | Completed task stays in list, second WhenAny may return wrong task, wastes cycles | -| 23 | Interlocked.Increment under lock in SlidingWindow | P2 | Fix | Low | Low | Wasted memory barrier — plain `++` under lock is correct and cheaper | -| 24 | Double lock acquisition per CB Closed-state call | P2 | Fix | Medium | Low | RecordSuccess + GetFailureRatio each acquire SlidingWindow lock separately | -| 25 | ConcurrentBag.Count in pool Return | P2 | Fix | Medium | Low | `Count` enumerates all thread-local lists — use Interlocked counter | | 26 | CB typed/non-generic strategy duplication (~200 lines) | P2 | Improvement | Medium | Medium | Extract shared state machine class | | 27 | Retry typed/non-generic strategy duplication (~100 lines) | P2 | Improvement | Medium | Medium | Extract shared retry loop | | 28 | PipelineBuilder typed/non-generic duplication (~80 lines) | P2 | Improvement | Medium | Medium | Extract shared base class | @@ -39,39 +33,6 @@ Features, improvements, and known tradeoffs under consideration for future versi | 12 | Hedging: HedgingDelayGenerator | P3 | Feature | Low | Low | Dynamic delay per attempt | | 14 | Hedging: HedgingRejectedException with aggregated errors | P3 | Improvement | Low | Low | Currently dead code — never thrown | | 30 | FallbackAction/ResilienceEventHandler Task.Run missing CancellationToken | P3 | Fix | Low | Low | Sync-over-async wrappers can't be interrupted by cancellation | -| 31 | Duplicate XML doc on ResilienceProperties.Clear | P3 | Fix | Low | Low | Copy-paste leftover — orphaned summary block | - -> **Completed (removed from backlog):** Solution structure, .editorconfig, global.json, CI workflows, Outcome\, ResilienceContext pooling, Strategy base types, Pipeline/PipelineBuilder, ResilienceEventHandler union struct, Timeout strategy, Retry strategy (with RetryDelay discriminated union), Circuit Breaker (sliding window, state machine, thread safety), Fallback (with FallbackAction implicit conversions), code review and fixes for 13 issues, Rate Limiter strategy (wrapping System.Threading.RateLimiting), Hedging strategy (parallel/latency/sequential modes, per-attempt CTS, cleanup-on-cancel), Pipeline ordering validation, Telemetry wired into all strategies, Docs (15 files), README, Samples, Benchmarks vs Polly, #6 Pipeline ordering validation, #7 Benchmarks, #8 README and docs, #13 Hedging Properties propagation (CopyFrom added), #15 DI configurators, #16 CB deadlock, #17 ResilienceProperties type safety, #32 Timeout OCE catch, #33 Timeout timer callback crash, #18 ManualControl initialization, #21 Registry race, #34 Hedging stale task. - ---- - -## P1 — Do First - -### 19. Hedging Sync Path Shares Context Across Attempts - -**Type:** Fix — Correctness - -**Why** - -Sync `Execute` in `HedgingStrategy` passes the same `ResilienceContext` to all sequential attempts. Any inner strategy that writes to `context.Properties` during attempt N leaves stale state visible to attempt N+1. The async path correctly creates a fresh per-attempt context. - -**Fix:** Create a per-attempt context copy in the sync path, matching the async path's `ResilienceContextPool.Shared.Rent(ct)` + `Properties.CopyFrom()`. - -**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `Execute`, line ~119 - ---- - -### 20. Hedging ResolveAction Missing Task.Run Wrapper - -**Type:** Fix — Deadlock risk - -**Why** - -Sync `ResolveAction` wraps a custom `ActionGenerator`'s async result with `.GetAwaiter().GetResult()` directly, without `Task.Run`. Every other sync-over-async site in the codebase uses `Task.Run` to escape the SynchronizationContext. - -**Fix:** Match the pattern: `Task.Run(() => customAction(ctx.CancellationToken).AsTask()).GetAwaiter().GetResult()`. - -**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `ResolveAction`, line ~241 --- @@ -134,62 +95,6 @@ Implement a custom `FirstCompletedAsync` that uses `TaskCompletionSource` + per- --- -### 22. Hedging Latency-Mode Double WhenAny + Stale Task - -**Type:** Fix — Correctness (minor) - -**Why** - -In latency mode, when an attempt completes before the delay, `Task.WhenAny(attempts)` is called twice (once nested, once after). The second call may return a different task. Also, the completed/failed task stays in `attempts`, so `WaitForBestOutcome` re-evaluates it, wasting a cycle and potentially setting `lastFailure` to the wrong attempt. - -**Fix:** Store the result of the first `WhenAny`, remove completed tasks from the list before launching the next attempt. - -**Location:** [HedgingStrategy.cs](../src/Resilion/Hedging/HedgingStrategy.cs) — `ExecuteAsync`, latency mode block - ---- - -### 23. Interlocked.Increment Under Lock in SlidingWindow - -**Type:** Fix — Efficiency - -**Why** - -`RecordSuccess()` and `RecordFailure()` acquire `_lock` then use `Interlocked.Increment`. Since the lock is held, `Interlocked` adds a full memory barrier for zero benefit. Plain `++` is correct and cheaper. - -**Fix:** Replace `Interlocked.Increment(ref _buckets[_currentBucketIndex].Successes)` with `_buckets[_currentBucketIndex].Successes++`. - -**Location:** [SlidingWindow.cs](../src/Resilion/CircuitBreaker/SlidingWindow.cs) — `RecordSuccess`, `RecordFailure` - ---- - -### 24. Double Lock Acquisition Per CB Closed-State Call - -**Type:** Fix — Efficiency - -**Why** - -In Circuit Breaker's Closed path, `RecordAndTransition` calls `_window.RecordFailure()` then `_window.GetFailureRatio()`. Each acquires `SlidingWindow._lock` independently. Both also run `AdvanceWindow()`. This doubles lock contention and duplicates window-advancement. - -**Fix:** Add `RecordAndGetRatio(bool isFailure, out int totalCount)` to SlidingWindow that does record + ratio under one lock acquisition. - -**Location:** [CircuitBreakerStrategy.cs](../src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs), [SlidingWindow.cs](../src/Resilion/CircuitBreaker/SlidingWindow.cs) - ---- - -### 25. ConcurrentBag.Count in Pool Return - -**Type:** Fix — Efficiency - -**Why** - -`ResilienceContextPool.Return` checks `_pool.Count < MaxPoolSize` before adding. `ConcurrentBag.Count` is O(n), acquiring locks on all thread-local lists. With many threads, this serializes the return path. - -**Fix:** Track count with `Interlocked.Increment`/`Decrement` on an `int _count` field instead. - -**Location:** [ResilienceContextPool.cs](../src/Resilion/ResilienceContextPool.cs) — `Return` - ---- - ### 26–29. Strategy/Builder/Options Duplication **Type:** Improvement — Maintainability @@ -294,18 +199,4 @@ Both `FallbackAction.Execute` and `ResilienceEventHandler.Invoke` call `Ta --- -### 31. Duplicate XML Doc on ResilienceProperties.Clear - -**Type:** Fix — Trivial - -**Why** - -Two consecutive identical `Removes all properties.` blocks before `Clear()`. Copy-paste leftover. - -**Location:** [ResilienceProperties.cs](../src/Resilion/ResilienceProperties.cs) - ---- - ---- - See also: [tradeoffs.md](tradeoffs.md) — accepted design imperfections with reasoning for why they won't be fixed. diff --git a/src/Resilion.Extensions/ResiliencePipelineRegistry.cs b/src/Resilion.Extensions/ResiliencePipelineRegistry.cs index 5b7101d..f6bc888 100644 --- a/src/Resilion.Extensions/ResiliencePipelineRegistry.cs +++ b/src/Resilion.Extensions/ResiliencePipelineRegistry.cs @@ -56,25 +56,19 @@ public void RegisterPipeline(TKey key, Action> /// No pipeline is registered with the specified key. public Pipeline GetPipeline(TKey key) { - if (!_pipelines.TryGetValue(key, out var existingLazy)) + var lazy = _pipelines.GetOrAdd(key, _ => new Lazy(() => { - // Factory creates Lazy once, GetOrAdd ensures only one Lazy per key is stored - var lazyFactory = new Lazy(() => + if (!_factories.TryGetValue(key, out var factory)) { - if (!_factories.TryGetValue(key, out var factory)) - { - throw new KeyNotFoundException($"No pipeline registered with key '{key}'."); - } - - var builder = new PipelineBuilder(); - factory(builder); - return builder.Build(); - }); + throw new KeyNotFoundException($"No pipeline registered with key '{key}'."); + } - existingLazy = _pipelines.GetOrAdd(key, lazyFactory); - } + var builder = new PipelineBuilder(); + factory(builder); + return builder.Build(); + })); - return existingLazy.Value; + return lazy.Value; } /// @@ -86,27 +80,21 @@ public Pipeline GetPipeline(TKey key) public Pipeline GetPipeline(TKey key) { var compositeKey = (key, typeof(TResult)); - if (!_typedPipelines.TryGetValue(compositeKey, out var existingLazy)) + var lazy = _typedPipelines.GetOrAdd(compositeKey, _ => new Lazy(() => { - // Factory creates Lazy once, GetOrAdd ensures only one Lazy per key is stored - var lazyFactory = new Lazy(() => + if (!_typedFactories.TryGetValue(compositeKey, out var factory)) { - if (!_typedFactories.TryGetValue(compositeKey, out var factory)) - { - throw new KeyNotFoundException( - $"No pipeline registered with key '{key}' and result type '{typeof(TResult).Name}'."); - } - - var configure = (Action>)factory; - var builder = new PipelineBuilder(); - configure(builder); - return (object)builder.Build(); - }); + throw new KeyNotFoundException( + $"No pipeline registered with key '{key}' and result type '{typeof(TResult).Name}'."); + } - existingLazy = _typedPipelines.GetOrAdd(compositeKey, lazyFactory); - } + var configure = (Action>)factory; + var builder = new PipelineBuilder(); + configure(builder); + return (object)builder.Build(); + })); - return (Pipeline)existingLazy.Value; + return (Pipeline)lazy.Value; } /// diff --git a/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs b/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs index 755ba5f..973ba96 100644 --- a/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs +++ b/src/Resilion/CircuitBreaker/CircuitBreakerStrategy.cs @@ -162,16 +162,8 @@ private async ValueTask RecordAndTransitionAsync(bool isFailure, ResilienceConte switch (currentState) { case CircuitState.Closed: - if (isFailure) - { - _window.RecordFailure(); - } - else - { - _window.RecordSuccess(); - } - - var failureRatio = _window.GetFailureRatio(out var totalCount); + // Record outcome and get ratio under single lock for efficiency + var failureRatio = _window.RecordAndGetRatio(isFailure, out var totalCount); if (failureRatio >= _options.FailureRatioThreshold && totalCount >= _options.MinimumThroughput) { diff --git a/src/Resilion/CircuitBreaker/SlidingWindow.cs b/src/Resilion/CircuitBreaker/SlidingWindow.cs index fd9f5f2..cae9d1f 100644 --- a/src/Resilion/CircuitBreaker/SlidingWindow.cs +++ b/src/Resilion/CircuitBreaker/SlidingWindow.cs @@ -42,7 +42,7 @@ internal void RecordSuccess() lock (_lock) { AdvanceWindow(); - Interlocked.Increment(ref _buckets[_currentBucketIndex].Successes); + _buckets[_currentBucketIndex].Successes++; } } @@ -54,7 +54,51 @@ internal void RecordFailure() lock (_lock) { AdvanceWindow(); - Interlocked.Increment(ref _buckets[_currentBucketIndex].Failures); + _buckets[_currentBucketIndex].Failures++; + } + } + + /// + /// Records an outcome and gets the current failure ratio and total throughput across all active buckets. + /// Combines both operations under a single lock acquisition for efficiency. + /// + /// true to record a failure; false to record success. + /// The total number of executions in the window. + /// The failure ratio clamped to [0.0, 1.0], or 0.0 if there are no executions. + internal double RecordAndGetRatio(bool isFailure, out int totalCount) + { + lock (_lock) + { + AdvanceWindow(); + + // Record the outcome + if (isFailure) + { + _buckets[_currentBucketIndex].Failures++; + } + else + { + _buckets[_currentBucketIndex].Successes++; + } + + // Get the ratio + var successes = 0; + var failures = 0; + + for (var i = 0; i < BucketCount; i++) + { + successes += _buckets[i].Successes; + failures += _buckets[i].Failures; + } + + totalCount = successes + failures; + if (totalCount == 0) + { + return 0.0; + } + + var ratio = (double)failures / totalCount; + return Math.Clamp(ratio, 0.0, 1.0); } } diff --git a/src/Resilion/Hedging/HedgingStrategy.cs b/src/Resilion/Hedging/HedgingStrategy.cs index ca64011..a95f48b 100644 --- a/src/Resilion/Hedging/HedgingStrategy.cs +++ b/src/Resilion/Hedging/HedgingStrategy.cs @@ -51,12 +51,16 @@ protected internal override async ValueTask> ExecuteAsync( { // Latency mode: wait for the delay, but also check if any attempt completes early. var delayTask = Task.Delay(_options.HedgingDelay, _timeProvider, userToken); - var winner = await Task.WhenAny(Task.WhenAny(attempts), delayTask).ConfigureAwait(false); + var whenAnyTask = Task.WhenAny(attempts); + var winner = await Task.WhenAny(whenAnyTask, delayTask).ConfigureAwait(false); if (winner != delayTask) { - // An attempt completed before the delay. Check if it succeeded. - var completedTask = await Task.WhenAny(attempts).ConfigureAwait(false); + // An attempt completed before the delay. The whenAnyTask has completed, + // revealing the first completed task from attempts. Await it to unwrap + // without calling WhenAny again (which would risk returning a different + // task if multiple completed between our WhenAny call and the second one). + var completedTask = await whenAnyTask.ConfigureAwait(false); var completed = await completedTask.ConfigureAwait(false); if (!_options.ShouldHandleOutcome(completed)) { @@ -145,7 +149,21 @@ protected internal override Outcome Execute( context.CancellationToken.ThrowIfCancellationRequested(); var action = ResolveAction(attemptIndex, callback, context); - lastOutcome = action(context); + + // Create per-attempt context copy to avoid stale state from previous attempts. + // Matches async path behavior (ResilienceContextPool.Shared.Rent + CopyFrom). + var attemptContext = ResilienceContextPool.Shared.Rent(context.CancellationToken); + attemptContext.OperationKey = context.OperationKey; + attemptContext.ContinueOnCapturedContext = context.ContinueOnCapturedContext; + attemptContext.Properties.CopyFrom(context.Properties); + try + { + lastOutcome = action(attemptContext); + } + finally + { + ResilienceContextPool.Shared.Return(attemptContext); + } if (!_options.ShouldHandleOutcome(lastOutcome)) { @@ -252,7 +270,13 @@ private Func> ResolveAction( { try { - var result = customAction(ctx.CancellationToken).GetAwaiter().GetResult(); + // Wrap async call with Task.Run to escape SynchronizationContext, + // preventing deadlock when ActionGenerator returns async action. + var result = Task.Run( + () => customAction(ctx.CancellationToken).AsTask(), + ctx.CancellationToken) + .GetAwaiter() + .GetResult(); return Outcome.FromResult(result); } catch (Exception ex) diff --git a/src/Resilion/ResilienceContextPool.cs b/src/Resilion/ResilienceContextPool.cs index c18a8e1..fc29ba9 100644 --- a/src/Resilion/ResilienceContextPool.cs +++ b/src/Resilion/ResilienceContextPool.cs @@ -19,6 +19,9 @@ public sealed class ResilienceContextPool // 256 is generous — most applications use far fewer concurrent pipeline executions. private const int MaxPoolSize = 256; + // Tracks pool count with Interlocked to avoid O(n) ConcurrentBag.Count enumeration. + private int _count; + /// /// Gets the shared default pool instance. Use this unless you have a specific reason /// to create a separate pool. @@ -36,6 +39,10 @@ public ResilienceContext Rent(CancellationToken cancellationToken = default) { context = new ResilienceContext(); } + else + { + Interlocked.Decrement(ref _count); + } context.CancellationToken = cancellationToken; return context; @@ -51,10 +58,15 @@ public void Return(ResilienceContext context) ArgumentNullException.ThrowIfNull(context); context.Reset(); - // Don't let the pool grow without bound. - if (_pool.Count < MaxPoolSize) + // Don't let the pool grow without bound. Use Interlocked counter to avoid O(n) ConcurrentBag.Count. + if (Interlocked.Increment(ref _count) <= MaxPoolSize) { _pool.Add(context); } + else + { + // Pool is full; discard this context instead of adding it. + Interlocked.Decrement(ref _count); + } } } diff --git a/src/Resilion/Retry/RetryDelay.cs b/src/Resilion/Retry/RetryDelay.cs index 7cb2fea..7b1b60a 100644 --- a/src/Resilion/Retry/RetryDelay.cs +++ b/src/Resilion/Retry/RetryDelay.cs @@ -102,6 +102,14 @@ internal override TimeSpan ComputeDelay(int attemptNumber, bool useJitter) var baseMs = BaseDelay.TotalMilliseconds; var maxMs = MaxDelay?.TotalMilliseconds ?? double.MaxValue; var delayMs = Math.Min(baseMs * attemptNumber, maxMs); + + // Guard against overflow when jitter multiplier (up to 1.25x) is applied. + // Match the pattern in ExponentialDelay to handle edge cases consistently. + if (double.IsInfinity(delayMs) || double.IsNaN(delayMs) || delayMs > TimeSpan.MaxValue.TotalMilliseconds) + { + delayMs = TimeSpan.MaxValue.TotalMilliseconds; + } + var delay = TimeSpan.FromMilliseconds(delayMs); return useJitter ? ApplyJitter(delay, MaxDelay) : delay; }

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 z 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