:drunk: Write shit code trying to split up the Auth (WIP)

2025-07-06 12:58:18 +08:00
parent 5757526ea5
commit 6a3d04af3d
224 changed files with 1889 additions and 36885 deletions
--- a/DysonNetwork.Pass/Storage/ICacheService.cs
+++ b/DysonNetwork.Pass/Storage/ICacheService.cs
@ -0,0 +1,127 @@
+using System.Collections.Concurrent;
+
+namespace DysonNetwork.Pass.Storage;
+
+public interface ICacheService
+{
+    Task<T?> GetAsync<T>(string key);
+    Task<(bool found, T? value)> GetAsyncWithStatus<T>(string key);
+    Task SetAsync<T>(string key, T value, TimeSpan? expiry = null);
+    Task SetWithGroupsAsync<T>(string key, T value, string[] groups, TimeSpan? expiry = null);
+    Task RemoveAsync(string key);
+    Task RemoveGroupAsync(string groupName);
+    Task<IAsyncDisposable?> AcquireLockAsync(string key, TimeSpan expiry, TimeSpan? wait = null);
+}
+
+public class InMemoryCacheService : ICacheService
+{
+    private readonly ConcurrentDictionary<string, object> _cache = new();
+    private readonly ConcurrentDictionary<string, HashSet<string>> _groups = new();
+    private readonly ConcurrentDictionary<string, DateTimeOffset> _expirations = new();
+
+    public Task<T?> GetAsync<T>(string key)
+    {
+        if (_cache.TryGetValue(key, out var value) && !IsExpired(key))
+        {
+            return Task.FromResult((T?)value);
+        }
+        Remove(key);
+        return Task.FromResult(default(T));
+    }
+
+    public Task<(bool found, T? value)> GetAsyncWithStatus<T>(string key)
+    {
+        if (_cache.TryGetValue(key, out var value) && !IsExpired(key))
+        {
+            return Task.FromResult((true, (T?)value));
+        }
+        Remove(key);
+        return Task.FromResult((false, default(T)));
+    }
+
+    public Task SetAsync<T>(string key, T value, TimeSpan? expiry = null)
+    {
+        _cache[key] = value!;
+        _expirations[key] = expiry.HasValue ? DateTimeOffset.UtcNow.Add(expiry.Value) : DateTimeOffset.MaxValue;
+        return Task.CompletedTask;
+    }
+
+    public Task SetWithGroupsAsync<T>(string key, T value, string[] groups, TimeSpan? expiry = null)
+    {
+        _cache[key] = value!;
+        _expirations[key] = expiry.HasValue ? DateTimeOffset.UtcNow.Add(expiry.Value) : DateTimeOffset.MaxValue;
+        foreach (var group in groups)
+        {
+            _groups.GetOrAdd(group, _ => new HashSet<string>()).Add(key);
+        }
+        return Task.CompletedTask;
+    }
+
+    public Task RemoveAsync(string key)
+    {
+        Remove(key);
+        return Task.CompletedTask;
+    }
+
+    public Task RemoveGroupAsync(string groupName)
+    {
+        if (_groups.TryRemove(groupName, out var keysToRemove))
+        {
+            foreach (var key in keysToRemove)
+            {
+                Remove(key);
+            }
+        }
+        return Task.CompletedTask;
+    }
+
+    public async Task<IAsyncDisposable?> AcquireLockAsync(string key, TimeSpan expiry, TimeSpan? wait = null)
+    {
+        var startTime = DateTime.UtcNow;
+        while (true)
+        {
+            if (_cache.TryAdd(key, new object()))
+            {
+                _expirations[key] = DateTimeOffset.UtcNow.Add(expiry);
+                return new AsyncLockReleaser(() => Remove(key));
+            }
+
+            if (wait == null || DateTime.UtcNow - startTime > wait.Value)
+            {
+                return null; // Could not acquire lock within wait time
+            }
+            await Task.Delay(50); // Wait a bit before retrying
+        }
+    }
+
+    private bool IsExpired(string key)
+    {
+        return _expirations.TryGetValue(key, out var expiration) && expiration <= DateTimeOffset.UtcNow;
+    }
+
+    private void Remove(string key)
+    {
+        _cache.TryRemove(key, out _);
+        _expirations.TryRemove(key, out _);
+        foreach (var group in _groups.Values)
+        {
+            group.Remove(key);
+        }
+    }
+
+    private class AsyncLockReleaser : IAsyncDisposable
+    {
+        private readonly Action _releaseAction;
+
+        public AsyncLockReleaser(Action releaseAction)
+        {
+            _releaseAction = releaseAction;
+        }
+
+        public ValueTask DisposeAsync()
+        {
+            _releaseAction();
+            return ValueTask.CompletedTask;
+        }
+    }
+}