< Summary

Information
Class: AsiBackbone.EntityFrameworkCore.CapabilityGrants.EfCoreCapabilityGrantUseStore
Assembly: AsiBackbone.EntityFrameworkCore
File(s): /home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.EntityFrameworkCore/CapabilityGrants/EfCoreCapabilityGrantUseStore.cs
Line coverage
78%
Covered lines: 83
Uncovered lines: 23
Coverable lines: 106
Total lines: 203
Line coverage: 78.3%
Branch coverage
56%
Covered branches: 13
Total branches: 23
Branch coverage: 56.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
TryConsumeAsync()57.89%281971.01%
SetStoppedAsync(...)100%11100%
SetCancelledAsync(...)100%11100%
PurgeExpiredAsync()100%11100%
SetStateAsync()50%2285.71%
Entries()100%11100%
AddClamped(...)50%22100%

File(s)

/home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.EntityFrameworkCore/CapabilityGrants/EfCoreCapabilityGrantUseStore.cs

#LineLine coverage
 1using System.Data.Common;
 2using AsiBackbone.Core.CapabilityGrants;
 3using AsiBackbone.Core.Entities;
 4using AsiBackbone.EntityFrameworkCore.Persistence;
 5using Microsoft.EntityFrameworkCore;
 6
 7namespace AsiBackbone.EntityFrameworkCore.CapabilityGrants;
 8
 9/// <summary>Provides durable, atomic capability-grant use control through a host-owned EF Core context.</summary>
 10public sealed class EfCoreCapabilityGrantUseStore : ICapabilityGrantUseStore
 11{
 12    private readonly DbContext dbContext;
 13    private readonly EfCoreCapabilityGrantUseStoreOptions options;
 14
 15    /// <summary>Initializes the durable use store.</summary>
 416    public EfCoreCapabilityGrantUseStore(DbContext dbContext, EfCoreCapabilityGrantUseStoreOptions options)
 17    {
 418        ArgumentNullException.ThrowIfNull(dbContext);
 419        ArgumentNullException.ThrowIfNull(options);
 420        options.Validate();
 421        this.dbContext = dbContext;
 422        this.options = options;
 423    }
 24
 25    /// <inheritdoc />
 26    public async ValueTask<CapabilityGrantUseResult> TryConsumeAsync(
 27        CapabilityGrant grant,
 28        int maxUseCount,
 29        DateTimeOffset usedUtc,
 30        CancellationToken cancellationToken = default)
 31    {
 532        ArgumentNullException.ThrowIfNull(grant);
 533        ArgumentOutOfRangeException.ThrowIfLessThan(maxUseCount, 1);
 534        cancellationToken.ThrowIfCancellationRequested();
 35
 536        DateTimeOffset normalizedUsedUtc = usedUtc.ToUniversalTime();
 537        DateTimeOffset retainUntilUtc = AddClamped(grant.ExpiresUtc, options.RetentionGracePeriod);
 538        if (normalizedUsedUtc > retainUntilUtc)
 39        {
 040            return CapabilityGrantUseResult.RetentionElapsed(
 041                "The grant is past the EF Core use store's retention horizon.");
 42        }
 43
 1044        for (int attempt = 0; attempt <= options.ContentionRetryCount; attempt++)
 45        {
 46            try
 47            {
 548                int affected = await Entries()
 549                    .Where(entity => entity.Issuer == grant.Issuer
 550                        && entity.TokenId == grant.TokenId
 551                        && entity.State == GrantUseState.Accepted
 552                        && entity.UseCount < maxUseCount)
 553                    .ExecuteUpdateAsync(setters => setters
 554                        .SetProperty(entity => entity.UseCount, entity => entity.UseCount + 1)
 555                        .SetProperty(entity => entity.LastUsedUtc, normalizedUsedUtc)
 556                        .SetProperty(entity => entity.RetainUntilUtc, retainUntilUtc)
 557                        .SetProperty(entity => entity.ConcurrencyStamp, GovernanceEntity.NewConcurrencyStamp()), cancell
 558                    .ConfigureAwait(false);
 59
 460                if (affected == 1)
 61                {
 062                    int count = await Entries().AsNoTracking()
 063                        .Where(entity => entity.Issuer == grant.Issuer && entity.TokenId == grant.TokenId)
 064                        .Select(entity => entity.UseCount)
 065                        .SingleAsync(cancellationToken)
 066                        .ConfigureAwait(false);
 067                    return CapabilityGrantUseResult.Accepted(count);
 68                }
 69
 470                CapabilityGrantUseEntity? existing = await Entries().AsNoTracking()
 471                    .SingleOrDefaultAsync(
 472                        entity => entity.Issuer == grant.Issuer && entity.TokenId == grant.TokenId,
 473                        cancellationToken)
 474                    .ConfigureAwait(false);
 75
 476                if (existing is not null)
 77                {
 378                    return existing.State switch
 379                    {
 180                        GrantUseState.Stopped => CapabilityGrantUseResult.Stopped("The durable capability grant is stopp
 181                        GrantUseState.Cancelled => CapabilityGrantUseResult.Cancelled("The durable capability grant is c
 182                        GrantUseState.Accepted or GrantUseState.UseLimitExceeded => CapabilityGrantUseResult.UseLimitExc
 083                        GrantUseState.Unavailable or GrantUseState.Unspecified => CapabilityGrantUseResult.Unavailable(
 084                            "The durable capability grant use record has an unavailable state."),
 085                        _ => CapabilityGrantUseResult.Unavailable("The durable capability grant use record has an unknow
 386                    };
 87                }
 88
 189                _ = Entries().Add(new CapabilityGrantUseEntity
 190                {
 191                    Id = Guid.NewGuid(),
 192                    ConcurrencyStamp = GovernanceEntity.NewConcurrencyStamp(),
 193                    Issuer = grant.Issuer,
 194                    TokenId = grant.TokenId,
 195                    UseCount = 1,
 196                    State = GrantUseState.Accepted,
 197                    LastUsedUtc = normalizedUsedUtc,
 198                    RetainUntilUtc = retainUntilUtc
 199                });
 1100                _ = await dbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 1101                return CapabilityGrantUseResult.Accepted(1);
 102            }
 0103            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
 104            {
 0105                throw;
 106            }
 1107            catch (Exception exception) when ((exception is DbUpdateException or DbException) && attempt < options.Conte
 108            {
 0109                dbContext.ChangeTracker.Clear();
 0110                await Task.Delay(TimeSpan.FromMilliseconds(10 * (attempt + 1)), cancellationToken).ConfigureAwait(false)
 0111            }
 0112            catch (InvalidOperationException) when (attempt < options.ContentionRetryCount)
 113            {
 0114                dbContext.ChangeTracker.Clear();
 0115                await Task.Delay(TimeSpan.FromMilliseconds(10 * (attempt + 1)), cancellationToken).ConfigureAwait(false)
 116            }
 1117            catch (Exception exception) when (exception is DbUpdateException or DbException or InvalidOperationException
 118            {
 1119                dbContext.ChangeTracker.Clear();
 1120                return CapabilityGrantUseResult.Unavailable("The EF Core capability grant use store could not answer the
 121            }
 122        }
 123
 0124        return CapabilityGrantUseResult.Unavailable("The EF Core capability grant use store exhausted contention retries
 5125    }
 126
 127    /// <summary>Marks an issuer-scoped grant as stopped.</summary>
 128    public ValueTask SetStoppedAsync(
 129        string issuer,
 130        string tokenId,
 131        DateTimeOffset retainUntilUtc,
 132        CancellationToken cancellationToken = default)
 133    {
 1134        return SetStateAsync(issuer, tokenId, retainUntilUtc, GrantUseState.Stopped, cancellationToken);
 135    }
 136
 137    /// <summary>Marks an issuer-scoped grant as cancelled.</summary>
 138    public ValueTask SetCancelledAsync(
 139        string issuer,
 140        string tokenId,
 141        DateTimeOffset retainUntilUtc,
 142        CancellationToken cancellationToken = default)
 143    {
 1144        return SetStateAsync(issuer, tokenId, retainUntilUtc, GrantUseState.Cancelled, cancellationToken);
 145    }
 146
 147    /// <summary>Purges records only after their expiry-plus-skew retention horizon.</summary>
 148    public async ValueTask<int> PurgeExpiredAsync(
 149        DateTimeOffset utcNow,
 150        CancellationToken cancellationToken = default)
 151    {
 1152        return await Entries()
 1153            .Where(entity => entity.RetainUntilUtc < utcNow.ToUniversalTime())
 1154            .ExecuteDeleteAsync(cancellationToken)
 1155            .ConfigureAwait(false);
 1156    }
 157
 158    private async ValueTask SetStateAsync(
 159        string issuer,
 160        string tokenId,
 161        DateTimeOffset retainUntilUtc,
 162        GrantUseState state,
 163        CancellationToken cancellationToken)
 164    {
 2165        ArgumentException.ThrowIfNullOrWhiteSpace(issuer);
 2166        ArgumentException.ThrowIfNullOrWhiteSpace(tokenId);
 2167        cancellationToken.ThrowIfCancellationRequested();
 168
 2169        CapabilityGrantUseEntity? entity = await Entries().SingleOrDefaultAsync(
 2170            item => item.Issuer == issuer.Trim() && item.TokenId == tokenId.Trim(), cancellationToken).ConfigureAwait(fa
 2171        if (entity is null)
 172        {
 2173            _ = Entries().Add(new CapabilityGrantUseEntity
 2174            {
 2175                Id = Guid.NewGuid(),
 2176                ConcurrencyStamp = GovernanceEntity.NewConcurrencyStamp(),
 2177                Issuer = issuer.Trim(),
 2178                TokenId = tokenId.Trim(),
 2179                State = state,
 2180                LastUsedUtc = DateTimeOffset.UnixEpoch,
 2181                RetainUntilUtc = retainUntilUtc.ToUniversalTime()
 2182            });
 183        }
 184        else
 185        {
 0186            entity.State = state;
 0187            entity.RetainUntilUtc = retainUntilUtc.ToUniversalTime();
 0188            entity.ConcurrencyStamp = GovernanceEntity.NewConcurrencyStamp();
 189        }
 190
 2191        _ = await dbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 2192    }
 193
 194    private DbSet<CapabilityGrantUseEntity> Entries()
 195    {
 15196        return dbContext.Set<CapabilityGrantUseEntity>();
 197    }
 198
 199    private static DateTimeOffset AddClamped(DateTimeOffset value, TimeSpan duration)
 200    {
 5201        return value > DateTimeOffset.MaxValue - duration ? DateTimeOffset.MaxValue : value + duration;
 202    }
 203}