371 lines
13 KiB
C#
371 lines
13 KiB
C#
using System.Diagnostics;
|
|
using System.Text.Json;
|
|
using Microsoft.Extensions.Logging;
|
|
using Microsoft.Extensions.Options;
|
|
using StackExchange.Redis;
|
|
|
|
namespace StellaOps.Provcache.Valkey;
|
|
|
|
/// <summary>
|
|
/// Valkey/Redis implementation of <see cref="IProvcacheStore"/> with read-through caching.
|
|
/// </summary>
|
|
public sealed class ValkeyProvcacheStore : IProvcacheStore, IAsyncDisposable
|
|
{
|
|
private readonly IConnectionMultiplexer _connectionMultiplexer;
|
|
private readonly ProvcacheOptions _options;
|
|
private readonly ILogger<ValkeyProvcacheStore> _logger;
|
|
private readonly TimeProvider _timeProvider;
|
|
private readonly JsonSerializerOptions _jsonOptions;
|
|
private readonly SemaphoreSlim _connectionLock = new(1, 1);
|
|
private IDatabase? _database;
|
|
private const int DefaultScanPageSize = 200;
|
|
private const int DefaultDeleteBatchSize = 500;
|
|
|
|
/// <inheritdoc />
|
|
public string ProviderName => "valkey";
|
|
|
|
public ValkeyProvcacheStore(
|
|
IConnectionMultiplexer connectionMultiplexer,
|
|
IOptions<ProvcacheOptions> options,
|
|
ILogger<ValkeyProvcacheStore> logger,
|
|
TimeProvider? timeProvider = null)
|
|
{
|
|
_connectionMultiplexer = connectionMultiplexer ?? throw new ArgumentNullException(nameof(connectionMultiplexer));
|
|
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
|
|
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
|
|
_timeProvider = timeProvider ?? TimeProvider.System;
|
|
_jsonOptions = new JsonSerializerOptions
|
|
{
|
|
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
|
|
WriteIndented = false
|
|
};
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async ValueTask<ProvcacheLookupResult> GetAsync(string veriKey, CancellationToken cancellationToken = default)
|
|
{
|
|
var sw = Stopwatch.StartNew();
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
|
|
try
|
|
{
|
|
var db = await GetDatabaseAsync(cancellationToken).ConfigureAwait(false);
|
|
var redisKey = BuildKey(veriKey);
|
|
|
|
var value = await db.StringGetAsync(redisKey).ConfigureAwait(false);
|
|
sw.Stop();
|
|
|
|
if (value.IsNullOrEmpty)
|
|
{
|
|
_logger.LogDebug("Cache miss for VeriKey {VeriKey} in {ElapsedMs}ms", veriKey, sw.Elapsed.TotalMilliseconds);
|
|
return ProvcacheLookupResult.Miss(sw.Elapsed.TotalMilliseconds);
|
|
}
|
|
|
|
var entry = JsonSerializer.Deserialize<ProvcacheEntry>((string)value!, _jsonOptions);
|
|
if (entry is null)
|
|
{
|
|
_logger.LogWarning("Failed to deserialize cache entry for VeriKey {VeriKey}", veriKey);
|
|
return ProvcacheLookupResult.Miss(sw.Elapsed.TotalMilliseconds);
|
|
}
|
|
|
|
// Optionally refresh TTL on read (sliding expiration)
|
|
if (_options.SlidingExpiration)
|
|
{
|
|
var ttl = entry.ExpiresAt - _timeProvider.GetUtcNow();
|
|
if (ttl > TimeSpan.Zero)
|
|
{
|
|
await db.KeyExpireAsync(redisKey, ttl).ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
_logger.LogDebug("Cache hit for VeriKey {VeriKey} in {ElapsedMs}ms", veriKey, sw.Elapsed.TotalMilliseconds);
|
|
return ProvcacheLookupResult.Hit(entry, ProviderName, sw.Elapsed.TotalMilliseconds);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
sw.Stop();
|
|
_logger.LogError(ex, "Error getting cache entry for VeriKey {VeriKey}", veriKey);
|
|
return ProvcacheLookupResult.Miss(sw.Elapsed.TotalMilliseconds);
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async ValueTask<ProvcacheBatchLookupResult> GetManyAsync(
|
|
IEnumerable<string> veriKeys,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var sw = Stopwatch.StartNew();
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
var keyList = veriKeys.ToList();
|
|
|
|
if (keyList.Count == 0)
|
|
{
|
|
return new ProvcacheBatchLookupResult
|
|
{
|
|
Hits = new Dictionary<string, ProvcacheEntry>(),
|
|
Misses = [],
|
|
ElapsedMs = 0
|
|
};
|
|
}
|
|
|
|
try
|
|
{
|
|
var db = await GetDatabaseAsync(cancellationToken).ConfigureAwait(false);
|
|
var redisKeys = keyList.Select(k => (RedisKey)BuildKey(k)).ToArray();
|
|
|
|
var values = await db.StringGetAsync(redisKeys).ConfigureAwait(false);
|
|
sw.Stop();
|
|
|
|
var hits = new Dictionary<string, ProvcacheEntry>();
|
|
var misses = new List<string>();
|
|
|
|
for (int i = 0; i < keyList.Count; i++)
|
|
{
|
|
var veriKey = keyList[i];
|
|
var value = values[i];
|
|
|
|
if (value.IsNullOrEmpty)
|
|
{
|
|
misses.Add(veriKey);
|
|
continue;
|
|
}
|
|
|
|
var entry = JsonSerializer.Deserialize<ProvcacheEntry>((string)value!, _jsonOptions);
|
|
if (entry is not null)
|
|
{
|
|
hits[veriKey] = entry;
|
|
}
|
|
else
|
|
{
|
|
misses.Add(veriKey);
|
|
}
|
|
}
|
|
|
|
_logger.LogDebug(
|
|
"Batch lookup: {Hits} hits, {Misses} misses in {ElapsedMs}ms",
|
|
hits.Count,
|
|
misses.Count,
|
|
sw.Elapsed.TotalMilliseconds);
|
|
|
|
return new ProvcacheBatchLookupResult
|
|
{
|
|
Hits = hits,
|
|
Misses = misses,
|
|
ElapsedMs = sw.Elapsed.TotalMilliseconds
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
sw.Stop();
|
|
_logger.LogError(ex, "Error in batch cache lookup");
|
|
return new ProvcacheBatchLookupResult
|
|
{
|
|
Hits = new Dictionary<string, ProvcacheEntry>(),
|
|
Misses = keyList,
|
|
ElapsedMs = sw.Elapsed.TotalMilliseconds
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async ValueTask SetAsync(ProvcacheEntry entry, CancellationToken cancellationToken = default)
|
|
{
|
|
try
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
var db = await GetDatabaseAsync(cancellationToken).ConfigureAwait(false);
|
|
var redisKey = BuildKey(entry.VeriKey);
|
|
var value = JsonSerializer.Serialize(entry, _jsonOptions);
|
|
|
|
var ttl = entry.ExpiresAt - _timeProvider.GetUtcNow();
|
|
if (ttl <= TimeSpan.Zero)
|
|
{
|
|
_logger.LogDebug("Skipping expired entry for VeriKey {VeriKey}", entry.VeriKey);
|
|
return;
|
|
}
|
|
|
|
// Cap TTL at MaxTtl
|
|
if (ttl > _options.MaxTtl)
|
|
{
|
|
ttl = _options.MaxTtl;
|
|
}
|
|
|
|
await db.StringSetAsync(redisKey, value, ttl).ConfigureAwait(false);
|
|
|
|
_logger.LogDebug("Stored cache entry for VeriKey {VeriKey} with TTL {Ttl}", entry.VeriKey, ttl);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error storing cache entry for VeriKey {VeriKey}", entry.VeriKey);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async ValueTask SetManyAsync(IEnumerable<ProvcacheEntry> entries, CancellationToken cancellationToken = default)
|
|
{
|
|
var entryList = entries.ToList();
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
if (entryList.Count == 0)
|
|
return;
|
|
|
|
try
|
|
{
|
|
var db = await GetDatabaseAsync(cancellationToken).ConfigureAwait(false);
|
|
var batch = db.CreateBatch();
|
|
var tasks = new List<Task>();
|
|
var now = _timeProvider.GetUtcNow();
|
|
|
|
foreach (var entry in entryList)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
var redisKey = BuildKey(entry.VeriKey);
|
|
var value = JsonSerializer.Serialize(entry, _jsonOptions);
|
|
|
|
var ttl = entry.ExpiresAt - now;
|
|
if (ttl <= TimeSpan.Zero)
|
|
continue;
|
|
|
|
if (ttl > _options.MaxTtl)
|
|
ttl = _options.MaxTtl;
|
|
|
|
tasks.Add(batch.StringSetAsync(redisKey, value, ttl));
|
|
}
|
|
|
|
batch.Execute();
|
|
await Task.WhenAll(tasks).ConfigureAwait(false);
|
|
|
|
_logger.LogDebug("Batch stored {Count} cache entries", entryList.Count);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error in batch cache store");
|
|
throw;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async ValueTask<bool> InvalidateAsync(string veriKey, CancellationToken cancellationToken = default)
|
|
{
|
|
try
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
var db = await GetDatabaseAsync(cancellationToken).ConfigureAwait(false);
|
|
var redisKey = BuildKey(veriKey);
|
|
|
|
var deleted = await db.KeyDeleteAsync(redisKey).ConfigureAwait(false);
|
|
|
|
_logger.LogDebug("Invalidated cache entry for VeriKey {VeriKey}: {Deleted}", veriKey, deleted);
|
|
return deleted;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error invalidating cache entry for VeriKey {VeriKey}", veriKey);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async ValueTask<long> InvalidateByPatternAsync(string pattern, CancellationToken cancellationToken = default)
|
|
{
|
|
try
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
var db = await GetDatabaseAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
var endpoints = _connectionMultiplexer.GetEndPoints();
|
|
if (endpoints.Length == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
var fullPattern = $"{_options.ValkeyKeyPrefix}{pattern}";
|
|
long deleted = 0;
|
|
|
|
foreach (var endpoint in endpoints)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
var server = _connectionMultiplexer.GetServer(endpoint);
|
|
if (server is null || !server.IsConnected)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var batchKeys = new List<RedisKey>(DefaultDeleteBatchSize);
|
|
foreach (var key in server.Keys(pattern: fullPattern, pageSize: DefaultScanPageSize))
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
batchKeys.Add(key);
|
|
if (batchKeys.Count >= DefaultDeleteBatchSize)
|
|
{
|
|
deleted += await db.KeyDeleteAsync(batchKeys.ToArray()).ConfigureAwait(false);
|
|
batchKeys.Clear();
|
|
}
|
|
}
|
|
|
|
if (batchKeys.Count > 0)
|
|
{
|
|
deleted += await db.KeyDeleteAsync(batchKeys.ToArray()).ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
_logger.LogInformation("Invalidated {Count} cache entries matching pattern {Pattern}", deleted, pattern);
|
|
return deleted;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error invalidating cache entries by pattern {Pattern}", pattern);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async ValueTask<ProvcacheEntry> GetOrSetAsync(
|
|
string veriKey,
|
|
Func<CancellationToken, ValueTask<ProvcacheEntry>> factory,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
var result = await GetAsync(veriKey, cancellationToken).ConfigureAwait(false);
|
|
if (result.IsHit && result.Entry is not null)
|
|
{
|
|
return result.Entry;
|
|
}
|
|
|
|
var entry = await factory(cancellationToken).ConfigureAwait(false);
|
|
await SetAsync(entry, cancellationToken).ConfigureAwait(false);
|
|
|
|
return entry;
|
|
}
|
|
|
|
private string BuildKey(string veriKey) => $"{_options.ValkeyKeyPrefix}{veriKey}";
|
|
|
|
private async Task<IDatabase> GetDatabaseAsync(CancellationToken cancellationToken)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
|
|
if (_database is not null)
|
|
return _database;
|
|
|
|
await _connectionLock.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
try
|
|
{
|
|
_database ??= _connectionMultiplexer.GetDatabase();
|
|
return _database;
|
|
}
|
|
finally
|
|
{
|
|
_connectionLock.Release();
|
|
}
|
|
}
|
|
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
_connectionLock.Dispose();
|
|
|
|
// Note: Don't dispose the connection multiplexer if it's shared (injected via DI)
|
|
// The DI container will handle its lifetime
|
|
await Task.CompletedTask;
|
|
}
|
|
}
|