bool Folder::init() { QString url = Utility::toCSyncScheme(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); setIgnoredFiles(); cfgFile.getCredentials()->syncContextPreInit(_csync_ctx); 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; } } return _csync_ctx; }
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; }
static void setup_local(void **state) { (void) state; /* unused */ assert_int_equal(system("mkdir -p /tmp/check_csync1"), 0); assert_int_equal(system("mkdir -p /tmp/check_csync2"), 0); assert_int_equal(system("mkdir -p /tmp/check_csync"), 0); assert_int_equal(system("echo \"This is test data\" > /tmp/check_csync1/testfile1.txt"), 0); assert_int_equal(system("echo \"This is also test data\" > /tmp/check_csync1/testfile2.txt"), 0); assert_int_equal(csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2"), 0); assert_int_equal(csync_set_config_dir(csync, "/tmp/check_csync/"), 0); assert_int_equal(csync_init(csync), 0); file_count = 0; printf("********** setting up local!\n"); }
static void setup_remote(void **state) { (void) state; /* unused */ assert_int_equal(system("mkdir -p /tmp/check_csync1"), 0); assert_int_equal(system("mkdir -p /tmp/check_csync2"), 0); assert_int_equal(system("echo \"This is test data\" > /tmp/check_csync1/testfile1.txt"), 0); assert_int_equal(system("echo \"This is also test data\" > /tmp/check_csync1/testfile2.txt"), 0); assert_int_equal(csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2"), 0); assert_int_equal(csync_set_config_dir(csync, "/tmp/check_csync/"), 0); assert_int_equal(csync_init(csync), 0); assert_int_equal(csync_update(csync), 0); assert_int_equal(csync_reconcile(csync), 0); assert_int_equal(csync_propagate(csync), 0); file_count = 0; }
static void setup(void **state) { CSYNC *csync; int rc; rc = system("rm -rf /tmp/check_csync1"); assert_int_equal(rc, 0); rc = system("mkdir -p /tmp/check_csync1"); assert_int_equal(rc, 0); rc = csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2"); assert_int_equal(rc, 0); csync_set_config_dir(csync, "/tmp/check_csync1/"); csync->statedb.file = c_strdup( TESTDB ); *state = csync; }
static void setup_module(void **state) { CSYNC *csync; int rc; rc = system("mkdir -p /tmp/check_csync1"); assert_int_equal(rc, 0); rc = system("mkdir -p /tmp/check_csync2"); assert_int_equal(rc, 0); rc = csync_create(&csync, "/tmp/check_csync1", "dummy://foo/bar"); assert_int_equal(rc, 0); rc = csync_set_config_dir(csync, "/tmp/check_csync"); assert_int_equal(rc, 0); *state = csync; }
static void setup_ftw(void **state) { CSYNC *csync; int rc; rc = system("mkdir -p /tmp/check_csync"); assert_int_equal(rc, 0); rc = system("mkdir -p /tmp/check_csync1"); assert_int_equal(rc, 0); rc = system("mkdir -p /tmp/check_csync2"); assert_int_equal(rc, 0); rc = csync_create(&csync, "/tmp", "/tmp"); assert_int_equal(rc, 0); rc = csync_set_config_dir(csync, "/tmp/check_csync"); assert_int_equal(rc, 0); rc = csync_init(csync); assert_int_equal(rc, 0); *state = csync; }
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); } } }