< Summary

Information
Class: AsiBackbone.Core.Evaluation.DefaultGovernancePolicyEvaluator<T>
Assembly: AsiBackbone.Core
File(s): /home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.Core/Evaluation/DefaultGovernancePolicyEvaluator.cs
Line coverage
96%
Covered lines: 388
Uncovered lines: 16
Coverable lines: 404
Total lines: 740
Line coverage: 96%
Branch coverage
86%
Covered branches: 142
Total branches: 164
Branch coverage: 86.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

File(s)

/home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.Core/Evaluation/DefaultGovernancePolicyEvaluator.cs

#LineLine coverage
 1using System.Collections.ObjectModel;
 2using AsiBackbone.Core.Constraints;
 3using AsiBackbone.Core.Decisions;
 4using AsiBackbone.Core.Results;
 5using AsiBackbone.Core.ThreatModeling;
 6using Microsoft.Extensions.Logging;
 7
 8namespace AsiBackbone.Core.Evaluation;
 9
 10/// <summary>
 11/// Default policy evaluator that runs the active constraint structure and composes the result into a governance decisio
 12/// </summary>
 13/// <typeparam name="TContext">The framework-neutral evaluation context type.</typeparam>
 14public sealed class DefaultGovernancePolicyEvaluator<TContext> : IGovernancePolicyEvaluator<TContext>
 15    where TContext : IGovernanceEvaluationContext
 16{
 1717    private static readonly IReadOnlyList<ConstraintEvaluationResult> EmptyConstraintResults =
 1718        Array.AsReadOnly(Array.Empty<ConstraintEvaluationResult>());
 19
 20    private const string InvalidAllowedThreatOutcomeMessage =
 21        "Threat model contributors cannot return an Allowed outcome. Use ThreatAssessment.NoThreat() for no finding, or 
 22
 1723    private static readonly Action<ILogger, string, string, string, Exception?> EmptyPolicyAllowedWarning =
 1724        LoggerMessage.Define<string, string, string>(
 1725            LogLevel.Warning,
 1726            new EventId(4110, nameof(EmptyPolicyAllowedWarning)),
 1727            "Policy evaluation ran with zero constraints while DenyWhenNoConstraints is false; default empty-policy beha
 28
 1729    private static readonly Action<ILogger, string, string, string, string, string, Exception?> ConstraintExceptionDenie
 1730        LoggerMessage.Define<string, string, string, string, string>(
 1731            LogLevel.Error,
 1732            new EventId(4120, nameof(ConstraintExceptionDeniedError)),
 1733            "Policy constraint '{ConstraintName}' threw during evaluation and was converted to a denied governance decis
 34
 1735    private static readonly Action<ILogger, string, string, string, string, string, Exception?> ThreatContributorExcepti
 1736        LoggerMessage.Define<string, string, string, string, string>(
 1737            LogLevel.Error,
 1738            new EventId(4130, nameof(ThreatContributorExceptionDeniedError)),
 1739            "Threat model contributor '{ContributorName}' threw during evaluation and was converted to a denied governan
 40
 41    private readonly IGovernanceConstraint<TContext>[] constraints;
 42    private readonly IThreatModelContributor<TContext>[] threatModelContributors;
 43    private readonly IGovernanceDecisionPolicy<TContext>? decisionPolicy;
 44    private readonly ILogger<DefaultGovernancePolicyEvaluator<TContext>>? logger;
 45    private readonly GovernancePolicyOptions options;
 46
 47    /// <summary>
 48    /// Initializes a new instance of the <see cref="DefaultGovernancePolicyEvaluator{TContext}" /> class.
 49    /// </summary>
 50    /// <param name="constraints">The constraints that make up the active policy structure.</param>
 51    /// <param name="threatModelContributors">Threat model contributors that inspect the context before constraint compo
 52    /// <param name="decisionPolicy">Optional decision policy applied after composition.</param>
 53    /// <param name="options">Evaluator options applied during composition.</param>
 54    /// <param name="logger">Optional logger used to emit operational warning signals.</param>
 15655    public DefaultGovernancePolicyEvaluator(
 15656        IEnumerable<IGovernanceConstraint<TContext>> constraints,
 15657        IEnumerable<IThreatModelContributor<TContext>>? threatModelContributors,
 15658        IGovernanceDecisionPolicy<TContext>? decisionPolicy,
 15659        GovernancePolicyOptions? options,
 15660        ILogger<DefaultGovernancePolicyEvaluator<TContext>>? logger)
 61    {
 15662        ArgumentNullException.ThrowIfNull(constraints);
 63
 64        // Keep exact-sized private snapshots rather than wrapping caller-owned lists.
 65        // This avoids per-evaluator ReadOnlyCollection<T> wrappers and prevents later caller mutations
 66        // from changing deterministic constraint/contributor order or behavior.
 15567        this.constraints = [.. constraints];
 15568        this.threatModelContributors = threatModelContributors is null ? [] : [.. threatModelContributors];
 15569        this.decisionPolicy = decisionPolicy;
 15570        this.logger = logger;
 15571        this.options = options ?? new GovernancePolicyOptions();
 15572        this.options.Validate();
 14373    }
 74
 75    /// <inheritdoc />
 76    public async ValueTask<GovernanceDecision> EvaluateAsync(
 77        TContext context,
 78        CancellationToken cancellationToken = default)
 79    {
 20680        ArgumentNullException.ThrowIfNull(context);
 20581        cancellationToken.ThrowIfCancellationRequested();
 82
 20383        ThreatEvaluationResult threatEvaluation = await EvaluateThreatModelContributorsAsync(
 20384            context,
 20385            cancellationToken)
 20386            .ConfigureAwait(false);
 87
 19388        if (threatEvaluation.BlockingDecision is GovernanceDecision threatDecision)
 89        {
 3790            return await ApplyDecisionPolicyAsync(
 3791                context,
 3792                threatDecision,
 3793                EmptyConstraintResults,
 3794                protectedThreatDecision: threatDecision,
 3795                cancellationToken)
 3796                .ConfigureAwait(false);
 97        }
 98
 15699        if (constraints.Length == 0)
 100        {
 13101            return await EvaluateEmptyPolicyAsync(
 13102                context,
 13103                threatEvaluation.WarningReasons,
 13104                cancellationToken)
 13105                .ConfigureAwait(false);
 106        }
 107
 143108        List<ConstraintEvaluationResult>? results = CreateConstraintResultsBuffer();
 143109        var denials = new OperationReasonAccumulator();
 143110        var warnings = new OperationReasonAccumulator();
 143111        warnings.AddRange(threatEvaluation.WarningReasons);
 112
 786113        foreach (IGovernanceConstraint<TContext> constraint in constraints)
 114        {
 265115            cancellationToken.ThrowIfCancellationRequested();
 116
 117            ConstraintEvaluationResult result;
 118            try
 119            {
 264120                result = await constraint
 264121                    .EvaluateAsync(context, cancellationToken)
 264122                    .ConfigureAwait(false);
 246123            }
 18124            catch (Exception exception) when (ShouldConvertExceptionToDenial(exception, options.TreatConstraintException
 125            {
 8126                return await CreateConstraintExceptionDecisionAsync(
 8127                    context,
 8128                    constraint,
 8129                    results,
 8130                    exception,
 8131                    cancellationToken)
 8132                    .ConfigureAwait(false);
 133            }
 134
 246135            results?.Add(result);
 136
 246137            if (!AccumulateConstraintResult(
 246138                    result,
 246139                    ref denials,
 246140                    ref warnings,
 246141                    options.ShortCircuitOnFirstDenial))
 142            {
 143                break;
 144            }
 235145        }
 146
 124147        GovernanceDecision composedDecision = Compose(
 124148            context,
 124149            denials,
 124150            warnings,
 124151            includeWarningsWhenDenied: options.ShortCircuitOnFirstDenial);
 152
 124153        return await ApplyDecisionPolicyAsync(
 124154            context,
 124155            composedDecision,
 124156            CreateConstraintResultsView(results),
 124157            CreateProtectedThreatWarningDecision(context, threatEvaluation.WarningReasons, composedDecision),
 124158            cancellationToken)
 124159            .ConfigureAwait(false);
 182160    }
 161
 162    private static bool ShouldConvertExceptionToDenial(Exception exception, bool treatExceptionAsDenial)
 163    {
 32164        return treatExceptionAsDenial &&
 32165               exception is not OperationCanceledException &&
 32166               !IsCriticalException(exception);
 167    }
 168
 169    private static bool IsCriticalException(Exception exception)
 170    {
 29171        return exception is OutOfMemoryException or
 29172               StackOverflowException or
 29173               AccessViolationException or
 29174               AppDomainUnloadedException or
 29175               BadImageFormatException or
 29176               InvalidProgramException ||
 29177               (exception.InnerException is not null && IsCriticalException(exception.InnerException));
 178    }
 179
 180    private List<ConstraintEvaluationResult>? CreateConstraintResultsBuffer()
 181    {
 143182        return decisionPolicy is null
 143183            ? null
 143184            : new List<ConstraintEvaluationResult>(constraints.Length);
 185    }
 186
 187    private static bool AccumulateConstraintResult(
 188        ConstraintEvaluationResult result,
 189        ref OperationReasonAccumulator denials,
 190        ref OperationReasonAccumulator warnings,
 191        bool shortCircuitOnFirstDenial)
 192    {
 246193        if (result.IsDenied)
 194        {
 33195            denials.AddRange(result.Reasons);
 196
 33197            if (!shortCircuitOnFirstDenial)
 198            {
 22199                warnings = default;
 200            }
 201
 33202            return !shortCircuitOnFirstDenial;
 203        }
 204
 213205        if (result.IsWarning && denials.Count == 0)
 206        {
 91207            warnings.AddRange(result.Reasons);
 208        }
 209
 213210        return true;
 211    }
 212
 213    private async ValueTask<GovernanceDecision> EvaluateEmptyPolicyAsync(
 214        TContext context,
 215        IReadOnlyList<OperationReason> threatWarningReasons,
 216        CancellationToken cancellationToken)
 217    {
 13218        if (!options.DenyWhenNoConstraints)
 219        {
 4220            LogEmptyPolicyAllowed(context);
 221        }
 222
 13223        GovernanceDecision noConstraintDecision = CreateNoConstraintDecision(
 13224            context,
 13225            threatWarningReasons,
 13226            options.DenyWhenNoConstraints);
 227
 13228        return await ApplyDecisionPolicyAsync(
 13229            context,
 13230            noConstraintDecision,
 13231            EmptyConstraintResults,
 13232            protectedThreatDecision: threatWarningReasons.Count > 0 ? noConstraintDecision : null,
 13233            cancellationToken)
 13234            .ConfigureAwait(false);
 13235    }
 236
 237    private static GovernanceDecision Compose(
 238        TContext context,
 239        OperationReasonAccumulator denials,
 240        OperationReasonAccumulator warnings,
 241        bool includeWarningsWhenDenied)
 242    {
 124243        return denials.Count > 0
 124244            ? includeWarningsWhenDenied && warnings.Count > 0
 124245                ? GovernanceDecision.Deny(
 124246                    warnings.ConcatAsArray(denials),
 124247                    correlationId: context.CorrelationId,
 124248                    traceId: context.TraceId,
 124249                    policyVersion: context.PolicyVersion,
 124250                    policyHash: context.PolicyHash)
 124251                : CreateDeniedDecision(context, denials)
 124252            : warnings.Count > 0
 124253            ? CreateWarningDecision(context, warnings)
 124254            : GovernanceDecision.Allow(
 124255            correlationId: context.CorrelationId,
 124256            traceId: context.TraceId,
 124257            policyVersion: context.PolicyVersion,
 124258            policyHash: context.PolicyHash);
 259    }
 260
 261    private static GovernanceDecision CreateNoConstraintDecision(
 262        TContext context,
 263        IReadOnlyList<OperationReason> threatWarningReasons)
 264    {
 4265        return threatWarningReasons.Count > 0
 4266            ? GovernanceDecision.Warning(
 4267                threatWarningReasons,
 4268                correlationId: context.CorrelationId,
 4269                traceId: context.TraceId,
 4270                policyVersion: context.PolicyVersion,
 4271                policyHash: context.PolicyHash)
 4272            : GovernanceDecision.Allow(
 4273            correlationId: context.CorrelationId,
 4274            traceId: context.TraceId,
 4275            policyVersion: context.PolicyVersion,
 4276            policyHash: context.PolicyHash);
 277    }
 278
 279    private GovernanceDecision CreateNoConstraintDecision(
 280        TContext context,
 281        IReadOnlyList<OperationReason> threatWarningReasons,
 282        bool denyWhenNoConstraints)
 283    {
 13284        return !denyWhenNoConstraints
 13285            ? CreateNoConstraintDecision(context, threatWarningReasons)
 13286            : GovernanceDecision.Deny(
 13287            options.NoConstraintsReasonCode,
 13288            options.NoConstraintsReasonMessage,
 13289            correlationId: context.CorrelationId,
 13290            traceId: context.TraceId,
 13291            policyVersion: context.PolicyVersion,
 13292            policyHash: context.PolicyHash);
 293    }
 294
 295    private static GovernanceDecision CreateDeniedDecision(
 296        TContext context,
 297        OperationReasonAccumulator denials)
 298    {
 19299        return denials.Count == 1
 19300            ? GovernanceDecision.Deny(
 19301                denials.FirstReason!,
 19302                correlationId: context.CorrelationId,
 19303                traceId: context.TraceId,
 19304                policyVersion: context.PolicyVersion,
 19305                policyHash: context.PolicyHash)
 19306            : GovernanceDecision.Deny(
 19307                denials.AsReadOnlyList(),
 19308                correlationId: context.CorrelationId,
 19309                traceId: context.TraceId,
 19310                policyVersion: context.PolicyVersion,
 19311                policyHash: context.PolicyHash);
 312    }
 313
 314    private static GovernanceDecision CreateWarningDecision(
 315        TContext context,
 316        OperationReasonAccumulator warnings)
 317    {
 79318        return warnings.Count == 1
 79319            ? GovernanceDecision.Warning(
 79320                warnings.FirstReason!,
 79321                correlationId: context.CorrelationId,
 79322                traceId: context.TraceId,
 79323                policyVersion: context.PolicyVersion,
 79324                policyHash: context.PolicyHash)
 79325            : GovernanceDecision.Warning(
 79326                warnings.AsReadOnlyList(),
 79327                correlationId: context.CorrelationId,
 79328                traceId: context.TraceId,
 79329                policyVersion: context.PolicyVersion,
 79330                policyHash: context.PolicyHash);
 331    }
 332
 333    private static IReadOnlyList<ConstraintEvaluationResult> CreateConstraintResultsView(
 334        List<ConstraintEvaluationResult>? results)
 335    {
 132336        return results is null || results.Count == 0
 132337            ? EmptyConstraintResults
 132338            : results.AsReadOnly();
 339    }
 340
 341    private static GovernanceDecision? CreateProtectedThreatWarningDecision(
 342        TContext context,
 343        IReadOnlyList<OperationReason> threatWarningReasons,
 344        GovernanceDecision composedDecision)
 345    {
 124346        return threatWarningReasons.Count > 0 && composedDecision.CanProceed
 124347            ? GovernanceDecision.Warning(
 124348                threatWarningReasons,
 124349                correlationId: context.CorrelationId,
 124350                traceId: context.TraceId,
 124351                policyVersion: context.PolicyVersion,
 124352                policyHash: context.PolicyHash)
 124353            : null;
 354    }
 355
 356    private async ValueTask<GovernanceDecision> ApplyDecisionPolicyAsync(
 357        TContext context,
 358        GovernanceDecision decision,
 359        IReadOnlyList<ConstraintEvaluationResult> results,
 360        GovernanceDecision? protectedThreatDecision,
 361        CancellationToken cancellationToken)
 362    {
 182363        if (decisionPolicy is null)
 364        {
 157365            return decision;
 366        }
 367
 25368        GovernanceDecision policyDecision = await decisionPolicy
 25369            .ApplyAsync(context, decision, results, cancellationToken)
 25370            .ConfigureAwait(false);
 371
 25372        return options.PreventThreatAssessmentAllowDowngrade && protectedThreatDecision is not null && policyDecision.Is
 25373            ? protectedThreatDecision
 25374            : policyDecision;
 182375    }
 376
 377    private async ValueTask<ThreatEvaluationResult> EvaluateThreatModelContributorsAsync(
 378        TContext context,
 379        CancellationToken cancellationToken)
 380    {
 203381        if (threatModelContributors.Length == 0)
 382        {
 138383            return ThreatEvaluationResult.Empty;
 384        }
 385
 65386        List<OperationReason>? reasons = null;
 65387        OperationReason? selectedReason = null;
 65388        GovernanceDecisionOutcome? selectedOutcome = null;
 389
 269390        foreach (IThreatModelContributor<TContext> contributor in threatModelContributors)
 391        {
 77392            cancellationToken.ThrowIfCancellationRequested();
 393
 394            ThreatAssessment? assessment;
 395            try
 396            {
 77397                assessment = await contributor
 77398                    .AssessAsync(context, cancellationToken)
 77399                    .ConfigureAwait(false);
 63400            }
 14401            catch (Exception exception) when (ShouldConvertExceptionToDenial(exception, options.TreatThreatContributorEx
 402            {
 5403                return CreateThreatContributorExceptionResult(context, contributor, exception);
 404            }
 405
 63406            if (assessment is null || !assessment.IsActionable)
 407            {
 408                continue;
 409            }
 410
 60411            GovernanceDecisionOutcome effectiveOutcome = GetEffectiveThreatOutcome(assessment);
 59412            var reason = assessment.ToOperationReason(GetContributorName(contributor), effectiveOutcome);
 59413            GovernanceDecisionOutcome moreRestrictiveOutcome = SelectMoreRestrictiveOutcome(selectedOutcome, effectiveOu
 414
 59415            if (selectedOutcome != moreRestrictiveOutcome)
 416            {
 54417                selectedOutcome = moreRestrictiveOutcome;
 54418                selectedReason = reason;
 419            }
 420
 59421            reasons ??= [];
 59422            reasons.Add(reason);
 59423        }
 424
 50425        return reasons is null || selectedOutcome is null
 50426            ? ThreatEvaluationResult.Empty
 50427            : CreateThreatEvaluationResult(context, selectedOutcome.Value, selectedReason!, reasons.AsReadOnly());
 193428    }
 429
 430    private ThreatEvaluationResult CreateThreatContributorExceptionResult(
 431        TContext context,
 432        IThreatModelContributor<TContext> contributor,
 433        Exception exception)
 434    {
 5435        string contributorName = GetContributorName(contributor);
 5436        LogThreatContributorExceptionDenied(context, contributorName, exception);
 437
 5438        Dictionary<string, string> metadata = new(StringComparer.Ordinal)
 5439        {
 5440            ["threat.contributor"] = contributorName,
 5441            ["threat.failure"] = exception.GetType().Name
 5442        };
 443
 5444        var reason = OperationReason.Create(
 5445            options.ThreatContributorExceptionReasonCode,
 5446            options.ThreatContributorExceptionReasonMessage,
 5447            metadata);
 448
 5449        var decision = GovernanceDecision.Deny(
 5450            reason,
 5451            correlationId: context.CorrelationId,
 5452            traceId: context.TraceId,
 5453            policyVersion: context.PolicyVersion,
 5454            policyHash: context.PolicyHash);
 455
 5456        return ThreatEvaluationResult.ForBlockingDecision(decision);
 457    }
 458
 459    private static ThreatEvaluationResult CreateThreatEvaluationResult(
 460        TContext context,
 461        GovernanceDecisionOutcome outcome,
 462        OperationReason selectedReason,
 463        ReadOnlyCollection<OperationReason> reasons)
 464    {
 48465        return outcome switch
 48466        {
 22467            GovernanceDecisionOutcome.Denied => ThreatEvaluationResult.ForBlockingDecision(
 22468                GovernanceDecision.Deny(
 22469                    reasons,
 22470                    correlationId: context.CorrelationId,
 22471                    traceId: context.TraceId,
 22472                    policyVersion: context.PolicyVersion,
 22473                    policyHash: context.PolicyHash)),
 5474            GovernanceDecisionOutcome.Deferred => ThreatEvaluationResult.ForBlockingDecision(
 5475                GovernanceDecision.Defer(
 5476                    selectedReason.Code,
 5477                    selectedReason.Message,
 5478                    correlationId: context.CorrelationId,
 5479                    traceId: context.TraceId,
 5480                    policyVersion: context.PolicyVersion,
 5481                    policyHash: context.PolicyHash)),
 3482            GovernanceDecisionOutcome.AcknowledgmentRequired => ThreatEvaluationResult.ForBlockingDecision(
 3483                GovernanceDecision.RequireAcknowledgment(
 3484                    selectedReason.Code,
 3485                    selectedReason.Message,
 3486                    correlationId: context.CorrelationId,
 3487                    traceId: context.TraceId,
 3488                    policyVersion: context.PolicyVersion,
 3489                    policyHash: context.PolicyHash)),
 2490            GovernanceDecisionOutcome.EscalationRecommended => ThreatEvaluationResult.ForBlockingDecision(
 2491                GovernanceDecision.Escalate(
 2492                    selectedReason.Code,
 2493                    selectedReason.Message,
 2494                    correlationId: context.CorrelationId,
 2495                    traceId: context.TraceId,
 2496                    policyVersion: context.PolicyVersion,
 2497                    policyHash: context.PolicyHash)),
 15498            GovernanceDecisionOutcome.Warning => ThreatEvaluationResult.ForWarningReasons(reasons),
 1499            GovernanceDecisionOutcome.Allowed => throw CreateInvalidAllowedThreatOutcomeException(),
 0500            _ => ThreatEvaluationResult.Empty
 48501        };
 502    }
 503
 504    private static GovernanceDecisionOutcome GetEffectiveThreatOutcome(ThreatAssessment assessment)
 505    {
 60506        return assessment.RecommendedOutcome is GovernanceDecisionOutcome.Allowed
 60507            ? throw CreateInvalidAllowedThreatOutcomeException()
 60508            : assessment.RecommendedOutcome;
 509    }
 510
 511    private static InvalidOperationException CreateInvalidAllowedThreatOutcomeException()
 512    {
 3513        return new InvalidOperationException(InvalidAllowedThreatOutcomeMessage);
 514    }
 515
 516    private static GovernanceDecisionOutcome SelectMoreRestrictiveOutcome(
 517        GovernanceDecisionOutcome? current,
 518        GovernanceDecisionOutcome candidate)
 519    {
 59520        return current is null
 59521            ? candidate
 59522            : GetThreatOutcomeRank(candidate) > GetThreatOutcomeRank(current.Value)
 59523            ? candidate
 59524            : current.Value;
 525    }
 526
 527    private static int GetThreatOutcomeRank(GovernanceDecisionOutcome outcome)
 528    {
 25529        return outcome switch
 25530        {
 2531            GovernanceDecisionOutcome.Denied => 5,
 4532            GovernanceDecisionOutcome.EscalationRecommended => 4,
 4533            GovernanceDecisionOutcome.AcknowledgmentRequired => 3,
 4534            GovernanceDecisionOutcome.Deferred => 2,
 10535            GovernanceDecisionOutcome.Warning => 1,
 1536            GovernanceDecisionOutcome.Allowed => throw CreateInvalidAllowedThreatOutcomeException(),
 0537            _ => 0
 25538        };
 539    }
 540
 541    private static string GetContributorName(IThreatModelContributor<TContext> contributor)
 542    {
 64543        return string.IsNullOrWhiteSpace(contributor.Name)
 64544            ? "<unnamed>"
 64545            : contributor.Name.Trim();
 546    }
 547
 548    private async ValueTask<GovernanceDecision> CreateConstraintExceptionDecisionAsync(
 549        TContext context,
 550        IGovernanceConstraint<TContext> constraint,
 551        List<ConstraintEvaluationResult>? results,
 552        Exception exception,
 553        CancellationToken cancellationToken)
 554    {
 8555        LogConstraintExceptionDenied(context, constraint.Name, exception);
 556
 8557        var exceptionResult = ConstraintEvaluationResult.Deny(
 8558            options.ConstraintExceptionReasonCode,
 8559            options.ConstraintExceptionReasonMessage);
 8560        results?.Add(exceptionResult);
 561
 8562        var exceptionDecision = GovernanceDecision.Deny(
 8563            exceptionResult.Reasons,
 8564            correlationId: context.CorrelationId,
 8565            traceId: context.TraceId,
 8566            policyVersion: context.PolicyVersion,
 8567            policyHash: context.PolicyHash);
 568
 8569        return await ApplyDecisionPolicyAsync(
 8570            context,
 8571            exceptionDecision,
 8572            CreateConstraintResultsView(results),
 8573            protectedThreatDecision: null,
 8574            cancellationToken)
 8575            .ConfigureAwait(false);
 8576    }
 577
 578    private void LogEmptyPolicyAllowed(TContext context)
 579    {
 4580        if (logger is null)
 581        {
 3582            return;
 583        }
 584
 1585        EmptyPolicyAllowedWarning(
 1586            logger,
 1587            context.CorrelationId ?? string.Empty,
 1588            context.PolicyVersion ?? string.Empty,
 1589            context.PolicyHash ?? string.Empty,
 1590            null);
 1591    }
 592
 593    private void LogConstraintExceptionDenied(
 594        TContext context,
 595        string constraintName,
 596        Exception exception)
 597    {
 8598        if (logger is null)
 599        {
 5600            return;
 601        }
 602
 3603        ConstraintExceptionDeniedError(
 3604            logger,
 3605            string.IsNullOrWhiteSpace(constraintName) ? "<unnamed>" : constraintName,
 3606            exception.GetType().Name,
 3607            context.CorrelationId ?? string.Empty,
 3608            context.PolicyVersion ?? string.Empty,
 3609            context.PolicyHash ?? string.Empty,
 3610            exception);
 3611    }
 612
 613    private void LogThreatContributorExceptionDenied(
 614        TContext context,
 615        string contributorName,
 616        Exception exception)
 617    {
 5618        if (logger is null)
 619        {
 5620            return;
 621        }
 622
 0623        ThreatContributorExceptionDeniedError(
 0624            logger,
 0625            contributorName,
 0626            exception.GetType().Name,
 0627            context.CorrelationId ?? string.Empty,
 0628            context.PolicyVersion ?? string.Empty,
 0629            context.PolicyHash ?? string.Empty,
 0630            exception);
 0631    }
 632
 633    private sealed class ThreatEvaluationResult
 634    {
 17635        private static readonly IReadOnlyList<OperationReason> EmptyReasons =
 17636            Array.AsReadOnly(Array.Empty<OperationReason>());
 637
 69638        private ThreatEvaluationResult(
 69639            IReadOnlyList<OperationReason> warningReasons,
 69640            GovernanceDecision? blockingDecision)
 641        {
 69642            WarningReasons = warningReasons;
 69643            BlockingDecision = blockingDecision;
 69644        }
 645
 646        public static ThreatEvaluationResult Empty { get; } = new(EmptyReasons, blockingDecision: null);
 647
 648        public IReadOnlyList<OperationReason> WarningReasons { get; }
 649
 650        public GovernanceDecision? BlockingDecision { get; }
 651
 652        public static ThreatEvaluationResult ForWarningReasons(IReadOnlyList<OperationReason> reasons)
 653        {
 15654            return new ThreatEvaluationResult(reasons, blockingDecision: null);
 655        }
 656
 657        public static ThreatEvaluationResult ForBlockingDecision(GovernanceDecision decision)
 658        {
 37659            return new ThreatEvaluationResult(EmptyReasons, decision);
 660        }
 661    }
 662
 663    private struct OperationReasonAccumulator
 664    {
 665        private List<OperationReason>? additionalReasons;
 666
 667        public OperationReason? FirstReason { get; private set; }
 668
 669        public int Count { get; private set; }
 670
 671        public void AddRange(IReadOnlyList<OperationReason> reasons)
 672        {
 808673            for (int index = 0; index < reasons.Count; index++)
 674            {
 137675                Add(reasons[index]);
 676            }
 267677        }
 678
 679        public readonly OperationReason[] ConcatAsArray(OperationReasonAccumulator other)
 680        {
 8681            int totalCount = Count + other.Count;
 8682            if (totalCount == 0)
 683            {
 0684                return [];
 685            }
 686
 8687            var reasons = new OperationReason[totalCount];
 8688            int nextIndex = CopyTo(reasons, 0);
 8689            _ = other.CopyTo(reasons, nextIndex);
 690
 8691            return reasons;
 692        }
 693
 694        public readonly ReadOnlyCollection<OperationReason> AsReadOnlyList()
 695        {
 10696            return Count switch
 10697            {
 0698                0 => Array.AsReadOnly(Array.Empty<OperationReason>()),
 0699                1 => Array.AsReadOnly([FirstReason!]),
 10700                _ => additionalReasons!.AsReadOnly()
 10701            };
 702        }
 703
 704        private void Add(OperationReason? reason)
 705        {
 137706            if (reason is null)
 707            {
 0708                return;
 709            }
 710
 137711            if (Count == 0)
 712            {
 122713                FirstReason = reason;
 122714                Count = 1;
 122715                return;
 716            }
 717
 15718            additionalReasons ??= [FirstReason!];
 15719            additionalReasons.Add(reason);
 15720            Count++;
 15721        }
 722
 723        private readonly int CopyTo(OperationReason[] destination, int startIndex)
 724        {
 16725            if (Count == 0)
 726            {
 0727                return startIndex;
 728            }
 729
 16730            if (Count == 1)
 731            {
 13732                destination[startIndex] = FirstReason!;
 13733                return startIndex + 1;
 734            }
 735
 3736            additionalReasons!.CopyTo(destination, startIndex);
 3737            return startIndex + additionalReasons.Count;
 738        }
 739    }
 740}

Methods/Properties

.cctor()
.ctor(System.Collections.Generic.IEnumerable`1<AsiBackbone.Core.Constraints.IGovernanceConstraint`1<TContext>>,System.Collections.Generic.IEnumerable`1<AsiBackbone.Core.ThreatModeling.IThreatModelContributor`1<TContext>>,AsiBackbone.Core.Evaluation.IGovernanceDecisionPolicy`1<TContext>,AsiBackbone.Core.Evaluation.GovernancePolicyOptions,Microsoft.Extensions.Logging.ILogger`1<AsiBackbone.Core.Evaluation.DefaultGovernancePolicyEvaluator`1<TContext>>)
EvaluateAsync()
ShouldConvertExceptionToDenial(System.Exception,System.Boolean)
IsCriticalException(System.Exception)
CreateConstraintResultsBuffer()
AccumulateConstraintResult(AsiBackbone.Core.Constraints.ConstraintEvaluationResult,AsiBackbone.Core.Evaluation.DefaultGovernancePolicyEvaluator`1/OperationReasonAccumulator<TContext>&,AsiBackbone.Core.Evaluation.DefaultGovernancePolicyEvaluator`1/OperationReasonAccumulator<TContext>&,System.Boolean)
EvaluateEmptyPolicyAsync()
Compose(TContext,AsiBackbone.Core.Evaluation.DefaultGovernancePolicyEvaluator`1/OperationReasonAccumulator<TContext>,AsiBackbone.Core.Evaluation.DefaultGovernancePolicyEvaluator`1/OperationReasonAccumulator<TContext>,System.Boolean)
CreateNoConstraintDecision(TContext,System.Collections.Generic.IReadOnlyList`1<AsiBackbone.Core.Results.OperationReason>)
CreateNoConstraintDecision(TContext,System.Collections.Generic.IReadOnlyList`1<AsiBackbone.Core.Results.OperationReason>,System.Boolean)
CreateDeniedDecision(TContext,AsiBackbone.Core.Evaluation.DefaultGovernancePolicyEvaluator`1/OperationReasonAccumulator<TContext>)
CreateWarningDecision(TContext,AsiBackbone.Core.Evaluation.DefaultGovernancePolicyEvaluator`1/OperationReasonAccumulator<TContext>)
CreateConstraintResultsView(System.Collections.Generic.List`1<AsiBackbone.Core.Constraints.ConstraintEvaluationResult>)
CreateProtectedThreatWarningDecision(TContext,System.Collections.Generic.IReadOnlyList`1<AsiBackbone.Core.Results.OperationReason>,AsiBackbone.Core.Decisions.GovernanceDecision)
ApplyDecisionPolicyAsync()
EvaluateThreatModelContributorsAsync()
CreateThreatContributorExceptionResult(TContext,AsiBackbone.Core.ThreatModeling.IThreatModelContributor`1<TContext>,System.Exception)
CreateThreatEvaluationResult(TContext,AsiBackbone.Core.Decisions.GovernanceDecisionOutcome,AsiBackbone.Core.Results.OperationReason,System.Collections.ObjectModel.ReadOnlyCollection`1<AsiBackbone.Core.Results.OperationReason>)
GetEffectiveThreatOutcome(AsiBackbone.Core.ThreatModeling.ThreatAssessment)
CreateInvalidAllowedThreatOutcomeException()
SelectMoreRestrictiveOutcome(System.Nullable`1<AsiBackbone.Core.Decisions.GovernanceDecisionOutcome>,AsiBackbone.Core.Decisions.GovernanceDecisionOutcome)
GetThreatOutcomeRank(AsiBackbone.Core.Decisions.GovernanceDecisionOutcome)
GetContributorName(AsiBackbone.Core.ThreatModeling.IThreatModelContributor`1<TContext>)
CreateConstraintExceptionDecisionAsync()
LogEmptyPolicyAllowed(TContext)
LogConstraintExceptionDenied(TContext,System.String,System.Exception)
LogThreatContributorExceptionDenied(TContext,System.String,System.Exception)
.cctor()
.ctor(System.Collections.Generic.IReadOnlyList`1<AsiBackbone.Core.Results.OperationReason>,AsiBackbone.Core.Decisions.GovernanceDecision)
ForWarningReasons(System.Collections.Generic.IReadOnlyList`1<AsiBackbone.Core.Results.OperationReason>)
ForBlockingDecision(AsiBackbone.Core.Decisions.GovernanceDecision)
AddRange(System.Collections.Generic.IReadOnlyList`1<AsiBackbone.Core.Results.OperationReason>)
ConcatAsArray(AsiBackbone.Core.Evaluation.DefaultGovernancePolicyEvaluator`1/OperationReasonAccumulator<TContext>)
AsReadOnlyList()
Add(AsiBackbone.Core.Results.OperationReason)
CopyTo(AsiBackbone.Core.Results.OperationReason[],System.Int32)