11743287486

Committed 08 Nov 2024 01:44PM UTC coverage: 84.369% (-0.02%) from 84.386%

Build # 11743287486

Build Type

push

github

Committed by

me-viper

Commit Message

chore: Apply formatting rules

Run Details

1820 of 2364 branches covered (76.99%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 3 files covered. (100.0%)

2 existing lines in 1 file now uncovered.

3815 of 4315 relevant lines covered (88.41%)

1721.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.19

/src/Extensions.AspNetCore/src/PooledOpaPolicyService.cs

﻿using DotNext.Threading;

using Microsoft.Extensions.ObjectPool;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.Primitives;

using OpaDotNet.Extensions.AspNetCore.Telemetry;
using OpaDotNet.Wasm;

namespace OpaDotNet.Extensions.AspNetCore;

internal class PooledOpaPolicyService : IOpaPolicyService, IDisposable
{
    private ObjectPool<IOpaEvaluator> _evaluatorPool;

    private readonly ILogger _logger;

    private readonly IDisposable _recompilationMonitor;

    private readonly OpaEvaluatorPoolProvider _poolProvider;

    private readonly IOpaPolicySource _factoryProvider;

    private readonly AsyncReaderWriterLock _syncLock = new();

    private readonly SemaphoreSlim? _concurrencyLock;

    public PooledOpaPolicyService(
        IOpaPolicySource factoryProvider,
        IOptions<OpaAuthorizationOptions> options,
        OpaEvaluatorPoolProvider poolProvider,
        ILogger<PooledOpaPolicyService> logger)
    {
        ArgumentNullException.ThrowIfNull(factoryProvider);
        ArgumentNullException.ThrowIfNull(options);
        ArgumentNullException.ThrowIfNull(poolProvider);
        ArgumentNullException.ThrowIfNull(logger);

        _factoryProvider = factoryProvider;
        _poolProvider = poolProvider;
        _logger = logger;

        _poolProvider.MaximumRetained = options.Value.MaximumEvaluatorsRetained;

        if (options.Value.MaximumEvaluators > 0)
            _concurrencyLock = new(options.Value.MaximumEvaluators, options.Value.MaximumEvaluators);

        _evaluatorPool = _poolProvider.Create(new OpaEvaluatorPoolPolicy(() => _factoryProvider.CreateEvaluator()));
        _recompilationMonitor = ChangeToken.OnChange(factoryProvider.OnPolicyUpdated, ResetPool);
    }

    private void ResetPool()
    {
        _logger.EvaluatorPoolResetting();

        using var writerLock = _syncLock.AcquireWriteLock();

        var oldPool = _evaluatorPool;
        _evaluatorPool = _poolProvider.Create(new OpaEvaluatorPoolPolicy(() => _factoryProvider.CreateEvaluator()));

        if (oldPool is not IDisposable pool)
        {
            _logger.EvaluatorPoolNotDisposable();
            return;
        }

        _logger.EvaluatorPoolDisposing();
        pool.Dispose();
    }

    private Task ConcurrencyLockWaitAsync(CancellationToken cancellationToken)
        => _concurrencyLock?.WaitAsync(cancellationToken) ?? Task.CompletedTask;

    public async ValueTask<bool> EvaluatePredicate<T>(T input, string entrypoint, CancellationToken cancellationToken)
    {
        ArgumentException.ThrowIfNullOrEmpty(entrypoint);

        await _syncLock.EnterReadLockAsync(cancellationToken).ConfigureAwait(false);
        await ConcurrencyLockWaitAsync(cancellationToken).ConfigureAwait(false);

        var pool = _evaluatorPool;
        var evaluator = pool.Get();

        try
        {
            var result = evaluator.EvaluatePredicate(input, entrypoint);
            return result.Result;
        }
        finally
        {
            pool.Return(evaluator);
            _concurrencyLock?.Release();
            _syncLock.Release();
        }
    }

    public async ValueTask<TOutput> Evaluate<TInput, TOutput>(TInput input, string entrypoint, CancellationToken cancellationToken)
        where TOutput : notnull
    {
        ArgumentException.ThrowIfNullOrEmpty(entrypoint);

        await _syncLock.EnterReadLockAsync(cancellationToken).ConfigureAwait(false);
        await ConcurrencyLockWaitAsync(cancellationToken).ConfigureAwait(false);

        var pool = _evaluatorPool;
        var evaluator = pool.Get();

        try
        {
            var result = evaluator.Evaluate<TInput, TOutput>(input, entrypoint);
            return result.Result;
        }
        finally
        {
            pool.Return(evaluator);
            _concurrencyLock?.Release();
            _syncLock.Release();
        }
    }

    public async ValueTask<string> EvaluateRaw(ReadOnlyMemory<char> inputJson, string entrypoint, CancellationToken cancellationToken)
    {
        ArgumentException.ThrowIfNullOrEmpty(entrypoint);

        await _syncLock.EnterReadLockAsync(cancellationToken).ConfigureAwait(false);
        await ConcurrencyLockWaitAsync(cancellationToken).ConfigureAwait(false);

        var pool = _evaluatorPool;
        var evaluator = pool.Get();

        try
        {
            return evaluator.EvaluateRaw(inputJson.Span, entrypoint);
        }
        finally
        {
            pool.Return(evaluator);
            _concurrencyLock?.Release();
            _syncLock.Release();
        }
    }

    public void Dispose()
    {
        _recompilationMonitor.Dispose();

        if (_evaluatorPool is IDisposable d)
            d.Dispose();

        _concurrencyLock?.Dispose();
        _syncLock.Dispose();
    }
}

1	using DotNext.Threading;
2
3	using Microsoft.Extensions.ObjectPool;
4	using Microsoft.Extensions.Options;
5	using Microsoft.Extensions.Primitives;
6
7	using OpaDotNet.Extensions.AspNetCore.Telemetry;
8	using OpaDotNet.Wasm;
9
10	namespace OpaDotNet.Extensions.AspNetCore;
11
12	internal class PooledOpaPolicyService : IOpaPolicyService, IDisposable
13	{
14	private ObjectPool<IOpaEvaluator> _evaluatorPool;
15
16	private readonly ILogger _logger;
17
18	private readonly IDisposable _recompilationMonitor;
19
20	private readonly OpaEvaluatorPoolProvider _poolProvider;
21
22	private readonly IOpaPolicySource _factoryProvider;
23
24	private readonly AsyncReaderWriterLock _syncLock = new();	40✔
25
26	private readonly SemaphoreSlim? _concurrencyLock;
27
28	public PooledOpaPolicyService(	40✔
29	IOpaPolicySource factoryProvider,	40✔
30	IOptions<OpaAuthorizationOptions> options,	40✔
31	OpaEvaluatorPoolProvider poolProvider,	40✔
32	ILogger<PooledOpaPolicyService> logger)	40✔
33	{
34	ArgumentNullException.ThrowIfNull(factoryProvider);	40✔
35	ArgumentNullException.ThrowIfNull(options);	40✔
36	ArgumentNullException.ThrowIfNull(poolProvider);	40✔
37	ArgumentNullException.ThrowIfNull(logger);	40✔
38
39	_factoryProvider = factoryProvider;	40✔
40	_poolProvider = poolProvider;	40✔
41	_logger = logger;	40✔
42
43	_poolProvider.MaximumRetained = options.Value.MaximumEvaluatorsRetained;	40✔
44
45	if (options.Value.MaximumEvaluators > 0)	40✔
46	_concurrencyLock = new(options.Value.MaximumEvaluators, options.Value.MaximumEvaluators);	2✔
47
48	_evaluatorPool = _poolProvider.Create(new OpaEvaluatorPoolPolicy(() => _factoryProvider.CreateEvaluator()));	93✔
49	_recompilationMonitor = ChangeToken.OnChange(factoryProvider.OnPolicyUpdated, ResetPool);	40✔
50	}	40✔
51
52	private void ResetPool()
53	{
54	_logger.EvaluatorPoolResetting();	200✔
55
56	using var writerLock = _syncLock.AcquireWriteLock();	200✔
57
58	var oldPool = _evaluatorPool;	200✔
59	_evaluatorPool = _poolProvider.Create(new OpaEvaluatorPoolPolicy(() => _factoryProvider.CreateEvaluator()));	456✔
60
61	if (oldPool is not IDisposable pool)	200!
62	{
UNCOV 63	_logger.EvaluatorPoolNotDisposable();	×
UNCOV 64	return;	×
65	}
66
67	_logger.EvaluatorPoolDisposing();	200✔
68	pool.Dispose();	200✔
69	}	400✔
70
71	private Task ConcurrencyLockWaitAsync(CancellationToken cancellationToken)
72	=> _concurrencyLock?.WaitAsync(cancellationToken) ?? Task.CompletedTask;	42,036✔
73
74	public async ValueTask<bool> EvaluatePredicate<T>(T input, string entrypoint, CancellationToken cancellationToken)
75	{
76	ArgumentException.ThrowIfNullOrEmpty(entrypoint);	42,030✔
77
78	await _syncLock.EnterReadLockAsync(cancellationToken).ConfigureAwait(false);	42,030✔
79	await ConcurrencyLockWaitAsync(cancellationToken).ConfigureAwait(false);	42,030✔
80
81	var pool = _evaluatorPool;	42,030✔
82	var evaluator = pool.Get();	42,030✔
83
84	try
85	{
86	var result = evaluator.EvaluatePredicate(input, entrypoint);	42,030✔
87	return result.Result;	42,030✔
88	}
89	finally
90	{
91	pool.Return(evaluator);	42,030✔
92	_concurrencyLock?.Release();	42,030✔
93	_syncLock.Release();	42,030✔
94	}
95	}	42,030✔
96
97	public async ValueTask<TOutput> Evaluate<TInput, TOutput>(TInput input, string entrypoint, CancellationToken cancellationToken)
98	where TOutput : notnull
99	{
100	ArgumentException.ThrowIfNullOrEmpty(entrypoint);	4✔
101
102	await _syncLock.EnterReadLockAsync(cancellationToken).ConfigureAwait(false);	4✔
103	await ConcurrencyLockWaitAsync(cancellationToken).ConfigureAwait(false);	4✔
104
105	var pool = _evaluatorPool;	4✔
106	var evaluator = pool.Get();	4✔
107
108	try
109	{
110	var result = evaluator.Evaluate<TInput, TOutput>(input, entrypoint);	4✔
111	return result.Result;	4✔
112	}
113	finally
114	{
115	pool.Return(evaluator);	4✔
116	_concurrencyLock?.Release();	4!
117	_syncLock.Release();	4✔
118	}
119	}	4✔
120
121	public async ValueTask<string> EvaluateRaw(ReadOnlyMemory<char> inputJson, string entrypoint, CancellationToken cancellationToken)
122	{
123	ArgumentException.ThrowIfNullOrEmpty(entrypoint);	2✔
124
125	await _syncLock.EnterReadLockAsync(cancellationToken).ConfigureAwait(false);	2✔
126	await ConcurrencyLockWaitAsync(cancellationToken).ConfigureAwait(false);	2✔
127
128	var pool = _evaluatorPool;	2✔
129	var evaluator = pool.Get();	2✔
130
131	try
132	{
133	return evaluator.EvaluateRaw(inputJson.Span, entrypoint);	2✔
134	}
135	finally
136	{
137	pool.Return(evaluator);	2✔
138	_concurrencyLock?.Release();	2!
139	_syncLock.Release();	2✔
140	}
141	}	2✔
142
143	public void Dispose()
144	{
145	_recompilationMonitor.Dispose();	40✔
146
147	if (_evaluatorPool is IDisposable d)	40✔
148	d.Dispose();	40✔
149
150	_concurrencyLock?.Dispose();	40✔
151	_syncLock.Dispose();	40✔
152	}	40✔
153	}

me-viper / OpaDotNet / 11743287486

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous