ByteSync/src/ByteSync.ServerCommon/Services/SynchronizationProgressService.cs at 54b3b70dbf7eaa941a814f13d662f0d5fa7ccb8d · POW-Software/ByteSync · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
using ByteSync.Common.Business.SharedFiles;
using ByteSync.Common.Business.Synchronizations;
using ByteSync.ServerCommon.Business.Auth;
using ByteSync.ServerCommon.Business.Repositories;
using ByteSync.ServerCommon.Entities;
using ByteSync.ServerCommon.Interfaces.Mappers;
using ByteSync.ServerCommon.Interfaces.Services;
using ByteSync.ServerCommon.Interfaces.Services.Clients;

namespace ByteSync.ServerCommon.Services;

public class SynchronizationProgressService : ISynchronizationProgressService
{
    private readonly IInvokeClientsService _invokeClientsService;
    private readonly ITrackingActionMapper _trackingActionMapper;
    private readonly ISynchronizationMapper _synchronizationMapper;
    private readonly ISharedFilesService _sharedFilesService;

    public SynchronizationProgressService(IInvokeClientsService invokeClientsService, ITrackingActionMapper trackingActionMapper,
        ISynchronizationMapper synchronizationMapper, ISharedFilesService sharedFilesService)
    {
        _invokeClientsService = invokeClientsService;
        _trackingActionMapper = trackingActionMapper;
        _synchronizationMapper = synchronizationMapper;
        _sharedFilesService = sharedFilesService;
    }

    public async Task UpdateSynchronizationProgress(TrackingActionResult trackingActionResult, bool needSendSynchronizationUpdated)
    {
        await SendSynchronizationProgressUpdated(trackingActionResult);

        if (needSendSynchronizationUpdated)
        {
            await SendSynchronizationUpdated(trackingActionResult.SynchronizationEntity);
        }
    }

    public async Task UpdateSynchronizationProgress(SynchronizationEntity synchronizationEntity, bool needSendSynchronizationUpdated)
    {
        await SendSynchronizationProgressUpdated(synchronizationEntity);

        if (needSendSynchronizationUpdated)
        {
            await SendSynchronizationUpdated(synchronizationEntity);
        }
    }

    public async Task InformSynchronizationStarted(SynchronizationEntity synchronizationEntity, Client client)
    {
        var synchronization = await MapToSynchronization(synchronizationEntity);
        await _invokeClientsService.SessionGroup(synchronization.SessionId).SynchronizationStarted(synchronization);
    }

    public async Task UploadIsFinished(SharedFileDefinition sharedFileDefinition, int totalParts, HashSet<string> targetInstanceIds)
    {
        var transferParameters = new TransferParameters
        {
            SessionId = sharedFileDefinition.SessionId,
            SharedFileDefinition = sharedFileDefinition,
            TotalParts = totalParts
        };
        await _sharedFilesService.AssertUploadIsFinished(transferParameters, targetInstanceIds);

        var fileTransferPush = new FileTransferPush
        {
            SessionId = sharedFileDefinition.SessionId,
            SharedFileDefinition = sharedFileDefinition,
            TotalParts = totalParts,
            ActionsGroupIds = sharedFileDefinition.ActionsGroupIds!
        };

        await _invokeClientsService.Clients(targetInstanceIds).UploadFinished(fileTransferPush);
    }

    public async Task FilePartIsUploaded(SharedFileDefinition sharedFileDefinition, int partNumber, HashSet<string> targetInstanceIds)
    {
        var transferParameters = new TransferParameters
        {
            SessionId = sharedFileDefinition.SessionId,
            SharedFileDefinition = sharedFileDefinition,
            PartNumber = partNumber
        };
        await _sharedFilesService.AssertFilePartIsUploaded(transferParameters, targetInstanceIds);

        var fileTransferPush = new FileTransferPush
        {
            SessionId = sharedFileDefinition.SessionId,
            SharedFileDefinition = sharedFileDefinition,
            PartNumber = partNumber,
            ActionsGroupIds = sharedFileDefinition.ActionsGroupIds!
        };

        await _invokeClientsService.Clients(targetInstanceIds).FilePartUploaded(fileTransferPush);
    }

    public Task<Synchronization> MapToSynchronization(SynchronizationEntity synchronizationEntity)
    {
        var synchronization = _synchronizationMapper.MapToSynchronization(synchronizationEntity);

        return Task.FromResult(synchronization);
    }

    private async Task SendSynchronizationUpdated(SynchronizationEntity synchronizationEntity)
    {
        var synchronization = await MapToSynchronization(synchronizationEntity);

        await _invokeClientsService.Clients(synchronizationEntity.Progress.Members).SynchronizationUpdated(synchronization);
    }

    private async Task SendSynchronizationProgressUpdated(SynchronizationEntity synchronizationEntity)
    {
        var synchronizationProgressPush = CreateSynchronizationProgressPush(synchronizationEntity, null);

        await _invokeClientsService.Clients(synchronizationEntity.Progress.Members)
            .SynchronizationProgressUpdated(synchronizationProgressPush);
    }

    private async Task SendSynchronizationProgressUpdated(TrackingActionResult trackingActionResult)
    {
        List<TrackingActionSummary> trackingActionSummaries = new List<TrackingActionSummary>();
        foreach (var trackingActionEntity in trackingActionResult.TrackingActionEntities)
        {
            var trackingActionSummary = _trackingActionMapper.MapToTrackingActionSummary(trackingActionEntity);

            trackingActionSummaries.Add(trackingActionSummary);
        }

        var synchronizationProgressPush = CreateSynchronizationProgressPush(trackingActionResult.SynchronizationEntity, trackingActionSummaries);

        await _invokeClientsService.Clients(trackingActionResult.SynchronizationEntity.Progress.Members)
            .SynchronizationProgressUpdated(synchronizationProgressPush);
    }

    private static SynchronizationProgressPush CreateSynchronizationProgressPush(SynchronizationEntity synchronizationEntity,
        List<TrackingActionSummary>? trackingActionSummaries)
    {
        var synchronizationProgressPush = new SynchronizationProgressPush
        {
            SessionId = synchronizationEntity.SessionId,

            ProcessedVolume = synchronizationEntity.Progress.ProcessedVolume,
            ExchangedVolume = synchronizationEntity.Progress.ExchangedVolume,
            FinishedActionsCount = synchronizationEntity.Progress.FinishedActionsCount,
            ErrorActionsCount = synchronizationEntity.Progress.ErrorsCount,

            Version = DateTimeOffset.UtcNow.Ticks,

            TrackingActionSummaries = trackingActionSummaries,
        };
        return synchronizationProgressPush;
    }
}