Files
systemrevivalserver/Redis/IRedisManager.cs
T
2025-11-10 07:42:03 -05:00

179 lines
6.4 KiB
C#

using System;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using StackExchange.Redis;
using System.Linq;
namespace Server.Redis;
public interface IRedisManager : IAsyncDisposable
{
IDatabase Db { get; }
ISubscriber Bus { get; }
Task<bool> AcquireLeaseAsync(string key, string value, TimeSpan ttl);
Task<bool> RenewLeaseAsync(string key, string value, TimeSpan ttl); // compare-and-set
Task<bool> ReleaseLeaseAsync(string key, string value);
Task<bool> SetJsonAsync<T>(string key, T value, TimeSpan? ttl = null);
Task<T?> GetJsonAsync<T>(string key);
Task<long> StreamAddAsync(string stream, string json, string? id = "*");
Task<RedisValue[]> StreamReadGroupAsync(string stream, string group, string consumer, int count = 100, int blockMs = 0);
Task AcknowledgeAsync(string stream, string group, params string[] ids);
}
public sealed class RedisManager : IRedisManager
{
private readonly ILogger<RedisManager> _logger;
private readonly ConnectionMultiplexer _mux;
public IDatabase Db => _mux.GetDatabase();
public ISubscriber Bus => _mux.GetSubscriber();
private static readonly JsonSerializerOptions JsonOptions = new()
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
WriteIndented = false
};
public RedisManager(ILogger<RedisManager> logger)
{
_logger = logger;
var connString = BuildRedisConnectionStringFromEnv();
_mux = ConnectionMultiplexer.Connect(connString);
_logger.LogInformation("Connected to Redis: {Endpoints}",
string.Join(",", _mux.GetEndPoints().Select(ep => ep.ToString())));
}
public async ValueTask DisposeAsync()
{
try { await _mux.CloseAsync(); } catch { }
_mux.Dispose();
}
// ---------- Leases (simple Redlock-ish) ----------
public async Task<bool> AcquireLeaseAsync(string key, string value, TimeSpan ttl)
{
return await Db.StringSetAsync(key, value, ttl, When.NotExists);
}
public async Task<bool> RenewLeaseAsync(string key, string value, TimeSpan ttl)
{
// Lua script: if value matches, update TTL (PEXPIRE) and keep value
const string script = @"
if redis.call('GET', KEYS[1]) == ARGV[1] then
redis.call('PEXPIRE', KEYS[1], ARGV[2])
return 1
else
return 0
end";
var res = (int)(long)await Db.ScriptEvaluateAsync(script,
new RedisKey[] { key },
new RedisValue[] { value, (long)ttl.TotalMilliseconds });
return res == 1;
}
public async Task<bool> ReleaseLeaseAsync(string key, string value)
{
// Lua script: delete only if owned by 'value'
const string script = @"
if redis.call('GET', KEYS[1]) == ARGV[1] then
return redis.call('DEL', KEYS[1])
else
return 0
end";
var res = (int)(long)await Db.ScriptEvaluateAsync(script,
new RedisKey[] { key },
new RedisValue[] { value });
return res == 1;
}
// ---------- JSON helpers ----------
public async Task<bool> SetJsonAsync<T>(string key, T value, TimeSpan? ttl = null)
{
var bytes = JsonSerializer.SerializeToUtf8Bytes(value, JsonOptions);
return await Db.StringSetAsync(key, bytes, ttl);
}
public async Task<T?> GetJsonAsync<T>(string key)
{
var bytes = await Db.StringGetAsync(key);
if (bytes.IsNullOrEmpty) return default;
return JsonSerializer.Deserialize<T>((byte[])bytes!, JsonOptions);
}
// ---------- Streams (write-ahead) ----------
public async Task<long> StreamAddAsync(string stream, string json, string? id = "*")
{
var entryId = await Db.StreamAddAsync(stream, "data", json,
maxLength: null, useApproximateMaxLength: false, messageId: id ?? "*");
return entryId.HasValue ? 1 : 0;
}
public async Task<RedisValue[]> StreamReadGroupAsync(
string stream, string group, string consumer, int count = 100, int blockMs = 0)
{
// Ensure group exists (create if not present)
try
{
await Db.StreamCreateConsumerGroupAsync(stream, group, "$", createStream: true);
}
catch (RedisServerException ex) when (ex.Message.Contains("BUSYGROUP"))
{
// group already exists
}
var deadline = blockMs > 0 ? DateTime.UtcNow.AddMilliseconds(blockMs) : (DateTime?)null;
StackExchange.Redis.StreamEntry[] entries;
// Poll until we have entries or we hit the deadline
while (true)
{
entries = await Db.StreamReadGroupAsync(stream, group, consumer, count: count, noAck: false);
if (entries.Length > 0) break;
if (deadline == null) break;
var remainingMs = (int)(deadline.Value - DateTime.UtcNow).TotalMilliseconds;
if (remainingMs <= 0) break;
// small sleep to avoid hot loop
await Task.Delay(Math.Min(remainingMs, 100));
}
// Return the "data" field only (matches your current interface)
var result = new RedisValue[entries.Length];
for (int i = 0; i < entries.Length; i++)
result[i] = entries[i].Values[0].Value; // field "data"
return result;
}
public async Task AcknowledgeAsync(string stream, string group, params string[] ids)
{
if (ids.Length == 0) return;
await Db.StreamAcknowledgeAsync(stream, group, Array.ConvertAll(ids, x => (RedisValue)x));
}
// ---------- Conn string from env ----------
private static string BuildRedisConnectionStringFromEnv()
{
var full = Environment.GetEnvironmentVariable("REDIS_CONNECTION_STRING");
if (!string.IsNullOrWhiteSpace(full)) return full;
var host = Environment.GetEnvironmentVariable("REDIS_HOST") ?? "localhost";
var port = int.TryParse(Environment.GetEnvironmentVariable("REDIS_PORT"), out var p) ? p : 6379;
var password = Environment.GetEnvironmentVariable("REDIS_PASSWORD");
var db = int.TryParse(Environment.GetEnvironmentVariable("REDIS_DB"), out var d) ? d : 0;
var cs = $"{host}:{port},defaultDatabase={db},abortConnect=false,syncTimeout=10000,connectRetry=3,connectTimeout=5000";
if (!string.IsNullOrWhiteSpace(password)) cs += $",password={password}";
return cs;
}
}