Skip to content

Commit fa92753

Browse files
paul-fresquetpaul-fresquet
committed
feat: remove TrackingActionUpdateHandlerResult
1 parent da2c1cd commit fa92753

6 files changed

Lines changed: 38 additions & 113 deletions

File tree

‎src/ByteSync.ServerCommon/Business/Repositories/TrackingActionUpdateHandlerResult.cs‎

Lines changed: 0 additions & 27 deletions
This file was deleted.

‎src/ByteSync.ServerCommon/Interfaces/Repositories/ITrackingActionRepository.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,5 +8,5 @@ public interface ITrackingActionRepository : IRepository<TrackingActionEntity>
88
Task<TrackingActionEntity> GetOrBuild(string sessionId, string key);
99

1010
Task<TrackingActionResult> AddOrUpdate(string sessionId, List<string> actionsGroupIds,
11-
Func<TrackingActionEntity, SynchronizationEntity, TrackingActionUpdateHandlerResult> updateHandler);
11+
Func<TrackingActionEntity, SynchronizationEntity, bool> updateHandler);
1212
}

‎src/ByteSync.ServerCommon/Repositories/TrackingActionRepository.cs‎

Lines changed: 11 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -44,38 +44,19 @@ private async Task<TrackingActionEntity> DoGetOrBuild(string sessionId, string a
4444

4545
if (trackingActionEntity == null)
4646
{
47-
4847
throw new Exception("TrackingActionEntity is null");
49-
50-
// trackingActionEntity = await _trackingActionEntityFactory.Create(sessionId, actionsGroupId);
51-
52-
// await Save(cacheKey, trackingActionEntity, null, actionsGroupIdLock);
5348
}
5449

5550
return trackingActionEntity;
5651
}
5752

5853
public async Task<TrackingActionResult> AddOrUpdate(string sessionId, List<string> actionsGroupIds,
59-
Func<TrackingActionEntity, SynchronizationEntity, TrackingActionUpdateHandlerResult> updateHandler)
54+
Func<TrackingActionEntity, SynchronizationEntity, bool> updateHandler)
6055
{
61-
// CacheKey? synchronizationCacheKey = null;
62-
// IRedLock? synchronizationLock = null;
63-
64-
// var locks = new ConcurrentBag<IAsyncDisposable>(); // Thread-safe
6556
var trackingActionEntities = new ConcurrentBag<TrackingActionEntity>();
66-
var updateHandlerResults = new ConcurrentBag<TrackingActionUpdateHandlerResult>();
67-
// bool areAllUpdated = true;
68-
69-
// if (updateSynchronization)
70-
// {
71-
// synchronizationCacheKey = _redisInfrastructureService.ComputeCacheKey(EntityType.Synchronization, sessionId);
72-
// synchronizationLock = await _redisInfrastructureService.AcquireLockAsync(synchronizationCacheKey);
73-
// locks.Add(synchronizationLock);
74-
// }
7557

7658
var synchronizationCacheKey = _redisInfrastructureService.ComputeCacheKey(EntityType.Synchronization, sessionId);
7759
await using var synchronizationLock = await _redisInfrastructureService.AcquireLockAsync(synchronizationCacheKey);
78-
// locks.Add(synchronizationLock);
7960

8061
var synchronizationEntity = await _synchronizationRepository.Get(sessionId);
8162
if (synchronizationEntity == null)
@@ -93,25 +74,23 @@ public async Task<TrackingActionResult> AddOrUpdate(string sessionId, List<strin
9374
await semaphore.WaitAsync();
9475
try
9576
{
96-
var cacheKey = _redisInfrastructureService.ComputeCacheKey(EntityType, $"{sessionId}_{actionsGroupId}");
97-
// var actionsGroupIdLock = await _redisInfrastructureService.AcquireLockAsync(cacheKey);
98-
// locks.Add(actionsGroupIdLock);
99-
100-
var trackingActionEntity = await DoGetOrBuild(sessionId, actionsGroupId, cacheKey, synchronizationLock);
101-
var updateHandlerResult = updateHandler.Invoke(trackingActionEntity, synchronizationEntity);
77+
var cacheKey = _redisInfrastructureService.ComputeCacheKey(EntityType, $"{sessionId}_{actionsGroupId}");
78+
var actionsGroupIdLock = await _redisInfrastructureService.AcquireLockAsync(cacheKey);
79+
80+
var trackingActionEntity = await DoGetOrBuild(sessionId, actionsGroupId, cacheKey, actionsGroupIdLock);
81+
bool isUpdated = updateHandler.Invoke(trackingActionEntity, synchronizationEntity);
10282

103-
if (updateHandlerResult.IsSuccess)
83+
if (isUpdated)
10484
{
105-
await Save(cacheKey, trackingActionEntity, transaction, synchronizationLock);
85+
await Save(cacheKey, trackingActionEntity, transaction, actionsGroupIdLock);
10686
trackingActionEntities.Add(trackingActionEntity);
107-
updateHandlerResults.Add(updateHandlerResult);
10887
}
10988
else
11089
{
11190
_logger.LogWarning("AddOrUpdate: can not update element {TrackingActionEntity} for session {SessionId}. No element will be updated",
11291
trackingActionEntity.ActionsGroupId, sessionId);
11392

114-
updateFailures.Add(true); // flag pour arrêt
93+
updateFailures.Add(true);
11594
}
11695
}
11796
finally
@@ -126,33 +105,11 @@ public async Task<TrackingActionResult> AddOrUpdate(string sessionId, List<strin
126105

127106
if (areAllUpdated)
128107
{
129-
if (updateHandlerResults.Any(uhr => uhr.IsAChange))
130-
{
131-
// var synchronizationCacheKey = _redisInfrastructureService.ComputeCacheKey(EntityType.Synchronization, sessionId);
132-
await _synchronizationCacheRepository.AddOrUpdate(synchronizationCacheKey, synEnt =>
133-
{
134-
foreach (var updateHandlerResult in updateHandlerResults)
135-
{
136-
synEnt!.Progress.FinishedActionsCount += updateHandlerResult.FinishedActionsCount;
137-
synEnt.Progress.ErrorsCount += updateHandlerResult.ErrorsCount;
138-
synEnt.Progress.ProcessedVolume += updateHandlerResult.ProcessedVolume;
139-
synEnt.Progress.ExchangedVolume += updateHandlerResult.ExchangedVolume;
140-
}
141-
142-
return synEnt;
143-
}, transaction, synchronizationLock);
144-
145-
// await _synchronizationCacheRepository.Save(synchronizationCacheKey!, synchronizationEntity, transaction, synchronizationLock);
146-
}
147-
108+
await _synchronizationCacheRepository.Save(synchronizationCacheKey, synchronizationEntity, transaction, synchronizationLock);
109+
148110
await transaction.ExecuteAsync();
149111
}
150112

151-
// foreach (var redisLock in locks)
152-
// {
153-
// await redisLock.DisposeAsync();
154-
// }
155-
156113
return new TrackingActionResult(areAllUpdated, trackingActionEntities.ToList(), synchronizationEntity);
157114
}
158115
}

‎src/ByteSync.ServerCommon/Services/SynchronizationService.cs‎

Lines changed: 18 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -84,7 +84,7 @@ public async Task OnUploadIsFinishedAsync(SharedFileDefinition sharedFileDefinit
8484
{
8585
if (!_synchronizationStatusCheckerService.CheckSynchronizationCanBeUpdated(synchronization))
8686
{
87-
return new TrackingActionUpdateHandlerResult(false);
87+
return false;
8888
}
8989

9090
trackingAction.IsSourceSuccess = true;
@@ -94,7 +94,7 @@ public async Task OnUploadIsFinishedAsync(SharedFileDefinition sharedFileDefinit
9494
targetInstanceIds.Add(targetClientInstanceId);
9595
}
9696

97-
return new TrackingActionUpdateHandlerResult(true);
97+
return true;
9898
});
9999

100100
if (result.IsSuccess)
@@ -133,25 +133,23 @@ public async Task OnDownloadIsFinishedAsync(SharedFileDefinition sharedFileDefin
133133
{
134134
if (!_synchronizationStatusCheckerService.CheckSynchronizationCanBeUpdated(synchronization))
135135
{
136-
return new TrackingActionUpdateHandlerResult(false);
136+
return false;
137137
}
138138

139-
var trackingActionUpdateHandlerResult = new TrackingActionUpdateHandlerResult(true);
140139
bool wasTrackingActionFinished = trackingAction.IsFinished;
141140

142141
trackingAction.AddSuccessOnTarget(client.ClientInstanceId);
143142

144143
if (!wasTrackingActionFinished && trackingAction.IsFinished)
145144
{
146-
trackingActionUpdateHandlerResult.FinishedActionsCount = 1;
147-
trackingActionUpdateHandlerResult.ProcessedVolume = trackingAction.Size ?? 0;
145+
synchronization.Progress.FinishedActionsCount += 1;
146+
synchronization.Progress.ProcessedVolume += trackingAction.Size ?? 0;
148147
}
149-
150-
trackingActionUpdateHandlerResult.ExchangedVolume = sharedFileDefinition.UploadedFileLength;
148+
synchronization.Progress.ExchangedVolume = sharedFileDefinition.UploadedFileLength;
151149

152150
needSendSynchronizationUpdated = CheckSynchronizationIsFinished(synchronization);
153151

154-
return trackingActionUpdateHandlerResult;
152+
return true;
155153
});
156154

157155
if (result.IsSuccess)
@@ -189,22 +187,21 @@ private async Task OnSuccessOnTarget(string sessionId, List<string> actionsGroup
189187
{
190188
if (!_synchronizationStatusCheckerService.CheckSynchronizationCanBeUpdated(synchronization))
191189
{
192-
return new TrackingActionUpdateHandlerResult(false);
190+
return false;
193191
}
194192

195-
var trackingActionUpdateHandlerResult = new TrackingActionUpdateHandlerResult(true);
196193
bool wasTrackingActionFinished = trackingAction.IsFinished;
197194

198195
trackingAction.AddSuccessOnTarget(client.ClientInstanceId);
199196

200197
if (!wasTrackingActionFinished && trackingAction.IsFinished)
201198
{
202-
trackingActionUpdateHandlerResult.FinishedActionsCount = 1;
199+
synchronization.Progress.FinishedActionsCount = 1;
203200
}
204201

205202
needSendSynchronizationUpdated = CheckSynchronizationIsFinished(synchronization);
206203

207-
return trackingActionUpdateHandlerResult;
204+
return true;
208205
});
209206

210207
if (result.IsSuccess)
@@ -227,25 +224,24 @@ public async Task OnLocalCopyIsDoneAsync(string sessionId, List<string> actionsG
227224
{
228225
if (!_synchronizationStatusCheckerService.CheckSynchronizationCanBeUpdated(synchronization))
229226
{
230-
return new TrackingActionUpdateHandlerResult(false);;
227+
return false;
231228
}
232229

233-
var trackingActionUpdateHandlerResult = new TrackingActionUpdateHandlerResult(true);
234230
bool wasTrackingActionFinished = trackingAction.IsFinished;
235231

236232
trackingAction.IsSourceSuccess = true;
237233
trackingAction.AddSuccessOnTarget(client.ClientInstanceId);
238234

239235
if (!wasTrackingActionFinished && trackingAction.IsFinished)
240236
{
241-
trackingActionUpdateHandlerResult.FinishedActionsCount = 1;
237+
synchronization.Progress.FinishedActionsCount = 1;
242238
}
243239

244-
trackingActionUpdateHandlerResult.ProcessedVolume = trackingAction.Size ?? 0;
240+
synchronization.Progress.ProcessedVolume = trackingAction.Size ?? 0;
245241

246242
needSendSynchronizationUpdated = CheckSynchronizationIsFinished(synchronization);
247243

248-
return trackingActionUpdateHandlerResult;
244+
return true;
249245
});
250246

251247
if (result.IsSuccess)
@@ -268,10 +264,9 @@ public async Task AssertSynchronizationActionErrors(string sessionId, List<strin
268264
{
269265
if (!_synchronizationStatusCheckerService.CheckSynchronizationCanBeUpdated(synchronization))
270266
{
271-
return new TrackingActionUpdateHandlerResult(false);
267+
return false;
272268
}
273269

274-
var trackingActionUpdateHandlerResult = new TrackingActionUpdateHandlerResult(true);
275270
bool wasTrackingActionFinished = trackingAction.IsFinished;
276271
bool isNewError = !trackingAction.IsError;
277272

@@ -293,16 +288,16 @@ public async Task AssertSynchronizationActionErrors(string sessionId, List<strin
293288

294289
if (isNewError)
295290
{
296-
trackingActionUpdateHandlerResult.ErrorsCount = 1;
291+
synchronization.Progress.ErrorsCount = 1;
297292
}
298293
if (!wasTrackingActionFinished && trackingAction.IsFinished)
299294
{
300-
trackingActionUpdateHandlerResult.FinishedActionsCount = 1;
295+
synchronization.Progress.FinishedActionsCount = 1;
301296
}
302297

303298
needSendSynchronizationUpdated = CheckSynchronizationIsFinished(synchronization);
304299

305-
return trackingActionUpdateHandlerResult;
300+
return true;
306301
});
307302

308303
if (result.IsSuccess)

‎tests/ByteSync.ServerCommon.Tests/Repositories/TrackingActionRepositoryTests.cs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -65,9 +65,9 @@ public async Task AddOrUpdate_WhenAllUpdatesSucceed_ShouldReturnUpdatedEntities(
6565

6666
await _synchronizationRepository.AddSynchronization(synchronizationEntity, actionsGroupDefinitions);
6767

68-
Func<TrackingActionEntity, SynchronizationEntity, TrackingActionUpdateHandlerResult> updateHandler = (_, _) =>
68+
Func<TrackingActionEntity, SynchronizationEntity, bool> updateHandler = (_, _) =>
6969
{
70-
return new TrackingActionUpdateHandlerResult(true);
70+
return true;
7171
};
7272

7373
// Act

‎tests/ByteSync.ServerCommon.Tests/Services/SynchronizationServiceTests.cs‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -169,8 +169,8 @@ public async Task OnUploadIsFinishedAsync_WhenCheckSynchronizationSuccess_RunsNo
169169
trackingActionEntity.TargetClientInstanceIds.Add("targetClientInstanceId");
170170
SynchronizationEntity synchronizationEntity = new SynchronizationEntity();
171171

172-
A.CallTo(() => _trackingActionRepository.AddOrUpdate(sessionId, A<List<string>>.Ignored, A<Func<TrackingActionEntity, SynchronizationEntity, TrackingActionUpdateHandlerResult>>.Ignored))
173-
.Invokes((string _, List<string> _, Func<TrackingActionEntity, SynchronizationEntity, TrackingActionUpdateHandlerResult> func) => func(trackingActionEntity, synchronizationEntity))
172+
A.CallTo(() => _trackingActionRepository.AddOrUpdate(sessionId, A<List<string>>.Ignored, A<Func<TrackingActionEntity, SynchronizationEntity, bool>>.Ignored))
173+
.Invokes((string _, List<string> _, Func<TrackingActionEntity, SynchronizationEntity, bool> func) => func(trackingActionEntity, synchronizationEntity))
174174
.Returns(new TrackingActionResult(true, new List<TrackingActionEntity>(), synchronizationEntity));
175175

176176
A.CallTo(() => _synchronizationStatusCheckerService.CheckSynchronizationCanBeUpdated(synchronizationEntity))
@@ -183,7 +183,7 @@ public async Task OnUploadIsFinishedAsync_WhenCheckSynchronizationSuccess_RunsNo
183183
await _synchronizationService.OnUploadIsFinishedAsync(sharedFileDefinition, 1, client);
184184

185185
// Assert
186-
A.CallTo(() => _trackingActionRepository.AddOrUpdate(sessionId, A<List<string>>.Ignored, A<Func<TrackingActionEntity, SynchronizationEntity, TrackingActionUpdateHandlerResult>>.Ignored))
186+
A.CallTo(() => _trackingActionRepository.AddOrUpdate(sessionId, A<List<string>>.Ignored, A<Func<TrackingActionEntity, SynchronizationEntity, bool>>.Ignored))
187187
.MustHaveHappenedOnceExactly();
188188
A.CallTo(() => _synchronizationStatusCheckerService.CheckSynchronizationCanBeUpdated(synchronizationEntity))
189189
.MustHaveHappenedOnceExactly();
@@ -203,8 +203,8 @@ public async Task OnUploadIsFinishedAsync_WhenCheckSynchronizationFails_Aborts()
203203
trackingActionEntity.TargetClientInstanceIds.Add("targetClientInstanceId");
204204
SynchronizationEntity synchronizationEntity = new SynchronizationEntity();
205205

206-
A.CallTo(() => _trackingActionRepository.AddOrUpdate(sessionId, A<List<string>>.Ignored, A<Func<TrackingActionEntity, SynchronizationEntity, TrackingActionUpdateHandlerResult>>.Ignored))
207-
.Invokes((string _, List<string> _, Func<TrackingActionEntity, SynchronizationEntity, TrackingActionUpdateHandlerResult> func) => func(trackingActionEntity, synchronizationEntity))
206+
A.CallTo(() => _trackingActionRepository.AddOrUpdate(sessionId, A<List<string>>.Ignored, A<Func<TrackingActionEntity, SynchronizationEntity, bool>>.Ignored))
207+
.Invokes((string _, List<string> _, Func<TrackingActionEntity, SynchronizationEntity, bool> func) => func(trackingActionEntity, synchronizationEntity))
208208
.Returns(new TrackingActionResult(false, new List<TrackingActionEntity>(), synchronizationEntity));
209209

210210
A.CallTo(() => _synchronizationStatusCheckerService.CheckSynchronizationCanBeUpdated(synchronizationEntity))
@@ -214,7 +214,7 @@ public async Task OnUploadIsFinishedAsync_WhenCheckSynchronizationFails_Aborts()
214214
await _synchronizationService.OnUploadIsFinishedAsync(sharedFileDefinition, 1, client);
215215

216216
// Assert
217-
A.CallTo(() => _trackingActionRepository.AddOrUpdate(sessionId, A<List<string>>.Ignored, A<Func<TrackingActionEntity, SynchronizationEntity, TrackingActionUpdateHandlerResult>>.Ignored))
217+
A.CallTo(() => _trackingActionRepository.AddOrUpdate(sessionId, A<List<string>>.Ignored, A<Func<TrackingActionEntity, SynchronizationEntity, bool>>.Ignored))
218218
.MustHaveHappenedOnceExactly();
219219
A.CallTo(() => _synchronizationStatusCheckerService.CheckSynchronizationCanBeUpdated(synchronizationEntity))
220220
.MustHaveHappenedOnceExactly();

0 commit comments

Comments
 (0)