shell/seadisk
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加文件缓存

Browse Source
This commit is contained in:
asypost committed 2026-07-14 21:28:08 +08:00
1 parent fb63205a70
commit 95b68b9542
18 files changed
+481 -107
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/seafile/fs/seafile_file_system.cpp
+122 -78
View File
@@ -5,30 +5,36 @@
#include <spdlog/spdlog.h>
#include <format>
namespace seafile::fs {
namespace {
namespace seafile::fs
{
namespace
{
constexpr int64_t UNIX_EPOCH_AS_FILETIME = 116444736000000000LL;
constexpr int64_t HUNDREDS_OF_NANOSECONDS_PER_SECOND = 10000000LL;
int64_t UnixTimeToFileTime(const int64_t unix_time) {
int64_t UnixTimeToFileTime(const int64_t unix_time)
{
return UNIX_EPOCH_AS_FILETIME + unix_time * HUNDREDS_OF_NANOSECONDS_PER_SECOND;
}
std::string normalize_path(const std::string &path) {
std::string normalize_path(const std::string& path)
{
std::string result = path;
std::ranges::replace(result, '\\', '/');
return result;
}
int64_t NowFileTime() {
int64_t NowFileTime()
{
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
return (static_cast<int64_t>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
}
void SetFileInfo(FSP_FSCTL_FILE_INFO *FileInfo, const uint32_t attributes, const uint64_t size,
const int64_t mtime) {
void SetFileInfo(FSP_FSCTL_FILE_INFO* FileInfo, const uint32_t attributes, const uint64_t size,
const int64_t mtime)
{
FileInfo->FileAttributes = attributes;
FileInfo->AllocationSize = size;
FileInfo->FileSize = size;
@@ -42,12 +48,15 @@ namespace seafile::fs {
}
tl::expected<void, SeafileException> SeafileFileSystem::initialize(const std::string &username,
const std::string &password) {
const auto authToken = api.authToken(username, password);
if (authToken.has_value()) {
tl::expected<void, api::SeafileException> SeafileFileSystem::initialize(const std::string& username,
const std::string& password)
{
const auto authToken = api->authToken(username, password);
if (authToken.has_value())
{
this->token = authToken.value().token;
if (const auto repo = api.defaultRepo(this->token, this->token_type); repo.has_value()) {
if (const auto repo = api->defaultRepo(this->token, this->token_type); repo.has_value())
{
this->repo_id = repo.value().repo_id.value_or("");
return {};
}
@@ -58,17 +67,23 @@ namespace seafile::fs {
return tl::make_unexpected(authToken.error());
}
void SeafileFileSystem::Close(PVOID FileContext) {
delete static_cast<SeaFileContext *>(FileContext);
void SeafileFileSystem::Close(PVOID FileContext)
{
delete static_cast<SeaFileContext*>(FileContext);
}
NTSTATUS SeafileFileSystem::GetSecurityByName(PWSTR FileName, PUINT32 PFileAttributes,
PSECURITY_DESCRIPTOR SecurityDescriptor,
SIZE_T *PSecurityDescriptorSize) {
if (PFileAttributes) {
if (wcscmp(FileName, L"\\") == 0) {
SIZE_T* PSecurityDescriptorSize)
{
if (PFileAttributes)
{
if (wcscmp(FileName, L"\\") == 0)
{
*PFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
} else {
}
else
{
*PFileAttributes = FILE_ATTRIBUTE_NORMAL;
}
}
@@ -79,17 +94,21 @@ namespace seafile::fs {
}
NTSTATUS SeafileFileSystem::Overwrite(PVOID FileContext, UINT32 FileAttributes, BOOLEAN ReplaceFileAttributes,
UINT64 AllocationSize, FSP_FSCTL_FILE_INFO *FileInfo) {
UINT64 AllocationSize, FSP_FSCTL_FILE_INFO* FileInfo)
{
return STATUS_MEDIA_WRITE_PROTECTED;
}
NTSTATUS SeafileFileSystem::GetVolumeInfo(FSP_FSCTL_VOLUME_INFO *VolumeInfo) const {
if (const auto userInfo = api.accountInfo(this->token, this->token_type); userInfo.has_value()) {
const auto &info = userInfo.value();
NTSTATUS SeafileFileSystem::GetVolumeInfo(FSP_FSCTL_VOLUME_INFO* VolumeInfo) const
{
if (const auto userInfo = api->accountInfo(this->token, this->token_type); userInfo.has_value())
{
const auto& info = userInfo.value();
VolumeInfo->FreeSize = info.total - info.usage;
VolumeInfo->TotalSize = info.total;
if (!this->volume_label.empty()) {
if (!this->volume_label.empty())
{
wcscpy_s(VolumeInfo->VolumeLabel, this->volume_label.data());
VolumeInfo->VolumeLabelLength = static_cast<UINT16>((wcslen(VolumeInfo->VolumeLabel) * sizeof(WCHAR)));
}
@@ -101,20 +120,24 @@ namespace seafile::fs {
return STATUS_END_OF_MEDIA;
}
void SeafileFileSystem::Cleanup(PVOID FileContext, PWSTR FileName, ULONG Flags) {
void SeafileFileSystem::Cleanup(PVOID FileContext, PWSTR FileName, ULONG Flags)
{
}
NTSTATUS SeafileFileSystem::Open(PWSTR FileName, UINT32 CreateOptions, UINT32 GrantedAccess, PVOID *PFileContext,
FSP_FSCTL_FILE_INFO *FileInfo) {
NTSTATUS SeafileFileSystem::Open(PWSTR FileName, UINT32 CreateOptions, UINT32 GrantedAccess, PVOID* PFileContext,
FSP_FSCTL_FILE_INFO* FileInfo)
{
const auto path = normalize_path(shell::util::StringUtil::utf16le_to_utf8(FileName));
if (repo_id.empty()) {
if (repo_id.empty())
{
spdlog::error(std::format("can't open file: {}, repo id is empty", path));
return STATUS_OBJECT_NAME_NOT_FOUND;
}
if (path == "/") {
auto repo = api.repoInfo(repo_id, token, token_type);
if (path == "/")
{
auto repo = api->repoInfo(repo_id, token, token_type);
if (!repo.has_value())
return STATUS_OBJECT_NAME_NOT_FOUND;
const auto ctx = new SeaFileContext{repo->id, path, SeaFileContext::Type::DIRECTORY, 0, ""};
@@ -124,8 +147,9 @@ namespace seafile::fs {
return STATUS_SUCCESS;
}
if (const auto dirInfo = api.dirDetail(repo_id, path, token, token_type); dirInfo.has_value()) {
const auto &info = dirInfo.value();
if (const auto dirInfo = api->dirDetail(repo_id, path, token, token_type); dirInfo.has_value())
{
const auto& info = dirInfo.value();
const auto ctx = new SeaFileContext{info.repo_id, info.path, SeaFileContext::Type::DIRECTORY, 0, ""};
*PFileContext = ctx;
SetFileInfo(FileInfo,FILE_ATTRIBUTE_DIRECTORY, 0, 0);
@@ -134,8 +158,9 @@ namespace seafile::fs {
}
if (const auto fileInfo = api.fileDetail(repo_id, path, token, token_type); fileInfo.has_value()) {
const auto &info = fileInfo.value();
if (const auto fileInfo = api->fileDetail(repo_id, path, token, token_type); fileInfo.has_value())
{
const auto& info = fileInfo.value();
const auto ctx = new SeaFileContext(repo_id, path, SeaFileContext::Type::FILE, info.size, "");
*PFileContext = ctx;
SetFileInfo(FileInfo,FILE_ATTRIBUTE_ARCHIVE, info.size, 0);
@@ -147,14 +172,16 @@ namespace seafile::fs {
}
NTSTATUS SeafileFileSystem::Read(PVOID FileContext, PVOID Buffer, UINT64 Offset, ULONG Length,
PULONG PBytesTransferred) {
const auto fc = static_cast<SeaFileContext *>(FileContext);
auto result = api.downloadFile(
PULONG PBytesTransferred)
{
const auto fc = static_cast<SeaFileContext*>(FileContext);
auto result = api->downloadFile(
fc->repo_id, fc->path,
Offset, Offset + Length - 1,
token, token_type);
if (result.has_value()) {
const auto &data = result.value();
if (result.has_value())
{
const auto& data = result.value();
const auto copy_len = (std::min)(data.size(), static_cast<size_t>(Length));
memcpy(Buffer, data.data(), copy_len);
*PBytesTransferred = static_cast<ULONG>(copy_len);
@@ -165,76 +192,87 @@ namespace seafile::fs {
}
NTSTATUS SeafileFileSystem::ReadDirectory(PVOID FileContext, PWSTR Pattern, PWSTR Marker,
PVOID Buffer, ULONG BufferLength, PULONG PBytesTransferred) {
const auto fc = static_cast<SeaFileContext *>(FileContext);
PVOID Buffer, ULONG BufferLength, PULONG PBytesTransferred)
{
const auto fc = static_cast<SeaFileContext*>(FileContext);
*PBytesTransferred = 0;
const auto cache_key = std::format("{}_{}", fc->repo_id, fc->path);
auto repo_entries = repo_dir_cache.get(cache_key);
if (!repo_entries.has_value()) {
if (auto entries_result = api.repoDir(fc->repo_id, fc->path, token, token_type); entries_result.has_value()) {
repo_entries = entries_result.value();
repo_dir_cache.put(cache_key, repo_entries.value(),std::chrono::seconds(60));
}else {
spdlog::error(std::format("can't read directory {},due to {}", fc->path,entries_result.error().what()));
}
}
if (repo_entries.has_value()) {
const auto &entries = repo_entries.value();
if (auto entries_result = api->repoDir(fc->repo_id, fc->path, token, token_type); entries_result.has_value())
{
const auto& entries = entries_result.value();
size_t start = 0;
if (Marker) {
if (Marker)
{
const auto marker = shell::util::StringUtil::utf16le_to_utf8(Marker);
for (auto i = 0; i < entries.size(); ++i) {
if (entries[i].name == marker) {
for (auto i = 0; i < entries.size(); ++i)
{
if (entries[i].name == marker)
{
start = i + 1;
break;
}
}
}
for (auto i = start; i < entries.size(); ++i) {
const auto &entry = entries[i];
for (auto i = start; i < entries.size(); ++i)
{
const auto& entry = entries[i];
const auto entry_name = shell::util::StringUtil::utf8_to_utf16le(entry.name);
const auto size = sizeof(FSP_FSCTL_DIR_INFO) + ((entry_name.size() + 1) * sizeof(WCHAR));
const auto dir_info = static_cast<FSP_FSCTL_DIR_INFO *>(std::malloc(size));
const auto dir_info = static_cast<FSP_FSCTL_DIR_INFO*>(std::malloc(size));
std::memset(dir_info, 0, size);
dir_info->Size = size;
dir_info->FileInfo.FileSize = entry.size.value_or(0);
if (entry.type == "file") {
if (entry.type == "file")
{
dir_info->FileInfo.FileAttributes = FILE_ATTRIBUTE_ARCHIVE;
} else {
}
else
{
dir_info->FileInfo.FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
}
wcscpy_s(dir_info->FileNameBuf, entry_name.size() + 1, entry_name.data());
if (*PBytesTransferred + size < BufferLength) {
if (!FspFileSystemAddDirInfo(dir_info, Buffer, BufferLength, PBytesTransferred)) {
if (*PBytesTransferred + size < BufferLength)
{
if (!FspFileSystemAddDirInfo(dir_info, Buffer, BufferLength, PBytesTransferred))
{
break;
}
} else {
}
else
{
break;
}
}
return STATUS_SUCCESS;
}
else
{
spdlog::error(std::format("read directory {} failed: {}", fc->path, entries_result.error().what()));
}
return STATUS_UNSUCCESSFUL;
}
NTSTATUS SeafileFileSystem::GetFileInfo(HANDLE Handle, FSP_FSCTL_FILE_INFO *FileInfo) {
auto fc = static_cast<SeaFileContext *>(Handle);
if (fc->repo_id.empty() || fc->path == "/" || fc->path.back() == '/') {
if (fc->repo_id.empty()) {
NTSTATUS SeafileFileSystem::GetFileInfo(HANDLE Handle, FSP_FSCTL_FILE_INFO* FileInfo)
{
auto fc = static_cast<SeaFileContext*>(Handle);
if (fc->repo_id.empty() || fc->path == "/" || fc->path.back() == '/')
{
if (fc->repo_id.empty())
{
SetFileInfo(FileInfo, FILE_ATTRIBUTE_DIRECTORY, 0, 0);
return STATUS_SUCCESS;
}
auto repo = api.repoInfo(fc->repo_id, token, token_type);
auto repo = api->repoInfo(fc->repo_id, token, token_type);
if (!repo.has_value())
return STATUS_UNSUCCESSFUL;
SetFileInfo(FileInfo, FILE_ATTRIBUTE_DIRECTORY, repo->size, repo->mtime);
return STATUS_SUCCESS;
}
auto fdetail = api.fileDetail(fc->repo_id, fc->path, token, token_type);
auto fdetail = api->fileDetail(fc->repo_id, fc->path, token, token_type);
if (!fdetail.has_value())
return STATUS_UNSUCCESSFUL;
SetFileInfo(FileInfo, FILE_ATTRIBUTE_NORMAL, fdetail->size, fdetail->mtime);
@@ -244,16 +282,19 @@ namespace seafile::fs {
NTSTATUS SeafileFileSystem::Create(PWSTR FileName, UINT32 CreateOptions, UINT32 GrantedAccess,
UINT32 FileAttributes, PSECURITY_DESCRIPTOR SecurityDescriptor,
UINT64 AllocationSize, PVOID *PFileContext, FSP_FSCTL_FILE_INFO *FileInfo) {
UINT64 AllocationSize, PVOID* PFileContext, FSP_FSCTL_FILE_INFO* FileInfo)
{
return Open(FileName, CreateOptions, GrantedAccess, PFileContext, FileInfo);
}
NTSTATUS SeafileFileSystem::GetDirInfoByName(PVOID FileContext, PWSTR FileName,
FSP_FSCTL_DIR_INFO *DirInfo) {
auto fc = static_cast<SeaFileContext *>(FileContext);
FSP_FSCTL_DIR_INFO* DirInfo)
{
auto fc = static_cast<SeaFileContext*>(FileContext);
std::wstring name(FileName);
if (name == L"." || name == L"..") {
if (name == L"." || name == L"..")
{
memset(DirInfo, 0, sizeof(FSP_FSCTL_DIR_INFO));
DirInfo->Size = sizeof(FSP_FSCTL_DIR_INFO) + (wcslen(FileName) + 1) * sizeof(WCHAR);
SetFileInfo(&DirInfo->FileInfo, FILE_ATTRIBUTE_DIRECTORY, 0, 0);
@@ -262,18 +303,20 @@ namespace seafile::fs {
}
std::string utf8_name;
for (const auto c: name)
for (const auto c : name)
utf8_name += static_cast<char>(c);
if (fc->repo_id.empty()) {
if (fc->repo_id.empty())
{
return STATUS_OBJECT_NAME_NOT_FOUND;
}
auto entries = api.repoDir(fc->repo_id, fc->path, token, token_type);
auto entries = api->repoDir(fc->repo_id, fc->path, token, token_type);
if (!entries.has_value())
return STATUS_OBJECT_NAME_NOT_FOUND;
for (const auto &entry: entries.value()) {
for (const auto& entry : entries.value())
{
if (entry.name != utf8_name)
continue;
memset(DirInfo, 0, sizeof(FSP_FSCTL_DIR_INFO));
@@ -288,7 +331,8 @@ namespace seafile::fs {
return STATUS_OBJECT_NAME_NOT_FOUND;
}
NTSTATUS SeafileFileSystem::SetVolumeLabel_(PWSTR VolumeLabel, FSP_FSCTL_VOLUME_INFO *VolumeInfo) {
NTSTATUS SeafileFileSystem::SetVolumeLabel_(PWSTR VolumeLabel, FSP_FSCTL_VOLUME_INFO* VolumeInfo)
{
return STATUS_ACCESS_DENIED;
}
}
src/seafile/fs/winfsp_adapter.cpp
-1
View File
@@ -100,7 +100,6 @@ namespace seafile::fs
FspFileSystemSetDebugLog(
FileSystem,
TRUE);
std::cout << Result << std::endl;
return Result;
}