2014-02-06 14:50:16 +04:00
|
|
|
/*
|
|
|
|
* Copyright (C) by Olivier Goffart <ogoffart@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.
|
|
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
|
2014-02-18 14:52:38 +04:00
|
|
|
#include "owncloudpropagator.h"
|
2014-02-06 14:50:16 +04:00
|
|
|
#include "networkjobs.h"
|
|
|
|
|
2014-02-18 14:52:38 +04:00
|
|
|
#include <QBuffer>
|
|
|
|
#include <QFile>
|
2017-03-24 17:01:50 +03:00
|
|
|
#include <QElapsedTimer>
|
2014-02-06 14:50:16 +04:00
|
|
|
|
|
|
|
|
2014-11-10 00:34:07 +03:00
|
|
|
namespace OCC {
|
2017-05-09 15:24:11 +03:00
|
|
|
|
2017-03-30 14:46:20 +03:00
|
|
|
Q_DECLARE_LOGGING_CATEGORY(lcPutJob)
|
2017-05-09 15:24:11 +03:00
|
|
|
Q_DECLARE_LOGGING_CATEGORY(lcPropagateUpload)
|
2020-05-13 18:34:41 +03:00
|
|
|
Q_DECLARE_LOGGING_CATEGORY(lcPropagateUploadV1)
|
|
|
|
Q_DECLARE_LOGGING_CATEGORY(lcPropagateUploadNG)
|
2017-05-09 15:24:11 +03:00
|
|
|
|
2014-11-14 18:40:13 +03:00
|
|
|
class BandwidthManager;
|
2014-02-06 14:50:16 +04:00
|
|
|
|
2015-06-29 19:56:09 +03:00
|
|
|
/**
|
|
|
|
* @brief The UploadDevice class
|
|
|
|
* @ingroup libsync
|
2015-06-26 18:07:47 +03:00
|
|
|
*/
|
2014-11-14 18:40:13 +03:00
|
|
|
class UploadDevice : public QIODevice
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
2014-02-10 16:00:22 +04:00
|
|
|
public:
|
2019-06-06 13:22:02 +03:00
|
|
|
UploadDevice(const QString &fileName, qint64 start, qint64 size, BandwidthManager *bwm);
|
2014-11-14 18:40:13 +03:00
|
|
|
~UploadDevice();
|
2015-01-14 17:14:17 +03:00
|
|
|
|
2019-06-06 13:22:02 +03:00
|
|
|
bool open(QIODevice::OpenMode mode) override;
|
|
|
|
void close() override;
|
2015-01-14 17:14:17 +03:00
|
|
|
|
2018-11-12 20:39:50 +03:00
|
|
|
qint64 writeData(const char *, qint64) override;
|
|
|
|
qint64 readData(char *data, qint64 maxlen) override;
|
|
|
|
bool atEnd() const override;
|
|
|
|
qint64 size() const override;
|
|
|
|
qint64 bytesAvailable() const override;
|
|
|
|
bool isSequential() const override;
|
|
|
|
bool seek(qint64 pos) override;
|
2014-02-10 16:00:22 +04:00
|
|
|
|
2014-11-14 18:40:13 +03:00
|
|
|
void setBandwidthLimited(bool);
|
|
|
|
bool isBandwidthLimited() { return _bandwidthLimited; }
|
|
|
|
void setChoked(bool);
|
|
|
|
bool isChoked() { return _choked; }
|
|
|
|
void giveBandwidthQuota(qint64 bwq);
|
2015-04-27 16:04:44 +03:00
|
|
|
|
|
|
|
signals:
|
|
|
|
|
2014-11-14 18:40:13 +03:00
|
|
|
private:
|
2019-06-06 13:22:02 +03:00
|
|
|
/// The local file to read data from
|
|
|
|
QFile _file;
|
|
|
|
|
|
|
|
/// Start of the file data to use
|
|
|
|
qint64 _start = 0;
|
|
|
|
/// Amount of file data after _start to use
|
|
|
|
qint64 _size = 0;
|
|
|
|
/// Position between _start and _start+_size
|
|
|
|
qint64 _read = 0;
|
2015-01-14 14:48:38 +03:00
|
|
|
|
2015-01-14 16:27:24 +03:00
|
|
|
// Bandwidth manager related
|
|
|
|
QPointer<BandwidthManager> _bandwidthManager;
|
2020-12-10 21:52:58 +03:00
|
|
|
qint64 _bandwidthQuota = 0;
|
|
|
|
qint64 _readWithProgress = 0;
|
|
|
|
bool _bandwidthLimited = false; // if _bandwidthQuota will be used
|
|
|
|
bool _choked = false; // if upload is paused (readData() will return 0)
|
2015-01-14 14:48:38 +03:00
|
|
|
friend class BandwidthManager;
|
2017-09-25 12:58:30 +03:00
|
|
|
public slots:
|
2014-11-14 18:40:13 +03:00
|
|
|
void slotJobUploadProgress(qint64 sent, qint64 t);
|
2014-02-10 16:00:22 +04:00
|
|
|
};
|
|
|
|
|
2015-06-29 19:56:09 +03:00
|
|
|
/**
|
|
|
|
* @brief The PUTFileJob class
|
|
|
|
* @ingroup libsync
|
2015-06-26 18:07:47 +03:00
|
|
|
*/
|
2014-02-06 14:50:16 +04:00
|
|
|
class PUTFileJob : public AbstractNetworkJob
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
2015-05-12 17:36:40 +03:00
|
|
|
|
|
|
|
private:
|
2017-03-03 13:20:53 +03:00
|
|
|
QIODevice *_device;
|
2014-02-06 14:50:16 +04:00
|
|
|
QMap<QByteArray, QByteArray> _headers;
|
2014-04-30 19:54:14 +04:00
|
|
|
QString _errorString;
|
2016-08-02 14:48:56 +03:00
|
|
|
QUrl _url;
|
2017-03-24 17:01:50 +03:00
|
|
|
QElapsedTimer _requestTimer;
|
2014-02-06 14:50:16 +04:00
|
|
|
|
|
|
|
public:
|
2014-02-17 16:48:56 +04:00
|
|
|
// Takes ownership of the device
|
2019-05-08 20:41:48 +03:00
|
|
|
explicit PUTFileJob(AccountPtr account, const QString &path, std::unique_ptr<QIODevice> device,
|
2018-11-12 20:46:39 +03:00
|
|
|
const QMap<QByteArray, QByteArray> &headers, int chunk, QObject *parent = nullptr)
|
2017-03-03 13:20:53 +03:00
|
|
|
: AbstractNetworkJob(account, path, parent)
|
2019-05-08 20:41:48 +03:00
|
|
|
, _device(device.release())
|
2017-03-03 13:20:53 +03:00
|
|
|
, _headers(headers)
|
|
|
|
, _chunk(chunk)
|
|
|
|
{
|
|
|
|
_device->setParent(this);
|
|
|
|
}
|
2019-05-08 20:41:48 +03:00
|
|
|
explicit PUTFileJob(AccountPtr account, const QUrl &url, std::unique_ptr<QIODevice> device,
|
2018-11-12 20:46:39 +03:00
|
|
|
const QMap<QByteArray, QByteArray> &headers, int chunk, QObject *parent = nullptr)
|
2016-08-02 14:48:56 +03:00
|
|
|
: AbstractNetworkJob(account, QString(), parent)
|
2019-05-08 20:41:48 +03:00
|
|
|
, _device(device.release())
|
2016-08-02 14:48:56 +03:00
|
|
|
, _headers(headers)
|
2017-03-03 13:20:53 +03:00
|
|
|
, _url(url)
|
|
|
|
, _chunk(chunk)
|
|
|
|
{
|
|
|
|
_device->setParent(this);
|
|
|
|
}
|
2015-03-23 18:13:52 +03:00
|
|
|
~PUTFileJob();
|
2014-09-15 19:55:55 +04:00
|
|
|
|
|
|
|
int _chunk;
|
2014-02-06 14:50:16 +04:00
|
|
|
|
2018-11-12 20:43:58 +03:00
|
|
|
void start() override;
|
2014-02-06 14:50:16 +04:00
|
|
|
|
2019-06-21 12:34:59 +03:00
|
|
|
bool finished() override;
|
2014-02-06 14:50:16 +04:00
|
|
|
|
2017-08-11 01:03:03 +03:00
|
|
|
QIODevice *device()
|
|
|
|
{
|
|
|
|
return _device;
|
|
|
|
}
|
|
|
|
|
2014-04-30 19:54:14 +04:00
|
|
|
QString errorString()
|
|
|
|
{
|
2017-03-23 17:53:22 +03:00
|
|
|
return _errorString.isEmpty() ? AbstractNetworkJob::errorString() : _errorString;
|
2015-01-30 11:16:14 +03:00
|
|
|
}
|
2014-04-30 19:54:14 +04:00
|
|
|
|
2018-01-24 00:51:25 +03:00
|
|
|
std::chrono::milliseconds msSinceStart() const
|
2017-03-24 17:01:50 +03:00
|
|
|
{
|
2018-01-24 00:51:25 +03:00
|
|
|
return std::chrono::milliseconds(_requestTimer.elapsed());
|
2017-03-24 17:01:50 +03:00
|
|
|
}
|
|
|
|
|
2014-02-06 14:50:16 +04:00
|
|
|
signals:
|
|
|
|
void finishedSignal();
|
2014-03-14 16:03:16 +04:00
|
|
|
void uploadProgress(qint64, qint64);
|
2015-04-27 16:04:44 +03:00
|
|
|
|
2014-02-06 14:50:16 +04:00
|
|
|
};
|
|
|
|
|
2015-06-29 19:56:09 +03:00
|
|
|
/**
|
2015-10-05 06:20:09 +03:00
|
|
|
* @brief This job implements the asynchronous PUT
|
2015-06-26 18:07:47 +03:00
|
|
|
*
|
2018-06-25 18:47:52 +03:00
|
|
|
* If the server replies to a PUT with a OC-JobStatus-Location path, we will query this url until the server
|
|
|
|
* replies with an etag.
|
2015-06-29 19:56:09 +03:00
|
|
|
* @ingroup libsync
|
2015-03-04 10:42:24 +03:00
|
|
|
*/
|
2014-07-25 15:30:48 +04:00
|
|
|
class PollJob : public AbstractNetworkJob
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
2014-07-28 14:12:52 +04:00
|
|
|
SyncJournalDb *_journal;
|
|
|
|
QString _localPath;
|
2017-05-17 11:55:42 +03:00
|
|
|
|
2014-07-25 15:30:48 +04:00
|
|
|
public:
|
2015-04-15 16:19:11 +03:00
|
|
|
SyncFileItemPtr _item;
|
2014-07-25 15:30:48 +04:00
|
|
|
// Takes ownership of the device
|
2015-04-15 16:19:11 +03:00
|
|
|
explicit PollJob(AccountPtr account, const QString &path, const SyncFileItemPtr &item,
|
2014-07-28 14:12:52 +04:00
|
|
|
SyncJournalDb *journal, const QString &localPath, QObject *parent)
|
|
|
|
: AbstractNetworkJob(account, path, parent)
|
|
|
|
, _journal(journal)
|
|
|
|
, _localPath(localPath)
|
|
|
|
, _item(item)
|
|
|
|
{
|
|
|
|
}
|
2014-07-25 15:30:48 +04:00
|
|
|
|
2018-11-12 20:39:50 +03:00
|
|
|
void start() override;
|
|
|
|
bool finished() override;
|
2014-07-25 15:30:48 +04:00
|
|
|
|
|
|
|
signals:
|
2014-07-28 14:12:52 +04:00
|
|
|
void finishedSignal();
|
2014-07-25 15:30:48 +04:00
|
|
|
};
|
|
|
|
|
2017-12-21 02:35:23 +03:00
|
|
|
class PropagateUploadEncrypted;
|
|
|
|
|
2015-06-29 19:56:09 +03:00
|
|
|
/**
|
2016-05-20 11:26:02 +03:00
|
|
|
* @brief The PropagateUploadFileCommon class is the code common between all chunking algorithms
|
2015-06-29 19:56:09 +03:00
|
|
|
* @ingroup libsync
|
2016-05-20 11:26:02 +03:00
|
|
|
*
|
|
|
|
* State Machine:
|
|
|
|
*
|
|
|
|
* +---> start() --> (delete job) -------+
|
|
|
|
* | |
|
|
|
|
* +--> slotComputeContentChecksum() <---+
|
|
|
|
* |
|
|
|
|
* v
|
|
|
|
* slotComputeTransmissionChecksum()
|
|
|
|
* |
|
|
|
|
* v
|
|
|
|
* slotStartUpload() -> doStartUpload()
|
|
|
|
* .
|
|
|
|
* .
|
|
|
|
* v
|
|
|
|
* finalize() or abortWithError() or startPollJob()
|
2015-06-26 18:07:47 +03:00
|
|
|
*/
|
2016-05-20 11:26:02 +03:00
|
|
|
class PropagateUploadFileCommon : public PropagateItemJob
|
|
|
|
{
|
2014-02-06 14:50:16 +04:00
|
|
|
Q_OBJECT
|
2015-03-04 10:42:24 +03:00
|
|
|
|
2021-01-21 18:07:30 +03:00
|
|
|
struct UploadStatus {
|
|
|
|
SyncFileItem::Status status = SyncFileItem::NoStatus;
|
|
|
|
QString message;
|
|
|
|
};
|
|
|
|
|
2016-05-20 11:26:02 +03:00
|
|
|
protected:
|
2016-01-06 12:01:22 +03:00
|
|
|
QVector<AbstractNetworkJob *> _jobs; /// network jobs that are currently in transit
|
2017-01-26 15:41:04 +03:00
|
|
|
bool _finished BITFIELD(1); /// Tells that all the jobs have been finished
|
|
|
|
bool _deleteExisting BITFIELD(1);
|
2015-05-12 17:36:40 +03:00
|
|
|
|
2018-10-08 13:04:54 +03:00
|
|
|
/** Whether an abort is currently ongoing.
|
|
|
|
*
|
|
|
|
* Important to avoid duplicate aborts since each finishing PUTFileJob might
|
|
|
|
* trigger an abort on error.
|
|
|
|
*/
|
|
|
|
bool _aborting BITFIELD(1);
|
|
|
|
|
2017-11-28 23:28:06 +03:00
|
|
|
/* This is a minified version of the SyncFileItem,
|
|
|
|
* that holds only the specifics about the file that's
|
|
|
|
* being uploaded.
|
|
|
|
*
|
|
|
|
* This is needed if we wanna apply changes on the file
|
|
|
|
* that's being uploaded while keeping the original on disk.
|
|
|
|
*/
|
|
|
|
struct UploadFileInfo {
|
|
|
|
QString _file; /// I'm still unsure if I should use a SyncFilePtr here.
|
2017-11-29 00:17:29 +03:00
|
|
|
QString _path; /// the full path on disk.
|
2019-02-13 12:15:33 +03:00
|
|
|
qint64 _size;
|
2017-11-28 23:28:06 +03:00
|
|
|
};
|
|
|
|
UploadFileInfo _fileToUpload;
|
2017-06-14 13:14:46 +03:00
|
|
|
QByteArray _transmissionChecksumHeader;
|
2015-11-23 13:53:06 +03:00
|
|
|
|
2014-02-06 14:50:16 +04:00
|
|
|
public:
|
2020-07-01 14:19:08 +03:00
|
|
|
PropagateUploadFileCommon(OwncloudPropagator *propagator, const SyncFileItemPtr &item);
|
2016-01-06 12:01:22 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Whether an existing entity with the same name may be deleted before
|
|
|
|
* the upload.
|
|
|
|
*
|
|
|
|
* Default: false.
|
|
|
|
*/
|
|
|
|
void setDeleteExisting(bool enabled);
|
|
|
|
|
2017-12-04 23:33:43 +03:00
|
|
|
/* start should setup the file, path and size that will be send to the server */
|
2018-11-12 20:39:50 +03:00
|
|
|
void start() override;
|
2017-12-21 01:36:49 +03:00
|
|
|
void setupEncryptedFile(const QString& path, const QString& filename, quint64 size);
|
2017-12-18 00:38:43 +03:00
|
|
|
void setupUnencryptedFile();
|
2017-12-05 00:27:13 +03:00
|
|
|
void startUploadFile();
|
2017-12-24 18:30:39 +03:00
|
|
|
void callUnlockFolder();
|
2018-11-12 20:39:50 +03:00
|
|
|
bool isLikelyFinishedQuickly() override { return _item->_size < propagator()->smallFileSize(); }
|
2016-10-20 10:15:34 +03:00
|
|
|
|
2014-02-06 14:50:16 +04:00
|
|
|
private slots:
|
2016-01-06 12:01:22 +03:00
|
|
|
void slotComputeContentChecksum();
|
2016-05-20 11:26:02 +03:00
|
|
|
// Content checksum computed, compute the transmission checksum
|
|
|
|
void slotComputeTransmissionChecksum(const QByteArray &contentChecksumType, const QByteArray &contentChecksum);
|
|
|
|
// transmission checksum computed, prepare the upload
|
|
|
|
void slotStartUpload(const QByteArray &transmissionChecksumType, const QByteArray &transmissionChecksum);
|
2021-01-21 14:19:41 +03:00
|
|
|
// invoked when encrypted folder lock has been released
|
|
|
|
void slotFolderUnlocked(const QByteArray &folderId, int httpReturnCode);
|
|
|
|
// invoked on internal error to unlock a folder and faile
|
|
|
|
void slotOnErrorStartFolderUnlock(SyncFileItem::Status status, const QString &errorString);
|
2017-05-17 11:55:42 +03:00
|
|
|
|
2016-05-20 11:26:02 +03:00
|
|
|
public:
|
|
|
|
virtual void doStartUpload() = 0;
|
2015-05-15 16:39:26 +03:00
|
|
|
|
2014-07-25 15:30:48 +04:00
|
|
|
void startPollJob(const QString &path);
|
2016-05-20 11:26:02 +03:00
|
|
|
void finalize();
|
2015-01-14 14:48:38 +03:00
|
|
|
void abortWithError(SyncFileItem::Status status, const QString &error);
|
2016-05-20 11:26:02 +03:00
|
|
|
|
|
|
|
public slots:
|
|
|
|
void slotJobDestroyed(QObject *job);
|
|
|
|
|
|
|
|
private slots:
|
|
|
|
void slotPollFinished();
|
|
|
|
|
|
|
|
protected:
|
2018-03-27 11:39:58 +03:00
|
|
|
void done(SyncFileItem::Status status, const QString &errorString = QString()) override;
|
|
|
|
|
2017-08-11 01:03:03 +03:00
|
|
|
/**
|
2018-05-14 14:07:39 +03:00
|
|
|
* Aborts all running network jobs, except for the ones that mayAbortJob
|
|
|
|
* returns false on and, for async aborts, emits abortFinished when done.
|
2017-08-11 01:03:03 +03:00
|
|
|
*/
|
2018-05-14 14:07:39 +03:00
|
|
|
void abortNetworkJobs(
|
|
|
|
AbortType abortType,
|
|
|
|
const std::function<bool(AbstractNetworkJob *job)> &mayAbortJob);
|
2017-08-11 01:03:03 +03:00
|
|
|
|
2017-01-13 16:44:45 +03:00
|
|
|
/**
|
|
|
|
* Checks whether the current error is one that should reset the whole
|
|
|
|
* transfer if it happens too often. If so: Bump UploadInfo::errorCount
|
|
|
|
* and maybe perform the reset.
|
|
|
|
*/
|
|
|
|
void checkResettingErrors();
|
|
|
|
|
2017-07-07 15:12:10 +03:00
|
|
|
/**
|
|
|
|
* Error handling functionality that is shared between jobs.
|
|
|
|
*/
|
|
|
|
void commonErrorHandling(AbstractNetworkJob *job);
|
|
|
|
|
2018-05-16 16:08:33 +03:00
|
|
|
/**
|
|
|
|
* Increases the timeout for the final MOVE/PUT for large files.
|
|
|
|
*
|
|
|
|
* This is an unfortunate workaround since the drawback is not being able to
|
|
|
|
* detect real disconnects in a timely manner. Shall go away when the server
|
|
|
|
* response starts coming quicker, or there is some sort of async api.
|
|
|
|
*
|
|
|
|
* See #6527, enterprise#2480
|
|
|
|
*/
|
2019-02-13 12:15:33 +03:00
|
|
|
static void adjustLastJobTimeout(AbstractNetworkJob *job, qint64 fileSize);
|
2018-05-16 16:08:33 +03:00
|
|
|
|
2018-06-25 18:47:52 +03:00
|
|
|
/** Bases headers that need to be sent on the PUT, or in the MOVE for chunking-ng */
|
2016-05-20 11:26:02 +03:00
|
|
|
QMap<QByteArray, QByteArray> headers();
|
2017-12-21 02:35:23 +03:00
|
|
|
private:
|
|
|
|
PropagateUploadEncrypted *_uploadEncryptedHelper;
|
|
|
|
bool _uploadingEncrypted;
|
2021-01-21 18:07:30 +03:00
|
|
|
UploadStatus _uploadStatus;
|
2016-05-20 11:26:02 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup libsync
|
|
|
|
*
|
|
|
|
* Propagation job, impementing the old chunking agorithm
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
class PropagateUploadFileV1 : public PropagateUploadFileCommon
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
|
|
|
|
|
|
|
private:
|
|
|
|
/**
|
|
|
|
* That's the start chunk that was stored in the database for resuming.
|
|
|
|
* In the non-resuming case it is 0.
|
|
|
|
* If we are resuming, this is the first chunk we need to send
|
|
|
|
*/
|
2017-09-28 11:03:04 +03:00
|
|
|
int _startChunk = 0;
|
2016-05-20 11:26:02 +03:00
|
|
|
/**
|
|
|
|
* This is the next chunk that we need to send. Starting from 0 even if _startChunk != 0
|
|
|
|
* (In other words, _startChunk + _currentChunk is really the number of the chunk we need to send next)
|
|
|
|
* (In other words, _currentChunk is the number of the chunk that we already sent or started sending)
|
|
|
|
*/
|
2017-09-28 11:03:04 +03:00
|
|
|
int _currentChunk = 0;
|
|
|
|
int _chunkCount = 0; /// Total number of chunks for this file
|
2019-02-13 12:15:33 +03:00
|
|
|
uint _transferId = 0; /// transfer id (part of the url)
|
2016-05-20 11:26:02 +03:00
|
|
|
|
2019-02-13 12:15:33 +03:00
|
|
|
qint64 chunkSize() const {
|
2017-06-20 21:27:26 +03:00
|
|
|
// Old chunking does not use dynamic chunking algorithm, and does not adjusts the chunk size respectively,
|
|
|
|
// thus this value should be used as the one classifing item to be chunked
|
|
|
|
return propagator()->syncOptions()._initialChunkSize;
|
|
|
|
}
|
2016-05-20 11:26:02 +03:00
|
|
|
|
|
|
|
public:
|
|
|
|
PropagateUploadFileV1(OwncloudPropagator *propagator, const SyncFileItemPtr &item)
|
|
|
|
: PropagateUploadFileCommon(propagator, item)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2018-11-12 20:39:50 +03:00
|
|
|
void doStartUpload() override;
|
2017-08-11 01:03:03 +03:00
|
|
|
public slots:
|
2018-11-12 20:39:50 +03:00
|
|
|
void abort(PropagatorJob::AbortType abortType) override;
|
2016-05-20 11:26:02 +03:00
|
|
|
private slots:
|
|
|
|
void startNextChunk();
|
|
|
|
void slotPutFinished();
|
|
|
|
void slotUploadProgress(qint64, qint64);
|
2014-02-10 16:00:22 +04:00
|
|
|
};
|
|
|
|
|
2016-08-02 14:48:56 +03:00
|
|
|
/**
|
|
|
|
* @ingroup libsync
|
|
|
|
*
|
|
|
|
* Propagation job, impementing the new chunking agorithm
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
class PropagateUploadFileNG : public PropagateUploadFileCommon
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
|
|
|
private:
|
2019-02-13 12:15:33 +03:00
|
|
|
qint64 _sent = 0; /// amount of data (bytes) that was already sent
|
2017-09-28 11:03:04 +03:00
|
|
|
uint _transferId = 0; /// transfer id (part of the url)
|
|
|
|
int _currentChunk = 0; /// Id of the next chunk that will be sent
|
2019-02-13 12:15:33 +03:00
|
|
|
qint64 _currentChunkSize = 0; /// current chunk size
|
2017-09-28 11:03:04 +03:00
|
|
|
bool _removeJobError = false; /// If not null, there was an error removing the job
|
2016-09-10 13:30:14 +03:00
|
|
|
|
|
|
|
// Map chunk number with its size from the PROPFIND on resume.
|
|
|
|
// (Only used from slotPropfindIterate/slotPropfindFinished because the LsColJob use signals to report data.)
|
2017-01-20 18:03:50 +03:00
|
|
|
struct ServerChunkInfo
|
|
|
|
{
|
2019-02-13 12:15:33 +03:00
|
|
|
qint64 size;
|
2017-01-20 18:03:50 +03:00
|
|
|
QString originalName;
|
|
|
|
};
|
2019-02-13 12:15:33 +03:00
|
|
|
QMap<qint64, ServerChunkInfo> _serverChunks;
|
2016-08-02 14:48:56 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the URL of a chunk.
|
|
|
|
* If chunk == -1, returns the URL of the parent folder containing the chunks
|
|
|
|
*/
|
|
|
|
QUrl chunkUrl(int chunk = -1);
|
|
|
|
|
|
|
|
public:
|
2017-03-24 17:01:50 +03:00
|
|
|
PropagateUploadFileNG(OwncloudPropagator *propagator, const SyncFileItemPtr &item)
|
|
|
|
: PropagateUploadFileCommon(propagator, item)
|
|
|
|
{
|
|
|
|
}
|
2016-08-02 14:48:56 +03:00
|
|
|
|
2018-11-12 20:39:50 +03:00
|
|
|
void doStartUpload() override;
|
2016-12-08 00:35:50 +03:00
|
|
|
|
2016-08-02 18:14:44 +03:00
|
|
|
private:
|
|
|
|
void startNewUpload();
|
|
|
|
void startNextChunk();
|
2017-08-11 01:03:03 +03:00
|
|
|
public slots:
|
2018-11-12 20:39:50 +03:00
|
|
|
void abort(AbortType abortType) override;
|
2016-08-02 14:48:56 +03:00
|
|
|
private slots:
|
2016-08-02 18:14:44 +03:00
|
|
|
void slotPropfindFinished();
|
|
|
|
void slotPropfindFinishedWithError();
|
2016-08-03 18:43:03 +03:00
|
|
|
void slotPropfindIterate(const QString &name, const QMap<QString, QString> &properties);
|
2016-10-31 19:44:00 +03:00
|
|
|
void slotDeleteJobFinished();
|
2021-02-17 16:30:26 +03:00
|
|
|
void slotMkColFinished();
|
2016-08-02 14:48:56 +03:00
|
|
|
void slotPutFinished();
|
|
|
|
void slotMoveJobFinished();
|
|
|
|
void slotUploadProgress(qint64, qint64);
|
|
|
|
};
|
2014-02-06 14:50:16 +04:00
|
|
|
}
|