2012-02-15 12:30:37 +04:00
|
|
|
/*
|
|
|
|
* Copyright (C) by Duncan Mac-Vicar P. <duncan@kde.org>
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2014-07-11 02:31:24 +04:00
|
|
|
#include "syncengine.h"
|
|
|
|
#include "account.h"
|
|
|
|
#include "theme.h"
|
2013-05-03 21:11:00 +04:00
|
|
|
#include "owncloudpropagator.h"
|
2013-10-03 22:00:58 +04:00
|
|
|
#include "syncjournaldb.h"
|
|
|
|
#include "syncjournalfilerecord.h"
|
2014-08-11 19:47:16 +04:00
|
|
|
#include "discoveryphase.h"
|
2013-07-30 13:19:22 +04:00
|
|
|
#include "creds/abstractcredentials.h"
|
2014-08-07 12:14:14 +04:00
|
|
|
#include "csync_util.h"
|
2014-10-22 12:20:38 +04:00
|
|
|
#include "syncfilestatus.h"
|
2014-09-19 12:58:52 +04:00
|
|
|
#include "csync_private.h"
|
2012-05-21 18:48:49 +04:00
|
|
|
|
2012-12-06 19:24:53 +04:00
|
|
|
#ifdef Q_OS_WIN
|
|
|
|
#include <windows.h>
|
|
|
|
#else
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
|
2014-10-09 13:03:07 +04:00
|
|
|
#include <climits>
|
2013-04-04 19:14:38 +04:00
|
|
|
#include <assert.h>
|
|
|
|
|
2012-02-15 12:30:37 +04:00
|
|
|
#include <QDebug>
|
2013-01-14 15:13:29 +04:00
|
|
|
#include <QSslSocket>
|
2012-02-15 12:30:37 +04:00
|
|
|
#include <QDir>
|
|
|
|
#include <QMutexLocker>
|
|
|
|
#include <QThread>
|
|
|
|
#include <QStringList>
|
|
|
|
#include <QTextStream>
|
2012-02-28 19:49:13 +04:00
|
|
|
#include <QTime>
|
2012-12-11 15:49:48 +04:00
|
|
|
#include <QUrl>
|
2012-12-13 22:52:07 +04:00
|
|
|
#include <QSslCertificate>
|
2014-07-22 20:07:02 +04:00
|
|
|
#include <QProcess>
|
2014-08-15 17:00:10 +04:00
|
|
|
#include <QElapsedTimer>
|
2015-01-05 15:54:31 +03:00
|
|
|
#include <qtextcodec.h>
|
2012-08-26 13:47:45 +04:00
|
|
|
|
2015-03-03 12:05:38 +03:00
|
|
|
#ifdef USE_NEON
|
|
|
|
extern "C" int owncloud_commit(CSYNC* ctx);
|
|
|
|
#endif
|
|
|
|
|
2014-11-10 00:34:07 +03:00
|
|
|
namespace OCC {
|
2012-02-15 12:30:37 +04:00
|
|
|
|
2014-05-29 13:34:25 +04:00
|
|
|
bool SyncEngine::_syncRunning = false;
|
2012-03-21 21:03:49 +04:00
|
|
|
|
2014-12-18 14:09:48 +03:00
|
|
|
SyncEngine::SyncEngine(AccountPtr account, CSYNC *ctx, const QString& localPath,
|
|
|
|
const QString& remoteURL, const QString& remotePath, OCC::SyncJournalDb* journal)
|
|
|
|
: _account(account)
|
|
|
|
, _csync_ctx(ctx)
|
2014-06-20 15:25:39 +04:00
|
|
|
, _needsUpdate(false)
|
|
|
|
, _localPath(localPath)
|
|
|
|
, _remoteUrl(remoteURL)
|
|
|
|
, _remotePath(remotePath)
|
|
|
|
, _journal(journal)
|
2014-07-15 13:22:16 +04:00
|
|
|
, _hasNoneFiles(false)
|
|
|
|
, _hasRemoveFile(false)
|
2014-06-20 15:25:39 +04:00
|
|
|
, _uploadLimit(0)
|
2014-06-23 14:48:34 +04:00
|
|
|
, _downloadLimit(0)
|
2014-09-10 19:25:13 +04:00
|
|
|
, _anotherSyncNeeded(false)
|
2012-02-15 12:30:37 +04:00
|
|
|
{
|
2013-05-16 15:54:22 +04:00
|
|
|
qRegisterMetaType<SyncFileItem>("SyncFileItem");
|
2013-10-28 13:47:10 +04:00
|
|
|
qRegisterMetaType<SyncFileItem::Status>("SyncFileItem::Status");
|
2014-02-19 17:53:31 +04:00
|
|
|
qRegisterMetaType<Progress::Info>("Progress::Info");
|
2014-02-05 23:18:03 +04:00
|
|
|
|
2014-05-20 14:28:55 +04:00
|
|
|
_thread.setObjectName("CSync_Neon_Thread");
|
2014-02-05 23:18:03 +04:00
|
|
|
_thread.start();
|
2012-02-15 12:30:37 +04:00
|
|
|
}
|
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
SyncEngine::~SyncEngine()
|
2012-02-15 12:30:37 +04:00
|
|
|
{
|
2014-02-05 23:18:03 +04:00
|
|
|
_thread.quit();
|
|
|
|
_thread.wait();
|
2012-02-15 12:30:37 +04:00
|
|
|
}
|
|
|
|
|
2013-06-19 20:17:32 +04:00
|
|
|
//Convert an error code from csync to a user readable string.
|
|
|
|
// Keep that function thread safe as it can be called from the sync thread or the main thread
|
2014-03-17 14:34:51 +04:00
|
|
|
QString SyncEngine::csyncErrorToString(CSYNC_STATUS err)
|
2012-12-20 19:45:56 +04:00
|
|
|
{
|
|
|
|
QString errStr;
|
|
|
|
|
|
|
|
switch( err ) {
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_OK:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("Success.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_STATEDB_LOAD_ERROR:
|
2014-02-04 14:08:18 +04:00
|
|
|
errStr = tr("CSync failed to load or create the journal file. "
|
|
|
|
"Make sure you have read and write permissions in the local sync directory.");
|
2012-12-20 19:45:56 +04:00
|
|
|
break;
|
2015-01-15 13:35:16 +03:00
|
|
|
case CSYNC_STATUS_STATEDB_CORRUPTED:
|
|
|
|
errStr = tr("CSync failed to load the journal file. The journal file is corrupted.");
|
2013-08-19 18:15:20 +04:00
|
|
|
break;
|
|
|
|
case CSYNC_STATUS_NO_MODULE:
|
2013-02-21 15:21:42 +04:00
|
|
|
errStr = tr("<p>The %1 plugin for csync could not be loaded.<br/>Please verify the installation!</p>").arg(Theme::instance()->appNameGUI());
|
2012-12-20 19:45:56 +04:00
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_TREE_ERROR:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("CSync got an error while processing internal trees.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_MEMORY_ERROR:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("CSync failed to reserve memory.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_PARAM_ERROR:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("CSync fatal parameter error.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_UPDATE_ERROR:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("CSync processing step update failed.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_RECONCILE_ERROR:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("CSync processing step reconcile failed.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_PROXY_AUTH_ERROR:
|
|
|
|
errStr = tr("CSync could not authenticate at the proxy.");
|
|
|
|
break;
|
|
|
|
case CSYNC_STATUS_LOOKUP_ERROR:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("CSync failed to lookup proxy or server.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_SERVER_AUTH_ERROR:
|
2013-02-21 15:21:42 +04:00
|
|
|
errStr = tr("CSync failed to authenticate at the %1 server.").arg(Theme::instance()->appNameGUI());
|
2012-12-20 19:45:56 +04:00
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_CONNECT_ERROR:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("CSync failed to connect to the network.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_TIMEOUT:
|
2014-06-29 16:06:45 +04:00
|
|
|
errStr = tr("A network connection timeout happened.");
|
2012-12-20 19:45:56 +04:00
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_HTTP_ERROR:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("A HTTP transmission error happened.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_PERMISSION_DENIED:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("CSync failed due to not handled permission deniend.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_NOT_FOUND:
|
2015-02-06 00:00:13 +03:00
|
|
|
errStr = tr("CSync failed to access") + " "; // filename gets added.
|
2012-12-20 19:45:56 +04:00
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_FILE_EXISTS:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("CSync tried to create a directory that already exists.");
|
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_OUT_OF_SPACE:
|
2013-02-21 15:21:42 +04:00
|
|
|
errStr = tr("CSync: No space on %1 server available.").arg(Theme::instance()->appNameGUI());
|
2012-12-20 19:45:56 +04:00
|
|
|
break;
|
2013-08-19 18:15:20 +04:00
|
|
|
case CSYNC_STATUS_UNSUCCESSFUL:
|
2012-12-20 19:45:56 +04:00
|
|
|
errStr = tr("CSync unspecified error.");
|
2013-10-02 21:41:17 +04:00
|
|
|
break;
|
|
|
|
case CSYNC_STATUS_ABORTED:
|
|
|
|
errStr = tr("Aborted by the user");
|
|
|
|
break;
|
2014-10-27 21:21:12 +03:00
|
|
|
case CSYNC_STATUS_SERVICE_UNAVAILABLE:
|
2015-02-25 10:57:39 +03:00
|
|
|
errStr = tr("The service is temporarily unavailable");
|
|
|
|
break;
|
|
|
|
case CSYNC_STATUS_STORAGE_UNAVAILABLE:
|
2015-01-15 14:19:06 +03:00
|
|
|
errStr = tr("The mounted directory is temporarily not available on the server");
|
|
|
|
break;
|
2014-12-02 14:25:51 +03:00
|
|
|
case CSYNC_STATUS_OPENDIR_ERROR:
|
2015-02-06 00:00:13 +03:00
|
|
|
errStr = tr("An error occurred while opening a directory");
|
2014-12-02 14:25:51 +03:00
|
|
|
break;
|
2012-12-20 19:45:56 +04:00
|
|
|
default:
|
2015-02-06 00:00:13 +03:00
|
|
|
errStr = tr("An internal error number %1 occurred.").arg( (int) err );
|
2012-12-20 19:45:56 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return errStr;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-01-16 12:17:19 +03:00
|
|
|
bool SyncEngine::checkErrorBlacklisting( SyncFileItem *item )
|
2013-11-20 16:44:01 +04:00
|
|
|
{
|
|
|
|
if( !_journal ) {
|
|
|
|
qWarning() << "Journal is undefined!";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-01-16 12:17:19 +03:00
|
|
|
SyncJournalErrorBlacklistRecord entry = _journal->errorBlacklistEntry(item->_file);
|
2014-10-08 11:07:05 +04:00
|
|
|
item->_hasBlacklistEntry = false;
|
2013-11-20 16:44:01 +04:00
|
|
|
|
2014-10-09 16:49:51 +04:00
|
|
|
if( !entry.isValid() ) {
|
|
|
|
return false;
|
|
|
|
}
|
2013-11-29 19:15:26 +04:00
|
|
|
|
2014-10-09 16:49:51 +04:00
|
|
|
item->_hasBlacklistEntry = true;
|
2013-11-20 16:44:01 +04:00
|
|
|
|
2014-10-09 16:49:51 +04:00
|
|
|
// If duration has expired, it's not blacklisted anymore
|
|
|
|
time_t now = Utility::qDateTimeToTime_t(QDateTime::currentDateTime());
|
|
|
|
if( now > entry._lastTryTime + entry._ignoreDuration ) {
|
|
|
|
qDebug() << "blacklist entry for " << item->_file << " has expired!";
|
|
|
|
return false;
|
|
|
|
}
|
2013-11-29 19:15:26 +04:00
|
|
|
|
2014-10-09 16:49:51 +04:00
|
|
|
// If the file has changed locally or on the server, the blacklist
|
|
|
|
// entry no longer applies
|
|
|
|
if( item->_direction == SyncFileItem::Up ) { // check the modtime
|
|
|
|
if(item->_modtime == 0 || entry._lastTryModtime == 0) {
|
|
|
|
return false;
|
|
|
|
} else if( item->_modtime != entry._lastTryModtime ) {
|
|
|
|
qDebug() << item->_file << " is blacklisted, but has changed mtime!";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else if( item->_direction == SyncFileItem::Down ) {
|
|
|
|
// download, check the etag.
|
|
|
|
if( item->_etag.isEmpty() || entry._lastTryEtag.isEmpty() ) {
|
|
|
|
qDebug() << item->_file << "one ETag is empty, no blacklisting";
|
|
|
|
return false;
|
|
|
|
} else if( item->_etag != entry._lastTryEtag ) {
|
|
|
|
qDebug() << item->_file << " is blacklisted, but has changed etag!";
|
|
|
|
return false;
|
2013-11-20 16:44:01 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-09 16:49:51 +04:00
|
|
|
qDebug() << "Item is on blacklist: " << entry._file
|
|
|
|
<< "retries:" << entry._retryCount
|
|
|
|
<< "for another" << (entry._lastTryTime + entry._ignoreDuration - now) << "s";
|
|
|
|
item->_instruction = CSYNC_INSTRUCTION_ERROR;
|
|
|
|
item->_status = SyncFileItem::FileIgnored;
|
|
|
|
item->_errorString = tr("The item is not synced because of previous errors: %1").arg(entry._errorString);
|
|
|
|
|
|
|
|
return true;
|
2013-11-20 16:44:01 +04:00
|
|
|
}
|
|
|
|
|
2014-09-03 14:11:03 +04:00
|
|
|
void SyncEngine::deleteStaleDownloadInfos()
|
|
|
|
{
|
|
|
|
// Find all downloadinfo paths that we want to preserve.
|
|
|
|
QSet<QString> download_file_paths;
|
|
|
|
foreach(const SyncFileItem& it, _syncedItems) {
|
|
|
|
if (it._direction == SyncFileItem::Down
|
|
|
|
&& it._type == SyncFileItem::File)
|
|
|
|
{
|
|
|
|
download_file_paths.insert(it._file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Delete from journal and from filesystem.
|
|
|
|
const QVector<SyncJournalDb::DownloadInfo> deleted_infos =
|
|
|
|
_journal->getAndDeleteStaleDownloadInfos(download_file_paths);
|
|
|
|
foreach (const SyncJournalDb::DownloadInfo & deleted_info, deleted_infos) {
|
|
|
|
const QString tmppath = _propagator->getFilePath(deleted_info._tmpfile);
|
|
|
|
qDebug() << "Deleting stale temporary file: " << tmppath;
|
|
|
|
QFile::remove(tmppath);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SyncEngine::deleteStaleUploadInfos()
|
|
|
|
{
|
|
|
|
// Find all blacklisted paths that we want to preserve.
|
|
|
|
QSet<QString> upload_file_paths;
|
|
|
|
foreach(const SyncFileItem& it, _syncedItems) {
|
|
|
|
if (it._direction == SyncFileItem::Up
|
|
|
|
&& it._type == SyncFileItem::File)
|
|
|
|
{
|
|
|
|
upload_file_paths.insert(it._file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Delete from journal.
|
|
|
|
_journal->deleteStaleUploadInfos(upload_file_paths);
|
|
|
|
}
|
|
|
|
|
2015-01-16 12:17:19 +03:00
|
|
|
void SyncEngine::deleteStaleErrorBlacklistEntries()
|
2014-09-03 14:11:03 +04:00
|
|
|
{
|
|
|
|
// Find all blacklisted paths that we want to preserve.
|
|
|
|
QSet<QString> blacklist_file_paths;
|
|
|
|
foreach(const SyncFileItem& it, _syncedItems) {
|
2014-10-08 11:07:05 +04:00
|
|
|
if (it._hasBlacklistEntry)
|
2014-09-03 14:11:03 +04:00
|
|
|
blacklist_file_paths.insert(it._file);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Delete from journal.
|
2015-01-16 12:17:19 +03:00
|
|
|
_journal->deleteStaleErrorBlacklistEntries(blacklist_file_paths);
|
2014-09-03 14:11:03 +04:00
|
|
|
}
|
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
int SyncEngine::treewalkLocal( TREE_WALK_FILE* file, void *data )
|
2013-01-15 23:41:52 +04:00
|
|
|
{
|
2014-03-17 14:34:51 +04:00
|
|
|
return static_cast<SyncEngine*>(data)->treewalkFile( file, false );
|
2013-01-15 23:41:52 +04:00
|
|
|
}
|
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
int SyncEngine::treewalkRemote( TREE_WALK_FILE* file, void *data )
|
2013-01-15 23:41:52 +04:00
|
|
|
{
|
2014-03-17 14:34:51 +04:00
|
|
|
return static_cast<SyncEngine*>(data)->treewalkFile( file, true );
|
2013-01-15 23:41:52 +04:00
|
|
|
}
|
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
int SyncEngine::treewalkFile( TREE_WALK_FILE *file, bool remote )
|
2013-01-15 23:41:52 +04:00
|
|
|
{
|
|
|
|
if( ! file ) return -1;
|
2014-08-07 12:14:14 +04:00
|
|
|
|
2015-01-05 15:54:31 +03:00
|
|
|
QTextCodec::ConverterState utf8State;
|
|
|
|
QTextCodec *codec = QTextCodec::codecForName("UTF-8");
|
|
|
|
Q_ASSERT(codec);
|
|
|
|
QString fileUtf8 = codec->toUnicode(file->path, qstrlen(file->path), &utf8State);
|
2015-02-17 20:40:17 +03:00
|
|
|
QString renameTarget;
|
|
|
|
QString key = fileUtf8;
|
2015-01-05 15:54:31 +03:00
|
|
|
|
|
|
|
auto instruction = file->instruction;
|
2015-02-17 20:40:17 +03:00
|
|
|
if (utf8State.invalidChars > 0 || utf8State.remainingChars > 0) {
|
|
|
|
qWarning() << "File ignored because of invalid utf-8 sequence: " << file->path;
|
2015-01-05 15:54:31 +03:00
|
|
|
instruction = CSYNC_INSTRUCTION_IGNORE;
|
2015-02-17 20:40:17 +03:00
|
|
|
} else {
|
|
|
|
renameTarget = codec->toUnicode(file->rename_path, qstrlen(file->rename_path), &utf8State);
|
|
|
|
if (utf8State.invalidChars > 0 || utf8State.remainingChars > 0) {
|
|
|
|
qWarning() << "File ignored because of invalid utf-8 sequence in the rename_path: " << file->path << file->rename_path;
|
|
|
|
instruction = CSYNC_INSTRUCTION_IGNORE;
|
|
|
|
}
|
|
|
|
if (instruction == CSYNC_INSTRUCTION_RENAME) {
|
|
|
|
key = renameTarget;
|
|
|
|
}
|
2015-01-05 15:54:31 +03:00
|
|
|
}
|
2014-08-07 12:14:14 +04:00
|
|
|
|
|
|
|
// Gets a default-contructed SyncFileItem or the one from the first walk (=local walk)
|
2015-02-17 20:40:17 +03:00
|
|
|
SyncFileItem item = _syncItemMap.value(key);
|
|
|
|
if (item._file.isEmpty() || instruction == CSYNC_INSTRUCTION_RENAME) {
|
|
|
|
item._file = fileUtf8;
|
|
|
|
}
|
2013-11-05 20:48:51 +04:00
|
|
|
item._originalFile = item._file;
|
2014-08-07 12:14:14 +04:00
|
|
|
|
2014-08-21 13:33:38 +04:00
|
|
|
if (item._instruction == CSYNC_INSTRUCTION_NONE
|
2015-01-05 15:54:31 +03:00
|
|
|
|| (item._instruction == CSYNC_INSTRUCTION_IGNORE && instruction != CSYNC_INSTRUCTION_NONE)) {
|
|
|
|
item._instruction = instruction;
|
2014-08-07 12:14:14 +04:00
|
|
|
item._modtime = file->modtime;
|
|
|
|
} else {
|
2015-01-05 15:54:31 +03:00
|
|
|
if (instruction != CSYNC_INSTRUCTION_NONE) {
|
|
|
|
qDebug() << "ERROR: Instruction" << item._instruction << "vs" << instruction << "for" << fileUtf8;
|
2014-08-07 12:14:14 +04:00
|
|
|
Q_ASSERT(!"Instructions are both unequal NONE");
|
2014-10-27 17:52:17 +03:00
|
|
|
return -1;
|
2014-08-07 12:14:14 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (file->file_id && strlen(file->file_id) > 0) {
|
|
|
|
item._fileId = file->file_id;
|
|
|
|
}
|
2014-06-03 13:50:13 +04:00
|
|
|
if (file->directDownloadUrl) {
|
|
|
|
item._directDownloadUrl = QString::fromUtf8( file->directDownloadUrl );
|
|
|
|
}
|
|
|
|
if (file->directDownloadCookies) {
|
|
|
|
item._directDownloadCookies = QString::fromUtf8( file->directDownloadCookies );
|
|
|
|
}
|
2014-06-23 17:05:48 +04:00
|
|
|
if (file->remotePerm && file->remotePerm[0]) {
|
2014-06-06 17:24:17 +04:00
|
|
|
item._remotePerm = QByteArray(file->remotePerm);
|
|
|
|
}
|
2014-08-07 12:14:14 +04:00
|
|
|
item._should_update_etag = item._should_update_etag || file->should_update_etag;
|
2013-09-04 18:33:06 +04:00
|
|
|
|
2013-11-20 16:44:01 +04:00
|
|
|
// record the seen files to be able to clean the journal later
|
2014-06-17 18:29:38 +04:00
|
|
|
_seenFiles.insert(item._file);
|
2015-02-19 17:00:37 +03:00
|
|
|
if (!renameTarget.isEmpty()) {
|
|
|
|
// Yes, this record both the rename renameTarget and the original so we keep both in case of a rename
|
|
|
|
_seenFiles.insert(renameTarget);
|
|
|
|
}
|
2013-11-11 14:11:45 +04:00
|
|
|
|
2014-06-23 17:05:48 +04:00
|
|
|
if (remote && file->remotePerm && file->remotePerm[0]) {
|
2014-06-23 15:35:34 +04:00
|
|
|
_remotePerms[item._file] = file->remotePerm;
|
|
|
|
}
|
|
|
|
|
2013-12-04 15:19:38 +04:00
|
|
|
switch(file->error_status) {
|
|
|
|
case CSYNC_STATUS_OK:
|
|
|
|
break;
|
|
|
|
case CSYNC_STATUS_INDIVIDUAL_IS_SYMLINK:
|
|
|
|
item._errorString = tr("Symbolic links are not supported in syncing.");
|
|
|
|
break;
|
2014-09-18 13:18:23 +04:00
|
|
|
case CSYNC_STATUS_INDIVIDUAL_IS_HARDLINK:
|
|
|
|
item._errorString = tr("Hard links are not supported in syncing.");
|
|
|
|
break;
|
2013-12-04 15:19:38 +04:00
|
|
|
case CSYNC_STATUS_INDIVIDUAL_IGNORE_LIST:
|
|
|
|
item._errorString = tr("File is listed on the ignore list.");
|
|
|
|
break;
|
|
|
|
case CSYNC_STATUS_INDIVIDUAL_IS_INVALID_CHARS:
|
|
|
|
item._errorString = tr("File contains invalid characters that can not be synced cross platform.");
|
|
|
|
break;
|
2015-02-27 13:25:03 +03:00
|
|
|
case CSYNC_STATUS_INDIVIDUAL_EXCLUDE_LONG_FILENAME:
|
|
|
|
item._errorString = tr("Filename is too long.");
|
|
|
|
break;
|
2014-04-28 19:25:18 +04:00
|
|
|
case CYSNC_STATUS_FILE_LOCKED_OR_OPEN:
|
|
|
|
item._errorString = QLatin1String("File locked"); // don't translate, internal use!
|
|
|
|
break;
|
2014-10-27 21:21:12 +03:00
|
|
|
case CSYNC_STATUS_SERVICE_UNAVAILABLE:
|
2015-02-25 10:57:39 +03:00
|
|
|
item._errorString = QLatin1String("Server temporarily unavailable.");
|
|
|
|
break;
|
|
|
|
case CSYNC_STATUS_STORAGE_UNAVAILABLE:
|
2014-10-27 21:21:12 +03:00
|
|
|
item._errorString = QLatin1String("Directory temporarily not available on server.");
|
2014-10-28 19:13:21 +03:00
|
|
|
item._status = SyncFileItem::SoftError;
|
2014-10-27 21:21:12 +03:00
|
|
|
break;
|
2013-12-04 15:19:38 +04:00
|
|
|
default:
|
|
|
|
Q_ASSERT("Non handled error-status");
|
|
|
|
/* No error string */
|
2013-09-02 19:25:07 +04:00
|
|
|
}
|
2014-12-06 14:27:50 +03:00
|
|
|
|
2015-02-17 20:40:17 +03:00
|
|
|
if (item._instruction == CSYNC_INSTRUCTION_IGNORE && (utf8State.invalidChars > 0 || utf8State.remainingChars > 0)) {
|
2015-01-05 15:54:31 +03:00
|
|
|
item._status = SyncFileItem::NormalError;
|
|
|
|
//item._instruction = CSYNC_INSTRUCTION_ERROR;
|
|
|
|
item._errorString = tr("Filename encoding is not valid");
|
2014-12-06 14:27:50 +03:00
|
|
|
}
|
2014-08-07 12:14:14 +04:00
|
|
|
|
2013-05-03 21:11:00 +04:00
|
|
|
item._isDirectory = file->type == CSYNC_FTW_TYPE_DIR;
|
2014-08-07 12:14:14 +04:00
|
|
|
|
|
|
|
// The etag is already set in the previous sync phases somewhere. Maybe we should remove it there
|
|
|
|
// and do it here so we have a consistent state about which tree stores information from which source.
|
2013-11-13 17:28:15 +04:00
|
|
|
item._etag = file->etag;
|
2013-09-11 10:49:09 +04:00
|
|
|
item._size = file->size;
|
2014-05-06 14:55:54 +04:00
|
|
|
|
2014-08-07 12:14:14 +04:00
|
|
|
if (!remote) {
|
|
|
|
item._inode = file->inode;
|
|
|
|
}
|
|
|
|
|
2013-12-06 17:11:51 +04:00
|
|
|
switch( file->type ) {
|
|
|
|
case CSYNC_FTW_TYPE_DIR:
|
|
|
|
item._type = SyncFileItem::Directory;
|
|
|
|
break;
|
|
|
|
case CSYNC_FTW_TYPE_FILE:
|
|
|
|
item._type = SyncFileItem::File;
|
|
|
|
break;
|
|
|
|
case CSYNC_FTW_TYPE_SLINK:
|
|
|
|
item._type = SyncFileItem::SoftLink;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
item._type = SyncFileItem::UnknownType;
|
|
|
|
}
|
2013-01-15 23:41:52 +04:00
|
|
|
|
|
|
|
SyncFileItem::Direction dir;
|
|
|
|
|
|
|
|
int re = 0;
|
|
|
|
switch(file->instruction) {
|
|
|
|
case CSYNC_INSTRUCTION_NONE:
|
2014-10-11 17:38:12 +04:00
|
|
|
if (remote && item._should_update_etag && !item._isDirectory && item._instruction == CSYNC_INSTRUCTION_NONE) {
|
2014-11-06 16:54:59 +03:00
|
|
|
// Update the database now already: New fileid or Etag or RemotePerm
|
|
|
|
// Or for files that were detected as "resolved conflict".
|
2014-08-07 12:14:14 +04:00
|
|
|
// They should have been a conflict because they both were new, or both
|
|
|
|
// had their local mtime or remote etag modified, but the size and mtime
|
|
|
|
// is the same on the server. This typically happen when the database is removed.
|
|
|
|
// Nothing will be done for those file, but we still need to update the database.
|
2014-11-06 16:54:59 +03:00
|
|
|
|
|
|
|
// Even if the mtime is different on the server, we always want to keep the mtime from
|
|
|
|
// the file system in the DB, this is to avoid spurious upload on the next sync
|
|
|
|
item._modtime = file->other.modtime;
|
|
|
|
|
2014-04-18 20:27:27 +04:00
|
|
|
_journal->setFileRecord(SyncJournalFileRecord(item, _localPath + item._file));
|
|
|
|
item._should_update_etag = false;
|
|
|
|
}
|
2014-06-27 17:26:12 +04:00
|
|
|
if (item._isDirectory && (remote || file->should_update_etag)) {
|
2013-10-03 22:00:58 +04:00
|
|
|
// Because we want still to update etags of directories
|
|
|
|
dir = SyncFileItem::None;
|
|
|
|
} else {
|
|
|
|
// No need to do anything.
|
2015-02-17 18:41:44 +03:00
|
|
|
if (file->other.instruction == CSYNC_INSTRUCTION_NONE) {
|
|
|
|
_hasNoneFiles = true;
|
|
|
|
}
|
2013-12-06 19:37:01 +04:00
|
|
|
|
2014-03-27 18:19:02 +04:00
|
|
|
emit syncItemDiscovered(item);
|
2013-10-03 22:00:58 +04:00
|
|
|
return re;
|
|
|
|
}
|
2013-01-15 23:41:52 +04:00
|
|
|
break;
|
|
|
|
case CSYNC_INSTRUCTION_RENAME:
|
|
|
|
dir = !remote ? SyncFileItem::Down : SyncFileItem::Up;
|
2015-02-17 20:40:17 +03:00
|
|
|
item._renameTarget = renameTarget;
|
2013-05-15 17:22:20 +04:00
|
|
|
if (item._isDirectory)
|
|
|
|
_renamedFolders.insert(item._file, item._renameTarget);
|
2013-01-15 23:41:52 +04:00
|
|
|
break;
|
|
|
|
case CSYNC_INSTRUCTION_REMOVE:
|
2014-07-15 13:22:16 +04:00
|
|
|
_hasRemoveFile = true;
|
2013-01-15 23:41:52 +04:00
|
|
|
dir = !remote ? SyncFileItem::Down : SyncFileItem::Up;
|
2014-07-15 13:22:16 +04:00
|
|
|
break;
|
2013-01-15 23:41:52 +04:00
|
|
|
case CSYNC_INSTRUCTION_CONFLICT:
|
|
|
|
case CSYNC_INSTRUCTION_IGNORE:
|
|
|
|
case CSYNC_INSTRUCTION_ERROR:
|
|
|
|
dir = SyncFileItem::None;
|
|
|
|
break;
|
|
|
|
case CSYNC_INSTRUCTION_EVAL:
|
|
|
|
case CSYNC_INSTRUCTION_NEW:
|
|
|
|
case CSYNC_INSTRUCTION_SYNC:
|
|
|
|
case CSYNC_INSTRUCTION_STAT_ERROR:
|
|
|
|
default:
|
|
|
|
dir = remote ? SyncFileItem::Down : SyncFileItem::Up;
|
2014-07-15 13:22:16 +04:00
|
|
|
if (!remote && file->instruction == CSYNC_INSTRUCTION_SYNC) {
|
|
|
|
// An upload of an existing file means that the file was left unchanged on the server
|
|
|
|
// This count as a NONE for detecting if all the file on the server were changed
|
|
|
|
_hasNoneFiles = true;
|
|
|
|
}
|
2013-01-15 23:41:52 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-03-20 17:56:31 +04:00
|
|
|
item._direction = dir;
|
2013-11-29 19:15:26 +04:00
|
|
|
// check for blacklisting of this item.
|
|
|
|
// if the item is on blacklist, the instruction was set to IGNORE
|
2015-01-16 12:17:19 +03:00
|
|
|
checkErrorBlacklisting( &item );
|
2013-11-29 19:15:26 +04:00
|
|
|
|
2014-03-14 21:29:23 +04:00
|
|
|
if (!item._isDirectory) {
|
|
|
|
_progressInfo._totalFileCount++;
|
|
|
|
if (Progress::isSizeDependent(file->instruction)) {
|
|
|
|
_progressInfo._totalSize += file->size;
|
|
|
|
}
|
2014-12-11 13:32:05 +03:00
|
|
|
} else if (file->instruction != CSYNC_INSTRUCTION_NONE) {
|
|
|
|
// Added or removed directories certainly count.
|
|
|
|
_progressInfo._totalFileCount++;
|
2014-03-14 21:29:23 +04:00
|
|
|
}
|
|
|
|
_needsUpdate = true;
|
|
|
|
|
2014-04-03 18:56:36 +04:00
|
|
|
item.log._etag = file->etag;
|
|
|
|
item.log._fileId = file->file_id;
|
|
|
|
item.log._instruction = file->instruction;
|
|
|
|
item.log._modtime = file->modtime;
|
|
|
|
item.log._size = file->size;
|
|
|
|
|
|
|
|
item.log._other_etag = file->other.etag;
|
|
|
|
item.log._other_fileId = file->other.file_id;
|
|
|
|
item.log._other_instruction = file->other.instruction;
|
|
|
|
item.log._other_modtime = file->other.modtime;
|
|
|
|
item.log._other_size = file->other.size;
|
2014-03-26 21:06:25 +04:00
|
|
|
|
2015-02-17 20:40:17 +03:00
|
|
|
_syncItemMap.insert(key, item);
|
2014-06-17 16:50:24 +04:00
|
|
|
|
2014-03-27 18:19:02 +04:00
|
|
|
emit syncItemDiscovered(item);
|
2013-01-15 23:41:52 +04:00
|
|
|
return re;
|
|
|
|
}
|
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
void SyncEngine::handleSyncError(CSYNC *ctx, const char *state) {
|
2013-11-25 01:21:29 +04:00
|
|
|
CSYNC_STATUS err = csync_get_status( ctx );
|
2013-08-19 18:15:20 +04:00
|
|
|
const char *errMsg = csync_get_status_string( ctx );
|
2013-08-21 17:29:04 +04:00
|
|
|
QString errStr = csyncErrorToString(err);
|
2013-05-05 13:41:31 +04:00
|
|
|
if( errMsg ) {
|
2013-11-25 21:22:41 +04:00
|
|
|
if( !errStr.endsWith(" ")) {
|
|
|
|
errStr.append(" ");
|
|
|
|
}
|
2013-05-05 13:41:31 +04:00
|
|
|
errStr += QString::fromUtf8(errMsg);
|
|
|
|
}
|
2013-11-25 21:22:41 +04:00
|
|
|
|
|
|
|
// if there is csyncs url modifier in the error message, replace it.
|
|
|
|
if( errStr.contains("ownclouds://") ) errStr.replace("ownclouds://", "https://");
|
|
|
|
if( errStr.contains("owncloud://") ) errStr.replace("owncloud://", "http://");
|
|
|
|
|
2013-02-15 22:29:27 +04:00
|
|
|
qDebug() << " #### ERROR during "<< state << ": " << errStr;
|
2013-08-19 18:15:20 +04:00
|
|
|
|
2013-11-25 01:21:29 +04:00
|
|
|
if( CSYNC_STATUS_IS_EQUAL( err, CSYNC_STATUS_ABORTED) ) {
|
|
|
|
qDebug() << "Update phase was aborted by user!";
|
|
|
|
} else if( CSYNC_STATUS_IS_EQUAL( err, CSYNC_STATUS_SERVICE_UNAVAILABLE ) ||
|
2013-08-19 18:15:20 +04:00
|
|
|
CSYNC_STATUS_IS_EQUAL( err, CSYNC_STATUS_CONNECT_ERROR )) {
|
2013-02-15 22:29:27 +04:00
|
|
|
emit csyncUnavailable();
|
2013-08-19 18:15:20 +04:00
|
|
|
} else {
|
2013-02-15 22:29:27 +04:00
|
|
|
emit csyncError(errStr);
|
|
|
|
}
|
2014-05-20 14:28:55 +04:00
|
|
|
finalize();
|
2013-02-15 22:29:27 +04:00
|
|
|
}
|
2013-01-15 23:41:52 +04:00
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
void SyncEngine::startSync()
|
2012-02-15 12:30:37 +04:00
|
|
|
{
|
2014-07-28 14:12:52 +04:00
|
|
|
if (_journal->exists()) {
|
|
|
|
QVector< SyncJournalDb::PollInfo > pollInfos = _journal->getPollInfos();
|
|
|
|
if (!pollInfos.isEmpty()) {
|
|
|
|
qDebug() << "Finish Poll jobs before starting a sync";
|
2014-12-18 14:09:48 +03:00
|
|
|
CleanupPollsJob *job = new CleanupPollsJob(pollInfos, _account,
|
2014-07-28 14:12:52 +04:00
|
|
|
_journal, _localPath, this);
|
|
|
|
connect(job, SIGNAL(finished()), this, SLOT(startSync()));
|
2014-07-29 17:51:22 +04:00
|
|
|
connect(job, SIGNAL(aborted(QString)), this, SLOT(slotCleanPollsJobAborted(QString)));
|
2014-07-28 14:12:52 +04:00
|
|
|
job->start();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-29 13:34:25 +04:00
|
|
|
Q_ASSERT(!_syncRunning);
|
|
|
|
_syncRunning = true;
|
2013-04-15 17:55:54 +04:00
|
|
|
|
2014-06-20 13:36:25 +04:00
|
|
|
Q_ASSERT(_csync_ctx);
|
2013-04-04 19:14:38 +04:00
|
|
|
|
2014-08-28 13:47:40 +04:00
|
|
|
if (!QDir(_localPath).exists()) {
|
|
|
|
// No _tr, it should only occur in non-mirall
|
|
|
|
emit csyncError("Unable to find local sync directory.");
|
|
|
|
finalize();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-05-07 19:47:29 +04:00
|
|
|
_syncedItems.clear();
|
2014-08-07 12:14:14 +04:00
|
|
|
_syncItemMap.clear();
|
2013-02-14 19:25:00 +04:00
|
|
|
_needsUpdate = false;
|
2014-01-20 19:29:26 +04:00
|
|
|
|
2014-02-06 17:52:56 +04:00
|
|
|
csync_resume(_csync_ctx);
|
2012-08-30 19:50:42 +04:00
|
|
|
|
2014-10-20 16:25:22 +04:00
|
|
|
int fileRecordCount = -1;
|
2013-10-04 16:44:57 +04:00
|
|
|
if (!_journal->exists()) {
|
2014-10-20 17:51:50 +04:00
|
|
|
qDebug() << "=====sync looks new (no DB exists)";
|
|
|
|
} else {
|
|
|
|
qDebug() << "=====sync with existing DB";
|
|
|
|
}
|
|
|
|
|
2014-11-20 15:46:44 +03:00
|
|
|
qDebug() << "=====Using Qt" << qVersion();
|
|
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
|
|
|
|
qDebug() << "=====Using SSL library version"
|
|
|
|
<< QSslSocket::sslLibraryVersionString().toUtf8().data();
|
|
|
|
#endif
|
2014-11-12 11:21:05 +03:00
|
|
|
|
2014-10-20 17:51:50 +04:00
|
|
|
fileRecordCount = _journal->getFileRecordCount(); // this creates the DB if it does not exist yet
|
|
|
|
bool isUpdateFrom_1_5 = _journal->isUpdateFrom_1_5();
|
|
|
|
|
|
|
|
if( fileRecordCount == -1 ) {
|
|
|
|
qDebug() << "No way to create a sync journal!";
|
|
|
|
emit csyncError(tr("Unable to initialize a sync journal."));
|
|
|
|
finalize();
|
|
|
|
return;
|
|
|
|
// database creation error!
|
|
|
|
}
|
2014-10-20 16:25:22 +04:00
|
|
|
|
2014-10-20 17:51:50 +04:00
|
|
|
if (fileRecordCount >= 1 && isUpdateFrom_1_5) {
|
2014-10-21 22:25:15 +04:00
|
|
|
qDebug() << "detected update from 1.5" << fileRecordCount << isUpdateFrom_1_5;
|
2014-10-20 17:51:50 +04:00
|
|
|
// Disable the read from DB to be sure to re-read all the fileid and etags.
|
|
|
|
csync_set_read_from_db(_csync_ctx, false);
|
2014-10-21 22:25:15 +04:00
|
|
|
} else {
|
|
|
|
csync_set_read_from_db(_csync_ctx, true);
|
2014-10-20 17:51:50 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
bool usingSelectiveSync = (!_selectiveSyncBlackList.isEmpty());
|
|
|
|
qDebug() << (usingSelectiveSync ? "====Using Selective Sync" : "====NOT Using Selective Sync");
|
|
|
|
if (fileRecordCount >= 0 && fileRecordCount < 50 && !usingSelectiveSync) {
|
|
|
|
qDebug() << "===== Activating recursive PROPFIND (currently" << fileRecordCount << "file records)";
|
2013-10-04 16:44:57 +04:00
|
|
|
bool no_recursive_propfind = false;
|
|
|
|
csync_set_module_property(_csync_ctx, "no_recursive_propfind", &no_recursive_propfind);
|
|
|
|
} else {
|
2014-10-21 00:23:26 +04:00
|
|
|
bool no_recursive_propfind = true;
|
|
|
|
csync_set_module_property(_csync_ctx, "no_recursive_propfind", &no_recursive_propfind);
|
2013-10-04 16:44:57 +04:00
|
|
|
}
|
2013-07-05 20:46:43 +04:00
|
|
|
|
2013-04-20 14:15:27 +04:00
|
|
|
csync_set_userdata(_csync_ctx, this);
|
2014-12-18 14:09:48 +03:00
|
|
|
_account->credentials()->syncContextPreStart(_csync_ctx);
|
2013-07-17 18:27:18 +04:00
|
|
|
|
2013-04-20 14:15:27 +04:00
|
|
|
// csync_set_auth_callback( _csync_ctx, getauth );
|
2014-02-19 13:51:04 +04:00
|
|
|
//csync_set_log_level( 11 ); don't set the loglevel here, it shall be done by folder.cpp or owncloudcmd.cpp
|
2014-05-02 15:04:53 +04:00
|
|
|
int timeout = OwncloudPropagator::httpTimeout();
|
|
|
|
csync_set_module_property(_csync_ctx, "timeout", &timeout);
|
|
|
|
|
2014-03-26 21:06:25 +04:00
|
|
|
_stopWatch.start();
|
2014-02-19 00:41:20 +04:00
|
|
|
|
2014-08-11 19:47:16 +04:00
|
|
|
qDebug() << "#### Discovery start #################################################### >>";
|
2013-09-24 17:56:03 +04:00
|
|
|
|
2014-12-02 14:25:51 +03:00
|
|
|
_discoveryMainThread = new DiscoveryMainThread(account());
|
|
|
|
_discoveryMainThread->setParent(this);
|
|
|
|
connect(this, SIGNAL(finished()), _discoveryMainThread, SLOT(deleteLater()));
|
2015-03-05 19:49:12 +03:00
|
|
|
connect(_discoveryMainThread, SIGNAL(etagConcatenation(QString)), this, SLOT(slotRootEtagReceived(QString)));
|
2014-12-02 14:25:51 +03:00
|
|
|
|
|
|
|
|
|
|
|
DiscoveryJob *discoveryJob = new DiscoveryJob(_csync_ctx);
|
|
|
|
discoveryJob->_selectiveSyncBlackList = _selectiveSyncBlackList;
|
|
|
|
discoveryJob->moveToThread(&_thread);
|
|
|
|
connect(discoveryJob, SIGNAL(finished(int)), this, SLOT(slotDiscoveryJobFinished(int)));
|
|
|
|
connect(discoveryJob, SIGNAL(folderDiscovered(bool,QString)),
|
2014-08-15 17:00:10 +04:00
|
|
|
this, SIGNAL(folderDiscovered(bool,QString)));
|
2014-12-02 14:25:51 +03:00
|
|
|
|
|
|
|
// This is used for the DiscoveryJob to be able to request the main thread/
|
|
|
|
// to read in directory contents.
|
|
|
|
qDebug() << Q_FUNC_INFO << _remotePath << _remoteUrl;
|
2015-01-20 20:49:49 +03:00
|
|
|
_discoveryMainThread->setupHooks( discoveryJob, _remotePath);
|
2014-12-02 14:25:51 +03:00
|
|
|
|
|
|
|
// Starts the update in a seperate thread
|
|
|
|
QMetaObject::invokeMethod(discoveryJob, "start", Qt::QueuedConnection);
|
2014-02-05 23:18:03 +04:00
|
|
|
}
|
|
|
|
|
2015-01-23 17:30:00 +03:00
|
|
|
void SyncEngine::slotRootEtagReceived(QString e) {
|
|
|
|
qDebug() << Q_FUNC_INFO << e;
|
|
|
|
if (_remoteRootEtag.isEmpty()) {
|
|
|
|
_remoteRootEtag = e;
|
|
|
|
emit rootEtag(_remoteRootEtag);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-11 19:47:16 +04:00
|
|
|
void SyncEngine::slotDiscoveryJobFinished(int discoveryResult)
|
2014-02-05 23:18:03 +04:00
|
|
|
{
|
2014-08-15 17:00:10 +04:00
|
|
|
// To clean the progress info
|
|
|
|
emit folderDiscovered(false, QString());
|
|
|
|
|
2014-08-11 19:47:16 +04:00
|
|
|
if (discoveryResult < 0 ) {
|
2013-04-20 14:15:27 +04:00
|
|
|
handleSyncError(_csync_ctx, "csync_update");
|
2013-02-15 22:29:27 +04:00
|
|
|
return;
|
2012-03-22 19:22:08 +04:00
|
|
|
}
|
2014-08-11 19:47:16 +04:00
|
|
|
qDebug() << "<<#### Discovery end #################################################### " << _stopWatch.addLapTime(QLatin1String("Discovery Finished"));
|
2012-02-15 12:30:37 +04:00
|
|
|
|
2014-10-20 18:50:55 +04:00
|
|
|
// Sanity check
|
|
|
|
if (!_journal->isConnected()) {
|
|
|
|
qDebug() << "Bailing out, DB failure";
|
|
|
|
emit csyncError(tr("Cannot open the sync journal"));
|
|
|
|
finalize();
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
// Commits a possibly existing (should not though) transaction and starts a new one for the propagate phase
|
2014-10-20 19:20:58 +04:00
|
|
|
_journal->commitIfNeededAndStartNewTransaction("Post discovery");
|
2014-10-20 18:50:55 +04:00
|
|
|
}
|
|
|
|
|
2013-04-20 14:15:27 +04:00
|
|
|
if( csync_reconcile(_csync_ctx) < 0 ) {
|
2013-07-29 16:28:19 +04:00
|
|
|
handleSyncError(_csync_ctx, "csync_reconcile");
|
2013-02-15 22:29:27 +04:00
|
|
|
return;
|
2012-03-22 19:22:08 +04:00
|
|
|
}
|
2014-06-07 13:49:46 +04:00
|
|
|
|
2014-03-26 21:06:25 +04:00
|
|
|
_stopWatch.addLapTime(QLatin1String("Reconcile Finished"));
|
2013-11-25 19:16:33 +04:00
|
|
|
|
2013-08-14 21:59:16 +04:00
|
|
|
_progressInfo = Progress::Info();
|
|
|
|
|
2014-07-15 13:22:16 +04:00
|
|
|
_hasNoneFiles = false;
|
|
|
|
_hasRemoveFile = false;
|
2013-02-20 20:26:07 +04:00
|
|
|
bool walkOk = true;
|
2013-11-11 14:11:45 +04:00
|
|
|
_seenFiles.clear();
|
|
|
|
|
2013-04-20 14:15:27 +04:00
|
|
|
if( csync_walk_local_tree(_csync_ctx, &treewalkLocal, 0) < 0 ) {
|
2013-02-15 22:29:27 +04:00
|
|
|
qDebug() << "Error in local treewalk.";
|
2013-02-20 20:26:07 +04:00
|
|
|
walkOk = false;
|
2013-01-15 23:41:52 +04:00
|
|
|
}
|
2013-04-20 14:15:27 +04:00
|
|
|
if( walkOk && csync_walk_remote_tree(_csync_ctx, &treewalkRemote, 0) < 0 ) {
|
2013-02-15 22:29:27 +04:00
|
|
|
qDebug() << "Error in remote treewalk.";
|
2013-01-15 23:41:52 +04:00
|
|
|
}
|
|
|
|
|
2014-09-19 12:58:52 +04:00
|
|
|
if (_csync_ctx->remote.root_perms) {
|
|
|
|
_remotePerms[QLatin1String("")] = _csync_ctx->remote.root_perms;
|
|
|
|
qDebug() << "Permissions of the root folder: " << _remotePerms[QLatin1String("")];
|
|
|
|
}
|
|
|
|
|
2015-03-02 17:08:21 +03:00
|
|
|
// Re-init the csync context to free memory
|
|
|
|
csync_commit(_csync_ctx);
|
|
|
|
|
2014-08-07 12:14:14 +04:00
|
|
|
// The map was used for merging trees, convert it to a list:
|
|
|
|
_syncedItems = _syncItemMap.values().toVector();
|
2015-03-02 17:08:21 +03:00
|
|
|
_syncItemMap.clear(); // free memory
|
2014-08-07 12:14:14 +04:00
|
|
|
|
2013-05-15 17:22:20 +04:00
|
|
|
// Adjust the paths for the renames.
|
|
|
|
for (SyncFileItemVector::iterator it = _syncedItems.begin();
|
|
|
|
it != _syncedItems.end(); ++it) {
|
|
|
|
it->_file = adjustRenamedPath(it->_file);
|
|
|
|
}
|
|
|
|
|
2014-06-27 15:34:15 +04:00
|
|
|
// Sort items per destination
|
|
|
|
std::sort(_syncedItems.begin(), _syncedItems.end());
|
|
|
|
|
2014-06-07 13:49:46 +04:00
|
|
|
// make sure everything is allowed
|
|
|
|
checkForPermission();
|
|
|
|
|
2014-03-14 21:43:23 +04:00
|
|
|
// To announce the beginning of the sync
|
2014-03-27 20:04:31 +04:00
|
|
|
emit aboutToPropagate(_syncedItems);
|
2014-10-09 13:03:07 +04:00
|
|
|
_progressInfo._completedFileCount = ULLONG_MAX; // indicate the start with max
|
2014-03-14 21:43:23 +04:00
|
|
|
emit transmissionProgress(_progressInfo);
|
2014-09-23 17:58:06 +04:00
|
|
|
_progressInfo._completedFileCount = 0;
|
2014-03-14 21:29:23 +04:00
|
|
|
|
2014-07-15 13:22:16 +04:00
|
|
|
if (!_hasNoneFiles && _hasRemoveFile) {
|
|
|
|
qDebug() << Q_FUNC_INFO << "All the files are going to be changed, asking the user";
|
2013-08-14 17:44:30 +04:00
|
|
|
bool cancel = false;
|
2014-03-20 17:56:31 +04:00
|
|
|
emit aboutToRemoveAllFiles(_syncedItems.first()._direction, &cancel);
|
2013-06-08 17:40:45 +04:00
|
|
|
if (cancel) {
|
|
|
|
qDebug() << Q_FUNC_INFO << "Abort sync";
|
2014-05-20 14:28:55 +04:00
|
|
|
finalize();
|
2013-06-08 17:40:45 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-02 14:25:51 +03:00
|
|
|
// FIXME: The propagator could create his session in propagator_legacy.cpp
|
|
|
|
// There's no reason to keep csync_owncloud.c around
|
2013-05-03 21:11:00 +04:00
|
|
|
ne_session_s *session = 0;
|
|
|
|
// that call to set property actually is a get which will return the session
|
|
|
|
csync_set_module_property(_csync_ctx, "get_dav_session", &session);
|
|
|
|
|
2014-07-22 20:07:02 +04:00
|
|
|
// post update phase script: allow to tweak stuff by a custom script in debug mode.
|
|
|
|
if( !qgetenv("OWNCLOUD_POST_UPDATE_SCRIPT").isEmpty() ) {
|
2014-10-15 18:43:58 +04:00
|
|
|
#ifndef NDEBUG
|
2014-07-22 20:07:02 +04:00
|
|
|
QString script = qgetenv("OWNCLOUD_POST_UPDATE_SCRIPT");
|
|
|
|
|
|
|
|
qDebug() << "OOO => Post Update Script: " << script;
|
|
|
|
QProcess::execute(script.toUtf8());
|
2014-10-15 18:43:58 +04:00
|
|
|
#else
|
2015-02-06 12:20:10 +03:00
|
|
|
qWarning() << "**** Attention: POST_UPDATE_SCRIPT installed, but not executed because compiled with NDEBUG";
|
2014-07-22 20:07:02 +04:00
|
|
|
#endif
|
2014-10-15 18:43:58 +04:00
|
|
|
}
|
2014-08-14 13:28:34 +04:00
|
|
|
|
|
|
|
// do a database commit
|
|
|
|
_journal->commit("post treewalk");
|
|
|
|
|
2014-11-25 18:24:47 +03:00
|
|
|
_propagator = QSharedPointer<OwncloudPropagator>(
|
2014-12-18 14:09:48 +03:00
|
|
|
new OwncloudPropagator (_account, session, _localPath, _remoteUrl, _remotePath, _journal, &_thread));
|
2013-10-04 17:13:36 +04:00
|
|
|
connect(_propagator.data(), SIGNAL(completed(SyncFileItem)),
|
2014-03-14 16:03:16 +04:00
|
|
|
this, SLOT(slotJobCompleted(SyncFileItem)));
|
|
|
|
connect(_propagator.data(), SIGNAL(progress(SyncFileItem,quint64)),
|
|
|
|
this, SLOT(slotProgress(SyncFileItem,quint64)));
|
|
|
|
connect(_propagator.data(), SIGNAL(adjustTotalTransmissionSize(qint64)), this, SLOT(slotAdjustTotalTransmissionSize(qint64)));
|
2014-05-26 14:23:25 +04:00
|
|
|
connect(_propagator.data(), SIGNAL(finished()), this, SLOT(slotFinished()), Qt::QueuedConnection);
|
2013-05-16 15:54:22 +04:00
|
|
|
|
2014-06-07 13:49:41 +04:00
|
|
|
// apply the network limits to the propagator
|
|
|
|
setNetworkLimits(_uploadLimit, _downloadLimit);
|
2014-01-31 20:29:50 +04:00
|
|
|
|
2014-09-03 14:11:03 +04:00
|
|
|
deleteStaleDownloadInfos();
|
|
|
|
deleteStaleUploadInfos();
|
2015-01-16 12:17:19 +03:00
|
|
|
deleteStaleErrorBlacklistEntries();
|
2014-09-03 14:11:03 +04:00
|
|
|
_journal->commit("post stale entry removal");
|
|
|
|
|
2014-11-07 13:41:21 +03:00
|
|
|
// Emit the started signal only after the propagator has been set up.
|
|
|
|
if (_needsUpdate)
|
|
|
|
emit(started());
|
|
|
|
|
2014-01-31 20:29:50 +04:00
|
|
|
_propagator->start(_syncedItems);
|
|
|
|
}
|
|
|
|
|
2014-07-29 17:51:22 +04:00
|
|
|
void SyncEngine::slotCleanPollsJobAborted(const QString &error)
|
|
|
|
{
|
|
|
|
csyncError(error);
|
|
|
|
finalize();
|
|
|
|
}
|
|
|
|
|
2014-06-07 13:49:41 +04:00
|
|
|
void SyncEngine::setNetworkLimits(int upload, int download)
|
2014-01-31 20:29:50 +04:00
|
|
|
{
|
2014-06-07 13:49:41 +04:00
|
|
|
_uploadLimit = upload;
|
|
|
|
_downloadLimit = download;
|
2014-01-31 20:29:50 +04:00
|
|
|
|
|
|
|
if( !_propagator ) return;
|
|
|
|
|
2014-06-07 13:49:41 +04:00
|
|
|
_propagator->_uploadLimit = upload;
|
|
|
|
_propagator->_downloadLimit = download;
|
2013-08-14 21:59:16 +04:00
|
|
|
|
2014-04-07 19:25:25 +04:00
|
|
|
int propDownloadLimit = _propagator->_downloadLimit
|
|
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
|
|
|
|
.load()
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
int propUploadLimit = _propagator->_uploadLimit
|
|
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
|
|
|
|
.load()
|
|
|
|
#endif
|
|
|
|
;
|
2014-04-07 18:48:14 +04:00
|
|
|
|
2014-04-15 18:15:33 +04:00
|
|
|
if( propDownloadLimit != 0 || propUploadLimit != 0 ) {
|
2014-04-07 18:48:14 +04:00
|
|
|
qDebug() << " N------N Network Limits (down/up) " << propDownloadLimit << propUploadLimit;
|
2014-04-07 17:10:44 +04:00
|
|
|
}
|
2013-05-16 15:54:22 +04:00
|
|
|
}
|
2013-05-07 19:47:29 +04:00
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
void SyncEngine::slotJobCompleted(const SyncFileItem &item)
|
2013-05-16 15:54:22 +04:00
|
|
|
{
|
2013-10-04 17:55:10 +04:00
|
|
|
qDebug() << Q_FUNC_INFO << item._file << item._status << item._errorString;
|
|
|
|
|
2013-10-04 17:13:36 +04:00
|
|
|
/* Update the _syncedItems vector */
|
2013-10-28 13:47:10 +04:00
|
|
|
int idx = _syncedItems.indexOf(item);
|
2013-10-04 17:13:36 +04:00
|
|
|
if (idx >= 0) {
|
|
|
|
_syncedItems[idx]._instruction = item._instruction;
|
|
|
|
_syncedItems[idx]._errorString = item._errorString;
|
|
|
|
_syncedItems[idx]._status = item._status;
|
2013-11-25 01:21:29 +04:00
|
|
|
|
2014-03-26 21:03:22 +04:00
|
|
|
_syncedItems[idx]._requestDuration = item._requestDuration;
|
|
|
|
_syncedItems[idx]._responseTimeStamp = item._responseTimeStamp;
|
2013-11-25 01:21:29 +04:00
|
|
|
} else {
|
|
|
|
qWarning() << Q_FUNC_INFO << "Could not find index in synced items!";
|
2014-03-14 16:03:16 +04:00
|
|
|
|
2013-10-04 17:13:36 +04:00
|
|
|
}
|
2013-05-16 15:54:22 +04:00
|
|
|
|
2014-03-14 16:03:16 +04:00
|
|
|
_progressInfo.setProgressComplete(item);
|
|
|
|
|
2013-10-28 13:47:10 +04:00
|
|
|
if (item._status == SyncFileItem::FatalError) {
|
2013-10-04 17:13:36 +04:00
|
|
|
emit csyncError(item._errorString);
|
|
|
|
}
|
2014-03-14 16:03:16 +04:00
|
|
|
|
2014-03-14 21:43:23 +04:00
|
|
|
emit transmissionProgress(_progressInfo);
|
2014-03-21 20:13:02 +04:00
|
|
|
emit jobCompleted(item);
|
2013-05-16 15:54:22 +04:00
|
|
|
}
|
2013-05-06 18:59:11 +04:00
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
void SyncEngine::slotFinished()
|
2013-05-16 15:54:22 +04:00
|
|
|
{
|
2014-09-10 19:25:13 +04:00
|
|
|
_anotherSyncNeeded = _anotherSyncNeeded || _propagator->_anotherSyncNeeded;
|
|
|
|
|
2013-05-16 15:54:22 +04:00
|
|
|
// emit the treewalk results.
|
2013-11-11 14:11:45 +04:00
|
|
|
if( ! _journal->postSyncCleanup( _seenFiles ) ) {
|
|
|
|
qDebug() << "Cleaning of synced ";
|
|
|
|
}
|
2014-06-17 18:29:38 +04:00
|
|
|
|
2013-11-21 14:13:58 +04:00
|
|
|
_journal->commit("All Finished.", false);
|
2013-10-03 22:00:58 +04:00
|
|
|
emit treeWalkResult(_syncedItems);
|
2014-05-20 14:28:55 +04:00
|
|
|
finalize();
|
|
|
|
}
|
2013-05-16 15:54:22 +04:00
|
|
|
|
2014-05-20 14:28:55 +04:00
|
|
|
void SyncEngine::finalize()
|
|
|
|
{
|
2014-06-18 17:04:55 +04:00
|
|
|
_thread.quit();
|
|
|
|
_thread.wait();
|
2015-03-02 17:08:21 +03:00
|
|
|
|
|
|
|
#ifdef USE_NEON
|
|
|
|
// De-init the neon HTTP(S) connections
|
2015-03-03 12:05:38 +03:00
|
|
|
owncloud_commit(_csync_ctx);
|
2015-03-02 17:08:21 +03:00
|
|
|
#endif
|
|
|
|
|
2013-05-16 15:54:22 +04:00
|
|
|
csync_commit(_csync_ctx);
|
|
|
|
|
2014-03-26 21:06:25 +04:00
|
|
|
qDebug() << "CSync run took " << _stopWatch.addLapTime(QLatin1String("Sync Finished"));
|
|
|
|
_stopWatch.stop();
|
|
|
|
|
2014-05-29 13:34:25 +04:00
|
|
|
_syncRunning = false;
|
2014-05-20 14:28:55 +04:00
|
|
|
emit finished();
|
2014-11-07 13:41:21 +03:00
|
|
|
|
|
|
|
// Delete the propagator only after emitting the signal.
|
2014-11-25 18:24:47 +03:00
|
|
|
_propagator.clear();
|
2012-02-28 19:49:13 +04:00
|
|
|
}
|
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
void SyncEngine::slotProgress(const SyncFileItem& item, quint64 current)
|
2014-01-07 18:42:21 +04:00
|
|
|
{
|
2014-03-14 16:03:16 +04:00
|
|
|
_progressInfo.setProgressItem(item, current);
|
2014-03-14 21:43:23 +04:00
|
|
|
emit transmissionProgress(_progressInfo);
|
2014-01-07 18:42:21 +04:00
|
|
|
}
|
|
|
|
|
2013-11-26 15:22:28 +04:00
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
void SyncEngine::slotAdjustTotalTransmissionSize(qint64 change)
|
2014-03-14 16:03:16 +04:00
|
|
|
{
|
|
|
|
_progressInfo._totalSize += change;
|
2013-07-19 15:05:30 +04:00
|
|
|
}
|
|
|
|
|
2013-05-15 17:22:20 +04:00
|
|
|
/* Given a path on the remote, give the path as it is when the rename is done */
|
2014-03-17 14:34:51 +04:00
|
|
|
QString SyncEngine::adjustRenamedPath(const QString& original)
|
2013-05-15 17:22:20 +04:00
|
|
|
{
|
|
|
|
int slashPos = original.size();
|
|
|
|
while ((slashPos = original.lastIndexOf('/' , slashPos - 1)) > 0) {
|
|
|
|
QHash< QString, QString >::const_iterator it = _renamedFolders.constFind(original.left(slashPos));
|
|
|
|
if (it != _renamedFolders.constEnd()) {
|
|
|
|
return *it + original.mid(slashPos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return original;
|
|
|
|
}
|
2013-10-02 21:41:17 +04:00
|
|
|
|
2014-10-09 18:43:56 +04:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* Make sure that we are allowed to do what we do by checking the permissions and the selective sync list
|
|
|
|
*
|
|
|
|
*/
|
2014-06-07 13:49:46 +04:00
|
|
|
void SyncEngine::checkForPermission()
|
|
|
|
{
|
|
|
|
for (SyncFileItemVector::iterator it = _syncedItems.begin(); it != _syncedItems.end(); ++it) {
|
|
|
|
|
|
|
|
if (it->_direction != SyncFileItem::Up) {
|
|
|
|
// Currently we only check server-side permissions
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-10-09 18:43:56 +04:00
|
|
|
// Do not propagate anything in the server if it is in the selective sync blacklist
|
|
|
|
const QString path = it->destination() + QLatin1Char('/');
|
|
|
|
if (std::binary_search(_selectiveSyncBlackList.constBegin(), _selectiveSyncBlackList.constEnd(),
|
|
|
|
path)) {
|
|
|
|
it->_instruction = CSYNC_INSTRUCTION_IGNORE;
|
|
|
|
it->_status = SyncFileItem::FileIgnored;
|
|
|
|
it->_errorString = tr("Ignored because of the \"choose what to sync\" blacklist");
|
|
|
|
|
|
|
|
if (it->_isDirectory) {
|
|
|
|
for (SyncFileItemVector::iterator it_next = it + 1; it_next != _syncedItems.end() && it_next->_file.startsWith(path); ++it_next) {
|
|
|
|
it = it_next;
|
|
|
|
it->_instruction = CSYNC_INSTRUCTION_IGNORE;
|
|
|
|
it->_status = SyncFileItem::FileIgnored;
|
|
|
|
it->_errorString = tr("Ignored because of the \"choose what to sync\" blacklist");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-06-07 13:49:46 +04:00
|
|
|
switch(it->_instruction) {
|
|
|
|
case CSYNC_INSTRUCTION_NEW: {
|
|
|
|
int slashPos = it->_file.lastIndexOf('/');
|
|
|
|
QString parentDir = slashPos <= 0 ? "" : it->_file.mid(0, slashPos);
|
|
|
|
const QByteArray perms = getPermissions(parentDir);
|
|
|
|
if (perms.isNull()) {
|
|
|
|
// No permissions set
|
|
|
|
break;
|
|
|
|
} else if (it->_isDirectory && !perms.contains("K")) {
|
|
|
|
qDebug() << "checkForPermission: ERROR" << it->_file;
|
|
|
|
it->_instruction = CSYNC_INSTRUCTION_ERROR;
|
|
|
|
it->_status = SyncFileItem::NormalError;
|
|
|
|
it->_errorString = tr("Not allowed because you don't have permission to add sub-directories in that directory");
|
|
|
|
|
|
|
|
for (SyncFileItemVector::iterator it_next = it + 1; it_next != _syncedItems.end() && it_next->_file.startsWith(path); ++it_next) {
|
|
|
|
it = it_next;
|
|
|
|
it->_instruction = CSYNC_INSTRUCTION_ERROR;
|
|
|
|
it->_status = SyncFileItem::NormalError;
|
|
|
|
it->_errorString = tr("Not allowed because you don't have permission to add parent directory");
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (!it->_isDirectory && !perms.contains("C")) {
|
|
|
|
qDebug() << "checkForPermission: ERROR" << it->_file;
|
|
|
|
it->_instruction = CSYNC_INSTRUCTION_ERROR;
|
|
|
|
it->_status = SyncFileItem::NormalError;
|
|
|
|
it->_errorString = tr("Not allowed because you don't have permission to add files in that directory");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CSYNC_INSTRUCTION_SYNC: {
|
|
|
|
const QByteArray perms = getPermissions(it->_file);
|
|
|
|
if (perms.isNull()) {
|
|
|
|
// No permissions set
|
|
|
|
break;
|
|
|
|
} if (!it->_isDirectory && !perms.contains("W")) {
|
|
|
|
qDebug() << "checkForPermission: RESTORING" << it->_file;
|
2014-08-07 12:14:14 +04:00
|
|
|
it->_should_update_etag = true;
|
2014-06-07 13:49:46 +04:00
|
|
|
it->_instruction = CSYNC_INSTRUCTION_CONFLICT;
|
|
|
|
it->_direction = SyncFileItem::Down;
|
|
|
|
it->_isRestoration = true;
|
2014-06-18 18:15:14 +04:00
|
|
|
// take the things to write to the db from the "other" node (i.e: info from server)
|
2014-08-07 12:14:14 +04:00
|
|
|
// ^^ FIXME This might not be needed anymore since we merge the info in treewalkFile
|
2014-06-18 18:15:14 +04:00
|
|
|
it->_modtime = it->log._other_modtime;
|
|
|
|
it->_fileId = it->log._other_fileId;
|
|
|
|
it->_etag = it->log._other_etag;
|
2014-06-07 13:49:46 +04:00
|
|
|
it->_errorString = tr("Not allowed to upload this file because it is read-only on the server, restoring");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CSYNC_INSTRUCTION_REMOVE: {
|
|
|
|
const QByteArray perms = getPermissions(it->_file);
|
|
|
|
if (perms.isNull()) {
|
|
|
|
// No permissions set
|
|
|
|
break;
|
2014-09-25 17:36:28 +04:00
|
|
|
}
|
|
|
|
if (!perms.contains("D")) {
|
2014-06-07 13:49:46 +04:00
|
|
|
qDebug() << "checkForPermission: RESTORING" << it->_file;
|
2014-08-07 12:14:14 +04:00
|
|
|
it->_should_update_etag = true;
|
2014-06-07 13:49:46 +04:00
|
|
|
it->_instruction = CSYNC_INSTRUCTION_NEW;
|
|
|
|
it->_direction = SyncFileItem::Down;
|
|
|
|
it->_isRestoration = true;
|
|
|
|
it->_errorString = tr("Not allowed to remove, restoring");
|
|
|
|
|
|
|
|
if (it->_isDirectory) {
|
|
|
|
// restore all sub items
|
|
|
|
for (SyncFileItemVector::iterator it_next = it + 1;
|
|
|
|
it_next != _syncedItems.end() && it_next->_file.startsWith(path); ++it_next) {
|
|
|
|
it = it_next;
|
|
|
|
|
|
|
|
if (it->_instruction != CSYNC_INSTRUCTION_REMOVE) {
|
|
|
|
qWarning() << "non-removed job within a removed directory"
|
|
|
|
<< it->_file << it->_instruction;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
qDebug() << "checkForPermission: RESTORING" << it->_file;
|
2014-08-07 12:14:14 +04:00
|
|
|
it->_should_update_etag = true;
|
2014-06-07 13:49:46 +04:00
|
|
|
|
|
|
|
it->_instruction = CSYNC_INSTRUCTION_NEW;
|
|
|
|
it->_direction = SyncFileItem::Down;
|
|
|
|
it->_isRestoration = true;
|
|
|
|
it->_errorString = tr("Not allowed to remove, restoring");
|
|
|
|
}
|
|
|
|
}
|
2014-10-09 18:43:56 +04:00
|
|
|
} else if(perms.contains("S") && perms.contains("D")) {
|
2014-09-25 17:36:28 +04:00
|
|
|
// this is a top level shared dir which can be removed to unshare it,
|
|
|
|
// regardless if it is a read only share or not.
|
|
|
|
// To avoid that we try to restore files underneath this dir which have
|
|
|
|
// not delete permission we fast forward the iterator and leave the
|
|
|
|
// delete jobs intact. It is not physically tried to remove this files
|
|
|
|
// underneath, propagator sees that.
|
|
|
|
if( it->_isDirectory ) {
|
|
|
|
// put a more descriptive message if really a top level share dir is removed.
|
2015-02-04 16:52:41 +03:00
|
|
|
if( it == _syncedItems.begin() || !(path.startsWith((it-1)->_file)) ) {
|
2014-09-25 17:36:28 +04:00
|
|
|
it->_errorString = tr("Local files and share folder removed.");
|
|
|
|
}
|
|
|
|
|
|
|
|
for (SyncFileItemVector::iterator it_next = it + 1;
|
|
|
|
it_next != _syncedItems.end() && it_next->_file.startsWith(path); ++it_next) {
|
|
|
|
it = it_next;
|
|
|
|
}
|
|
|
|
}
|
2014-06-07 13:49:46 +04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case CSYNC_INSTRUCTION_RENAME: {
|
|
|
|
|
|
|
|
int slashPos = it->_renameTarget.lastIndexOf('/');
|
2014-08-07 16:27:27 +04:00
|
|
|
const QString parentDir = slashPos <= 0 ? "" : it->_renameTarget.mid(0, slashPos);
|
2014-06-07 13:49:46 +04:00
|
|
|
const QByteArray destPerms = getPermissions(parentDir);
|
|
|
|
const QByteArray filePerms = getPermissions(it->_file);
|
|
|
|
|
|
|
|
//true when it is just a rename in the same directory. (not a move)
|
|
|
|
bool isRename = it->_file.startsWith(parentDir) && it->_file.lastIndexOf('/') == slashPos;
|
|
|
|
|
|
|
|
|
|
|
|
// Check if we are allowed to move to the destination.
|
|
|
|
bool destinationOK = true;
|
|
|
|
if (isRename || destPerms.isNull()) {
|
|
|
|
// no need to check for the destination dir permission
|
|
|
|
destinationOK = true;
|
|
|
|
} else if (it->_isDirectory && !destPerms.contains("K")) {
|
|
|
|
destinationOK = false;
|
|
|
|
} else if (!it->_isDirectory && !destPerms.contains("C")) {
|
|
|
|
destinationOK = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// check if we are allowed to move from the source
|
|
|
|
bool sourceOK = true;
|
|
|
|
if (!filePerms.isNull()
|
|
|
|
&& ((isRename && !filePerms.contains("N"))
|
2014-08-07 16:27:27 +04:00
|
|
|
|| (!isRename && !filePerms.contains("V")))) {
|
2014-06-07 13:49:46 +04:00
|
|
|
|
|
|
|
// We are not allowed to move or rename this file
|
|
|
|
sourceOK = false;
|
|
|
|
|
|
|
|
if (filePerms.contains("D") && destinationOK) {
|
|
|
|
// but we are allowed to delete it
|
|
|
|
// TODO! simulate delete & upload
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-27 17:26:12 +04:00
|
|
|
#if 0 /* We don't like the idea of renaming behind user's back, as the user may be working with the files */
|
|
|
|
|
2014-06-07 13:49:46 +04:00
|
|
|
if (!sourceOK && !destinationOK) {
|
|
|
|
// Both the source and the destination won't allow move. Move back to the original
|
|
|
|
std::swap(it->_file, it->_renameTarget);
|
|
|
|
it->_direction = SyncFileItem::Down;
|
|
|
|
it->_errorString = tr("Move not allowed, item restored");
|
|
|
|
it->_isRestoration = true;
|
|
|
|
qDebug() << "checkForPermission: MOVING BACK" << it->_file;
|
2014-06-27 17:26:12 +04:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
if (!sourceOK || !destinationOK) {
|
2014-06-07 13:49:46 +04:00
|
|
|
// One of them is not possible, just throw an error
|
|
|
|
it->_instruction = CSYNC_INSTRUCTION_ERROR;
|
|
|
|
it->_status = SyncFileItem::NormalError;
|
|
|
|
const QString errorString = tr("Move not allowed because %1 is read-only").arg(
|
|
|
|
sourceOK ? tr("the destination") : tr("the source"));
|
|
|
|
it->_errorString = errorString;
|
|
|
|
|
|
|
|
qDebug() << "checkForPermission: ERROR MOVING" << it->_file << errorString;
|
|
|
|
|
2014-06-27 17:26:12 +04:00
|
|
|
// Avoid a rename on next sync:
|
|
|
|
// TODO: do the resolution now already so we don't need two sync
|
|
|
|
// At this point we would need to go back to the propagate phase on both remote to take
|
|
|
|
// the decision.
|
|
|
|
_journal->avoidRenamesOnNextSync(it->_file);
|
2014-09-10 19:25:13 +04:00
|
|
|
_anotherSyncNeeded = true;
|
2014-06-27 17:26:12 +04:00
|
|
|
|
|
|
|
|
2014-06-07 13:49:46 +04:00
|
|
|
if (it->_isDirectory) {
|
|
|
|
for (SyncFileItemVector::iterator it_next = it + 1;
|
2014-06-27 17:26:12 +04:00
|
|
|
it_next != _syncedItems.end() && it_next->destination().startsWith(path); ++it_next) {
|
2014-06-07 13:49:46 +04:00
|
|
|
it = it_next;
|
|
|
|
it->_instruction = CSYNC_INSTRUCTION_ERROR;
|
|
|
|
it->_status = SyncFileItem::NormalError;
|
|
|
|
it->_errorString = errorString;
|
|
|
|
qDebug() << "checkForPermission: ERROR MOVING" << it->_file;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-17 16:50:24 +04:00
|
|
|
QByteArray SyncEngine::getPermissions(const QString& file) const
|
2014-06-07 13:49:46 +04:00
|
|
|
{
|
|
|
|
static bool isTest = qgetenv("OWNCLOUD_TEST_PERMISSIONS").toInt();
|
|
|
|
if (isTest) {
|
|
|
|
QRegExp rx("_PERM_([^_]*)_[^/]*$");
|
|
|
|
if (rx.indexIn(file) != -1) {
|
|
|
|
return rx.cap(1).toLatin1();
|
|
|
|
}
|
|
|
|
}
|
2014-06-17 16:50:24 +04:00
|
|
|
return _remotePerms.value(file);
|
2014-06-07 13:49:46 +04:00
|
|
|
}
|
|
|
|
|
2014-10-09 17:11:04 +04:00
|
|
|
void SyncEngine::setSelectiveSyncBlackList(const QStringList& list)
|
|
|
|
{
|
|
|
|
_selectiveSyncBlackList = list;
|
|
|
|
}
|
|
|
|
|
2014-10-13 19:23:42 +04:00
|
|
|
bool SyncEngine::estimateState(QString fn, csync_ftw_type_e t, SyncFileStatus* s)
|
|
|
|
{
|
2014-10-18 16:18:11 +04:00
|
|
|
Q_UNUSED(t);
|
2014-12-12 18:38:07 +03:00
|
|
|
QString pat(fn);
|
|
|
|
if( t == CSYNC_FTW_TYPE_DIR && ! fn.endsWith(QLatin1Char('/'))) {
|
|
|
|
pat.append(QLatin1Char('/'));
|
|
|
|
}
|
|
|
|
|
2014-10-13 19:23:42 +04:00
|
|
|
Q_FOREACH(const SyncFileItem &item, _syncedItems) {
|
|
|
|
//qDebug() << Q_FUNC_INFO << fn << item._file << fn.startsWith(item._file) << item._file.startsWith(fn);
|
2014-12-12 18:38:07 +03:00
|
|
|
|
|
|
|
if (item._file.startsWith(pat) ||
|
|
|
|
item._file == fn /* the same directory or file */) {
|
2014-10-13 19:23:42 +04:00
|
|
|
qDebug() << Q_FUNC_INFO << "Setting" << fn << " to STATUS_EVAL";
|
|
|
|
s->set(SyncFileStatus::STATUS_EVAL);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2014-06-07 13:49:46 +04:00
|
|
|
|
2014-11-07 13:41:21 +03:00
|
|
|
qint64 SyncEngine::timeSinceFileTouched(const QString& fn) const
|
|
|
|
{
|
|
|
|
// This copy is essential for thread safety.
|
|
|
|
QSharedPointer<OwncloudPropagator> prop = _propagator;
|
|
|
|
if (prop) {
|
|
|
|
return prop->timeSinceFileTouched(fn);
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-12-18 17:39:20 +03:00
|
|
|
AccountPtr SyncEngine::account() const
|
|
|
|
{
|
|
|
|
return _account;
|
|
|
|
}
|
|
|
|
|
2014-03-17 14:34:51 +04:00
|
|
|
void SyncEngine::abort()
|
2013-10-02 21:41:17 +04:00
|
|
|
{
|
2015-03-05 18:50:33 +03:00
|
|
|
qDebug() << Q_FUNC_INFO << _discoveryMainThread;
|
2014-12-02 14:25:51 +03:00
|
|
|
// Aborts the discovery phase job
|
|
|
|
if (_discoveryMainThread) {
|
|
|
|
_discoveryMainThread->abort();
|
|
|
|
}
|
|
|
|
// Sets a flag for the update phase
|
2013-10-02 21:41:17 +04:00
|
|
|
csync_request_abort(_csync_ctx);
|
2014-12-02 14:25:51 +03:00
|
|
|
// For the propagator
|
|
|
|
if(_propagator) {
|
2014-02-06 17:52:56 +04:00
|
|
|
_propagator->abort();
|
2014-12-02 14:25:51 +03:00
|
|
|
}
|
2013-10-02 21:41:17 +04:00
|
|
|
}
|
|
|
|
|
2014-11-10 00:34:07 +03:00
|
|
|
} // namespace OCC
|