feat: add AcquireRedisLockException

Author: paul-fresquet

src/ByteSync.Client/Interfaces/Services/Sessions/ISessionService.cs

@@ -52,7 +52,7 @@ public interface ISessionService
 
     Task SetLocalSession(LocalSession localSession, RunLocalSessionProfileInfo? runLocalSessionProfileInfo, SessionSettings sessionSettings);
 
-    Task SetSessionSettings(SessionSettings sessionSettings);
+    Task SetSessionSettings(SessionSettings sessionSettings, bool callApi);
 
     Task SetSessionStatus(SessionStatus sessionStatus);
 

src/ByteSync.Client/Services/Inventories/DataInventoryStarter.cs

@@ -1,6 +1,5 @@
 using System.Reactive;
 using System.Reactive.Linq;
-using System.Threading.Tasks;
 using ByteSync.Business.PathItems;
 using ByteSync.Business.Profiles;
 using ByteSync.Business.SessionMembers;
@@ -11,15 +10,13 @@
 using ByteSync.Common.Business.Sessions;
 using ByteSync.Common.Business.Sessions.Cloud;
 using ByteSync.Common.Business.Sessions.Local;
-using ByteSync.Common.Helpers;
 using ByteSync.Interfaces.Controls.Communications;
 using ByteSync.Interfaces.Controls.Communications.Http;
 using ByteSync.Interfaces.Controls.Encryptions;
 using ByteSync.Interfaces.Controls.Inventories;
 using ByteSync.Interfaces.Repositories;
 using ByteSync.Interfaces.Services.Sessions;
 using DynamicData;
-using Serilog;
 
 namespace ByteSync.Services.Inventories;
 
@@ -32,10 +29,11 @@ public class DataInventoryStarter : IDataInventoryStarter
     private readonly IInventoryApiClient _inventoryApiClient;
     private readonly IPathItemRepository _pathItemRepository;
     private readonly ISessionMemberRepository _sessionMemberRepository;
+    private readonly ILogger<DataInventoryStarter> _logger;
 
-    public DataInventoryStarter(ISessionService sessionService, ICloudProxy connectionManager, 
-        IDataEncrypter dataEncrypter, IDataInventoryRunner dataInventoryRunner, 
-        IInventoryApiClient inventoryApiClient, IPathItemRepository pathItemRepository, ISessionMemberRepository sessionMemberRepository)
+    public DataInventoryStarter(ISessionService sessionService, ICloudProxy connectionManager, IDataEncrypter dataEncrypter, 
+        IDataInventoryRunner dataInventoryRunner, IInventoryApiClient inventoryApiClient, IPathItemRepository pathItemRepository, 
+        ISessionMemberRepository sessionMemberRepository, ILogger<DataInventoryStarter> logger)
     {
         _sessionService = sessionService;
         _connectionManager = connectionManager;
@@ -44,6 +42,7 @@ public DataInventoryStarter(ISessionService sessionService, ICloudProxy connecti
         _inventoryApiClient = inventoryApiClient;
         _pathItemRepository = pathItemRepository;
         _sessionMemberRepository = sessionMemberRepository;
+        _logger = logger;
 
         _connectionManager.HubPushHandler2.InventoryStarted
             .Where(dto => _sessionService.CheckSession(dto.SessionId))
@@ -65,7 +64,7 @@ public DataInventoryStarter(ISessionService sessionService, ICloudProxy connecti
                 }
                 catch (Exception e)
                 {
-                    Log.Error(e, "An unexpected error occurred while checking the inventory auto-start");
+                    _logger.LogError(e, "An unexpected error occurred while checking the inventory auto-start");
                 }
                 return Unit.Default;
             })
@@ -130,11 +129,11 @@ public async Task<StartInventoryResult> StartDataInventory(bool isLaunchedByUser
 
         if (isLaunchedByUser)
         {
-            Log.Information("The current user has requested to start the Data Inventory");
+            _logger.LogInformation("The current user has requested to start the Data Inventory");
         }
         else
         {
-            Log.Information("The Data Inventory has been automatically started");
+            _logger.LogInformation("The Data Inventory has been automatically started");
         }
 
         var sessionSettings = _sessionService.CurrentSessionSettings;
@@ -150,14 +149,12 @@ public async Task<StartInventoryResult> StartDataInventory(bool isLaunchedByUser
         {
             return result;
         }
-
-        // todo : remonter également les autres paramètres pour contrôle par les aux parties de l'égalité des paramètres
 
         result = await SendSessionSettings(session, sessionSettings);
 
         if (result.IsOK)
         {
-            await _sessionService.SetSessionSettings(sessionSettings);
+            await _sessionService.SetSessionSettings(sessionSettings, false);
             await _dataInventoryRunner.RunDataInventory();
 
             return result;
@@ -172,17 +169,17 @@ public async void OnDataInventoryStarted(InventoryStartedDTO inventoryStartedDto
     {
         try
         {
-            Log.Information("The Data Inventory has been started by another client (ClientInstanceId:{ClientInstanceId})", 
+            _logger.LogInformation("The Data Inventory has been started by another client (ClientInstanceId:{ClientInstanceId})", 
                 inventoryStartedDto.ClientInstanceId);
 
             var sessionSettings = _dataEncrypter.DecryptSessionSettings(inventoryStartedDto.EncryptedSessionSettings);
 
-            await _sessionService.SetSessionSettings(sessionSettings);
+            await _sessionService.SetSessionSettings(sessionSettings, false);
             await _dataInventoryRunner.RunDataInventory();
         }
         catch (Exception ex)
         {
-            Log.Error(ex, "OnStartInventory");
+            _logger.LogError(ex, "OnStartInventory");
         }
     }
 
@@ -269,7 +266,7 @@ private void FinalizeSessionSettings(SessionSettings sessionSettings)
 
     private StartInventoryResult LogAndBuildStartInventoryResult(AbstractSession localSession, StartInventoryStatuses status)
     {
-        Log.Information("StartInventory: session {@localSession} - {Status}", localSession.SessionId, status);
+        _logger.LogInformation("StartInventory: session {@localSession} - {Status}", localSession.SessionId, status);
         return StartInventoryResult.BuildFrom(status);
     }
 }

src/ByteSync.Client/Services/Sessions/SessionService.cs

@@ -164,15 +164,18 @@ public Task SetLocalSession(LocalSession localSession, RunLocalSessionProfileInf
         });
     }
 
-    public async Task SetSessionSettings(SessionSettings sessionSettings)
+    public async Task SetSessionSettings(SessionSettings sessionSettings, bool callApi)
     {
         var currentSession = CurrentSession;
 
         if (currentSession is CloudSession)
         {
             var encryptedSessionSettings = _dataEncrypter.EncryptSessionSettings(sessionSettings);
-                    
-            await _cloudSessionApiClient.UpdateSettings(currentSession.SessionId, encryptedSessionSettings);
+
+            if (callApi)
+            {
+                await _cloudSessionApiClient.UpdateSettings(currentSession.SessionId, encryptedSessionSettings);
+            }
         }
 
         _sessionSettings.OnNext(sessionSettings);

src/ByteSync.ServerCommon/Exceptions/AcquireRedisLockException.cs

@@ -0,0 +1,20 @@
+using RedLockNet;
+
+namespace ByteSync.ServerCommon.Exceptions;
+
+public class AcquireRedisLockException : Exception
+{
+    public AcquireRedisLockException(string message) : base(message)
+    {
+    }
+    
+    public AcquireRedisLockException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+
+    public AcquireRedisLockException(string key, IRedLock redisLock) :
+        base("Could not acquire redis lock, key: " + key + ", status: " + redisLock.Status)
+    {
+
+    }
+}

src/ByteSync.ServerCommon/Repositories/BaseRepository.cs

@@ -2,6 +2,7 @@
 using ByteSync.Common.Controls.Json;
 using ByteSync.Common.Helpers;
 using ByteSync.ServerCommon.Business.Repositories;
+using ByteSync.ServerCommon.Exceptions;
 using ByteSync.ServerCommon.Interfaces.Repositories;
 using ByteSync.ServerCommon.Interfaces.Services;
 using RedLockNet;
@@ -134,7 +135,7 @@ private async Task<UpdateEntityResult<T>> DoUpdate(string key, Func<T, bool> upd
             }
             else
             {
-                throw new Exception("Could not acquire redis lock");
+                throw new AcquireRedisLockException(key, redisLock);
             }
         }
         finally

src/ByteSync.ServerCommon/Repositories/SharedFilesRepository.cs

@@ -1,5 +1,6 @@
 using ByteSync.Common.Business.SharedFiles;
 using ByteSync.ServerCommon.Business.Sessions;
+using ByteSync.ServerCommon.Exceptions;
 using ByteSync.ServerCommon.Interfaces.Repositories;
 using ByteSync.ServerCommon.Interfaces.Services;
 
@@ -97,15 +98,15 @@ public async Task<List<SharedFileData>> Clear(string sessionId)
                 }
                 else
                 {
-                    throw new Exception("Could not acquire redis lock");
+                    throw new AcquireRedisLockException(sharedFileCacheKey, sharedFileLock);
                 }
             }
 
             await database.KeyDeleteAsync(sessionSharedFilesKey);
         }
         else
         {
-            throw new Exception("Could not acquire redis lock");
+            throw new AcquireRedisLockException(sessionSharedFilesKey, sessionSharedFilesLock);
         }
 
         return result;

src/ByteSync.ServerCommon/Services/CacheService.cs

@@ -1,4 +1,5 @@
 using ByteSync.ServerCommon.Business.Settings;
+using ByteSync.ServerCommon.Exceptions;
 using ByteSync.ServerCommon.Interfaces.Services;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -67,7 +68,7 @@ public async Task<IRedLock> AcquireLockAsync(string key)
         }
         else
         {
-            throw new Exception("Could not acquire redis lock for key: " + key);
+            throw new AcquireRedisLockException(key, redisLock);
         }
     }
 }