< Summary

Information
Class: AsiBackbone.AspNetCore.Endpoints.DefaultEndpointGovernanceService
Assembly: AsiBackbone.AspNetCore
File(s): /home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.AspNetCore/Endpoints/DefaultEndpointGovernanceService.cs
Line coverage
100%
Covered lines: 295
Uncovered lines: 0
Coverable lines: 295
Total lines: 554
Line coverage: 100%
Branch coverage
90%
Covered branches: 80
Total branches: 88
Branch coverage: 90.9%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%1616100%
EvaluateAsync()100%1010100%
SanitizeMetadataAsync()100%44100%
EvaluatePolicyAsync()100%66100%
ValidateCapabilityAsync()100%88100%
EmitAuditAsync()92.86%1414100%
CreateCompletedResult(...)100%1010100%
CreateMetadataSanitizationFailure(...)100%11100%
CreateAllowDecision(...)100%11100%
BackfillTraceId(...)75%44100%
.ctor(...)100%11100%
GetPolicyEvaluator()50%22100%
GetCapabilityValidator()50%22100%
GetAuditSink()50%22100%
GetMetadataSanitizer()50%22100%
CreateBlockedDecisionResult(...)75%44100%
CreateConfigurationFailure(...)50%22100%
CreateCapabilityFailure(...)100%22100%

File(s)

/home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.AspNetCore/Endpoints/DefaultEndpointGovernanceService.cs

#LineLine coverage
 1using AsiBackbone.AspNetCore.Acknowledgments;
 2using AsiBackbone.AspNetCore.Actors;
 3using AsiBackbone.AspNetCore.Correlation;
 4using AsiBackbone.AspNetCore.Results;
 5using AsiBackbone.Core.Actors;
 6using AsiBackbone.Core.Audit;
 7using AsiBackbone.Core.Constraints;
 8using AsiBackbone.Core.Decisions;
 9using AsiBackbone.Core.Evaluation;
 10using AsiBackbone.Core.Metadata;
 11using AsiBackbone.Core.Results;
 12using Microsoft.AspNetCore.Http;
 13using Microsoft.Extensions.DependencyInjection;
 14using Microsoft.Extensions.Options;
 15
 16namespace AsiBackbone.AspNetCore.Endpoints;
 17
 18/// <summary>
 19/// Default host-adapter implementation for ergonomic ASP.NET Core endpoint governance.
 20/// </summary>
 21public sealed class DefaultEndpointGovernanceService : IEndpointGovernanceService
 22{
 23    private const string MetadataSanitizationDeniedReasonCode = "endpoint.metadata_sanitization.denied";
 24    private const string MetadataSanitizationDeniedReasonMessage =
 25        "Endpoint governance metadata was denied by the configured sanitation policy.";
 26
 27    private readonly IServiceProvider serviceProvider;
 28    private readonly IHttpGovernanceActorContextResolver actorContextResolver;
 29    private readonly IHttpGovernanceRequestCorrelationResolver requestCorrelationResolver;
 30    private readonly IAcknowledgmentChallengeService acknowledgmentChallengeService;
 31    private readonly EndpointGovernanceOptions endpointOptions;
 32    private readonly GovernanceHttpResultMappingOptions resultOptions;
 33
 34    /// <summary>
 35    /// Initializes a new instance of the <see cref="DefaultEndpointGovernanceService" /> class.
 36    /// </summary>
 5837    public DefaultEndpointGovernanceService(
 5838        IServiceProvider serviceProvider,
 5839        IHttpGovernanceActorContextResolver actorContextResolver,
 5840        IHttpGovernanceRequestCorrelationResolver requestCorrelationResolver,
 5841        IAcknowledgmentChallengeService acknowledgmentChallengeService,
 5842        IOptions<EndpointGovernanceOptions> endpointOptions,
 5843        IOptions<GovernanceHttpResultMappingOptions> resultOptions)
 44    {
 5845        this.serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
 5746        this.actorContextResolver = actorContextResolver ?? throw new ArgumentNullException(nameof(actorContextResolver)
 5647        this.requestCorrelationResolver = requestCorrelationResolver ?? throw new ArgumentNullException(nameof(requestCo
 5548        this.acknowledgmentChallengeService = acknowledgmentChallengeService ?? throw new ArgumentNullException(nameof(a
 5449        this.endpointOptions = endpointOptions?.Value ?? throw new ArgumentNullException(nameof(endpointOptions));
 5250        this.resultOptions = resultOptions?.Value ?? throw new ArgumentNullException(nameof(resultOptions));
 5051        this.endpointOptions.Validate();
 5052        this.resultOptions.Validate();
 5053    }
 54
 55    /// <inheritdoc />
 56    public async ValueTask<EndpointGovernanceResult> EvaluateAsync(
 57        HttpContext httpContext,
 58        EndpointGovernanceDescriptor descriptor,
 59        CancellationToken cancellationToken = default)
 60    {
 4861        ArgumentNullException.ThrowIfNull(httpContext);
 4862        ArgumentNullException.ThrowIfNull(descriptor);
 4863        cancellationToken.ThrowIfCancellationRequested();
 64
 4765        if (!descriptor.HasGovernanceMetadata)
 66        {
 167            return EndpointGovernanceResult.Allow();
 68        }
 69
 4670        var optionalServices = new EndpointGovernanceOptionalServiceResolver(
 4671            httpContext.RequestServices,
 4672            serviceProvider);
 4673        GovernanceHttpRequestCorrelation correlation = requestCorrelationResolver.ResolveRequestCorrelation();
 4674        IReadOnlyDictionary<string, string> endpointMetadata = descriptor.ToMetadata(endpointOptions.MetadataMode);
 75
 4676        IReadOnlyDictionary<string, string> mergedMetadata = correlation.MergeMetadata(endpointMetadata);
 4677        MetadataStageResult metadataStage = await SanitizeMetadataAsync(
 4678            optionalServices,
 4679            correlation,
 4680            mergedMetadata,
 4681            cancellationToken).ConfigureAwait(false);
 82
 4683        if (metadataStage.TerminalResult is not null)
 84        {
 185            return metadataStage.TerminalResult;
 86        }
 87
 4588        endpointMetadata = metadataStage.Metadata;
 89
 90        // The sanitized dictionary already contains request metadata, so it is authoritative. Merging request
 91        // metadata underneath it again would reintroduce any entry the sanitizer dropped: a dropped key is simply
 92        // absent from the sanitized result, so there would be nothing to override the raw value.
 4593        GovernanceEvaluationContext evaluationContext = correlation.ToEvaluationContext(
 4594            endpointOptions.PolicyVersion,
 4595            endpointOptions.PolicyHash,
 4596            endpointMetadata,
 4597            mergeRequestMetadata: false);
 98
 4599        DecisionStageResult policyStage = await EvaluatePolicyAsync(
 45100            httpContext,
 45101            descriptor,
 45102            optionalServices,
 45103            correlation,
 45104            endpointMetadata,
 45105            evaluationContext,
 45106            cancellationToken).ConfigureAwait(false);
 107
 44108        if (policyStage.TerminalResult is not null)
 109        {
 2110            return policyStage.TerminalResult;
 111        }
 112
 42113        DecisionStageResult capabilityStage = await ValidateCapabilityAsync(
 42114            httpContext,
 42115            descriptor,
 42116            optionalServices,
 42117            endpointMetadata,
 42118            policyStage.Decision,
 42119            cancellationToken).ConfigureAwait(false);
 120
 42121        if (capabilityStage.TerminalResult is not null)
 122        {
 5123            return capabilityStage.TerminalResult;
 124        }
 125
 37126        AuditStageResult auditStage = await EmitAuditAsync(
 37127            httpContext,
 37128            descriptor,
 37129            optionalServices,
 37130            endpointMetadata,
 37131            capabilityStage.Decision,
 37132            cancellationToken).ConfigureAwait(false);
 133
 36134        return auditStage.TerminalResult is not null
 36135            ? auditStage.TerminalResult
 36136            : CreateCompletedResult(
 36137            descriptor,
 36138            endpointMetadata,
 36139            capabilityStage.Decision,
 36140            auditStage.Actor);
 45141    }
 142
 143    private async ValueTask<MetadataStageResult> SanitizeMetadataAsync(
 144        EndpointGovernanceOptionalServiceResolver optionalServices,
 145        GovernanceHttpRequestCorrelation correlation,
 146        IReadOnlyDictionary<string, string> endpointMetadata,
 147        CancellationToken cancellationToken)
 148    {
 46149        IGovernanceMetadataSanitizer? metadataSanitizer = optionalServices.GetMetadataSanitizer();
 46150        if (metadataSanitizer is null)
 151        {
 41152            return new MetadataStageResult(endpointMetadata, TerminalResult: null);
 153        }
 154
 5155        GovernanceMetadataSanitizationResult sanitizationResult = await metadataSanitizer
 5156            .SanitizeAsync(endpointMetadata, cancellationToken)
 5157            .ConfigureAwait(false);
 158
 5159        return sanitizationResult.CanProceed
 5160            ? new MetadataStageResult(sanitizationResult.SanitizedMetadata, TerminalResult: null)
 5161            : new MetadataStageResult(
 5162                endpointMetadata,
 5163                CreateMetadataSanitizationFailure(correlation, sanitizationResult));
 46164    }
 165
 166    private async ValueTask<DecisionStageResult> EvaluatePolicyAsync(
 167        HttpContext httpContext,
 168        EndpointGovernanceDescriptor descriptor,
 169        EndpointGovernanceOptionalServiceResolver optionalServices,
 170        GovernanceHttpRequestCorrelation correlation,
 171        IReadOnlyDictionary<string, string> endpointMetadata,
 172        GovernanceEvaluationContext evaluationContext,
 173        CancellationToken cancellationToken)
 174    {
 45175        GovernanceDecision allowedDecision = CreateAllowDecision(evaluationContext, correlation.TraceId);
 45176        if (descriptor.PolicyTypes.Count == 0)
 177        {
 6178            return new DecisionStageResult(allowedDecision, TerminalResult: null);
 179        }
 180
 39181        IGovernancePolicyEvaluator<GovernanceEvaluationContext>? evaluator =
 39182            optionalServices.GetPolicyEvaluator();
 39183        if (evaluator is null)
 184        {
 2185            EndpointGovernanceResult terminalResult = endpointOptions.FailClosedWhenPolicyEvaluatorMissing
 2186                ? CreateConfigurationFailure(
 2187                    httpContext,
 2188                    descriptor,
 2189                    endpointMetadata,
 2190                    "endpoint.policy_evaluator.missing",
 2191                    "Endpoint governance policy metadata was present, but no AsiBackbone policy evaluator was registered
 2192                    allowedDecision,
 2193                    "aspnetcore.endpoint.governance.configuration.policy_evaluator")
 2194                : EndpointGovernanceResult.Allow(allowedDecision);
 195
 2196            return new DecisionStageResult(allowedDecision, terminalResult);
 197        }
 198
 37199        GovernanceDecision decision = await evaluator
 37200            .EvaluateAsync(evaluationContext, cancellationToken)
 37201            .ConfigureAwait(false);
 202
 36203        decision = BackfillTraceId(decision, correlation.TraceId);
 204
 36205        return new DecisionStageResult(decision, TerminalResult: null);
 44206    }
 207
 208    private async ValueTask<DecisionStageResult> ValidateCapabilityAsync(
 209        HttpContext httpContext,
 210        EndpointGovernanceDescriptor descriptor,
 211        EndpointGovernanceOptionalServiceResolver optionalServices,
 212        IReadOnlyDictionary<string, string> endpointMetadata,
 213        GovernanceDecision decision,
 214        CancellationToken cancellationToken)
 215    {
 216        // Capability requirements apply to every decision that is not already denied, including warning,
 217        // acknowledgment-required, deferred, and escalation-recommended outcomes. A missing grant must take precedence
 218        // over any later host flow that could otherwise approve the request without re-checking the grant.
 42219        if (decision.IsDenied || descriptor.CapabilityScopes.Count == 0)
 220        {
 22221            return new DecisionStageResult(decision, TerminalResult: null);
 222        }
 223
 20224        IEndpointCapabilityGrantValidator? capabilityValidator =
 20225            optionalServices.GetCapabilityValidator();
 20226        if (capabilityValidator is null)
 227        {
 7228            EndpointGovernanceResult? terminalResult = endpointOptions.FailClosedWhenCapabilityValidatorMissing
 7229                ? CreateCapabilityFailure(
 7230                    httpContext,
 7231                    descriptor,
 7232                    endpointMetadata,
 7233                    "endpoint.capability_validator.missing",
 7234                    "Endpoint capability metadata was present, but no host-owned endpoint capability validator was regis
 7235                    decision,
 7236                    "aspnetcore.endpoint.governance.capability.configuration")
 7237                : null;
 238
 7239            return new DecisionStageResult(decision, terminalResult);
 240        }
 241
 242        // The feature reports the grant accepted by this evaluation only. Clearing it first keeps an identifier left by
 243        // earlier request processing from reaching the receipt when the validator accepts nothing.
 13244        httpContext.Features.Set<IEndpointCapabilityGrantFeature>(null);
 245
 13246        GovernanceDecision validatedDecision = await capabilityValidator
 13247            .ValidateAsync(httpContext, descriptor, decision, cancellationToken)
 13248            .ConfigureAwait(false);
 249
 13250        validatedDecision = BackfillTraceId(validatedDecision, decision.TraceId);
 251
 13252        return new DecisionStageResult(validatedDecision, TerminalResult: null);
 42253    }
 254
 255    private async ValueTask<AuditStageResult> EmitAuditAsync(
 256        HttpContext httpContext,
 257        EndpointGovernanceDescriptor descriptor,
 258        EndpointGovernanceOptionalServiceResolver optionalServices,
 259        IReadOnlyDictionary<string, string> endpointMetadata,
 260        GovernanceDecision decision,
 261        CancellationToken cancellationToken)
 262    {
 37263        if (!descriptor.EmitGovernanceAudit)
 264        {
 25265            return new AuditStageResult(Actor: null, TerminalResult: null);
 266        }
 267
 12268        IDecisionReceiptSink? auditSink = optionalServices.GetAuditSink();
 12269        if (auditSink is null)
 270        {
 3271            EndpointGovernanceResult terminalResult = endpointOptions.FailClosedWhenAuditSinkMissing
 3272                ? CreateConfigurationFailure(
 3273                    httpContext,
 3274                    descriptor,
 3275                    endpointMetadata,
 3276                    "endpoint.audit_sink.missing",
 3277                    "Endpoint governance audit emission was requested, but no host-owned audit sink was registered.",
 3278                    decision,
 3279                    "aspnetcore.endpoint.governance.configuration.audit_sink")
 3280                : EndpointGovernanceResult.Allow(decision);
 281
 3282            return new AuditStageResult(Actor: null, terminalResult);
 283        }
 284
 9285        IGovernanceActorContext actor = actorContextResolver.ResolveActorContext();
 9286        var receipt = DecisionReceipt.FromDecision(
 9287            actor,
 9288            descriptor.OperationName,
 9289            decision,
 9290            metadata: endpointMetadata,
 9291            decisionStage: "aspnetcore.endpoint.governance");
 292
 293        // Only a grant accepted for a decision that was not then denied is recorded, so a receipt never names a grant a
 294        // the authority for an operation that did not go ahead on it.
 9295        string? capabilityGrantId = descriptor.CapabilityScopes.Count > 0 && !decision.IsDenied
 9296            ? httpContext.Features.Get<IEndpointCapabilityGrantFeature>()?.GrantId
 9297            : null;
 298
 9299        if (!string.IsNullOrWhiteSpace(capabilityGrantId))
 300        {
 2301            receipt = receipt.WithCapabilityGrantId(capabilityGrantId);
 302        }
 303
 9304        await auditSink.WriteAsync(receipt, cancellationToken).ConfigureAwait(false);
 8305        return new AuditStageResult(actor, TerminalResult: null);
 36306    }
 307
 308    private EndpointGovernanceResult CreateCompletedResult(
 309        EndpointGovernanceDescriptor descriptor,
 310        IReadOnlyDictionary<string, string> endpointMetadata,
 311        GovernanceDecision decision,
 312        IGovernanceActorContext? actor)
 313    {
 33314        if (decision.RequiresAcknowledgment && descriptor.RequiresAcknowledgment)
 315        {
 6316            actor ??= actorContextResolver.ResolveActorContext();
 317
 6318            if (!AcknowledgmentActorBinding.IsSufficient(actor))
 319            {
 1320                return EndpointGovernanceResult.Block(
 1321                    Microsoft.AspNetCore.Http.Results.Problem(
 1322                        title: "Acknowledgment challenge actor binding failed.",
 1323                        detail: AcknowledgmentActorBinding.FailureMessage,
 1324                        statusCode: StatusCodes.Status403Forbidden,
 1325                        extensions: new Dictionary<string, object?>(StringComparer.Ordinal)
 1326                        {
 1327                            ["reasonCodes"] = new[] { AcknowledgmentActorBinding.FailureCode },
 1328                            ["outcome"] = decision.Outcome.ToString()
 1329                        }),
 1330                    decision);
 331            }
 332
 5333            AcknowledgmentChallenge challenge = acknowledgmentChallengeService.CreateChallenge(
 5334                actor,
 5335                descriptor.OperationName,
 5336                decision,
 5337                endpointMetadata);
 338
 5339            IResult challengeResult = Microsoft.AspNetCore.Http.Results.Json(
 5340                challenge,
 5341                statusCode: endpointOptions.AcknowledgmentChallengeStatusCode);
 342
 5343            return EndpointGovernanceResult.Challenge(challenge, challengeResult, decision);
 344        }
 345
 27346        return decision.CanProceed
 27347            ? EndpointGovernanceResult.Allow(decision)
 27348            : CreateBlockedDecisionResult(decision);
 349    }
 350
 351    private EndpointGovernanceResult CreateMetadataSanitizationFailure(
 352        GovernanceHttpRequestCorrelation correlation,
 353        GovernanceMetadataSanitizationResult sanitizationResult)
 354    {
 1355        var reasons = new List<OperationReason>(sanitizationResult.Reasons.Count + 1)
 1356        {
 1357            OperationReason.Create(
 1358                MetadataSanitizationDeniedReasonCode,
 1359                MetadataSanitizationDeniedReasonMessage)
 1360        };
 1361        reasons.AddRange(sanitizationResult.Reasons);
 362
 1363        var decision = GovernanceDecision.Deny(
 1364            reasons,
 1365            correlationId: correlation.CorrelationId,
 1366            traceId: correlation.TraceId,
 1367            policyVersion: endpointOptions.PolicyVersion,
 1368            policyHash: endpointOptions.PolicyHash);
 369
 1370        return CreateBlockedDecisionResult(decision);
 371    }
 372
 373    private static GovernanceDecision CreateAllowDecision(
 374        GovernanceEvaluationContext evaluationContext,
 375        string? traceId)
 376    {
 45377        return GovernanceDecision.Allow(
 45378            correlationId: evaluationContext.CorrelationId,
 45379            traceId: traceId,
 45380            policyVersion: evaluationContext.PolicyVersion,
 45381            policyHash: evaluationContext.PolicyHash);
 382    }
 383
 384    private static GovernanceDecision BackfillTraceId(GovernanceDecision decision, string? traceId)
 385    {
 49386        return decision.TraceId is null && traceId is not null
 49387            ? decision.WithTraceId(traceId)
 49388            : decision;
 389    }
 390
 391    private readonly record struct MetadataStageResult(
 392        IReadOnlyDictionary<string, string> Metadata,
 393        EndpointGovernanceResult? TerminalResult);
 394
 395    private readonly record struct DecisionStageResult(
 396        GovernanceDecision Decision,
 397        EndpointGovernanceResult? TerminalResult);
 398
 399    private readonly record struct AuditStageResult(
 400        IGovernanceActorContext? Actor,
 401        EndpointGovernanceResult? TerminalResult);
 402
 46403    private sealed class EndpointGovernanceOptionalServiceResolver(
 46404        IServiceProvider requestServices,
 46405        IServiceProvider governanceServices)
 406    {
 407        private IGovernancePolicyEvaluator<GovernanceEvaluationContext>? policyEvaluator;
 408        private IEndpointCapabilityGrantValidator? capabilityValidator;
 409        private IDecisionReceiptSink? auditSink;
 410        private IGovernanceMetadataSanitizer? metadataSanitizer;
 411        private bool policyEvaluatorResolved;
 412        private bool capabilityValidatorResolved;
 413        private bool auditSinkResolved;
 414        private bool metadataSanitizerResolved;
 415
 416        public IGovernancePolicyEvaluator<GovernanceEvaluationContext>? GetPolicyEvaluator()
 417        {
 39418            if (!policyEvaluatorResolved)
 419            {
 39420                policyEvaluator = requestServices
 39421                    .GetService<IGovernancePolicyEvaluator<GovernanceEvaluationContext>>();
 39422                policyEvaluatorResolved = true;
 423            }
 424
 39425            return policyEvaluator;
 426        }
 427
 428        public IEndpointCapabilityGrantValidator? GetCapabilityValidator()
 429        {
 20430            if (!capabilityValidatorResolved)
 431            {
 20432                capabilityValidator = requestServices.GetService<IEndpointCapabilityGrantValidator>();
 20433                capabilityValidatorResolved = true;
 434            }
 435
 20436            return capabilityValidator;
 437        }
 438
 439        public IDecisionReceiptSink? GetAuditSink()
 440        {
 12441            if (!auditSinkResolved)
 442            {
 12443                auditSink = governanceServices.GetService<IDecisionReceiptSink>();
 12444                auditSinkResolved = true;
 445            }
 446
 12447            return auditSink;
 448        }
 449
 450        public IGovernanceMetadataSanitizer? GetMetadataSanitizer()
 451        {
 46452            if (!metadataSanitizerResolved)
 453            {
 46454                metadataSanitizer = requestServices.GetService<IGovernanceMetadataSanitizer>();
 46455                metadataSanitizerResolved = true;
 456            }
 457
 46458            return metadataSanitizer;
 459        }
 460    }
 461
 462    private EndpointGovernanceResult CreateBlockedDecisionResult(GovernanceDecision decision)
 463    {
 16464        return decision.IsDenied && resultOptions.DeniedStatusCode == StatusCodes.Status403Forbidden
 16465            ? EndpointGovernanceResult.BlockWithDefaultFailure(decision)
 16466            : EndpointGovernanceResult.Block(decision.ToHttpResult(resultOptions), decision);
 467    }
 468
 469    private EndpointGovernanceResult CreateConfigurationFailure(
 470        HttpContext httpContext,
 471        EndpointGovernanceDescriptor descriptor,
 472        IReadOnlyDictionary<string, string> metadata,
 473        string code,
 474        string message,
 475        GovernanceDecision currentDecision,
 476        string decisionStage)
 477    {
 3478        var decision = GovernanceDecision.Deny(
 3479            code,
 3480            message,
 3481            correlationId: currentDecision.CorrelationId,
 3482            traceId: currentDecision.TraceId,
 3483            policyVersion: currentDecision.PolicyVersion,
 3484            policyHash: currentDecision.PolicyHash);
 485
 3486        return AsiBackboneEndpointGovernanceDevelopmentDiagnostics.IsEnabled(httpContext, endpointOptions)
 3487            ? EndpointGovernanceResult.Block(
 3488                AsiBackboneEndpointGovernanceDevelopmentDiagnostics.CreateProblem(
 3489                    httpContext,
 3490                    endpointOptions,
 3491                    descriptor,
 3492                    decision,
 3493                    decisionStage,
 3494                    title: "Endpoint governance configuration is incomplete.",
 3495                    detail: message,
 3496                    statusCode: endpointOptions.ConfigurationFailureStatusCode,
 3497                    metadata: metadata),
 3498                decision)
 3499            : EndpointGovernanceResult.Block(
 3500                Microsoft.AspNetCore.Http.Results.Problem(
 3501                    title: "Endpoint governance configuration is incomplete.",
 3502                    detail: message,
 3503                    statusCode: endpointOptions.ConfigurationFailureStatusCode,
 3504                    extensions: new Dictionary<string, object?>(StringComparer.Ordinal)
 3505                    {
 3506                        ["reasonCodes"] = decision.ReasonCodes,
 3507                        ["outcome"] = decision.Outcome.ToString()
 3508                    }),
 3509                decision);
 510    }
 511
 512    private EndpointGovernanceResult CreateCapabilityFailure(
 513        HttpContext httpContext,
 514        EndpointGovernanceDescriptor descriptor,
 515        IReadOnlyDictionary<string, string> metadata,
 516        string code,
 517        string message,
 518        GovernanceDecision currentDecision,
 519        string decisionStage)
 520    {
 5521        var decision = GovernanceDecision.Deny(
 5522            code,
 5523            message,
 5524            correlationId: currentDecision.CorrelationId,
 5525            traceId: currentDecision.TraceId,
 5526            policyVersion: currentDecision.PolicyVersion,
 5527            policyHash: currentDecision.PolicyHash);
 528
 5529        return AsiBackboneEndpointGovernanceDevelopmentDiagnostics.IsEnabled(httpContext, endpointOptions)
 5530            ? EndpointGovernanceResult.Block(
 5531                AsiBackboneEndpointGovernanceDevelopmentDiagnostics.CreateProblem(
 5532                    httpContext,
 5533                    endpointOptions,
 5534                    descriptor,
 5535                    decision,
 5536                    decisionStage,
 5537                    title: "Endpoint capability grant validation failed.",
 5538                    detail: message,
 5539                    statusCode: endpointOptions.CapabilityFailureStatusCode,
 5540                    metadata: metadata),
 5541                decision)
 5542            : EndpointGovernanceResult.Block(
 5543                Microsoft.AspNetCore.Http.Results.Problem(
 5544                    title: "Endpoint capability grant validation failed.",
 5545                    detail: message,
 5546                    statusCode: endpointOptions.CapabilityFailureStatusCode,
 5547                    extensions: new Dictionary<string, object?>(StringComparer.Ordinal)
 5548                    {
 5549                        ["reasonCodes"] = decision.ReasonCodes,
 5550                        ["outcome"] = decision.Outcome.ToString()
 5551                    }),
 5552                decision);
 553    }
 554}

Methods/Properties

.ctor(System.IServiceProvider,AsiBackbone.AspNetCore.Actors.IHttpGovernanceActorContextResolver,AsiBackbone.AspNetCore.Correlation.IHttpGovernanceRequestCorrelationResolver,AsiBackbone.AspNetCore.Acknowledgments.IAcknowledgmentChallengeService,Microsoft.Extensions.Options.IOptions`1<AsiBackbone.AspNetCore.Endpoints.EndpointGovernanceOptions>,Microsoft.Extensions.Options.IOptions`1<AsiBackbone.AspNetCore.Results.GovernanceHttpResultMappingOptions>)
EvaluateAsync()
SanitizeMetadataAsync()
EvaluatePolicyAsync()
ValidateCapabilityAsync()
EmitAuditAsync()
CreateCompletedResult(AsiBackbone.AspNetCore.Endpoints.EndpointGovernanceDescriptor,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,AsiBackbone.Core.Decisions.GovernanceDecision,AsiBackbone.Core.Actors.IGovernanceActorContext)
CreateMetadataSanitizationFailure(AsiBackbone.AspNetCore.Correlation.GovernanceHttpRequestCorrelation,AsiBackbone.Core.Metadata.GovernanceMetadataSanitizationResult)
CreateAllowDecision(AsiBackbone.Core.Constraints.GovernanceEvaluationContext,System.String)
BackfillTraceId(AsiBackbone.Core.Decisions.GovernanceDecision,System.String)
.ctor(System.IServiceProvider,System.IServiceProvider)
GetPolicyEvaluator()
GetCapabilityValidator()
GetAuditSink()
GetMetadataSanitizer()
CreateBlockedDecisionResult(AsiBackbone.Core.Decisions.GovernanceDecision)
CreateConfigurationFailure(Microsoft.AspNetCore.Http.HttpContext,AsiBackbone.AspNetCore.Endpoints.EndpointGovernanceDescriptor,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.String,System.String,AsiBackbone.Core.Decisions.GovernanceDecision,System.String)
CreateCapabilityFailure(Microsoft.AspNetCore.Http.HttpContext,AsiBackbone.AspNetCore.Endpoints.EndpointGovernanceDescriptor,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.String,System.String,AsiBackbone.Core.Decisions.GovernanceDecision,System.String)