feat: restore redlock, improve lock management

Author: paul-fresquet

src/ByteSync.ServerCommon/Interfaces/Repositories/ICacheRepository.cs

@@ -17,5 +17,5 @@ Task<UpdateEntityResult<T>> Update(CacheKey cacheKey, Func<T, bool> updateHandle
 
     Task Delete(CacheKey cacheKey, ITransaction? transaction = null);
 
-    Task<IRedLock> AcquireLockAsync(CacheKey cacheKey);
+    // Task<IRedLock> AcquireLockAsync(CacheKey cacheKey);
 }

src/ByteSync.ServerCommon/Repositories/CacheRepository.cs

@@ -120,10 +120,10 @@ public async Task Delete(CacheKey cacheKey, ITransaction? transaction = null)
         await database.KeyDeleteAsync(cacheKey.Value);
     }
 
-    public async Task<IRedLock> AcquireLockAsync(CacheKey cacheKey)
-    {
-        return await _redisInfrastructureService.AcquireLockAsync(cacheKey);
-    }
+    // public async Task<IRedLock> AcquireLockAsync(CacheKey cacheKey)
+    // {
+    //     return await _redisInfrastructureService.AcquireLockAsync(cacheKey);
+    // }
 
     private async Task<UpdateEntityResult<T>> SaveInternal(CacheKey cacheKey, T element, IDatabaseAsync database)
     {

src/ByteSync.ServerCommon/Repositories/TrackingActionRepository.cs

@@ -61,7 +61,7 @@ public async Task<TrackingActionResult> AddOrUpdate(string sessionId, List<strin
         // CacheKey? synchronizationCacheKey = null;
         // IRedLock? synchronizationLock = null;
 
-        var locks = new ConcurrentBag<IAsyncDisposable>(); // Thread-safe
+        // var locks = new ConcurrentBag<IAsyncDisposable>(); // Thread-safe
         var trackingActionEntities = new ConcurrentBag<TrackingActionEntity>();
         var updateHandlerResults = new ConcurrentBag<TrackingActionUpdateHandlerResult>();
         // bool areAllUpdated = true;
@@ -74,8 +74,8 @@ public async Task<TrackingActionResult> AddOrUpdate(string sessionId, List<strin
         // }
 
         var synchronizationCacheKey = _redisInfrastructureService.ComputeCacheKey(EntityType.Synchronization, sessionId);
-        var synchronizationLock = await _redisInfrastructureService.AcquireLockAsync(synchronizationCacheKey);
-        locks.Add(synchronizationLock);
+        await using var synchronizationLock = await _redisInfrastructureService.AcquireLockAsync(synchronizationCacheKey);
+        // locks.Add(synchronizationLock);
 
         var synchronizationEntity = await _synchronizationRepository.Get(sessionId);
         if (synchronizationEntity == null)
@@ -148,10 +148,10 @@ await _synchronizationCacheRepository.AddOrUpdate(synchronizationCacheKey, synEn
             await transaction.ExecuteAsync();
         }
 
-        foreach (var redisLock in locks)
-        {
-            await redisLock.DisposeAsync();
-        }
+        // foreach (var redisLock in locks)
+        // {
+        //     await redisLock.DisposeAsync();
+        // }
 
         return new TrackingActionResult(areAllUpdated, trackingActionEntities.ToList(), synchronizationEntity);
     }

src/ByteSync.ServerCommon/Services/RedisInfrastructureService.cs

@@ -80,29 +80,29 @@ public async Task<IRedLock> AcquireLockAsync(EntityType entityType, string entit
 
     public async Task<IRedLock> AcquireLockAsync(CacheKey cacheKey)
     {
-        // var redisLock = await _redLockFactory.CreateLockAsync(cacheKey.Value, TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(2));
-        //
-        // if (redisLock.IsAcquired)
-        // {
-        //     return redisLock;
-        // }
-        // else
-        // {
-        //     throw new AcquireRedisLockException(cacheKey.Value, redisLock);
-        // }
+        var redisLock = await _redLockFactory.CreateLockAsync(cacheKey.Value, TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(2));
 
-        var myLock = new MyLock
+        if (redisLock.IsAcquired)
         {
-            Resource = cacheKey.Value,
-            LockId = Guid.NewGuid().ToString(),
-            IsAcquired = true,
-            Status = RedLockStatus.Acquired,
-            InstanceSummary = new RedLockInstanceSummary(),
-            ExtendCount = 0
-        };
-        
-        return myLock;
+            return redisLock;
+        }
+        else
+        {
+            throw new AcquireRedisLockException(cacheKey.Value, redisLock);
+        }
 
+        // var myLock = new MyLock
+        // {
+        //     Resource = cacheKey.Value,
+        //     LockId = Guid.NewGuid().ToString(),
+        //     IsAcquired = true,
+        //     Status = RedLockStatus.Acquired,
+        //     InstanceSummary = new RedLockInstanceSummary(),
+        //     ExtendCount = 0
+        // };
+        //
+        // return myLock;
+        //
 
     }