void CSyncThread::startNextTransfer()
{
while (_iterator < _syncedItems.size()) {
const SyncFileItem &item = _syncedItems.at(_iterator);
++_iterator;
while (!_directoriesToUpdate.isEmpty() && !item._file.startsWith(_directoriesToUpdate.last()._path)) {
// We are leaving a directory. Everything we needed to download from that directory is done.
// Update the directory etag in the database to the new one.
_journal->setFileRecord(_directoriesToUpdate.pop());
}
if (!_lastDeleted.isEmpty() &&
item._file.startsWith(_lastDeleted) ) {
if( item._instruction != CSYNC_INSTRUCTION_REMOVE ) {
qDebug() << "WRN: Child of a deleted directory has different instruction than delete."
<< item._file << _lastDeleted << item._instruction;
} else {
// If the item's name starts with the name of the previously deleted directory, we
// can assume this file was already destroyed by the previous call.
_journal->deleteFileRecord(item._file);
continue;
}
}
if (item._instruction == CSYNC_INSTRUCTION_SYNC || item._instruction == CSYNC_INSTRUCTION_NEW
|| item._instruction == CSYNC_INSTRUCTION_CONFLICT) {
slotProgress((item._dir != SyncFileItem::Up) ? Progress::StartDownload : Progress::StartUpload,
item._file, 0, item._size);
}
_propagator->propagate(item);
return; //propagate is async.
}
// We are finished !!
while (!_directoriesToUpdate.isEmpty()) {
// Save the etag of directories to the database.
_journal->setFileRecord(_directoriesToUpdate.pop());
}
// emit the treewalk results.
emit treeWalkResult(_syncedItems);
csync_commit(_csync_ctx);
qDebug() << "CSync run took " << _syncTime.elapsed() << " Milliseconds";
slotProgress(Progress::EndSync,QString(), 0 , 0);
emit finished();
_propagator.reset(0);
_syncMutex.unlock();
thread()->quit();
}
void QFileTrans::slotPresenceReceived(const QXmppPresence &presence)
{
bool check;
Q_UNUSED(check);
// if we don't have a recipient, or if the presence is not from the recipient,
// do nothing
if (m_recipient.isEmpty() ||
QXmppUtils::jidToBareJid(presence.from()) != m_recipient ||
presence.type() != QXmppPresence::Available)
return;
// send the file and connect to the job's signals
QXmppTransferJob *job = transferManager->sendFile(presence.from(), ":/example_3_transferHandling.cpp", "example source code");
check = connect(job, SIGNAL(error(QXmppTransferJob::Error)),
this, SLOT(slotError(QXmppTransferJob::Error)));
Q_ASSERT(check);
check = connect(job, SIGNAL(finished()),
this, SLOT(slotFinished()));
Q_ASSERT(check);
check = connect(job, SIGNAL(progress(qint64,qint64)),
this, SLOT(slotProgress(qint64,qint64)));
Q_ASSERT(check);
}
bool CSyncThread::checkBlacklisting( SyncFileItem *item )
{
bool re = false;
if( !_journal ) {
qWarning() << "Journal is undefined!";
return false;
}
SyncJournalBlacklistRecord entry = _journal->blacklistEntry(item->_file);
item->_blacklistedInDb = false;
// if there is a valid entry in the blacklist table and the retry count is
// already null or smaller than 0, the file is blacklisted.
if( entry.isValid() ) {
item->_blacklistedInDb = true;
if( entry._retryCount <= 0 ) {
re = true;
}
// if the retryCount is 0, but the etag for downloads or the mtime for uploads
// has changed, it is tried again
// note that if the retryCount is -1 we never try again.
if( entry._retryCount == 0 ) {
if( item->_dir == SyncFileItem::Up ) { // check the modtime
if(item->_modtime == 0 || entry._lastTryModtime == 0) {
re = false;
} else {
if( item->_modtime != entry._lastTryModtime ) {
re = false;
qDebug() << item->_file << " is blacklisted, but has changed mtime!";
}
}
} else {
// 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 ) {
re = false;
qDebug() << item->_file << " is blacklisted, but has changed etag!";
}
}
}
}
if( re ) {
qDebug() << "Item is on blacklist: " << entry._file << "retries:" << entry._retryCount;
item->_instruction = CSYNC_INSTRUCTION_IGNORE;
// FIXME: put the error string into an .arg(..) later
item->_errorString = tr("The item is not synced because of previous errors:")
+ QLatin1String(" ")+ entry._errorString;
slotProgress( Progress::SoftError, *item );
}
}
return re;
}
void xmppClient::slotPresenceReceived(const QXmppPresence &presence)
{
const QLatin1String recipient("*****@*****.**");
// if we are the recipient, or if the presence is not from the recipient,
// do nothing
if (jidToBareJid(configuration().jid()) == recipient ||
jidToBareJid(presence.from()) != recipient ||
presence.type() != QXmppPresence::Available)
return;
// send the file and connect to the job's signals
QXmppTransferJob *job = transferManager->sendFile(presence.from(), "xmppClient.cpp");
bool check = connect( job, SIGNAL(error(QXmppTransferJob::Error)),
this, SLOT(slotError(QXmppTransferJob::Error)) );
Q_ASSERT(check);
check = connect( job, SIGNAL(finished()),
this, SLOT(slotFinished()) );
Q_ASSERT(check);
check = connect( job, SIGNAL(progress(qint64,qint64)),
this, SLOT(slotProgress(qint64,qint64)) );
Q_ASSERT(check);
}
void CSyncThread::startNextTransfer()
{
while (_iterator < _syncedItems.size()) {
const SyncFileItem &item = _syncedItems.at(_iterator);
++_iterator;
while (!_directoriesToUpdate.isEmpty() && !item._file.startsWith(_directoriesToUpdate.last()._path)) {
_journal->setFileRecord(_directoriesToUpdate.pop());
}
if (!_lastDeleted.isEmpty() && item._file.startsWith(_lastDeleted)
&& item._instruction == CSYNC_INSTRUCTION_REMOVE) {
// If the item's name starts with the name of the previously deleted directory, we
// can assume this file was already destroyed by the previous recursive call.
_journal->deleteFileRecord(item._file);
continue;
}
if (item._instruction == CSYNC_INSTRUCTION_SYNC || item._instruction == CSYNC_INSTRUCTION_NEW
|| item._instruction == CSYNC_INSTRUCTION_CONFLICT) {
slotProgress((item._dir != SyncFileItem::Up) ? Progress::StartDownload : Progress::StartUpload,
item._file, 0, item._size);
}
_propagator->propagate(item);
return; //propagate is async.
}
while (!_directoriesToUpdate.isEmpty()) {
_journal->setFileRecord(_directoriesToUpdate.pop());
}
// Everything is finished.
_progressDataBase.save(_localPath);
// emit the treewalk results.
emit treeWalkResult(_syncedItems);
csync_commit(_csync_ctx);
qDebug() << "CSync run took " << _syncTime.elapsed() << " Milliseconds";
slotProgress(Progress::EndSync,QString(), 0 , 0);
emit finished();
_propagator.reset(0);
_syncMutex.unlock();
thread()->quit();
}
BundlingWidget::BundlingWidget( Connections* cons, QWidget* parent ) :
m_progress( 0 )
{
m_cons = cons;
connect( cons, SIGNAL( progress() ), this, SLOT( slotProgress() ), Qt::QueuedConnection );
connect( cons, SIGNAL( finished() ), this, SLOT( slotFinished() ) );
m_layout = new QVBoxLayout();
QHBoxLayout* hLayout = new QHBoxLayout();
m_startButton = new QPushButton( tr( "Bundle" ) );
connect( m_startButton, SIGNAL( clicked() ), this, SLOT( start() ) );
SliderWithEdit* cthr = new SliderWithEdit( QString( "compatibility threshold" ) );
cthr->setMin( 0.01f );
cthr->setMax( 1.0f );
cthr->setValue( 0.8f );
m_layout->addWidget( cthr );
connect( cthr, SIGNAL( valueChanged( float, int) ), m_cons, SLOT( setCthr( float, int) ) );
SliderWithEdit* bell = new SliderWithEdit( QString( "mean shift kernel radius" ) );
bell->setMin( 0.01f );
bell->setMax( 100.0f );
bell->setValue( 5.0f );
m_layout->addWidget( bell );
connect( bell, SIGNAL( valueChanged( float, int) ), m_cons, SLOT( setBell( float, int) ) );
SliderWithEditInt* smooth = new SliderWithEditInt( QString( "smoothing steps" ) );
smooth->setMin( 1 );
smooth->setMax( 10 );
smooth->setValue( 3 );
m_layout->addWidget( smooth );
connect( smooth, SIGNAL( valueChanged( int, int) ), m_cons, SLOT( setSmooth( int, int) ) );
int iterations = 10;//TODO: calculate number of iterations
m_progressBar = new QProgressBar( this );
m_progressBar->setValue( 0 );
m_progressBar->setMaximum( iterations );
m_progressBar->hide();
m_layout->addWidget( m_progressBar );
hLayout->addStretch();
hLayout->addWidget( m_startButton );
m_layout->addLayout( hLayout );
m_layout->addStretch();
setLayout( m_layout );
}
void IbbTransferTarget::slotFileReceived(QXmppTransferJob *job)
{
qDebug() << "Got transfer request from:" << job->jid();
bool check = connect(job, SIGNAL(error(QXmppTransferJob::Error)), this, SLOT(slotError(QXmppTransferJob::Error)));
Q_ASSERT(check);
check = connect(job, SIGNAL(finished()), this, SLOT(slotFinished()));
Q_ASSERT(check);
check = connect(job, SIGNAL(progress(qint64,qint64)), this, SLOT(slotProgress(qint64,qint64)));
Q_ASSERT(check);
m_buffer->open(QIODevice::WriteOnly);
job->accept(m_buffer);
}
void xmppClient::slotFileReceived(QXmppTransferJob *job)
{
qDebug() << "Got transfer request from:" << job->jid();
bool check = connect(job, SIGNAL(error(QXmppTransferJob::Error)), this, SLOT(slotError(QXmppTransferJob::Error)));
Q_ASSERT(check);
check = connect(job, SIGNAL(finished()), this, SLOT(slotFinished()));
Q_ASSERT(check);
check = connect(job, SIGNAL(progress(qint64,qint64)), this, SLOT(slotProgress(qint64,qint64)));
Q_ASSERT(check);
// allocate a buffer to receive the file
QBuffer *buffer = new QBuffer(this);
buffer->open(QIODevice::WriteOnly);
job->accept(buffer);
}
void CSyncThread::slotFinished()
{
// emit the treewalk results.
if( ! _journal->postSyncCleanup( _seenFiles ) ) {
qDebug() << "Cleaning of synced ";
}
_journal->commit("All Finished.", false);
emit treeWalkResult(_syncedItems);
csync_commit(_csync_ctx);
qDebug() << "CSync run took " << _syncTime.elapsed() << " Milliseconds";
slotProgress(Progress::EndSync,SyncFileItem(), 0 , 0);
emit finished();
_propagator.reset(0);
_syncMutex.unlock();
_thread.quit();
}
void SD::start()
{
QAtomicInt currentId( 0 );
int numThreads = GLFunctions::idealThreadCount;
// create threads
for ( int i = 0; i < numThreads; ++i )
{
SDThread* t = new SDThread( m_dataset, i );
m_threads.push_back( t );
connect( t, SIGNAL( progress() ), this, SLOT( slotProgress() ), Qt::QueuedConnection );
connect( t, SIGNAL( finished() ), this, SLOT( slotThreadFinished() ), Qt::QueuedConnection );
}
// run threads
for ( int i = 0; i < numThreads; ++i )
{
++m_threadsRunning;
m_threads[i]->start();
}
}
/*
* read from the stderr of the child
* process
*/
void FileTransfer::slotRead() {
QByteArray ar(4096);
int len = read(m_comm[0], ar.data(), 4096 );
for (int i = 0; i < len; i++ ) {
// printf("%c", ar[i] );
}
ar.resize( len );
QString str( ar );
QStringList lis = QStringList::split(' ', str );
/*
* Transfer finished.. either complete or incomplete
*/
if ( lis[0].simplifyWhiteSpace() == "Transfer" ) {
return;
}
/*
* do progress reading
*/
slotProgress( lis );
}
bool SongDownloader::downloadFromQueue() {
QUrl downloadUrl = m_downloadQueue.dequeue();
//Extract the filename from the URL path
QString filename = downloadUrl.path();
QFileInfo fileInfo(filename);
filename = fileInfo.fileName();
m_pDownloadedFile = new QFile(filename + TEMP_EXTENSION);
if (!m_pDownloadedFile->open(QIODevice::WriteOnly)) {
//TODO: Error
qDebug() << "Failed to open" << m_pDownloadedFile->fileName();
return false;
}
qDebug() << "SongDownloader: setting up download stuff";
m_pRequest = new QNetworkRequest(downloadUrl);
//Set up user agent for great justice
QString mixxxUA = QString("%1 %2").arg(QApplication::applicationName(),
Version::version());
// HTTP request headers must be latin1.
QByteArray mixxxUABA = mixxxUA.toLatin1();
m_pRequest->setRawHeader("User-Agent", mixxxUABA);
m_pReply = m_pNetwork->get(*m_pRequest);
connect(m_pReply, SIGNAL(readyRead()), this, SLOT(slotReadyRead()));
connect(m_pReply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(slotError(QNetworkReply::NetworkError)));
connect(m_pReply, SIGNAL(downloadProgress(qint64, qint64)),
this, SLOT(slotProgress(qint64, qint64)));
connect(m_pReply, SIGNAL(downloadProgress(qint64, qint64)),
this, SIGNAL(downloadProgress(qint64, qint64)));
connect(m_pReply, SIGNAL(finished()),
this, SLOT(slotDownloadFinished()));
return true;
}
void CSyncThread::slotUpdateFinished(int updateResult)
{
if (updateResult < 0 ) {
handleSyncError(_csync_ctx, "csync_update");
return;
}
qDebug() << "<<#### Update end #################################################### " << _syncTime.elapsed();
if( csync_reconcile(_csync_ctx) < 0 ) {
handleSyncError(_csync_ctx, "csync_reconcile");
return;
}
slotProgress(Progress::StartSync, SyncFileItem(), 0, 0);
_progressInfo = Progress::Info();
_hasFiles = false;
bool walkOk = true;
_seenFiles.clear();
if( csync_walk_local_tree(_csync_ctx, &treewalkLocal, 0) < 0 ) {
qDebug() << "Error in local treewalk.";
walkOk = false;
}
if( walkOk && csync_walk_remote_tree(_csync_ctx, &treewalkRemote, 0) < 0 ) {
qDebug() << "Error in remote treewalk.";
}
// Adjust the paths for the renames.
for (SyncFileItemVector::iterator it = _syncedItems.begin();
it != _syncedItems.end(); ++it) {
it->_file = adjustRenamedPath(it->_file);
}
if (!_hasFiles && !_syncedItems.isEmpty()) {
qDebug() << Q_FUNC_INFO << "All the files are going to be removed, asking the user";
bool cancel = false;
emit aboutToRemoveAllFiles(_syncedItems.first()._dir, &cancel);
if (cancel) {
qDebug() << Q_FUNC_INFO << "Abort sync";
return;
}
}
if (_needsUpdate)
emit(started());
ne_session_s *session = 0;
// that call to set property actually is a get which will return the session
// FIXME add a csync_get_module_property to csync
csync_set_module_property(_csync_ctx, "get_dav_session", &session);
Q_ASSERT(session);
_propagator.reset(new OwncloudPropagator (session, _localPath, _remoteUrl, _remotePath,
_journal, &_thread));
connect(_propagator.data(), SIGNAL(completed(SyncFileItem)),
this, SLOT(transferCompleted(SyncFileItem)), Qt::QueuedConnection);
connect(_propagator.data(), SIGNAL(progress(Progress::Kind,SyncFileItem,quint64,quint64)),
this, SLOT(slotProgress(Progress::Kind,SyncFileItem,quint64,quint64)));
connect(_propagator.data(), SIGNAL(progressChanged(qint64)), this, SLOT(slotProgressChanged(qint64)));
connect(_propagator.data(), SIGNAL(finished()), this, SLOT(slotFinished()));
setNetworkLimits();
_propagator->start(_syncedItems);
}
void CSyncThread::transferCompleted(const SyncFileItem &item)
{
qDebug() << Q_FUNC_INFO << item._file << item._status << item._errorString;
/* Update the _syncedItems vector */
// Search for the item in the starting from _iterator because it should be a bit before it.
// This works because SyncFileItem::operator== only compare the file name;
int idx = _syncedItems.lastIndexOf(item, _iterator);
if (idx >= 0) {
_syncedItems[idx]._instruction = item._instruction;
_syncedItems[idx]._errorString = item._errorString;
_syncedItems[idx]._status = item._status;
}
/* Remember deleted directory */
if (item._isDirectory && item._instruction == CSYNC_INSTRUCTION_DELETED) {
_lastDeleted = item._file;
} else {
_lastDeleted.clear();
}
/* Update the database */
if (item._instruction == CSYNC_INSTRUCTION_DELETED) {
_journal->deleteFileRecord(item._originalFile);
if (!item._renameTarget.isEmpty()) {
SyncJournalFileRecord record(item, _localPath + item._renameTarget);
record._path = item._renameTarget;
_journal->setFileRecord(record);
}
} else if(item._instruction == CSYNC_INSTRUCTION_ERROR) {
// Don't update parents directories
_directoriesToUpdate.clear();
} else if (item._isDirectory) {
// directory must not be saved to the db before we finished processing them.
SyncJournalFileRecord record(item, _localPath + item._file);
_directoriesToUpdate.push(record);
} else if(item._instruction == CSYNC_INSTRUCTION_UPDATED) {
SyncJournalFileRecord record(item, _localPath + item._file);
_journal->setFileRecord(record);
slotProgress((item._dir != SyncFileItem::Up) ? Progress::EndDownload : Progress::EndUpload,
item._file, item._size, item._size);
_progressInfo.current_file_no++;
_progressInfo.overall_current_bytes += item._size;
}
/* Start the transfer of the next file or abort if there is an error */
if (item._status != SyncFileItem::FatalError) {
startNextTransfer();
} else {
emit treeWalkResult(_syncedItems);
emit csyncError(item._errorString);
emit finished();
csync_commit(_csync_ctx);
_syncMutex.unlock();
thread()->quit();
}
}
void SyncEngine::slotUpdateFinished(int updateResult)
{
if (updateResult < 0 ) {
handleSyncError(_csync_ctx, "csync_update");
return;
}
qDebug() << "<<#### Update end #################################################### " << _stopWatch.addLapTime(QLatin1String("Update Finished"));
if( csync_reconcile(_csync_ctx) < 0 ) {
handleSyncError(_csync_ctx, "csync_reconcile");
return;
}
_stopWatch.addLapTime(QLatin1String("Reconcile Finished"));
_progressInfo = Progress::Info();
_hasFiles = false;
bool walkOk = true;
_seenFiles.clear();
if( csync_walk_local_tree(_csync_ctx, &treewalkLocal, 0) < 0 ) {
qDebug() << "Error in local treewalk.";
walkOk = false;
}
if( walkOk && csync_walk_remote_tree(_csync_ctx, &treewalkRemote, 0) < 0 ) {
qDebug() << "Error in remote treewalk.";
}
// Adjust the paths for the renames.
for (SyncFileItemVector::iterator it = _syncedItems.begin();
it != _syncedItems.end(); ++it) {
it->_file = adjustRenamedPath(it->_file);
}
// Sanity check
if (!_journal->isConnected()) {
qDebug() << "Bailing out, DB failure";
emit csyncError(tr("Cannot open the sync journal"));
finalize();
return;
}
// To announce the beginning of the sync
emit aboutToPropagate(_syncedItems);
emit transmissionProgress(_progressInfo);
if (!_hasFiles && !_syncedItems.isEmpty()) {
qDebug() << Q_FUNC_INFO << "All the files are going to be removed, asking the user";
bool cancel = false;
emit aboutToRemoveAllFiles(_syncedItems.first()._direction, &cancel);
if (cancel) {
qDebug() << Q_FUNC_INFO << "Abort sync";
finalize();
return;
}
}
if (_needsUpdate)
emit(started());
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);
Q_ASSERT(session);
_propagator.reset(new OwncloudPropagator (session, _localPath, _remoteUrl, _remotePath,
_journal, &_thread));
connect(_propagator.data(), SIGNAL(completed(SyncFileItem)),
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)));
connect(_propagator.data(), SIGNAL(finished()), this, SLOT(slotFinished()), Qt::QueuedConnection);
// apply the network limits to the propagator
setNetworkLimits(_uploadLimit, _downloadLimit);
_propagator->start(_syncedItems);
}
void SyncEngine::slotDiscoveryJobFinished(int discoveryResult)
{
// To clean the progress info
emit folderDiscovered(false, QString());
if (discoveryResult < 0 ) {
handleSyncError(_csync_ctx, "csync_update");
return;
}
qDebug() << "<<#### Discovery end #################################################### " << _stopWatch.addLapTime(QLatin1String("Discovery Finished"));
// 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
_journal->commitIfNeededAndStartNewTransaction("Post discovery");
}
if( csync_reconcile(_csync_ctx) < 0 ) {
handleSyncError(_csync_ctx, "csync_reconcile");
return;
}
_stopWatch.addLapTime(QLatin1String("Reconcile Finished"));
_progressInfo = Progress::Info();
_hasNoneFiles = false;
_hasRemoveFile = false;
bool walkOk = true;
_seenFiles.clear();
if( csync_walk_local_tree(_csync_ctx, &treewalkLocal, 0) < 0 ) {
qDebug() << "Error in local treewalk.";
walkOk = false;
}
if( walkOk && csync_walk_remote_tree(_csync_ctx, &treewalkRemote, 0) < 0 ) {
qDebug() << "Error in remote treewalk.";
}
// The map was used for merging trees, convert it to a list:
_syncedItems = _syncItemMap.values().toVector();
// Adjust the paths for the renames.
for (SyncFileItemVector::iterator it = _syncedItems.begin();
it != _syncedItems.end(); ++it) {
it->_file = adjustRenamedPath(it->_file);
}
// Sort items per destination
std::sort(_syncedItems.begin(), _syncedItems.end());
// make sure everything is allowed
checkForPermission();
// To announce the beginning of the sync
emit aboutToPropagate(_syncedItems);
_progressInfo._completedFileCount = ULLONG_MAX; // indicate the start with max
emit transmissionProgress(_progressInfo);
_progressInfo._completedFileCount = 0;
if (!_hasNoneFiles && _hasRemoveFile) {
qDebug() << Q_FUNC_INFO << "All the files are going to be changed, asking the user";
bool cancel = false;
emit aboutToRemoveAllFiles(_syncedItems.first()._direction, &cancel);
if (cancel) {
qDebug() << Q_FUNC_INFO << "Abort sync";
finalize();
return;
}
}
if (_needsUpdate)
emit(started());
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);
Q_ASSERT(session);
// post update phase script: allow to tweak stuff by a custom script in debug mode.
if( !qgetenv("OWNCLOUD_POST_UPDATE_SCRIPT").isEmpty() ) {
#ifndef NDEBUG
QString script = qgetenv("OWNCLOUD_POST_UPDATE_SCRIPT");
qDebug() << "OOO => Post Update Script: " << script;
QProcess::execute(script.toUtf8());
#else
qDebug() << "**** Attention: POST_UPDATE_SCRIPT installed, but not executed because compiled with NDEBUG";
#endif
}
// do a database commit
_journal->commit("post treewalk");
_propagator.reset(new OwncloudPropagator (session, _localPath, _remoteUrl, _remotePath,
_journal, &_thread));
connect(_propagator.data(), SIGNAL(completed(SyncFileItem)),
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)));
connect(_propagator.data(), SIGNAL(finished()), this, SLOT(slotFinished()), Qt::QueuedConnection);
// apply the network limits to the propagator
setNetworkLimits(_uploadLimit, _downloadLimit);
deleteStaleDownloadInfos();
deleteStaleUploadInfos();
deleteStaleBlacklistEntries();
_journal->commit("post stale entry removal");
_propagator->start(_syncedItems);
}
void CSyncThread::startSync()
{
if (!_syncMutex.tryLock()) {
qDebug() << Q_FUNC_INFO << "WARNING: Another sync seems to be running. Not starting a new one.";
return;
}
if( ! _csync_ctx ) {
qDebug() << "XXXXXXXXXXXXXXXX FAIL: do not have csync_ctx!";
}
qDebug() << Q_FUNC_INFO << "Sync started";
qDebug() << "starting to sync " << qApp->thread() << QThread::currentThread();
_syncedItems.clear();
_needsUpdate = false;
_abortRequestedMutex.lock();
if (!_abortRequested.fetchAndAddRelease(0)) {
csync_resume(_csync_ctx);
}
_abortRequestedMutex.unlock();
// maybe move this somewhere else where it can influence a running sync?
MirallConfigFile cfg;
if (!_journal->exists()) {
qDebug() << "=====sync looks new (no DB exists), activating recursive PROPFIND if csync supports it";
bool no_recursive_propfind = false;
csync_set_module_property(_csync_ctx, "no_recursive_propfind", &no_recursive_propfind);
} else {
// retrieve the file count from the db and close it afterwards because
// csync_update also opens the database.
int fileRecordCount = 0;
fileRecordCount = _journal->getFileRecordCount();
_journal->close();
if( fileRecordCount == -1 ) {
qDebug() << "No way to create a sync journal!";
emit csyncError(tr("Unable to initialize a sync journal."));
csync_commit(_csync_ctx);
emit finished();
_syncMutex.unlock();
thread()->quit();
return;
// database creation error!
} else if ( fileRecordCount < 50 ) {
qDebug() << "=====sync DB has only" << fileRecordCount << "items, enable recursive PROPFIND if csync supports it";
bool no_recursive_propfind = false;
csync_set_module_property(_csync_ctx, "no_recursive_propfind", &no_recursive_propfind);
} else {
qDebug() << "=====sync with existing DB";
}
}
csync_set_module_property(_csync_ctx, "csync_context", _csync_ctx);
csync_set_userdata(_csync_ctx, this);
// TODO: This should be a part of this method, but we don't have
// any way to get "session_key" module property from csync. Had we
// have it, then we could keep this code and remove it from
// AbstractCredentials implementations.
if (Account *account = AccountManager::instance()->account()) {
account->credentials()->syncContextPreStart(_csync_ctx);
} else {
qDebug() << Q_FUNC_INFO << "No default Account object, huh?";
}
// if (_lastAuthCookies.length() > 0) {
// // Stuff cookies inside csync, then we can avoid the intermediate HTTP 401 reply
// // when https://github.com/owncloud/core/pull/4042 is merged.
// QString cookiesAsString;
// foreach(QNetworkCookie c, _lastAuthCookies) {
// cookiesAsString += c.name();
// cookiesAsString += '=';
// cookiesAsString += c.value();
// cookiesAsString += "; ";
// }
// csync_set_module_property(_csync_ctx, "session_key", cookiesAsString.to
// }
// csync_set_auth_callback( _csync_ctx, getauth );
csync_set_log_callback( csyncLogCatcher );
csync_set_log_level( 11 );
_syncTime.start();
QElapsedTimer updateTime;
updateTime.start();
qDebug() << "#### Update start #################################################### >>";
if( csync_update(_csync_ctx) < 0 ) {
handleSyncError(_csync_ctx, "csync_update");
return;
}
qDebug() << "<<#### Update end #################################################### " << updateTime.elapsed();
if( csync_reconcile(_csync_ctx) < 0 ) {
handleSyncError(_csync_ctx, "csync_reconcile");
return;
}
slotProgress(Progress::StartSync, SyncFileItem(), 0, 0);
_progressInfo = Progress::Info();
_hasFiles = false;
bool walkOk = true;
_seenFiles.clear();
if( csync_walk_local_tree(_csync_ctx, &treewalkLocal, 0) < 0 ) {
qDebug() << "Error in local treewalk.";
walkOk = false;
}
if( walkOk && csync_walk_remote_tree(_csync_ctx, &treewalkRemote, 0) < 0 ) {
qDebug() << "Error in remote treewalk.";
}
// Adjust the paths for the renames.
for (SyncFileItemVector::iterator it = _syncedItems.begin();
it != _syncedItems.end(); ++it) {
it->_file = adjustRenamedPath(it->_file);
}
if (!_hasFiles && !_syncedItems.isEmpty()) {
qDebug() << Q_FUNC_INFO << "All the files are going to be removed, asking the user";
bool cancel = false;
emit aboutToRemoveAllFiles(_syncedItems.first()._dir, &cancel);
if (cancel) {
qDebug() << Q_FUNC_INFO << "Abort sync";
return;
}
}
if (_needsUpdate)
emit(started());
ne_session_s *session = 0;
// that call to set property actually is a get which will return the session
// FIXME add a csync_get_module_property to csync
csync_set_module_property(_csync_ctx, "get_dav_session", &session);
Q_ASSERT(session);
_propagator.reset(new OwncloudPropagator (session, _localPath, _remotePath,
_journal, &_abortRequested));
connect(_propagator.data(), SIGNAL(completed(SyncFileItem)),
this, SLOT(transferCompleted(SyncFileItem)), Qt::QueuedConnection);
connect(_propagator.data(), SIGNAL(progress(Progress::Kind,SyncFileItem,quint64,quint64)),
this, SLOT(slotProgress(Progress::Kind,SyncFileItem,quint64,quint64)));
connect(_propagator.data(), SIGNAL(progressChanged(qint64)), this, SLOT(slotProgressChanged(qint64)));
connect(_propagator.data(), SIGNAL(finished()), this, SLOT(slotFinished()));
int downloadLimit = 0;
if (cfg.useDownloadLimit()) {
downloadLimit = cfg.downloadLimit() * 1000;
}
_propagator->_downloadLimit = downloadLimit;
int uploadLimit = -75; // 75%
int useUpLimit = cfg.useUploadLimit();
if ( useUpLimit >= 1) {
uploadLimit = cfg.uploadLimit() * 1000;
} else if (useUpLimit == 0) {
uploadLimit = 0;
}
_propagator->_uploadLimit = uploadLimit;
_propagator->start(_syncedItems);
}
int CSyncThread::treewalkFile( TREE_WALK_FILE *file, bool remote )
{
if( ! file ) return -1;
SyncFileItem item;
item._file = QString::fromUtf8( file->path );
item._originalFile = item._file;
item._instruction = file->instruction;
item._dir = SyncFileItem::None;
item._fileId = QString::fromUtf8(file->file_id);
// record the seen files to be able to clean the journal later
_seenFiles[item._file] = QString();
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;
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;
default:
Q_ASSERT("Non handled error-status");
/* No error string */
}
item._isDirectory = file->type == CSYNC_FTW_TYPE_DIR;
item._modtime = file->modtime;
item._etag = file->etag;
item._size = file->size;
item._should_update_etag = file->should_update_etag;
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;
}
SyncFileItem::Direction dir;
int re = 0;
switch(file->instruction) {
case CSYNC_INSTRUCTION_NONE:
break;
case CSYNC_INSTRUCTION_NEW:
case CSYNC_INSTRUCTION_SYNC:
case CSYNC_INSTRUCTION_CONFLICT:
case CSYNC_INSTRUCTION_RENAME:
case CSYNC_INSTRUCTION_REMOVE:
_progressInfo.overall_file_count++;
_progressInfo.overall_transmission_size += file->size;
//fall trough
default:
_needsUpdate = true;
}
switch(file->instruction) {
case CSYNC_INSTRUCTION_UPDATED:
// We need to update the database.
_journal->setFileRecord(SyncJournalFileRecord(item, _localPath + item._file));
item._instruction = CSYNC_INSTRUCTION_NONE;
// fall trough
case CSYNC_INSTRUCTION_NONE:
if (item._isDirectory && remote) {
// Because we want still to update etags of directories
dir = SyncFileItem::None;
} else {
// No need to do anything.
_hasFiles = true;
return re;
}
break;
case CSYNC_INSTRUCTION_RENAME:
dir = !remote ? SyncFileItem::Down : SyncFileItem::Up;
item._renameTarget = QString::fromUtf8( file->rename_path );
if (item._isDirectory)
_renamedFolders.insert(item._file, item._renameTarget);
break;
case CSYNC_INSTRUCTION_REMOVE:
dir = !remote ? SyncFileItem::Down : SyncFileItem::Up;
break;
case CSYNC_INSTRUCTION_CONFLICT:
case CSYNC_INSTRUCTION_IGNORE:
case CSYNC_INSTRUCTION_ERROR:
//
slotProgress(Progress::SoftError, item, 0, 0);
dir = SyncFileItem::None;
break;
case CSYNC_INSTRUCTION_EVAL:
case CSYNC_INSTRUCTION_NEW:
case CSYNC_INSTRUCTION_SYNC:
case CSYNC_INSTRUCTION_STAT_ERROR:
case CSYNC_INSTRUCTION_DELETED:
default:
dir = remote ? SyncFileItem::Down : SyncFileItem::Up;
break;
}
item._dir = dir;
// check for blacklisting of this item.
// if the item is on blacklist, the instruction was set to IGNORE
checkBlacklisting( &item );
if (file->instruction != CSYNC_INSTRUCTION_IGNORE
&& file->instruction != CSYNC_INSTRUCTION_REMOVE) {
_hasFiles = true;
}
_syncedItems.append(item);
return re;
}
QssEditor::QssEditor(QWidget *parent) :
QWidget(parent),
ui(new Ui::QssEditor),
m_changed(false)
{
ui->setupUi(this);
// some default values
QHash<QString, QVariant> defaultValues;
defaultValues.insert(SETTING_PREVIEW_DELAY, 750);
Settings::instance()->addDefaultValues(defaultValues);
resetWindowTitle();
// icons
ui->toolOpen->setIcon(QIcon::fromTheme("document-open", QIcon(":/images/open.png")));
ui->toolSave->setIcon(QIcon::fromTheme("document-save", QIcon(":/images/save.png")));
ui->toolSaveAs->setIcon(QIcon::fromTheme("document-save-as", QIcon(":/images/saveas.png")));
ui->toolClose->setIcon(QIcon::fromTheme("window-close", QIcon(":/images/close.png")));
ui->toolUndo->setIcon(QIcon::fromTheme("edit-undo", QIcon(":/images/undo.png")));
ui->toolRedo->setIcon(QIcon::fromTheme("edit-redo", QIcon(":/images/redo.png")));
ui->toolOptions->setIcon(QIcon::fromTheme("preferences-system", QIcon(":/images/options.png")));
// application shortcuts
new QShortcut(QKeySequence::Quit, this, SLOT(slotQuit()));
new QShortcut(QKeySequence::Find, this, SLOT(slotFind()));
new QShortcut(QKeySequence::FindNext, this, SLOT(slotFindNext()));
new QShortcut(QKeySequence::HelpContents, this, SLOT(slotAbout()));
// shortcuts
ui->toolOpen->setShortcut(QKeySequence::Open);
ui->toolSave->setShortcut(QKeySequence::Save);
ui->toolSaveAs->setShortcut(QKeySequence::SaveAs);
ui->toolClose->setShortcut(QKeySequence::Close);
// built-in Qt icon
ui->toolAboutQt->setIcon(QIcon(
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
":/qt-project.org/qmessagebox/images/qtlogo-64.png"
#else
":/trolltech/qmessagebox/images/qtlogo-64.png"
#endif
));
// menu for toolbutton
QMenu *toolButtonMenu = new QMenu(this);
toolButtonMenu->addAction("Item1");
toolButtonMenu->addSeparator();
toolButtonMenu->addAction("Item2");
ui->toolButton->setMenu(toolButtonMenu);
m_timerDelayedApply = new QTimer(this);
m_timerDelayedApply->setSingleShot(true);
connect(m_timerDelayedApply, SIGNAL(timeout()), this, SLOT(slotApplyCss()));
resetPreviewDelay();
QTimer *timerProgress = new QTimer(this);
timerProgress->setInterval(500);
connect(timerProgress, SIGNAL(timeout()), this, SLOT(slotProgress()));
timerProgress->start();
ui->splitter->setCollapsible(0, false);
ui->splitter->setStretchFactor(0, 1);
// splitter size
QList<int> list = QList<int>() << width()/2 << width()/2;
ui->splitter->setSizes(list);
// some MDI windows
QMdiSubWindow *mdi = ui->mdiArea->addSubWindow(new QLabel("MDI", ui->mdiArea));
mdi->resize(160, 80);
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
ui->tree->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
ui->table->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
#else
ui->tree->header()->setResizeMode(QHeaderView::ResizeToContents);
ui->table->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
#endif
ui->tree->topLevelItem(0)->setExpanded(true);
ui->text->setCaretLineVisible(true);
ui->text->setCaretLineBackgroundColor(QColor("gainsboro"));
ui->text->setAutoIndent(true);
ui->text->setIndentationGuides(false);
ui->text->setIndentationsUseTabs(true);
ui->text->setIndentationWidth(4);
ui->text->setMarginsBackgroundColor(QColor("gainsboro"));
ui->text->setMarginLineNumbers(1, true);
ui->text->setMarginWidth(1, 50);
ui->text->setAutoCompletionSource(QsciScintilla::AcsAll);
ui->text->setAutoCompletionReplaceWord(true);
ui->text->setAutoCompletionCaseSensitivity(false);
ui->text->setAutoCompletionUseSingle(QsciScintilla::AcusAlways);
ui->text->setAutoCompletionThreshold(0);
ui->text->setBraceMatching(QsciScintilla::SloppyBraceMatch);
ui->text->setMatchedBraceBackgroundColor(Qt::yellow);
ui->text->setUnmatchedBraceForegroundColor(Qt::blue);
// QSS lexer
QsciLexerQSS *lexQss = new QsciLexerQSS(this);
ui->text->setLexer(lexQss);
ui->text->setFocus();
ui->text->installEventFilter(this);
restoreLastFiles();
QTimer::singleShot(0, this, SLOT(slotDelayedOpen()));
}
