bug fix
This commit is contained in:
asypost committed
1 parent
ae3a25857f
commit
7296b3096a
13 files changed
+467
-206
No files matched your search
+237
-125
@@ -13,30 +13,38 @@
|
||||
#include "util/application_path.hpp"
|
||||
#include "util/string_util.hpp"
|
||||
|
||||
namespace seafile::fs {
|
||||
namespace seafile::fs
|
||||
{
|
||||
using RepoEntry = storage::RepoEntry;
|
||||
using AccountInfo = api::AccountInfo;
|
||||
using RepoInfo = storage::RepoInfo;
|
||||
|
||||
namespace {
|
||||
std::string normalizePath(std::string path) {
|
||||
namespace
|
||||
{
|
||||
std::string normalizePath(std::string path)
|
||||
{
|
||||
std::ranges::replace(path, '\\', '/');
|
||||
while (path.size() > 1 && path.back() == '/') {
|
||||
while (path.size() > 1 && path.back() == '/')
|
||||
{
|
||||
path.pop_back();
|
||||
}
|
||||
return path.empty() ? "/" : path;
|
||||
}
|
||||
|
||||
std::vector<std::string> splitPath(const std::string &path) {
|
||||
std::vector<std::string> splitPath(const std::string& path)
|
||||
{
|
||||
auto parts = shell::util::StringUtil::split(path, "/");
|
||||
std::erase(parts, "");
|
||||
return parts;
|
||||
}
|
||||
|
||||
std::string joinPath(const std::vector<std::string> &parts, const size_t start) {
|
||||
std::string joinPath(const std::vector<std::string>& parts, const size_t start)
|
||||
{
|
||||
std::string result;
|
||||
for (size_t i = start; i < parts.size(); ++i) {
|
||||
if (!result.empty()) {
|
||||
for (size_t i = start; i < parts.size(); ++i)
|
||||
{
|
||||
if (!result.empty())
|
||||
{
|
||||
result += '/';
|
||||
}
|
||||
result += parts[i];
|
||||
@@ -44,18 +52,22 @@ namespace seafile::fs {
|
||||
return result.empty() ? "/" : "/" + result;
|
||||
}
|
||||
|
||||
std::string parentPath(const std::string &path) {
|
||||
if (path == "/") {
|
||||
std::string parentPath(const std::string& path)
|
||||
{
|
||||
if (path == "/")
|
||||
{
|
||||
return "/";
|
||||
}
|
||||
const auto pos = path.find_last_of('/');
|
||||
if (pos == std::string::npos || pos == 0) {
|
||||
if (pos == std::string::npos || pos == 0)
|
||||
{
|
||||
return "/";
|
||||
}
|
||||
return path.substr(0, pos);
|
||||
}
|
||||
|
||||
auto make_storage(const std::string &path) {
|
||||
auto make_storage(const std::string& path)
|
||||
{
|
||||
// clang-format off
|
||||
return sqlite_orm::make_storage(path,
|
||||
sqlite_orm::make_table("account_info",
|
||||
@@ -93,6 +105,7 @@ namespace seafile::fs {
|
||||
sqlite_orm::make_column("magic", &RepoInfo::magic),
|
||||
sqlite_orm::make_column("random_key", &RepoInfo::random_key)
|
||||
),
|
||||
sqlite_orm::make_index("idx_repo_entry_path", &RepoEntry::path),
|
||||
sqlite_orm::make_table("repo_entry",
|
||||
sqlite_orm::make_column("repo_id", &RepoEntry::repo_id),
|
||||
sqlite_orm::make_column("type", &RepoEntry::type),
|
||||
@@ -117,26 +130,33 @@ namespace seafile::fs {
|
||||
}
|
||||
}
|
||||
|
||||
struct SeafileStore::Database {
|
||||
struct SeafileStore::Database
|
||||
{
|
||||
using Storage = decltype(make_storage(""));
|
||||
Storage storage;
|
||||
std::recursive_mutex mutex;
|
||||
std::recursive_mutex mutex;
|
||||
|
||||
explicit Database(const std::string &path)
|
||||
: storage(make_storage(path)) {
|
||||
explicit Database(const std::string& path)
|
||||
: storage(make_storage(path))
|
||||
{
|
||||
storage.pragma.journal_mode(sqlite_orm::journal_mode::WAL);
|
||||
storage.pragma.synchronous(1);
|
||||
}
|
||||
};
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::auth() {
|
||||
tl::expected<void, api::SeafileException> SeafileStore::auth()
|
||||
{
|
||||
const auto auth_info = this->api.auth(this->username, this->password);
|
||||
if (auth_info) {
|
||||
if (auth_info)
|
||||
{
|
||||
return {};
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException(auth_info.error()));
|
||||
}
|
||||
|
||||
SeafileStore::SeafileStore(const std::string &db_path, const std::string &server, const std::string &user,
|
||||
const std::string &password) : api(server) {
|
||||
SeafileStore::SeafileStore(const std::string& db_path, const std::string& server, const std::string& user,
|
||||
const std::string& password) : api(server)
|
||||
{
|
||||
this->database = std::make_unique<Database>(db_path);
|
||||
this->username = user;
|
||||
this->password = password;
|
||||
@@ -144,10 +164,10 @@ namespace seafile::fs {
|
||||
}
|
||||
|
||||
tl::expected<RepoEntry, api::SeafileException> SeafileStore::findRepoEntry(
|
||||
const std::string &repo_id, const std::string &path) {
|
||||
|
||||
const std::string& repo_id, const std::string& path)
|
||||
{
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
auto& storage = this->database->storage;
|
||||
const auto entries = storage.get_all<RepoEntry>(
|
||||
sqlite_orm::where(
|
||||
sqlite_orm::and_(
|
||||
@@ -155,89 +175,109 @@ namespace seafile::fs {
|
||||
sqlite_orm::c(&RepoEntry::path) == path
|
||||
)
|
||||
));
|
||||
if (!entries.empty()) {
|
||||
if (!entries.empty())
|
||||
{
|
||||
return entries.at(0);
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException("entry not exists"));
|
||||
}
|
||||
|
||||
tl::expected<std::string, api::SeafileException> SeafileStore::defaultRepoId() const {
|
||||
const auto repo = this->api.defaultRepo();
|
||||
if (repo) {
|
||||
if (repo->exists) {
|
||||
return repo->repo_id.value();
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException("No default repo"));
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException(repo.error()));
|
||||
}
|
||||
|
||||
tl::expected<bool, api::SeafileException> SeafileStore::checkIsUpdated(const std::string &repo_id) {
|
||||
tl::expected<bool, api::SeafileException> SeafileStore::checkIsUpdated(const std::string& repo_id)
|
||||
{
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
auto& storage = this->database->storage;
|
||||
const auto repos = storage.get_all<RepoInfo>(
|
||||
sqlite_orm::where(
|
||||
sqlite_orm::c(&RepoInfo::id) == repo_id
|
||||
));
|
||||
if (repos.empty()) {
|
||||
if (repos.empty())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
const auto& repo = repos.at(0);
|
||||
const auto &commit_id = repo.head_commit_id;
|
||||
const auto& commit_id = repo.head_commit_id;
|
||||
const auto repo_info = this->api.repoInfo(repo_id);
|
||||
if (repo_info) {
|
||||
if (repo_info)
|
||||
{
|
||||
return repo_info.value().head_commit_id == commit_id;
|
||||
}
|
||||
|
||||
return tl::make_unexpected(repo_info.error());
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::checkAndSync(const std::string &repo_id) {
|
||||
if (!this->checkIsUpdated(repo_id)) {
|
||||
|
||||
try {
|
||||
tl::expected<void, api::SeafileException> SeafileStore::checkAndSync(const std::string& repo_id)
|
||||
{
|
||||
const auto is_updated = this->checkIsUpdated(repo_id);
|
||||
if (!is_updated)
|
||||
{
|
||||
return tl::make_unexpected(is_updated.error());
|
||||
}
|
||||
if (!is_updated.value())
|
||||
{
|
||||
try
|
||||
{
|
||||
{
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
auto& storage = this->database->storage;
|
||||
storage.remove_all<RepoEntry>(sqlite_orm::where(
|
||||
sqlite_orm::c(&RepoEntry::repo_id) == repo_id
|
||||
)
|
||||
);
|
||||
}
|
||||
const auto repo_entries = this->api.repoDir(repo_id, "/");
|
||||
if (!repo_entries) {
|
||||
if (!repo_entries)
|
||||
{
|
||||
return tl::make_unexpected(repo_entries.error());
|
||||
}
|
||||
{
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
for (const auto &repo_entry: *repo_entries) {
|
||||
storage.replace(RepoEntry::from_api_model(repo_id, "/", repo_entry));
|
||||
}
|
||||
auto& storage = this->database->storage;
|
||||
std::vector<RepoEntry> entries;
|
||||
entries.reserve(repo_entries->size());
|
||||
std::transform(repo_entries->begin(), repo_entries->end(), std::back_inserter(entries),
|
||||
[&repo_id](const auto& entry)
|
||||
{
|
||||
return RepoEntry::from_api_model(repo_id, "/", entry);
|
||||
});
|
||||
storage.transaction([&entries,&storage]
|
||||
{
|
||||
storage.replace_range(entries.begin(), entries.end());
|
||||
return true;
|
||||
});
|
||||
}
|
||||
} catch (std::exception &e) {
|
||||
}
|
||||
catch (std::exception& e)
|
||||
{
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::init() {
|
||||
try {
|
||||
tl::expected<void, api::SeafileException> SeafileStore::init()
|
||||
{
|
||||
try
|
||||
{
|
||||
std::lock_guard lock(database->mutex);
|
||||
this->database->storage.sync_schema();
|
||||
} catch (std::exception &e) {
|
||||
}
|
||||
catch (std::exception& e)
|
||||
{
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
if (const auto auth_token = this->auth(); !auth_token) {
|
||||
if (const auto auth_token = this->auth(); !auth_token)
|
||||
{
|
||||
return tl::make_unexpected(auth_token.error());
|
||||
}
|
||||
return this->sync();
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::syncUserInfo() {
|
||||
tl::expected<void, api::SeafileException> SeafileStore::syncUserInfo()
|
||||
{
|
||||
const auto user_info = this->api.accountInfo();
|
||||
if (!user_info) {
|
||||
if (!user_info)
|
||||
{
|
||||
return tl::make_unexpected(user_info.error());
|
||||
}
|
||||
std::lock_guard lock(database->mutex);
|
||||
@@ -245,83 +285,129 @@ namespace seafile::fs {
|
||||
return {};
|
||||
}
|
||||
|
||||
tl::expected<std::vector<RepoInfo>, api::SeafileException> SeafileStore::syncRepos() {
|
||||
tl::expected<std::vector<RepoInfo>, api::SeafileException> SeafileStore::syncRepos()
|
||||
{
|
||||
const auto repos = this->api.repos("mine", "");
|
||||
if (!repos) {
|
||||
if (!repos)
|
||||
{
|
||||
return tl::make_unexpected(repos.error());
|
||||
}
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
auto& storage = this->database->storage;
|
||||
std::vector<RepoInfo> result;
|
||||
result.reserve(repos->size());
|
||||
for (const auto &repo: *repos) {
|
||||
for (const auto& repo : *repos)
|
||||
{
|
||||
const auto storage_repo = RepoInfo::from_api_model(repo);
|
||||
result.push_back(storage_repo);
|
||||
try {
|
||||
try
|
||||
{
|
||||
const auto existings = storage.get_all<RepoInfo>(
|
||||
sqlite_orm::where(sqlite_orm::c(&RepoInfo::id) == storage_repo.id));
|
||||
std::optional<RepoInfo> existing = std::nullopt;
|
||||
if (!existings.empty()) {
|
||||
if (!existings.empty())
|
||||
{
|
||||
existing = existings.at(0);
|
||||
}
|
||||
if (existing && existing->head_commit_id != storage_repo.head_commit_id) {
|
||||
if (existing && existing->head_commit_id != storage_repo.head_commit_id)
|
||||
{
|
||||
storage.remove_all<RepoEntry>(sqlite_orm::where(
|
||||
sqlite_orm::c(&RepoEntry::repo_id) == storage_repo.id));
|
||||
}
|
||||
storage.replace(storage_repo);
|
||||
} catch (std::exception &e) {
|
||||
}
|
||||
catch (std::exception& e)
|
||||
{
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
tl::expected<RepoInfo, api::SeafileException> SeafileStore::findRepoByName(const std::string &name) {
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
try {
|
||||
auto repos = storage.get_all<RepoInfo>(
|
||||
sqlite_orm::where(sqlite_orm::c(&RepoInfo::name) == name));
|
||||
if (!repos.empty()) {
|
||||
return repos.at(0);
|
||||
}
|
||||
if (const auto synced = this->syncRepos(); synced) {
|
||||
tl::expected<RepoInfo, api::SeafileException> SeafileStore::findRepoByName(const std::string& name)
|
||||
{
|
||||
try
|
||||
{
|
||||
std::vector<RepoInfo> repos;
|
||||
{
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto& storage = this->database->storage;
|
||||
repos = storage.get_all<RepoInfo>(
|
||||
sqlite_orm::where(sqlite_orm::c(&RepoInfo::name) == name));
|
||||
if (!repos.empty()) {
|
||||
return repos.at(0);
|
||||
}
|
||||
} else {
|
||||
return tl::make_unexpected(synced.error());
|
||||
}
|
||||
}catch (const std::exception &e) {
|
||||
if (!repos.empty())
|
||||
{
|
||||
return repos.at(0);
|
||||
}
|
||||
// if (const auto synced = this->syncRepos(); synced)
|
||||
// {
|
||||
// std::lock_guard lock(database->mutex);
|
||||
// auto& storage = this->database->storage;
|
||||
// repos = storage.get_all<RepoInfo>(
|
||||
// sqlite_orm::where(sqlite_orm::c(&RepoInfo::name) == name));
|
||||
// if (!repos.empty())
|
||||
// {
|
||||
// return repos.at(0);
|
||||
// }
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// return tl::make_unexpected(synced.error());
|
||||
// }
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException(std::format("repo not found: {}", name)));
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::fetchAndStoreRepoDir(
|
||||
const std::string &repo_id, const std::string &parent_path) {
|
||||
const std::string& repo_id, const std::string& parent_path)
|
||||
{
|
||||
const auto entries = this->api.repoDir(repo_id, parent_path);
|
||||
if (!entries) {
|
||||
if (!entries)
|
||||
{
|
||||
return tl::make_unexpected(entries.error());
|
||||
}
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
try {
|
||||
for (const auto &entry: *entries) {
|
||||
storage.replace(RepoEntry::from_api_model(repo_id, parent_path, entry));
|
||||
}
|
||||
} catch (std::exception &e) {
|
||||
try
|
||||
{
|
||||
std::vector<RepoEntry> repo_entries;
|
||||
repo_entries.reserve(entries->size());
|
||||
std::transform(entries->begin(), entries->end(), std::back_inserter(repo_entries),
|
||||
[&repo_id,&parent_path](const auto& entry)
|
||||
{
|
||||
return RepoEntry::from_api_model(repo_id, parent_path, entry);
|
||||
});
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto& storage = this->database->storage;
|
||||
constexpr std::size_t batch_size = 500;
|
||||
storage.transaction([&]
|
||||
{
|
||||
for (auto it = repo_entries.begin(); it != repo_entries.end();)
|
||||
{
|
||||
auto end = it;
|
||||
std::advance(end, std::min(batch_size,static_cast<std::size_t>(std::distance(it, repo_entries.end()))));
|
||||
|
||||
storage.replace_range(it, end);
|
||||
|
||||
it = end;
|
||||
}
|
||||
return true;
|
||||
});
|
||||
}
|
||||
catch (std::exception& e)
|
||||
{
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::vector<RepoEntry> SeafileStore::queryDirectoryChildren(
|
||||
const std::string &repo_id, const std::string &parent_path) {
|
||||
const std::string& repo_id, const std::string& parent_path)
|
||||
{
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
auto& storage = this->database->storage;
|
||||
const std::string prefix = (parent_path == "/") ? "" : parent_path;
|
||||
const auto all = storage.get_all<RepoEntry>(
|
||||
sqlite_orm::where(
|
||||
@@ -329,10 +415,12 @@ namespace seafile::fs {
|
||||
sqlite_orm::c(&RepoEntry::repo_id) == repo_id,
|
||||
sqlite_orm::like(&RepoEntry::path, prefix + "/%")
|
||||
)
|
||||
));
|
||||
),sqlite_orm::order_by(&RepoEntry::name));
|
||||
std::vector<RepoEntry> children;
|
||||
for (auto &entry: all) {
|
||||
if (const auto rest = entry.path.substr(prefix.size() + 1); rest.find('/') == std::string::npos) {
|
||||
for (auto& entry : all)
|
||||
{
|
||||
if (const auto rest = entry.path.substr(prefix.size() + 1); rest.find('/') == std::string::npos)
|
||||
{
|
||||
children.push_back(entry);
|
||||
}
|
||||
}
|
||||
@@ -340,99 +428,122 @@ namespace seafile::fs {
|
||||
}
|
||||
|
||||
tl::expected<std::variant<RepoInfo, RepoEntry>, api::SeafileException> SeafileStore::pathInfo(
|
||||
const std::string &path) {
|
||||
const std::string& path)
|
||||
{
|
||||
const auto normalized = normalizePath(path);
|
||||
const auto parts = splitPath(normalized);
|
||||
if (parts.empty()) {
|
||||
if (parts.empty())
|
||||
{
|
||||
return tl::make_unexpected(api::SeafileException("pathInfo does not support root path"));
|
||||
}
|
||||
|
||||
const auto &repo_name = parts[0];
|
||||
const auto& repo_name = parts[0];
|
||||
const auto repo = findRepoByName(repo_name);
|
||||
if (!repo) {
|
||||
if (!repo)
|
||||
{
|
||||
return tl::make_unexpected(repo.error());
|
||||
}
|
||||
|
||||
if (parts.size() == 1) {
|
||||
if (parts.size() == 1)
|
||||
{
|
||||
return std::variant<RepoInfo, RepoEntry>(*repo);
|
||||
}
|
||||
|
||||
const auto inner_path = joinPath(parts, 1);
|
||||
auto entry = findRepoEntry(repo->id, inner_path);
|
||||
if (entry) {
|
||||
if (entry)
|
||||
{
|
||||
return std::variant<RepoInfo, RepoEntry>(*entry);
|
||||
}
|
||||
|
||||
const auto parent_path = parentPath(inner_path);
|
||||
if (const auto res = fetchAndStoreRepoDir(repo->id, parent_path); !res) {
|
||||
if (const auto res = fetchAndStoreRepoDir(repo->id, parent_path); !res)
|
||||
{
|
||||
return tl::make_unexpected(res.error());
|
||||
}
|
||||
|
||||
entry = findRepoEntry(repo->id, inner_path);
|
||||
if (entry) {
|
||||
if (entry)
|
||||
{
|
||||
return std::variant<RepoInfo, RepoEntry>(*entry);
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException(std::format("path not found: {}", path)));
|
||||
}
|
||||
|
||||
tl::expected<std::variant<std::vector<RepoInfo>, std::vector<RepoEntry> >, api::SeafileException>
|
||||
SeafileStore::listDir(const std::string &path) {
|
||||
tl::expected<std::variant<std::vector<RepoInfo>, std::vector<RepoEntry>>, api::SeafileException>
|
||||
SeafileStore::listDir(const std::string& path)
|
||||
{
|
||||
const auto normalized = normalizePath(path);
|
||||
const auto parts = splitPath(normalized);
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
|
||||
if (parts.empty()) {
|
||||
auto repos = storage.get_all<RepoInfo>();
|
||||
if (repos.empty()) {
|
||||
if (const auto synced = this->syncRepos(); synced) {
|
||||
if (parts.empty())
|
||||
{
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto& storage = this->database->storage;
|
||||
auto repos = storage.get_all<RepoInfo>(sqlite_orm::order_by(&RepoInfo::id));
|
||||
if (repos.empty())
|
||||
{
|
||||
if (const auto synced = this->syncRepos(); synced)
|
||||
{
|
||||
repos = storage.get_all<RepoInfo>();
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
return tl::make_unexpected(synced.error());
|
||||
}
|
||||
}
|
||||
return std::variant<std::vector<RepoInfo>, std::vector<RepoEntry> >(std::move(repos));
|
||||
return std::variant<std::vector<RepoInfo>, std::vector<RepoEntry>>(std::move(repos));
|
||||
}
|
||||
|
||||
const auto &repo_name = parts[0];
|
||||
const auto& repo_name = parts[0];
|
||||
const auto repo = findRepoByName(repo_name);
|
||||
if (!repo) {
|
||||
if (!repo)
|
||||
{
|
||||
return tl::make_unexpected(repo.error());
|
||||
}
|
||||
|
||||
const auto inner_path = joinPath(parts, 1);
|
||||
auto children = queryDirectoryChildren(repo->id, inner_path);
|
||||
if (children.empty()) {
|
||||
if (const auto res = fetchAndStoreRepoDir(repo->id, inner_path); !res) {
|
||||
if (children.empty())
|
||||
{
|
||||
if (const auto res = fetchAndStoreRepoDir(repo->id, inner_path); !res)
|
||||
{
|
||||
return tl::make_unexpected(res.error());
|
||||
}
|
||||
children = queryDirectoryChildren(repo->id, inner_path);
|
||||
}
|
||||
return std::variant<std::vector<RepoInfo>, std::vector<RepoEntry> >(std::move(children));
|
||||
return std::variant<std::vector<RepoInfo>, std::vector<RepoEntry>>(std::move(children));
|
||||
}
|
||||
|
||||
tl::expected<std::string, api::SeafileException> SeafileStore::readFile(
|
||||
const std::string& repo_id, const std::string& path, const size_t offset, const size_t length) const {
|
||||
if (length == 0) {
|
||||
const std::string& repo_id, const std::string& path, const size_t offset, const size_t length) const
|
||||
{
|
||||
if (length == 0)
|
||||
{
|
||||
return std::string{};
|
||||
}
|
||||
return this->api.downloadFile(repo_id, path, offset, offset + length - 1);
|
||||
}
|
||||
|
||||
tl::expected<api::AccountInfo, api::SeafileException> SeafileStore::accountInfo() const {
|
||||
tl::expected<api::AccountInfo, api::SeafileException> SeafileStore::accountInfo() const
|
||||
{
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto& storage = this->database->storage;
|
||||
if (const auto infos = storage.get_all<AccountInfo>(); !infos.empty()) {
|
||||
if (const auto infos = storage.get_all<AccountInfo>(); !infos.empty())
|
||||
{
|
||||
return infos.front();
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException("account info not synced"));
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::sync() {
|
||||
if (const auto sync_account = this->syncUserInfo(); !sync_account) {
|
||||
tl::expected<void, api::SeafileException> SeafileStore::sync()
|
||||
{
|
||||
if (const auto sync_account = this->syncUserInfo(); !sync_account)
|
||||
{
|
||||
return tl::make_unexpected(sync_account.error());
|
||||
}
|
||||
if (const auto sync_repos = syncRepos(); !sync_repos) {
|
||||
if (const auto sync_repos = syncRepos(); !sync_repos)
|
||||
{
|
||||
return tl::make_unexpected(sync_repos.error());
|
||||
}
|
||||
return {};
|
||||
@@ -440,7 +551,8 @@ namespace seafile::fs {
|
||||
|
||||
SeafileStore::~SeafileStore() = default;
|
||||
|
||||
std::filesystem::path SeafileStore::storePath() {
|
||||
std::filesystem::path SeafileStore::storePath()
|
||||
{
|
||||
return shell::util::ApplicationPath::get().parent_path() / "seafile.sqlite";
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user