void Folder::setIgnoredFiles() { MirallConfigFile cfgFile; csync_clear_exclude_list( _csync_ctx ); QString excludeList = cfgFile.excludeFile( MirallConfigFile::SystemScope ); if( !excludeList.isEmpty() ) { qDebug() << "==== added system ignore list to csync:" << excludeList.toUtf8(); csync_add_exclude_list( _csync_ctx, excludeList.toUtf8() ); } excludeList = cfgFile.excludeFile( MirallConfigFile::UserScope ); if( !excludeList.isEmpty() ) { qDebug() << "==== added user defined ignore list to csync:" << excludeList.toUtf8(); csync_add_exclude_list( _csync_ctx, excludeList.toUtf8() ); } }
void IgnoreListEditor::readIgnoreFile(const QString &file, bool readOnly) { MirallConfigFile cfgFile; const QString disabledTip(tr("This entry is provided by the system at '%1' " "and cannot be modified in this view.") .arg(QDir::toNativeSeparators(cfgFile.excludeFile(MirallConfigFile::SystemScope)))); QFile ignores(file); if (ignores.open(QIODevice::ReadOnly)) { while (!ignores.atEnd()) { QString line = QString::fromUtf8(ignores.readLine()); line.chop(1); if (!line.isEmpty() && !line.startsWith("#")) { QListWidgetItem *item = new QListWidgetItem; setupItemFlags(item); if (line.startsWith("]")) { line = line.mid(1); item->setCheckState(Qt::Checked); } item->setText(line); if (readOnly) { item->setFlags(item->flags() ^ Qt::ItemIsEnabled); item->setToolTip(disabledTip); } ui->listWidget->addItem(item); } } } }
bool ownCloudFolder::init() { QString url = replaceScheme(ownCloudInfo::instance()->webdavUrl() + secondPath()); QString localpath = path(); if( csync_create( &_csync_ctx, localpath.toUtf8().data(), url.toUtf8().data() ) < 0 ) { qDebug() << "Unable to create csync-context!"; slotCSyncError(tr("Unable to create csync-context")); _csync_ctx = 0; } else { csync_set_log_callback( _csync_ctx, csyncLogCatcher ); csync_set_log_verbosity(_csync_ctx, 11); MirallConfigFile cfgFile; csync_set_config_dir( _csync_ctx, cfgFile.configPath().toUtf8() ); csync_enable_conflictcopys(_csync_ctx); QString excludeList = cfgFile.excludeFile(); if( !excludeList.isEmpty() ) { qDebug() << "==== added CSync exclude List: " << excludeList.toUtf8(); csync_add_exclude_list( _csync_ctx, excludeList.toUtf8() ); } csync_set_auth_callback( _csync_ctx, getauth ); if( csync_init( _csync_ctx ) < 0 ) { qDebug() << "Could not initialize csync!" << csync_get_error(_csync_ctx) << csync_get_error_string(_csync_ctx); slotCSyncError(CSyncThread::csyncErrorToString(csync_get_error(_csync_ctx), csync_get_error_string(_csync_ctx))); csync_destroy(_csync_ctx); _csync_ctx = 0; } setProxy(); } return _csync_ctx; }
// add a monitor to the local file system. If there is a change in the // file system, the method slotFolderMonitorFired is triggered through // the SignalMapper void FolderMan::registerFolderMonitor( Folder *folder ) { if( !folder ) return; if( !_folderWatchers.contains(folder->alias() ) ) { FolderWatcher *fw = new FolderWatcher(folder->path(), this); MirallConfigFile cfg; fw->addIgnoreListFile( cfg.excludeFile(MirallConfigFile::SystemScope) ); fw->addIgnoreListFile( cfg.excludeFile(MirallConfigFile::UserScope) ); // Connect the folderChanged signal, which comes with the changed path, // to the signal mapper which maps to the folder alias. The changed path // is lost this way, but we do not need it for the current implementation. connect(fw, SIGNAL(folderChanged(QString)), _folderWatcherSignalMapper, SLOT(map())); _folderWatcherSignalMapper->setMapping(fw, folder->alias()); _folderWatchers.insert(folder->alias(), fw); } }
Folder::Folder(const QString &alias, const QString &path, const QString& secondPath, QObject *parent) : QObject(parent) , _path(path) , _secondPath(secondPath) , _alias(alias) , _enabled(true) , _thread(0) , _csync(0) , _csyncError(false) , _csyncUnavail(false) , _csync_ctx(0) { qsrand(QTime::currentTime().msec()); _watcher = new FolderWatcher(path, this); MirallConfigFile cfg; _watcher->addIgnoreListFile( cfg.excludeFile(MirallConfigFile::SystemScope) ); _watcher->addIgnoreListFile( cfg.excludeFile(MirallConfigFile::UserScope) ); QObject::connect(_watcher, SIGNAL(folderChanged(const QStringList &)), SLOT(slotChanged(const QStringList &))); _syncResult.setStatus( SyncResult::NotYetStarted ); ServerActionNotifier *notifier = new ServerActionNotifier(this); connect(notifier, SIGNAL(guiLog(QString,QString)), Logger::instance(), SIGNAL(optionalGuiLog(QString,QString))); connect(this, SIGNAL(syncFinished(SyncResult)), this, SLOT(slotSyncFinished(SyncResult))); connect(this, SIGNAL(syncFinished(SyncResult)), notifier, SLOT(slotSyncFinished(SyncResult))); // check if the local path exists checkLocalPath(); int polltime = cfg.remotePollInterval(); qDebug() << "setting remote poll timer interval to" << polltime << "msec"; _pollTimer.setInterval( polltime ); QObject::connect(&_pollTimer, SIGNAL(timeout()), this, SLOT(slotPollTimerTimeout())); _pollTimer.start(); _syncResult.setFolder(alias); }
IgnoreListEditor::IgnoreListEditor(QWidget *parent) : QDialog(parent), ui(new Ui::IgnoreListEditor) { ui->setupUi(this); ui->descriptionLabel->setText(tr("Files or directories matching a pattern will not be synchronized.\n\n" "Checked items will also be deleted if they prevent a directory from " "being removed. This is useful for meta data.")); MirallConfigFile cfgFile; readIgnoreFile(cfgFile.excludeFile(MirallConfigFile::SystemScope), true); readIgnoreFile(cfgFile.excludeFile(MirallConfigFile::UserScope), false); connect(this, SIGNAL(accepted()), SLOT(slotUpdateLocalIgnoreList())); ui->removePushButton->setEnabled(false); connect(ui->listWidget, SIGNAL(itemSelectionChanged()), SLOT(slotItemSelectionChanged())); connect(ui->listWidget, SIGNAL(itemActivated(QListWidgetItem*)), SLOT(slotItemChanged(QListWidgetItem*))); connect(ui->removePushButton, SIGNAL(clicked()), SLOT(slotRemoveCurrentItem())); connect(ui->addPushButton, SIGNAL(clicked()), SLOT(slotAddPattern())); connect(ui->listWidget, SIGNAL(itemDoubleClicked(QListWidgetItem*)), SLOT(slotEditPattern(QListWidgetItem*))); }
void IgnoreListEditor::slotUpdateLocalIgnoreList() { MirallConfigFile cfgFile; QString ignoreFile = cfgFile.excludeFile(MirallConfigFile::UserScope); QFile ignores(ignoreFile); if (ignores.open(QIODevice::WriteOnly)) { for(int i = 0; i < ui->listWidget->count(); ++i) { QListWidgetItem *item = ui->listWidget->item(i); if (item->flags() & Qt::ItemIsEnabled) { QByteArray prepend; if (item->checkState() == Qt::Checked) { prepend = "]"; } ignores.write(prepend+item->text().toUtf8()+'\n'); } } } else { QMessageBox::warning(this, tr("Could not open file"), tr("Cannot write changes to '%1'.").arg(ignoreFile)); } }
void CSyncThread::startSync() { if (!_syncMutex.tryLock()) { qDebug() << Q_FUNC_INFO << "WARNING: Another sync seems to be running. Not starting a new one."; return; } qDebug() << Q_FUNC_INFO << "Sync started"; qDebug() << "starting to sync " << qApp->thread() << QThread::currentThread(); CSYNC *csync; int proxyPort = _proxy.port(); _mutex.lock(); _syncedItems.clear(); _needsUpdate = false; _mutex.unlock(); if( csync_create(&csync, _source.toUtf8().data(), _target.toUtf8().data()) < 0 ) { emit csyncError( tr("CSync create failed.") ); } csync_set_log_verbosity(csync, 11); MirallConfigFile cfg; csync_set_config_dir( csync, cfg.configPath().toUtf8() ); _mutex.lock(); _csyncConfigDir = cfg.configPath(); _mutex.unlock(); csync_enable_conflictcopys(csync); QString excludeList = cfg.excludeFile(); if( !excludeList.isEmpty() ) { qDebug() << "==== added CSync exclude List: " << excludeList.toUtf8(); csync_add_exclude_list( csync, excludeList.toUtf8() ); } // cleans up behind us and emits finished() to ease error handling CSyncRunScopeHelper helper(csync, this); csync_set_userdata(csync, this); csync_set_log_callback( csync, csyncLogCatcher ); csync_set_auth_callback( csync, getauth ); csync_set_progress_callback( csync, progress ); if( csync_init(csync) < 0 ) { handleSyncError(csync, "csync_init"); return; } // set module properties, mainly the proxy information. // do not use QLatin1String here because that has to be real const char* for C. csync_set_module_property(csync, "csync_context", csync); csync_set_module_property(csync, "proxy_type", (char*) proxyTypeToCStr(_proxy.type()) ); csync_set_module_property(csync, "proxy_host", _proxy.hostName().toUtf8().data() ); csync_set_module_property(csync, "proxy_port", &proxyPort ); csync_set_module_property(csync, "proxy_user", _proxy.user().toUtf8().data() ); csync_set_module_property(csync, "proxy_pwd" , _proxy.password().toUtf8().data() ); qDebug() << "#### Update start #################################################### >>"; if( csync_update(csync) < 0 ) { handleSyncError(csync, "csync_update"); return; } qDebug() << "<<#### Update end ###########################################################"; if( csync_reconcile(csync) < 0 ) { handleSyncError(csync, "cysnc_reconcile"); return; } bool walkOk = true; if( csync_walk_local_tree(csync, &treewalkLocal, 0) < 0 ) { qDebug() << "Error in local treewalk."; walkOk = false; } if( walkOk && csync_walk_remote_tree(csync, &treewalkRemote, 0) < 0 ) { qDebug() << "Error in remote treewalk."; } if (_needsUpdate) emit(started()); if( csync_propagate(csync) < 0 ) { handleSyncError(csync, "cysnc_reconcile"); return; } if( walkOk ) { if( csync_walk_local_tree(csync, &walkFinalize, 0) < 0 || csync_walk_remote_tree( csync, &walkFinalize, 0 ) < 0 ) { qDebug() << "Error in finalize treewalk."; } else { // emit the treewalk results. emit treeWalkResult(_syncedItems); } } qDebug() << Q_FUNC_INFO << "Sync finished"; }
ownCloudFolder::ownCloudFolder(const QString &alias, const QString &mpath, const QString &secondPath, QObject *parent) : Folder(alias, mpath, secondPath, parent) , _thread(0) , _csync(0) , _csyncError(false) , _csyncUnavail(false) , _wipeDb(false) { ServerActionNotifier *notifier = new ServerActionNotifier(this); connect(notifier, SIGNAL(guiLog(QString,QString)), Logger::instance(), SIGNAL(guiLog(QString,QString))); connect(this, SIGNAL(syncFinished(SyncResult)), notifier, SLOT(slotSyncFinished(SyncResult))); qDebug() << "****** ownCloud folder using watcher *******"; // The folder interval is set in the folder parent class. QString url = replaceScheme(secondPath); QString localpath = path(); if( csync_create( &_csync_ctx, localpath.toUtf8().data(), url.toUtf8().data() ) < 0 ) { qDebug() << "Unable to create csync-context!"; _csync_ctx = 0; } else { csync_set_log_callback( _csync_ctx, csyncLogCatcher ); csync_set_log_verbosity(_csync_ctx, 11); MirallConfigFile cfgFile; csync_set_config_dir( _csync_ctx, cfgFile.configPath().toUtf8() ); csync_enable_conflictcopys(_csync_ctx); QString excludeList = cfgFile.excludeFile(); if( !excludeList.isEmpty() ) { qDebug() << "==== added CSync exclude List: " << excludeList.toUtf8(); csync_add_exclude_list( _csync_ctx, excludeList.toUtf8() ); } csync_set_auth_callback( _csync_ctx, getauth ); if( csync_init( _csync_ctx ) < 0 ) { qDebug() << "Could not initialize csync!"; _csync_ctx = 0; } if( _csync_ctx ) { /* Store proxy */ QList<QNetworkProxy> proxies = QNetworkProxyFactory::proxyForQuery(QUrl(cfgFile.ownCloudUrl())); // We set at least one in Application Q_ASSERT(proxies.count() > 0); QNetworkProxy proxy = proxies.first(); int proxyPort = proxy.port(); csync_set_module_property(_csync_ctx, "proxy_type", (char*) proxyTypeToCStr(proxy.type()) ); csync_set_module_property(_csync_ctx, "proxy_host", proxy.hostName().toUtf8().data() ); csync_set_module_property(_csync_ctx, "proxy_port", &proxyPort ); csync_set_module_property(_csync_ctx, "proxy_user", proxy.user().toUtf8().data() ); csync_set_module_property(_csync_ctx, "proxy_pwd" , proxy.password().toUtf8().data() ); csync_set_module_property(_csync_ctx, "csync_context", _csync_ctx); } } }
void CSyncThread::run() { CSYNC *csync; WalkStats *wStats = new WalkStats; QTime walkTime; wStats->sourcePath = 0; wStats->errorType = 0; wStats->eval = 0; wStats->removed = 0; wStats->renamed = 0; wStats->newFiles = 0; wStats->ignores = 0; wStats->sync = 0; wStats->seenFiles = 0; wStats->conflicts = 0; wStats->error = 0; wStats->dirPermErrors = 0; ProxyInfo *proxyInfo = new ProxyInfo; _mutex.lock(); proxyInfo->proxyType = qstrdup( _proxyType.toAscii().constData() ); proxyInfo->proxyHost = qstrdup( _proxyHost.toAscii().constData() ); proxyInfo->proxyPort = qstrdup( _proxyPort.toAscii().constData() ); proxyInfo->proxyUser = qstrdup( _proxyUser.toAscii().constData() ); proxyInfo->proxyPwd = qstrdup( _proxyPwd.toAscii().constData() ); if( csync_create(&csync, _source.toUtf8().data(), _target.toUtf8().data()) < 0 ) { emit csyncError( tr("CSync create failed.") ); } // FIXME: Check if we really need this stringcopy! wStats->sourcePath = qstrdup( _source.toUtf8().constData() ); _csyncConfigDir = QString::fromUtf8( csync_get_config_dir( csync )); _mutex.unlock(); qDebug() << "## CSync Thread local only: " << _localCheckOnly; csync_set_auth_callback( csync, getauth ); csync_enable_conflictcopys(csync); MirallConfigFile cfg; QString excludeList = cfg.excludeFile(); if( !excludeList.isEmpty() ) { qDebug() << "==== added CSync exclude List: " << excludeList.toAscii(); csync_add_exclude_list( csync, excludeList.toAscii() ); } QTime t; t.start(); _mutex.lock(); if( _localCheckOnly ) { csync_set_local_only( csync, true ); } csync_set_userdata(csync, (void*) proxyInfo); _mutex.unlock(); if( csync_init(csync) < 0 ) { CSYNC_ERROR_CODE err = csync_get_error( csync ); QString errStr; switch( err ) { case CSYNC_ERR_LOCK: errStr = tr("CSync failed to create a lock file."); break; case CSYNC_ERR_STATEDB_LOAD: errStr = tr("CSync failed to load the state db."); break; case CSYNC_ERR_TIMESKEW: errStr = tr("The system time on this client is different than the system time on the server. " "Please use a time synchronization service (NTP) on the server and client machines " "so that the times remain the same."); break; case CSYNC_ERR_FILESYSTEM: errStr = tr("CSync could not detect the filesystem type."); break; case CSYNC_ERR_TREE: errStr = tr("CSync got an error while processing internal trees."); break; case CSYNC_ERR_ACCESS_FAILED: errStr = tr("<p>The target directory %1 does not exist.</p><p>Please check the sync setup.</p>").arg(_target); // this is critical. The database has to be removed. emitStateDb(csync); // to make the name of the csync db known. emit wipeDb(); break; case CSYNC_ERR_MODULE: errStr = tr("<p>The ownCloud plugin for csync could not be loaded.<br/>Please verify the installation!</p>"); break; case CSYNC_ERR_LOCAL_CREATE: case CSYNC_ERR_LOCAL_STAT: errStr = tr("The local filesystem can not be written. Please check permissions."); break; case CSYNC_ERR_REMOTE_CREATE: case CSYNC_ERR_REMOTE_STAT: errStr = tr("A remote file can not be written. Please check the remote access."); break; default: errStr = tr("An internal error number %1 happend.").arg( (int) err ); } qDebug() << " #### ERROR String emitted: " << errStr; emit csyncError(errStr); goto cleanup; } emitStateDb(csync); qDebug() << "#### Update start #################################################### >>"; if( csync_update(csync) < 0 ) { CSYNC_ERROR_CODE err = csync_get_error( csync ); QString errStr; switch( err ) { case CSYNC_ERR_PROXY: errStr = tr("CSync failed to reach the host. Either host or proxy settings are not valid."); break; default: errStr = tr("CSync Update failed."); break; } emit csyncError( errStr ); goto cleanup; } qDebug() << "<<#### Update end ###########################################################"; csync_set_userdata(csync, wStats); walkTime.start(); if( csync_walk_local_tree(csync, &checkPermissions, 0) < 0 ) { qDebug() << "Error in treewalk."; if( wStats->errorType == WALK_ERROR_WALK ) { emit csyncError(tr("CSync encountered an error while examining the file system.\n" "Syncing is not possible.")); } else if( wStats->errorType == WALK_ERROR_INSTRUCTIONS ) { emit csyncError(tr("CSync update generated a strange instruction.\n" "Please write a bug report.")); } emit csyncError(tr("Local filesystem problems. Better disable Syncing and check.")); goto cleanup; } else { // only warn, do not stop the sync process. if( wStats->errorType == WALK_ERROR_DIR_PERMS ) { emit csyncError(tr("The local filesystem has %1 write protected directories." "That can hinder successful syncing.<p/>" "Please make sure that all local directories are writeable.").arg(wStats->dirPermErrors)); } } // emit the treewalk results. Do not touch the wStats after this. emit treeWalkResult(wStats); _mutex.lock(); if( _localCheckOnly ) { _mutex.unlock(); qDebug() << " ..... Local only walk finished: " << walkTime.elapsed(); // we have to go out here as its local check only. goto cleanup; } else { _mutex.unlock(); // check if we can write all over. if( csync_reconcile(csync) < 0 ) { emit csyncError(tr("CSync reconcile failed.")); goto cleanup; } if( csync_propagate(csync) < 0 ) { emit csyncError(tr("CSync propagate failed.")); goto cleanup; } } cleanup: csync_destroy(csync); if( proxyInfo->proxyType ) free( proxyInfo->proxyType ); if( proxyInfo->proxyHost ) free( proxyInfo->proxyHost ); if( proxyInfo->proxyPort ) free( proxyInfo->proxyPort ); if( proxyInfo->proxyUser ) free( proxyInfo->proxyUser ); if( proxyInfo->proxyPwd ) free( proxyInfo->proxyPwd ); free( proxyInfo ); /* * Attention: do not delete the wStat memory here. it is deleted in the * slot catching the signel treeWalkResult because this thread can faster * die than the slot has read out the data. */ qDebug() << "CSync run took " << t.elapsed() << " Milliseconds"; }
void CSyncThread::run() { CSYNC *csync; WalkStats *wStats = new WalkStats; QTime walkTime; wStats->sourcePath = 0; wStats->errorType = 0; wStats->eval = 0; wStats->removed = 0; wStats->renamed = 0; wStats->newFiles = 0; wStats->ignores = 0; wStats->sync = 0; wStats->seenFiles = 0; wStats->conflicts = 0; wStats->error = 0; _mutex.lock(); if( csync_create(&csync, _source.toLocal8Bit().data(), _target.toLocal8Bit().data()) < 0 ) { emit csyncError( tr("CSync create failed.") ); } // FIXME: Check if we really need this stringcopy! wStats->sourcePath = qstrdup( _source.toLocal8Bit().constData() ); _mutex.unlock(); qDebug() << "## CSync Thread local only: " << _localCheckOnly; csync_set_auth_callback( csync, getauth ); csync_enable_conflictcopys(csync); MirallConfigFile cfg; QString excludeList = cfg.excludeFile(); if( !excludeList.isEmpty() ) { qDebug() << "==== added CSync exclude List: " << excludeList.toAscii(); csync_add_exclude_list( csync, excludeList.toAscii() ); } QTime t; t.start(); _mutex.lock(); if( _localCheckOnly ) { csync_set_local_only( csync, true ); } _mutex.unlock(); if( csync_init(csync) < 0 ) { CSYNC_ERROR_CODE err = csync_errno(); QString errStr; switch( err ) { case CSYNC_ERR_LOCK: errStr = tr("CSync failed to create a lock file."); break; case CSYNC_ERR_STATEDB_LOAD: errStr = tr("CSync failed to load the state db."); break; case CSYNC_ERR_MODULE: errStr = tr("CSync failed to load the ownCloud module."); break; case CSYNC_ERR_TIMESKEW: errStr = tr("The system time between the local machine and the server differs " "too much. Please use a time syncronization service (ntp) on both machines."); break; case CSYNC_ERR_FILESYSTEM: errStr = tr("CSync could not detect the filesystem type."); break; case CSYNC_ERR_TREE: errStr = tr("CSync got an error while processing internal trees."); break; default: errStr = tr("An internal error number %1 happend.").arg( (int) err ); } qDebug() << " #### ERROR String emitted: " << errStr; emit csyncError(errStr); goto cleanup; } qDebug() << "############################################################### >>"; if( csync_update(csync) < 0 ) { emit csyncError(tr("CSync Update failed.")); goto cleanup; } qDebug() << "<<###############################################################"; csync_set_userdata(csync, wStats); walkTime.start(); if( csync_walk_local_tree(csync, &checkPermissions, 0) < 0 ) { qDebug() << "Error in treewalk."; if( wStats->errorType == WALK_ERROR_DIR_PERMS ) { emit csyncError(tr("The local filesystem has directories which are write protected.\n" "That prevents ownCloud from successful syncing.\n" "Please make sure that all directories are writeable.")); } else if( wStats->errorType == WALK_ERROR_WALK ) { emit csyncError(tr("CSync encountered an error while examining the file system.\n" "Syncing is not possible.")); } else if( wStats->errorType == WALK_ERROR_INSTRUCTIONS ) { emit csyncError(tr("CSync update generated a strange instruction.\n" "Please write a bug report.")); } emit csyncError(tr("Local filesystem problems. Better disable Syncing and check.")); goto cleanup; } qDebug() << " ..... Local walk finished: " << walkTime.elapsed(); // emit the treewalk results. Do not touch the wStats after this. emit treeWalkResult(wStats); _mutex.lock(); if( _localCheckOnly ) { _mutex.unlock(); // we have to go out here as its local check only. goto cleanup; } else { _mutex.unlock(); // check if we can write all over. if( csync_reconcile(csync) < 0 ) { emit csyncError(tr("CSync reconcile failed.")); goto cleanup; } if( csync_propagate(csync) < 0 ) { emit csyncError(tr("CSync propagate failed.")); goto cleanup; } } cleanup: csync_destroy(csync); /* * Attention: do not delete the wStat memory here. it is deleted in the * slot catching the signel treeWalkResult because this thread can faster * die than the slot has read out the data. */ qDebug() << "CSync run took " << t.elapsed() << " Milliseconds"; }