Repository navigation
Expand file tree
/
Copy pathprogressdispatcher.h
More file actions
331 lines (270 loc) · 8.81 KB
/
Copy pathprogressdispatcher.h
File metadata and controls
331 lines (270 loc) · 8.81 KB
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
/*
* Copyright (C) by Klaas Freitag <freitag@owncloud.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*/
#ifndef PROGRESSDISPATCHER_H
#define PROGRESSDISPATCHER_H
#include "owncloudlib.h"
#include <QObject>
#include <QHash>
#include <QTime>
#include <QQueue>
#include <QElapsedTimer>
#include <QTimer>
#include "syncfileitem.h"
#include "csync/csync_exclude.h"
namespace OCC {
class Folder;
/**
* @brief The ProgressInfo class
* @ingroup libsync
*/
class OWNCLOUDSYNC_EXPORT ProgressInfo : public QObject
{
Q_OBJECT
public:
ProgressInfo();
/** Resets for a new sync run.
*/
void reset();
/** Records the status of the sync run
*/
enum Status {
/// Emitted once at start
Starting,
/**
* Emitted once without _currentDiscoveredFolder when it starts,
* then for each folder.
*/
Discovery,
/// Emitted once when reconcile starts
Reconcile,
/// Emitted during propagation, with progress data
Propagation,
/**
* Emitted once when done
*
* Except when SyncEngine jumps directly to finalize() without going
* through slotPropagationFinished().
*/
Done
};
Status status() const;
/**
* Called when propagation starts.
*
* isUpdatingEstimates() will return true afterwards.
*/
void startEstimateUpdates();
/**
* Returns true when startEstimateUpdates() was called.
*
* This is used when the SyncEngine wants to indicate a new sync
* is about to start via the transmissionProgress() signal. The
* first ProgressInfo will have isUpdatingEstimates() == false.
*/
bool isUpdatingEstimates() const;
/**
* Increase the file and size totals by the amount indicated in item.
*/
void adjustTotalsForFile(const SyncFileItem &item);
/**
* Update totals for item.
*
* adjustTotalsForFile() is called during the treewalk phase to collect
* the initial total size and file count.
* This function is called at most once per item during propagation
* to adjust them when its actual size has been determined.
*
* The value in item.size must be the same as during the call to
* adjustTotalsForFile() while newSize is the newly determined actual
* size.
*/
void updateTotalsForFile(const SyncFileItem &item, qint64 newSize);
qint64 totalFiles() const;
qint64 completedFiles() const;
qint64 totalSize() const;
qint64 completedSize() const;
/** Number of a file that is currently in progress. */
qint64 currentFile() const;
/** Return true if the size needs to be taken in account in the total amount of time */
static inline bool isSizeDependent(const SyncFileItem &item)
{
return !item.isDirectory()
&& (item._instruction == CSYNC_INSTRUCTION_CONFLICT
|| item._instruction == CSYNC_INSTRUCTION_SYNC
|| item._instruction == CSYNC_INSTRUCTION_NEW
|| item._instruction == CSYNC_INSTRUCTION_TYPE_CHANGE)
&& !(item._type == ItemTypeVirtualFile
|| item._type == ItemTypeVirtualFileDehydration);
}
/**
* Holds estimates about progress, returned to the user.
*/
struct Estimates
{
/// Estimated completion amount per second. (of bytes or files)
qint64 estimatedBandwidth;
/// Estimated time remaining in milliseconds.
quint64 estimatedEta;
};
/**
* Holds the current state of something making progress and maintains an
* estimate of the current progress per second.
*/
struct OWNCLOUDSYNC_EXPORT Progress
{
Progress()
: _progressPerSec(0)
, _prevCompleted(0)
, _initialSmoothing(1.0)
, _completed(0)
, _total(0)
{
}
/** Returns the estimates about progress per second and eta. */
Estimates estimates() const;
qint64 completed() const;
qint64 remaining() const;
private:
/**
* Update the exponential moving average estimate of _progressPerSec.
*/
void update();
/**
* Changes the _completed value and does sanity checks on
* _prevCompleted and _total.
*/
void setCompleted(qint64 completed);
// Updated by update()
double _progressPerSec;
qint64 _prevCompleted;
// Used to get to a good value faster when
// progress measurement stats. See update().
double _initialSmoothing;
// Set and updated by ProgressInfo
qint64 _completed;
qint64 _total;
friend class ProgressInfo;
};
Status _status;
struct OWNCLOUDSYNC_EXPORT ProgressItem
{
SyncFileItem _item;
Progress _progress;
};
QHash<QString, ProgressItem> _currentItems;
SyncFileItem _lastCompletedItem;
// Used during local and remote update phase
QString _currentDiscoveredRemoteFolder;
QString _currentDiscoveredLocalFolder;
void setProgressComplete(const SyncFileItem &item);
void setProgressItem(const SyncFileItem &item, qint64 completed);
/**
* Get the total completion estimate
*/
Estimates totalProgress() const;
/**
* Get the optimistic eta.
*
* This value is based on the highest observed transfer bandwidth
* and files-per-second speed.
*/
quint64 optimisticEta() const;
/**
* Whether the remaining-time estimate is trusted.
*
* We don't trust it if it is hugely above the optimistic estimate.
* See #5046.
*/
bool trustEta() const;
/**
* Get the current file completion estimate structure
*/
Estimates fileProgress(const SyncFileItem &item) const;
private slots:
/**
* Called every second once started, this function updates the
* estimates.
*/
void updateEstimates();
private:
// Sets the completed size by summing finished jobs with the progress
// of active ones.
void recomputeCompletedSize();
// Triggers the update() slot every second once propagation started.
QTimer _updateEstimatesTimer;
Progress _sizeProgress;
Progress _fileProgress;
// All size from completed jobs only.
qint64 _totalSizeOfCompletedJobs;
// The fastest observed rate of files per second in this sync.
double _maxFilesPerSecond;
double _maxBytesPerSecond;
};
namespace Progress {
OWNCLOUDSYNC_EXPORT QString asActionString(const SyncFileItem &item);
OWNCLOUDSYNC_EXPORT QString asResultString(const SyncFileItem &item);
OWNCLOUDSYNC_EXPORT bool isWarningKind(SyncFileItem::Status);
OWNCLOUDSYNC_EXPORT bool isIgnoredKind(SyncFileItem::Status);
}
/** Type of error
*
* Used for ProgressDispatcher::syncError. May trigger error interactivity
* in IssuesWidget.
*/
enum class ErrorCategory {
Normal,
InsufficientRemoteStorage,
};
/**
* @file progressdispatcher.h
* @brief A singleton class to provide sync progress information to other gui classes.
*
* How to use the ProgressDispatcher:
* Just connect to the two signals either to progress for every individual file
* or the overall sync progress.
*
*/
class OWNCLOUDSYNC_EXPORT ProgressDispatcher : public QObject
{
Q_OBJECT
public:
static ProgressDispatcher *instance();
~ProgressDispatcher() override;
signals:
/**
@brief Signals the progress of data transmission.
@param[out] folder The folder which is being processed
@param[out] progress A struct with all progress info.
*/
void progressInfo(const QString &folder, const ProgressInfo &progress);
/**
* @brief: the item was completed by a job
*/
void itemCompleted(const QString &folder, const SyncFileItemPtr &item);
/**
* @brief A new folder-wide sync error was seen.
*/
void syncError(const QString &folder, const QString &message, ErrorCategory category);
void excluded(Folder *folder, const QString &path, CSYNC_EXCLUDE_TYPE reason);
/**
* @brief Emitted for a folder when a sync is done, listing all pending conflicts
*/
void folderConflicts(const QString &folder, const QStringList &conflictPaths);
private:
ProgressDispatcher(QObject *parent = nullptr);
QElapsedTimer _timer;
static ProgressDispatcher *_instance;
};
}
#endif // PROGRESSDISPATCHER_H