2012-02-15 17:44:09 +04:00
|
|
|
/*
|
|
|
|
* Copyright (C) by Duncan Mac-Vicar P. <duncan@kde.org>
|
|
|
|
* Copyright (C) by Klaas Freitag <freitag@owncloud.org>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2012-05-21 18:48:49 +04:00
|
|
|
#include "mirall/owncloudfolder.h"
|
|
|
|
#include "mirall/mirallconfigfile.h"
|
2012-10-02 15:24:10 +04:00
|
|
|
#include "mirall/owncloudinfo.h"
|
2012-11-13 14:15:25 +04:00
|
|
|
#include "mirall/credentialstore.h"
|
2012-12-11 15:49:48 +04:00
|
|
|
#include "mirall/logger.h"
|
2012-05-21 18:48:49 +04:00
|
|
|
|
|
|
|
#include <csync.h>
|
|
|
|
|
2012-02-15 17:44:09 +04:00
|
|
|
#include <QDebug>
|
|
|
|
#include <QDir>
|
|
|
|
#include <QUrl>
|
|
|
|
#include <QMutexLocker>
|
|
|
|
#include <QThread>
|
|
|
|
#include <QStringList>
|
|
|
|
#include <QTextStream>
|
2012-02-28 19:49:13 +04:00
|
|
|
#include <QTimer>
|
2012-08-02 12:17:15 +04:00
|
|
|
#include <QNetworkProxy>
|
2012-10-08 13:08:37 +04:00
|
|
|
#include <QNetworkAccessManager>
|
|
|
|
#include <QNetworkProxyFactory>
|
2012-02-15 17:44:09 +04:00
|
|
|
|
|
|
|
namespace Mirall {
|
|
|
|
|
2012-03-30 15:57:02 +04:00
|
|
|
|
2012-12-12 22:30:28 +04:00
|
|
|
static QString replaceScheme(const QString &urlStr)
|
|
|
|
{
|
|
|
|
|
|
|
|
QUrl url( urlStr );
|
|
|
|
if( url.scheme() == QLatin1String("http") ) {
|
|
|
|
url.setScheme( QLatin1String("owncloud") );
|
|
|
|
} else {
|
|
|
|
// connect SSL!
|
|
|
|
url.setScheme( QLatin1String("ownclouds") );
|
|
|
|
}
|
|
|
|
return url.toString();
|
|
|
|
}
|
|
|
|
|
2012-02-15 17:44:09 +04:00
|
|
|
ownCloudFolder::ownCloudFolder(const QString &alias,
|
|
|
|
const QString &path,
|
|
|
|
const QString &secondPath,
|
|
|
|
QObject *parent)
|
2012-03-26 15:20:15 +04:00
|
|
|
: Folder(alias, path, secondPath, parent)
|
2012-02-15 17:44:09 +04:00
|
|
|
, _secondPath(secondPath)
|
2012-08-26 13:47:45 +04:00
|
|
|
, _thread(0)
|
2012-02-15 17:44:09 +04:00
|
|
|
, _csync(0)
|
2012-03-22 19:22:08 +04:00
|
|
|
, _csyncError(false)
|
2012-06-25 16:18:13 +04:00
|
|
|
, _wipeDb(false)
|
2012-02-15 17:44:09 +04:00
|
|
|
{
|
2012-12-12 22:30:28 +04:00
|
|
|
_notifier = new DownloadNotifier(QDir::fromNativeSeparators(path),
|
|
|
|
replaceScheme(secondPath), this);
|
|
|
|
connect(_notifier, SIGNAL(guiLog(QString,QString)), Logger::instance(), SIGNAL(guiLog(QString,QString)));
|
2012-02-29 18:25:16 +04:00
|
|
|
qDebug() << "****** ownCloud folder using watcher *******";
|
2012-03-08 14:39:31 +04:00
|
|
|
// The folder interval is set in the folder parent class.
|
2012-02-15 17:44:09 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
ownCloudFolder::~ownCloudFolder()
|
|
|
|
{
|
2012-06-11 12:10:07 +04:00
|
|
|
|
2012-02-15 17:44:09 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
bool ownCloudFolder::isBusy() const
|
|
|
|
{
|
2012-08-26 13:47:45 +04:00
|
|
|
return ( _thread && _thread->isRunning() );
|
2012-02-15 17:44:09 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
QString ownCloudFolder::secondPath() const
|
|
|
|
{
|
2012-03-26 15:20:15 +04:00
|
|
|
QString re(_secondPath);
|
|
|
|
MirallConfigFile cfg;
|
2012-08-17 19:13:17 +04:00
|
|
|
const QString ocUrl = cfg.ownCloudUrl(QString::null, true);
|
2012-04-30 10:56:56 +04:00
|
|
|
// qDebug() << "**** " << ocUrl << " <-> " << re;
|
2012-03-26 15:20:15 +04:00
|
|
|
if( re.startsWith( ocUrl ) ) {
|
|
|
|
re.remove( ocUrl );
|
|
|
|
}
|
|
|
|
|
|
|
|
return re;
|
2012-02-15 17:44:09 +04:00
|
|
|
}
|
|
|
|
|
2012-10-06 00:42:21 +04:00
|
|
|
QString ownCloudFolder::nativeSecondPath() const
|
|
|
|
{
|
|
|
|
// TODO: fold into secondPath() after 1.1.0 release
|
|
|
|
QString path = secondPath();
|
|
|
|
if (!path.startsWith(QLatin1Char('/')) || path.isEmpty())
|
|
|
|
path.prepend(QLatin1Char('/'));
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
2012-02-28 19:49:13 +04:00
|
|
|
void ownCloudFolder::startSync()
|
|
|
|
{
|
|
|
|
startSync( QStringList() );
|
|
|
|
}
|
|
|
|
|
2012-02-15 17:44:09 +04:00
|
|
|
void ownCloudFolder::startSync(const QStringList &pathList)
|
|
|
|
{
|
2012-08-26 13:47:45 +04:00
|
|
|
if (_thread && _thread->isRunning()) {
|
2012-02-15 17:44:09 +04:00
|
|
|
qCritical() << "* ERROR csync is still running and new sync requested.";
|
|
|
|
return;
|
|
|
|
}
|
2012-08-26 13:47:45 +04:00
|
|
|
delete _csync;
|
|
|
|
delete _thread;
|
2012-03-22 19:22:08 +04:00
|
|
|
_errors.clear();
|
|
|
|
_csyncError = false;
|
2012-06-25 16:18:13 +04:00
|
|
|
_wipeDb = false;
|
2012-02-15 17:44:09 +04:00
|
|
|
|
2012-03-13 20:37:43 +04:00
|
|
|
MirallConfigFile cfgFile;
|
|
|
|
|
2012-06-20 14:52:21 +04:00
|
|
|
_syncResult.clearErrors();
|
2012-12-06 20:34:12 +04:00
|
|
|
// we now have watchers for everything, so every sync is remote.
|
|
|
|
_syncResult.setLocalRunOnly( false );
|
2012-04-17 15:16:48 +04:00
|
|
|
Folder::startSync( pathList );
|
2012-02-15 17:44:09 +04:00
|
|
|
|
2012-12-12 22:30:28 +04:00
|
|
|
QString url = replaceScheme(_secondPath);
|
2012-04-17 15:16:48 +04:00
|
|
|
|
2012-12-12 22:30:28 +04:00
|
|
|
qDebug() << "*** Start syncing url to ownCloud: " << url;
|
2012-08-26 13:47:45 +04:00
|
|
|
_thread = new QThread(this);
|
2012-12-12 22:30:28 +04:00
|
|
|
_csync = new CSyncThread( path(), url);
|
2012-08-26 13:47:45 +04:00
|
|
|
_csync->moveToThread(_thread);
|
2012-08-02 12:17:15 +04:00
|
|
|
|
2012-10-09 05:08:39 +04:00
|
|
|
QList<QNetworkProxy> proxies = QNetworkProxyFactory::proxyForQuery(QUrl(cfgFile.ownCloudUrl()));
|
2012-10-09 04:34:22 +04:00
|
|
|
// We set at least one in Application
|
|
|
|
Q_ASSERT(proxies.count() > 0);
|
|
|
|
QNetworkProxy proxy = proxies.first();
|
2012-10-02 15:24:10 +04:00
|
|
|
|
2012-11-13 14:15:25 +04:00
|
|
|
_csync->setConnectionDetails( CredentialStore::instance()->user(),
|
|
|
|
CredentialStore::instance()->password(),
|
|
|
|
proxy );
|
2013-01-15 23:41:52 +04:00
|
|
|
qRegisterMetaType<SyncFileItemVector>("SyncFileItemVector");
|
|
|
|
connect( _csync, SIGNAL(treeWalkResult(const SyncFileItemVector&)),
|
|
|
|
this, SLOT(slotThreadTreeWalkResult(const SyncFileItemVector&)), Qt::QueuedConnection);
|
2012-08-02 12:17:15 +04:00
|
|
|
|
2012-08-26 13:47:45 +04:00
|
|
|
connect(_csync, SIGNAL(started()), SLOT(slotCSyncStarted()), Qt::QueuedConnection);
|
|
|
|
connect(_csync, SIGNAL(finished()), SLOT(slotCSyncFinished()), Qt::QueuedConnection);
|
2012-12-11 15:49:48 +04:00
|
|
|
connect(_csync, SIGNAL(csyncError(QString)), SLOT(slotCSyncError(QString)), Qt::QueuedConnection);
|
2012-12-12 22:30:28 +04:00
|
|
|
connect(_csync, SIGNAL(fileReceived(QString)),
|
|
|
|
_notifier, SLOT(slotFileReceived(QString)), Qt::QueuedConnection);
|
2012-03-22 19:22:08 +04:00
|
|
|
|
2012-08-26 13:47:45 +04:00
|
|
|
_thread->start();
|
|
|
|
QMetaObject::invokeMethod(_csync, "startSync", Qt::QueuedConnection);
|
|
|
|
|
2012-02-15 17:44:09 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void ownCloudFolder::slotCSyncStarted()
|
|
|
|
{
|
|
|
|
qDebug() << " * csync thread started";
|
|
|
|
emit syncStarted();
|
|
|
|
}
|
|
|
|
|
2012-03-22 19:22:08 +04:00
|
|
|
void ownCloudFolder::slotCSyncError(const QString& err)
|
|
|
|
{
|
|
|
|
_errors.append( err );
|
|
|
|
_csyncError = true;
|
|
|
|
}
|
|
|
|
|
2012-03-21 21:03:49 +04:00
|
|
|
void ownCloudFolder::slotCSyncFinished()
|
|
|
|
{
|
2012-04-30 10:56:56 +04:00
|
|
|
qDebug() << "-> CSync Finished slot with error " << _csyncError;
|
|
|
|
|
2012-03-22 19:22:08 +04:00
|
|
|
if (_csyncError) {
|
2012-04-17 15:16:48 +04:00
|
|
|
_syncResult.setStatus(SyncResult::Error);
|
2012-03-22 19:22:08 +04:00
|
|
|
|
|
|
|
qDebug() << " ** error Strings: " << _errors;
|
2012-04-17 15:16:48 +04:00
|
|
|
_syncResult.setErrorStrings( _errors );
|
2012-03-21 21:03:49 +04:00
|
|
|
qDebug() << " * owncloud csync thread finished with error";
|
2012-06-25 16:18:13 +04:00
|
|
|
if( _wipeDb ) wipe();
|
2012-03-22 19:22:08 +04:00
|
|
|
} else {
|
2012-04-17 15:16:48 +04:00
|
|
|
_syncResult.setStatus(SyncResult::Success);
|
2012-03-22 19:22:08 +04:00
|
|
|
}
|
2012-03-21 21:03:49 +04:00
|
|
|
|
2012-08-26 13:47:45 +04:00
|
|
|
if( _thread && _thread->isRunning() ) {
|
|
|
|
_thread->quit();
|
|
|
|
}
|
2012-04-17 15:16:48 +04:00
|
|
|
emit syncFinished( _syncResult );
|
2012-02-15 17:44:09 +04:00
|
|
|
}
|
|
|
|
|
2013-01-15 23:41:52 +04:00
|
|
|
void ownCloudFolder::slotThreadTreeWalkResult(const SyncFileItemVector& items)
|
|
|
|
{
|
|
|
|
_syncResult.setSyncFileItemVector(items);
|
|
|
|
}
|
|
|
|
|
2012-04-30 10:56:56 +04:00
|
|
|
void ownCloudFolder::slotTerminateSync()
|
|
|
|
{
|
|
|
|
qDebug() << "folder " << alias() << " Terminating!";
|
|
|
|
QString configDir = _csync->csyncConfigDir();
|
|
|
|
qDebug() << "csync's Config Dir: " << configDir;
|
|
|
|
|
2012-08-26 13:47:45 +04:00
|
|
|
if( _thread ) {
|
|
|
|
_thread->terminate();
|
|
|
|
_thread->wait();
|
2012-10-06 00:53:12 +04:00
|
|
|
// TODO: crashes on win, leak for now, fix properly after 1.1.0
|
|
|
|
#ifndef Q_OS_WIN
|
2012-04-30 10:56:56 +04:00
|
|
|
delete _csync;
|
2012-10-06 00:53:12 +04:00
|
|
|
#endif
|
2012-08-26 13:47:45 +04:00
|
|
|
delete _thread;
|
2012-04-30 10:56:56 +04:00
|
|
|
_csync = 0;
|
2012-08-26 13:47:45 +04:00
|
|
|
_thread = 0;
|
2012-04-30 10:56:56 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if( ! configDir.isEmpty() ) {
|
|
|
|
QFile file( configDir + QLatin1String("/lock"));
|
|
|
|
if( file.exists() ) {
|
|
|
|
qDebug() << "After termination, lock file exists and gets removed.";
|
|
|
|
file.remove();
|
|
|
|
}
|
|
|
|
}
|
2012-08-26 13:47:45 +04:00
|
|
|
|
|
|
|
_errors.append( tr("The CSync thread terminated.") );
|
|
|
|
_csyncError = true;
|
|
|
|
qDebug() << "-> CSync Terminated!";
|
|
|
|
slotCSyncFinished();
|
2012-04-30 10:56:56 +04:00
|
|
|
}
|
|
|
|
|
2012-06-25 17:31:13 +04:00
|
|
|
void ownCloudFolder::slotLocalPathChanged( const QString& dir )
|
|
|
|
{
|
|
|
|
QDir notifiedDir(dir);
|
|
|
|
QDir localPath( path() );
|
|
|
|
|
2012-06-26 14:27:50 +04:00
|
|
|
if( notifiedDir.absolutePath() == localPath.absolutePath() ) {
|
2012-06-25 17:31:13 +04:00
|
|
|
if( !localPath.exists() ) {
|
|
|
|
qDebug() << "XXXXXXX The sync folder root was removed!!";
|
2012-08-26 13:47:45 +04:00
|
|
|
if( _thread && _thread->isRunning() ) {
|
2012-06-25 17:31:13 +04:00
|
|
|
qDebug() << "CSync currently running, set wipe flag!!";
|
|
|
|
} else {
|
|
|
|
qDebug() << "CSync not running, wipe it now!!";
|
|
|
|
wipe();
|
|
|
|
}
|
|
|
|
|
|
|
|
qDebug() << "ALARM: The local path was DELETED!";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-11 12:10:07 +04:00
|
|
|
// This removes the csync File database if the sync folder definition is removed
|
|
|
|
// permanentely. This is needed to provide a clean startup again in case another
|
|
|
|
// local folder is synced to the same ownCloud.
|
|
|
|
// See http://bugs.owncloud.org/thebuggenie/owncloud/issues/oc-788
|
|
|
|
void ownCloudFolder::wipe()
|
|
|
|
{
|
2012-10-29 14:23:41 +04:00
|
|
|
QString stateDbFile = path()+QLatin1String(".csync_journal.db");
|
|
|
|
|
|
|
|
QFile file(stateDbFile);
|
|
|
|
if( file.exists() ) {
|
|
|
|
if( !file.remove()) {
|
|
|
|
qDebug() << "WRN: Failed to remove existing csync StateDB " << stateDbFile;
|
2012-06-11 12:10:07 +04:00
|
|
|
} else {
|
2012-10-29 14:23:41 +04:00
|
|
|
qDebug() << "wipe: Removed csync StateDB " << stateDbFile;
|
2012-06-11 12:10:07 +04:00
|
|
|
}
|
2012-10-29 14:23:41 +04:00
|
|
|
} else {
|
|
|
|
qDebug() << "WRN: statedb is empty, can not remove.";
|
|
|
|
}
|
|
|
|
// Check if the tmp database file also exists
|
|
|
|
QString ctmpName = path() + QLatin1String(".csync_journal.db.ctmp");
|
|
|
|
QFile ctmpFile( ctmpName );
|
|
|
|
if( ctmpFile.exists() ) {
|
|
|
|
ctmpFile.remove();
|
2012-06-11 12:10:07 +04:00
|
|
|
}
|
2012-10-29 14:23:41 +04:00
|
|
|
_wipeDb = false;
|
2012-06-11 12:10:07 +04:00
|
|
|
}
|
|
|
|
|
2012-12-12 22:30:28 +04:00
|
|
|
DownloadNotifier::DownloadNotifier(const QString &localPrefix, const QString &remotePrefix, QObject *parent)
|
|
|
|
: QObject(parent), _timer(new QTimer(this)), _items(0)
|
|
|
|
{
|
|
|
|
_timer->setSingleShot(true);
|
|
|
|
connect(_timer, SIGNAL(timeout()), SLOT(sendResults()));
|
|
|
|
|
|
|
|
_localPrefix = localPrefix;
|
|
|
|
_remotePrefix = remotePrefix;
|
|
|
|
}
|
|
|
|
|
|
|
|
void DownloadNotifier::slotFileReceived(const QString & url)
|
|
|
|
{
|
|
|
|
if (_url.isEmpty())
|
|
|
|
_url = url;
|
|
|
|
_items++;
|
|
|
|
_timer->stop();
|
|
|
|
_timer->start(1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DownloadNotifier::sendResults()
|
|
|
|
{
|
|
|
|
QString file = _url;
|
|
|
|
file.replace(_remotePrefix, _localPrefix);
|
|
|
|
file = QDir::toNativeSeparators(QDir::cleanPath(file));
|
|
|
|
if (_items == 1)
|
|
|
|
emit guiLog(tr("New file available"), tr("'%1' has been synced to this machine.").arg(file));
|
|
|
|
else
|
|
|
|
emit guiLog(tr("New files available"), tr("'%1' and %n other file(s) have been synced to this machine.",
|
|
|
|
"", _items-1).arg(file).arg(_items));
|
|
|
|
|
|
|
|
// reset
|
|
|
|
_items = 0;
|
|
|
|
_url = QString::null;
|
|
|
|
}
|
|
|
|
|
2012-02-15 17:44:09 +04:00
|
|
|
} // ns
|
|
|
|
|