void AutoUpdateManager::onFileChanged(const QString& local_path)
{
qDebug("[AutoUpdateManager] detected cache file %s changed", local_path.toUtf8().data());
if (!watch_infos_.contains(local_path)) {
// filter unwanted events
return;
}
WatchedFileInfo &info = watch_infos_[local_path];
QFileInfo finfo(local_path);
// Download the doc file in the mac will automatically upload
// If the timestamp has not changed, it will not be uploaded
qint64 mtime = finfo.lastModified().toMSecsSinceEpoch();
if (mtime == info.mtime) {
qDebug("[AutoUpdateManager] Received a file %s upload notification, but the timestamp has not changed, "
"it will not upload", local_path.toUtf8().data());
return;
}
#ifdef Q_OS_MAC
if (MacImageFilesWorkAround::instance()->isRecentOpenedImage(local_path)) {
qDebug("[AutoUpdateManager] skip the image file updates on mac for %s", toCStr(local_path));
return;
}
#endif
removePath(&watcher_, local_path);
QString repo_id, path_in_repo;
if (!finfo.exists()) {
qDebug("[AutoUpdateManager] detected cache file %s renamed or removed", local_path.toUtf8().data());
WatchedFileInfo deferred_info = info;
removeWatch(local_path);
// Some application would deleted and recreate the file when saving.
// We work around that by double checking whether the file gets
// recreated after a short period
QTimer::singleShot(5000, this, SLOT(checkFileRecreated()));
deleted_files_infos_.enqueue(deferred_info);
return;
}
uploadFile(local_path);
}
int SeafileRpcClient::removeCloneTask(const QString& repo_id, QString *err)
{
GError *error = NULL;
int ret = searpc_client_call__int (seafile_rpc_client_,
"seafile_remove_clone_task",
&error, 1,
"string", toCStr(repo_id));
if (ret < 0) {
if (err) {
*err = error ? error->message : tr("Unknown error");
}
if (error) {
g_error_free(error);
}
}
return ret;
}
int delete_dir_recursively(const QString& path_in)
{
qWarning ("removing folder %s\n", toCStr(path_in));
#if defined(Q_OS_WIN32)
const QString path = QDir::toNativeSeparators(QDir::cleanPath(path_in));
if (path.length() <= 3) {
// avoid errornous delete drives like C:/ D:/ E:/
return -1;
}
int len = path.length();
wchar_t *wpath = new wchar_t[len + 2];
wcscpy(wpath, path.toStdWString().c_str());
wpath[len + 1] = L'\0';
SHFILEOPSTRUCTW fileop;
fileop.hwnd = NULL; // no status display
fileop.wFunc = FO_DELETE; // delete operation
fileop.pFrom = wpath; // source file name as double null terminated string
fileop.pTo = NULL; // no destination needed
fileop.fFlags = FOF_NOCONFIRMATION|FOF_SILENT; // do not prompt the user
fileop.fAnyOperationsAborted = FALSE;
fileop.lpszProgressTitle = NULL;
fileop.hNameMappings = NULL;
int ret = SHFileOperationW(&fileop);
delete []wpath;
if (ret == 0) {
return 0;
} else {
return -1;
}
return 0;
#else
return posix_rmdir(path_in);
#endif
}
void SeafileApplet::start()
{
refreshQss();
configurator_->checkInit();
initLog();
account_mgr_->start();
#if defined(Q_WS_WIN)
QString crash_rpt_path = QDir(configurator_->ccnetDir()).filePath("logs/seafile-crash-report.txt");
if (!g_setenv ("CRASH_RPT_PATH", toCStr(crash_rpt_path), FALSE))
qDebug("Failed to set CRASH_RPT_PATH env variable.\n");
#endif
daemon_mgr_->startCcnetDaemon();
connect(daemon_mgr_, SIGNAL(daemonStarted()),
this, SLOT(onDaemonStarted()));
}
void SeafileApiClient::httpRequestFinished()
{
int code = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (code == 0 && reply_->error() != QNetworkReply::NoError) {
if (NetworkManager::instance()->shouldRetry(reply_->error())) {
qWarning("[api] network proxy error, retrying\n");
resendRequest(reply_->url());
return;
}
if (!shouldIgnoreRequestError(reply_)) {
qWarning("[api] network error for %s: %s\n", toCStr(reply_->url().toString()),
reply_->errorString().toUtf8().data());
}
emit networkError(reply_->error(), reply_->errorString());
return;
}
if (handleHttpRedirect()) {
return;
}
if ((code / 100) == 4 || (code / 100) == 5) {
if (!shouldIgnoreRequestError(reply_)) {
QByteArray content = reply_->readAll();
qWarning("request failed for %s: %s\n",
reply_->url().toString().toUtf8().data(),
content.left(kMaxHttpErrorLogLen).data());
if (content.length() > kMaxHttpErrorLogLen) {
qDebug("request failed for %s: %s\n",
reply_->url().toString().toUtf8().data(),
content.data());
}
}
emit requestFailed(code);
return;
}
emit requestSuccess(*reply_);
}
void do_stop()
{
CcnetClient *sync_client = ccnet_client_new();
const QString ccnet_dir = defaultCcnetDir();
if (ccnet_client_load_confdir(sync_client, NULL, toCStr(ccnet_dir)) < 0) {
return;
}
if (ccnet_client_connect_daemon(sync_client, CCNET_CLIENT_SYNC) < 0) {
return;
}
CcnetMessage *quit_message;
quit_message = ccnet_message_new (sync_client->base.id,
sync_client->base.id,
kAppletCommandsMQ, "quit", 0);
ccnet_client_send_message(sync_client, quit_message);
ccnet_message_free(quit_message);
g_object_unref (sync_client);
}
void SeafileRpcClient::getTransferDetail(CloneTask* task)
{
GError *error = NULL;
GObject *obj = searpc_client_call__object(
seafile_rpc_client_,
"seafile_find_transfer_task",
SEAFILE_TYPE_TASK,
&error, 1,
"string", toCStr(task->repo_id));
if (error != NULL) {
g_error_free(error);
return;
}
if (obj == NULL) {
return;
}
if (task->state == "error") {
char *err = NULL;
g_object_get(obj, "error_str", &err, NULL);
task->error_str = err;
} else {
int block_done = 0;
int block_total = 0;
g_object_get (obj,
"block_done", &block_done,
"block_total", &block_total,
NULL);
task->block_done = block_done;
task->block_total = block_total;
}
g_object_unref (obj);
}
int AccountManager::saveAccount(const Account& account)
{
for (size_t i = 0; i < accounts_.size(); i++) {
if (accounts_[i].serverUrl == account.serverUrl
&& accounts_[i].username == account.username) {
accounts_.erase(accounts_.begin() + i);
break;
}
}
accounts_.insert(accounts_.begin(), account);
QString url = account.serverUrl.toEncoded().data();
qint64 timestamp = QDateTime::currentMSecsSinceEpoch();
QString sql = "REPLACE INTO Accounts VALUES ('%1', '%2', '%3', %4) ";
sql = sql.arg(url).arg(account.username).arg(account.token).arg(QString::number(timestamp));
sqlite_query_exec (db, toCStr(sql));
emit accountsChanged();
return 0;
}
void GetLatestVersionRequest::requestSuccess(QNetworkReply& reply)
{
json_error_t error;
json_t *root = parseJSON(reply, &error);
if (!root) {
qDebug("GetLatestVersionRequest: failed to parse json:%s\n", error.text);
emit failed(ApiError::fromJsonError());
return;
}
QScopedPointer<json_t, JsonPointerCustomDeleter> json(root);
QMap<QString, QVariant> dict = mapFromJSON(json.data(), &error);
if (dict.contains(kOsName)) {
QString version = dict.value(kOsName).toString();
qDebug("The latest version is %s", toCStr(version));
emit success(version);
return;
}
emit failed(ApiError::fromJsonError());
}
int AccountManager::replaceAccount(const Account& old_account, const Account& new_account)
{
int i = 0;
for (i = 0; i < accounts_.size(); i++) {
if (accounts_[i].serverUrl == old_account.serverUrl
&& accounts_[i].username == old_account.username) {
accounts_.erase(accounts_.begin() + i);
break;
}
}
accounts_.insert(accounts_.begin(), new_account);
QString old_url = old_account.serverUrl.toEncoded().data();
QString new_url = new_account.serverUrl.toEncoded().data();
qint64 timestamp = QDateTime::currentMSecsSinceEpoch();
QString sql =
"UPDATE Accounts "
"SET url = '%1', "
" username = '******', "
" token = '%3', "
" lastVisited = '%4' "
"WHERE url = '%5' "
" AND username = '******'";
sql = sql.arg(new_url).arg(new_account.username). \
arg(new_account.token).arg(QString::number(timestamp)) \
.arg(old_url);
sqlite_query_exec (db, toCStr(sql));
emit accountsChanged();
return 0;
}
void SeafileRpcClient::getSyncStatus(LocalRepo &repo)
{
if (repo.worktree_invalid) {
repo.setSyncInfo("error", "invalid worktree");
return;
}
GError *error = NULL;
SeafileSyncTask *task = (SeafileSyncTask *)
searpc_client_call__object (seafile_rpc_client_,
"seafile_get_repo_sync_task",
SEAFILE_TYPE_SYNC_TASK,
&error, 1,
"string", toCStr(repo.id));
if (error) {
repo.setSyncInfo("unknown");
g_error_free(error);
return;
}
if (!task) {
repo.setSyncInfo("waiting for sync");
return;
}
char *state = NULL;
char *err = NULL;
g_object_get(task, "state", &state, "error", &err, NULL);
repo.setSyncInfo(state,
g_strcmp0(state, "error") == 0 ? err : NULL);
g_free (state);
g_free (err);
g_object_unref(task);
}
int SeafileRpcClient::getLocalRepo(const QString& repo_id, LocalRepo *repo)
{
GError *error = NULL;
GObject *obj = searpc_client_call__object(
seafile_rpc_client_,
"seafile_get_repo",
SEAFILE_TYPE_REPO,
&error, 1,
"string", toCStr(repo_id));
if (error != NULL) {
return -1;
}
if (obj == NULL) {
return -1;
}
*repo = LocalRepo::fromGObject(obj);
g_object_unref(obj);
getSyncStatus(*repo);
return 0;
}
int SeafileRpcClient::cloneRepo(const QString& id,
int repo_version, const QString& relayId,
const QString &name, const QString &wt,
const QString &token, const QString &passwd,
const QString &magic, const QString &peerAddr,
const QString &port, const QString &email,
const QString& random_key, int enc_version,
QString *error_ret)
{
GError *error = NULL;
searpc_client_call__string(
seafile_rpc_client_,
"seafile_clone",
&error, 13,
"string", toCStr(id),
"int", repo_version,
"string", toCStr(relayId),
"string", toCStr(name),
"string", toCStr(wt),
"string", toCStr(token),
"string", toCStr(passwd),
"string", toCStr(magic),
"string", toCStr(peerAddr),
"string", toCStr(port),
"string", toCStr(email),
"string", toCStr(random_key),
"int", enc_version);
if (error != NULL) {
if (error_ret) {
*error_ret = error->message;
}
return -1;
}
return 0;
}
int atoi(rostring s)
{
return atoi(toCStr(s));
}
void LocalRepo::translateSyncState(const QString &status)
{
if (status == "synchronized") {
sync_state_str = QObject::tr("synchronized");
sync_state = SYNC_STATE_DONE;
} else if (status == "committing") {
sync_state_str = QObject::tr("indexing files");
sync_state = SYNC_STATE_ING;
has_data_transfer = false;
} else if (status == "initializing") {
sync_state_str = QObject::tr("sync initializing");
sync_state = SYNC_STATE_INIT;
} else if (status == "downloading") {
sync_state_str = QObject::tr("downloading");
sync_state = SYNC_STATE_ING;
has_data_transfer = true;
} else if (status == "uploading") {
sync_state_str = QObject::tr("uploading");
sync_state = SYNC_STATE_ING;
has_data_transfer = true;
} else if (status == "merging") {
sync_state_str = QObject::tr("sync merging");
sync_state = SYNC_STATE_ING;
has_data_transfer = false;
} else if (status == "waiting for sync") {
sync_state_str = QObject::tr("waiting for sync");
sync_state = SYNC_STATE_WAITING;
} else if (status == "relay not connected") {
sync_state_str = QObject::tr("server not connected");
sync_state = SYNC_STATE_WAITING;
} else if (status == "relay authenticating") {
sync_state_str = QObject::tr("server authenticating");
sync_state = SYNC_STATE_WAITING;
} else if (status == "auto sync is turned off") {
sync_state_str = QObject::tr("auto sync is turned off");
sync_state = SYNC_STATE_DISABLED;
} else if (status == "cancel pending") {
sync_state_str = QObject::tr("sync initializing");
sync_state = SYNC_STATE_INIT;
} else {
qWarning("unknown sync status: %s\n", toCStr(status));
sync_state_str = QObject::tr("unknown");
sync_state = SYNC_STATE_UNKNOWN;
}
if (!auto_sync && sync_state != SYNC_STATE_ING) {
sync_state_str = QObject::tr("auto sync is turned off");
sync_state = SYNC_STATE_DISABLED;
return;
}
}
int SeafileRpcClient::downloadRepo(const QString& id,
int repo_version, const QString& relayId,
const QString& name, const QString& wt,
const QString& token, const QString& passwd,
const QString& magic, const QString& peerAddr,
const QString& port, const QString& email,
const QString& random_key, int enc_version,
const QString& more_info,
QString *error_ret)
{
GError *error = NULL;
char *ret = searpc_client_call__string(
seafile_rpc_client_,
"seafile_download",
&error, 14,
"string", toCStr(id),
"int", repo_version,
"string", toCStr(relayId),
"string", toCStr(name),
"string", toCStr(wt),
"string", toCStr(token),
"string", toCStr(passwd),
"string", toCStr(magic),
"string", toCStr(peerAddr),
"string", toCStr(port),
"string", toCStr(email),
"string", toCStr(random_key),
"int", enc_version,
"string", toCStr(more_info));
if (error != NULL) {
if (error_ret) {
*error_ret = error->message;
}
g_error_free(error);
return -1;
}
g_free(ret);
return 0;
}
inline std::string toStr (XMLCh const * xmlCh)
{
return std::string (toCStr (xmlCh).get ());
}
void AutoUpdateManager::onUpdateTaskFinished(bool success)
{
if (system_shut_down_) {
return;
}
FileUploadTask *task = qobject_cast<FileUploadTask *>(sender());
if (task == NULL)
return;
const QString local_path = task->localFilePath();
const QFileInfo finfo = QFileInfo(local_path);
if (!finfo.exists()) {
//TODO: What if the delete&recreate happens just before this function is called?
qWarning("[AutoUpdateManager] file %s not exists anymore", toCStr(local_path));
return;
}
if (!watch_infos_.contains(local_path)) {
qWarning("[AutoUpdateManager] no watch info for file %s", toCStr(local_path));
return;
}
WatchedFileInfo& info = watch_infos_[local_path];
info.uploading = false;
if (success) {
qDebug("[AutoUpdateManager] uploaded new version of file %s", local_path.toUtf8().data());
info.mtime = finfo.lastModified().toMSecsSinceEpoch();
info.fsize = finfo.size();
seafApplet->trayIcon()->showMessage(tr("Upload Success"),
tr("File \"%1\"\nuploaded successfully.").arg(finfo.fileName()),
task->repoId());
// This would also set the "uploading" and "num_upload_errors" column to 0.
FileCache::instance()->saveCachedFileId(task->repoId(),
info.path_in_repo,
task->account().getSignature(),
task->oid(),
task->localFilePath());
emit fileUpdated(task->repoId(), task->path());
} else {
qWarning("[AutoUpdateManager] failed to upload new version of file %s: %s",
toCStr(local_path),
toCStr(task->errorString()));
QString error_msg;
if (task->httpErrorCode() == 403) {
error_msg = tr("Permission Error!");
} else if (task->httpErrorCode() == 401) {
error_msg = tr("Authorization expired");
} else if (task->httpErrorCode() == 441) {
error_msg = tr("File does not exist");
} else {
error_msg = task->errorString();
}
QString name = ::getBaseName(local_path);
DirentsCache::ReturnEntry retval = DirentsCache::instance()->getCachedDirents(info.repo_id, task->path());
QList<SeafDirent> *l = retval.second;
QString msg = tr("File \"%1\"\nfailed to upload.").arg(QFileInfo(local_path).fileName());
if (l != NULL) {
foreach (const SeafDirent dirent, *l) {
if (dirent.name == name) {
if (dirent.is_locked) {
msg = tr("The file is locked by %1, "
"please try again later").arg(dirent.getLockOwnerDisplayString());
}
}
}
}
seafApplet->trayIcon()->showMessage(tr("Upload Failure: %1").arg(error_msg),
msg,
task->repoId());
}
