Starting attempt to implement the new rust time transfer server
This commit is contained in:
WolverinDEV
@@ -0,0 +1,587 @@
|
||||
//
|
||||
// Created by WolverinDEV on 20/04/2021.
|
||||
//
|
||||
|
||||
#include <cassert>
|
||||
#include <log/LogUtils.h>
|
||||
#include "./provider.h"
|
||||
#include "./imports.h"
|
||||
|
||||
using namespace ts::server;
|
||||
using namespace ts::server::file;
|
||||
using namespace ts::server::file::transfer;
|
||||
using namespace ts::server::file::filesystem;
|
||||
|
||||
RustFileSystem::~RustFileSystem() = default;
|
||||
|
||||
std::shared_ptr<ExecuteResponse<ServerCommandError>> RustFileSystem::initialize_server(
|
||||
const std::shared_ptr<VirtualFileServer> &) {
|
||||
/* Nothing to do. */
|
||||
auto response = this->create_execute_response<ServerCommandError>();
|
||||
response->emplace_success();
|
||||
return response;
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<FileInfoError, FileInfoResponse>> RustFileSystem::query_channel_info(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server, const std::vector<std::tuple<ChannelId, std::string>> &files) {
|
||||
std::vector<TeaFilePath> file_paths{};
|
||||
file_paths.reserve(files.size());
|
||||
for(const auto& [ channel_id, path ] : files) {
|
||||
file_paths.push_back(TeaFilePath{
|
||||
.type = 0,
|
||||
.channel_id = channel_id,
|
||||
.path = path.c_str()
|
||||
});
|
||||
}
|
||||
|
||||
return this->execute_info(virtual_server->unique_id().c_str(), file_paths.data(), file_paths.size());
|
||||
}
|
||||
|
||||
std::shared_ptr<RustFileSystem::directory_query_response_t> RustFileSystem::query_channel_directory(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server, ChannelId channelId, const std::string &directory) {
|
||||
TeaFilePath path{
|
||||
.type = 0,
|
||||
.channel_id = channelId,
|
||||
.path = directory.c_str()
|
||||
};
|
||||
return this->execute_query(virtual_server->unique_id().c_str(), &path);
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<FileInfoError, FileInfoResponse>> RustFileSystem::query_icon_info(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server, const std::vector<std::string> &files) {
|
||||
std::vector<TeaFilePath> file_paths{};
|
||||
file_paths.reserve(files.size());
|
||||
for(const auto& path : files) {
|
||||
file_paths.push_back(TeaFilePath{
|
||||
.type = 1,
|
||||
.channel_id = 0,
|
||||
.path = path.c_str()
|
||||
});
|
||||
}
|
||||
|
||||
return this->execute_info(virtual_server->unique_id().c_str(), file_paths.data(), file_paths.size());
|
||||
}
|
||||
|
||||
std::shared_ptr<RustFileSystem::directory_query_response_t> RustFileSystem::query_icon_directory(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server) {
|
||||
TeaFilePath path{
|
||||
.type = 1,
|
||||
.channel_id = 0,
|
||||
.path = nullptr
|
||||
};
|
||||
return this->execute_query(virtual_server->unique_id().c_str(), &path);
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<FileInfoError, FileInfoResponse>> RustFileSystem::query_avatar_info(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server, const std::vector<std::string> &files) {
|
||||
std::vector<TeaFilePath> file_paths{};
|
||||
file_paths.reserve(files.size());
|
||||
for(const auto& path : files) {
|
||||
file_paths.push_back(TeaFilePath{
|
||||
.type = 2,
|
||||
.channel_id = 0,
|
||||
.path = path.c_str()
|
||||
});
|
||||
}
|
||||
|
||||
return this->execute_info(virtual_server->unique_id().c_str(), file_paths.data(), file_paths.size());
|
||||
}
|
||||
|
||||
std::shared_ptr<RustFileSystem::directory_query_response_t> RustFileSystem::query_avatar_directory(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server) {
|
||||
TeaFilePath path{
|
||||
.type = 2,
|
||||
.channel_id = 0,
|
||||
.path = nullptr
|
||||
};
|
||||
return this->execute_query(virtual_server->unique_id().c_str(), &path);
|
||||
}
|
||||
|
||||
inline void path_info_to_directory_entry(DirectoryEntry& target, const TeaFilePathInfo& info) {
|
||||
switch (info.file_type) {
|
||||
case 1:
|
||||
target.type = DirectoryEntry::FILE;
|
||||
break;
|
||||
case 2:
|
||||
target.type = DirectoryEntry::DIRECTORY;
|
||||
break;
|
||||
|
||||
default:
|
||||
target.type = DirectoryEntry::UNKNOWN;
|
||||
return;
|
||||
}
|
||||
|
||||
assert(info.name);
|
||||
target.name = std::string{info.name};
|
||||
target.modified_at = std::chrono::system_clock::time_point{} + std::chrono::seconds{info.modify_timestamp};
|
||||
target.size = info.file_size;
|
||||
target.empty = info.directory_empty;
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<FileInfoError, FileInfoResponse>> RustFileSystem::execute_info(const char *server_unique_id, void *paths,
|
||||
size_t paths_count) {
|
||||
auto response = this->create_execute_response<FileInfoError, FileInfoResponse>();
|
||||
|
||||
const TeaFilePathInfo* result{nullptr};
|
||||
auto error_ptr = libteaspeak_file_system_query_file_info(server_unique_id, (const TeaFilePath*) paths, paths_count, &result);
|
||||
if(error_ptr) {
|
||||
libteaspeak_file_free_file_info(result);
|
||||
|
||||
response->emplace_fail(FileInfoErrorType::UNKNOWN, error_ptr);
|
||||
libteaspeak_free_str(error_ptr);
|
||||
} else {
|
||||
assert(result);
|
||||
std::vector<FileInfoResponse::FileInfo> file_infos{};
|
||||
file_infos.reserve(paths_count);
|
||||
|
||||
auto info_ptr{result};
|
||||
while(info_ptr->query_result >= 0) {
|
||||
auto& info = file_infos.emplace_back();
|
||||
switch (info_ptr->query_result) {
|
||||
case 0:
|
||||
/* success */
|
||||
info.status = FileInfoResponse::StatusType::SUCCESS;
|
||||
path_info_to_directory_entry(info.info, *info_ptr);
|
||||
break;
|
||||
|
||||
case 1:
|
||||
info.status = FileInfoResponse::StatusType::PATH_EXCEEDS_ROOT_PATH;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
info.status = FileInfoResponse::StatusType::PATH_DOES_NOT_EXISTS;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
info.status = FileInfoResponse::StatusType::UNKNOWN_FILE_TYPE;
|
||||
break;
|
||||
|
||||
default:
|
||||
info.status = FileInfoResponse::StatusType::FAILED_TO_QUERY_INFO;
|
||||
info.error_detail = std::string{"invalid query result "} + std::to_string(info_ptr->query_result);
|
||||
break;
|
||||
}
|
||||
|
||||
info_ptr++;
|
||||
}
|
||||
|
||||
assert(file_infos.size() == paths_count);
|
||||
libteaspeak_file_free_file_info(result);
|
||||
response->emplace_success(FileInfoResponse{file_infos});
|
||||
}
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
std::shared_ptr<RustFileSystem::directory_query_response_t> RustFileSystem::execute_query(const char *server_unique_id, void *path) {
|
||||
auto response = this->create_execute_response<DirectoryQueryError, std::deque<DirectoryEntry>>();
|
||||
|
||||
const TeaFilePathInfo* result{nullptr};
|
||||
auto error_ptr = libteaspeak_file_system_query_directory(server_unique_id, (const TeaFilePath*) path, &result);
|
||||
if(error_ptr) {
|
||||
libteaspeak_file_free_file_info(result);
|
||||
|
||||
response->emplace_fail(DirectoryQueryErrorType::UNKNOWN, error_ptr);
|
||||
libteaspeak_free_str(error_ptr);
|
||||
} else {
|
||||
assert(result);
|
||||
/* result->query_result could be zero or minus one in both cases we're iterating the query result */
|
||||
if(result->query_result > 0) {
|
||||
/* An error occurred */
|
||||
switch(result->query_result) {
|
||||
case 1:
|
||||
response->emplace_fail(DirectoryQueryErrorType::PATH_EXCEEDS_ROOT_PATH, "");
|
||||
break;
|
||||
|
||||
case 2:
|
||||
response->emplace_fail(DirectoryQueryErrorType::PATH_DOES_NOT_EXISTS, "");
|
||||
break;
|
||||
|
||||
case 4:
|
||||
response->emplace_fail(DirectoryQueryErrorType::PATH_IS_A_FILE, "");
|
||||
break;
|
||||
|
||||
case 5:
|
||||
response->emplace_fail(DirectoryQueryErrorType::UNKNOWN, "io error");
|
||||
break;
|
||||
|
||||
default:
|
||||
response->emplace_fail(DirectoryQueryErrorType::UNKNOWN, std::string{"unknown error result "} + std::to_string(result->query_result));
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
std::deque<DirectoryEntry> entries{};
|
||||
|
||||
auto info_ptr{result};
|
||||
while(info_ptr->query_result >= 0) {
|
||||
assert(info_ptr->query_result == 0);
|
||||
path_info_to_directory_entry(entries.emplace_back(), *info_ptr);
|
||||
info_ptr++;
|
||||
}
|
||||
|
||||
response->emplace_success(std::move(entries));
|
||||
}
|
||||
libteaspeak_file_free_file_info(result);
|
||||
}
|
||||
return response;
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<FileDeleteError, FileDeleteResponse>> RustFileSystem::delete_channel_files(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server, ChannelId channel_id, const std::vector<std::string> &files) {
|
||||
std::vector<TeaFilePath> file_paths{};
|
||||
file_paths.reserve(files.size());
|
||||
for(const auto& path : files) {
|
||||
file_paths.push_back(TeaFilePath{
|
||||
.type = 0,
|
||||
.channel_id = channel_id,
|
||||
.path = path.c_str()
|
||||
});
|
||||
}
|
||||
|
||||
return this->execute_delete(virtual_server->unique_id().c_str(), file_paths.data(), file_paths.size());
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<FileDeleteError, FileDeleteResponse>> RustFileSystem::delete_icons(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server, const std::vector<std::string> &files) {
|
||||
std::vector<TeaFilePath> file_paths{};
|
||||
file_paths.reserve(files.size());
|
||||
for(const auto& path : files) {
|
||||
file_paths.push_back(TeaFilePath{
|
||||
.type = 1,
|
||||
.channel_id = 0,
|
||||
.path = path.c_str()
|
||||
});
|
||||
}
|
||||
|
||||
return this->execute_delete(virtual_server->unique_id().c_str(), file_paths.data(), file_paths.size());
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<FileDeleteError, FileDeleteResponse>> RustFileSystem::delete_avatars(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server, const std::vector<std::string> &files) {
|
||||
std::vector<TeaFilePath> file_paths{};
|
||||
file_paths.reserve(files.size());
|
||||
for(const auto& path : files) {
|
||||
file_paths.push_back(TeaFilePath{
|
||||
.type = 2,
|
||||
.channel_id = 0,
|
||||
.path = path.c_str()
|
||||
});
|
||||
}
|
||||
|
||||
return this->execute_delete(virtual_server->unique_id().c_str(), file_paths.data(), file_paths.size());
|
||||
}
|
||||
|
||||
inline void path_info_to_delete_result(FileDeleteResponse::DeleteResult& result, const TeaFilePathInfo& info) {
|
||||
switch (info.query_result) {
|
||||
case 0:
|
||||
result.status = FileDeleteResponse::StatusType::SUCCESS;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
result.status = FileDeleteResponse::StatusType::PATH_EXCEEDS_ROOT_PATH;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
result.status = FileDeleteResponse::StatusType::PATH_DOES_NOT_EXISTS;
|
||||
break;
|
||||
|
||||
case 5:
|
||||
result.status = FileDeleteResponse::StatusType::FAILED_TO_DELETE_FILES;
|
||||
break;
|
||||
|
||||
case 6:
|
||||
result.status = FileDeleteResponse::StatusType::SOME_FILES_ARE_LOCKED;
|
||||
break;
|
||||
|
||||
default:
|
||||
result.status = FileDeleteResponse::StatusType::FAILED_TO_DELETE_FILES;
|
||||
result.error_detail = std::string{"unknown delete error "} + std::to_string(info.query_result);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<FileDeleteError, FileDeleteResponse>> RustFileSystem::execute_delete(const char *server_unique_id, void *paths,
|
||||
size_t paths_count) {
|
||||
auto response = this->create_execute_response<FileDeleteError, FileDeleteResponse>();
|
||||
|
||||
const TeaFilePathInfo* result{nullptr};
|
||||
auto error_ptr = libteaspeak_file_system_delete_files(server_unique_id, (const TeaFilePath*) paths, paths_count, &result);
|
||||
if(error_ptr) {
|
||||
libteaspeak_file_free_file_info(result);
|
||||
|
||||
response->emplace_fail(FileDeleteErrorType::UNKNOWN, error_ptr);
|
||||
libteaspeak_free_str(error_ptr);
|
||||
} else {
|
||||
assert(result);
|
||||
std::vector<FileDeleteResponse::DeleteResult> results{};
|
||||
results.reserve(paths_count);
|
||||
|
||||
auto info_ptr{result};
|
||||
while(info_ptr->query_result >= 0) {
|
||||
path_info_to_delete_result(results.emplace_back(), *info_ptr);
|
||||
info_ptr++;
|
||||
}
|
||||
|
||||
assert(results.size() == paths_count);
|
||||
libteaspeak_file_free_file_info(result);
|
||||
response->emplace_success(FileDeleteResponse{results});
|
||||
}
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<DirectoryModifyError>> RustFileSystem::create_channel_directory(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server, ChannelId channelId, const std::string &path) {
|
||||
auto response = this->create_execute_response<DirectoryModifyError>();
|
||||
auto result = libteaspeak_file_system_create_channel_directory(virtual_server->unique_id().c_str(), channelId, path.c_str());
|
||||
switch (result) {
|
||||
case 0:
|
||||
response->emplace_success();
|
||||
break;
|
||||
|
||||
case 1:
|
||||
response->emplace_fail(DirectoryModifyErrorType::UNKNOWN, "server not found");
|
||||
break;
|
||||
|
||||
case 2:
|
||||
response->emplace_fail(DirectoryModifyErrorType::PATH_EXCEEDS_ROOT_PATH, "");
|
||||
break;
|
||||
|
||||
case 3:
|
||||
response->emplace_fail(DirectoryModifyErrorType::PATH_ALREADY_EXISTS, "");
|
||||
break;
|
||||
|
||||
case 4:
|
||||
response->emplace_fail(DirectoryModifyErrorType::FAILED_TO_CREATE_DIRECTORIES, "");
|
||||
break;
|
||||
|
||||
default:
|
||||
response->emplace_fail(DirectoryModifyErrorType::UNKNOWN, std::string{"invalid return code "} + std::to_string(result));
|
||||
break;
|
||||
}
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<FileModifyError>> RustFileSystem::rename_channel_file(
|
||||
const std::shared_ptr<VirtualFileServer> &virtual_server, ChannelId old_channel_id, const std::string &old_path, ChannelId new_channel_id,
|
||||
const std::string &new_path) {
|
||||
auto response = this->create_execute_response<FileModifyError>();
|
||||
auto result = libteaspeak_file_system_rename_channel_file(virtual_server->unique_id().c_str(), old_channel_id, old_path.c_str(), new_channel_id, new_path.c_str());
|
||||
switch (result) {
|
||||
case 0:
|
||||
response->emplace_success();
|
||||
break;
|
||||
|
||||
case 1:
|
||||
response->emplace_fail(FileModifyErrorType::UNKNOWN, "server not found");
|
||||
break;
|
||||
|
||||
case 2:
|
||||
response->emplace_fail(FileModifyErrorType::UNKNOWN, "invalid path types");
|
||||
break;
|
||||
|
||||
case 3:
|
||||
response->emplace_fail(FileModifyErrorType::PATH_EXCEEDS_ROOT_PATH, "");
|
||||
break;
|
||||
|
||||
case 4:
|
||||
response->emplace_fail(FileModifyErrorType::TARGET_PATH_EXCEEDS_ROOT_PATH, "");
|
||||
break;
|
||||
|
||||
case 5:
|
||||
response->emplace_fail(FileModifyErrorType::PATH_DOES_NOT_EXISTS, "");
|
||||
break;
|
||||
|
||||
case 6:
|
||||
response->emplace_fail(FileModifyErrorType::SOME_FILES_ARE_LOCKED, "");
|
||||
break;
|
||||
|
||||
case 7:
|
||||
response->emplace_fail(FileModifyErrorType::TARGET_PATH_ALREADY_EXISTS, "");
|
||||
break;
|
||||
|
||||
case 8:
|
||||
response->emplace_fail(FileModifyErrorType::FAILED_TO_RENAME_FILE, "");
|
||||
break;
|
||||
|
||||
default:
|
||||
response->emplace_fail(FileModifyErrorType::UNKNOWN, std::string{"invalid return code "} + std::to_string(result));
|
||||
break;
|
||||
}
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>>
|
||||
RustFileTransfer::initialize_channel_transfer(transfer::Transfer::Direction direction,
|
||||
const std::shared_ptr<VirtualFileServer> &ptr, ChannelId id,
|
||||
const transfer::AbstractProvider::TransferInfo &info) {
|
||||
auto result = this->create_execute_response<TransferInitError, std::shared_ptr<Transfer>>();
|
||||
result->emplace_fail(TransferInitError::Type::UNKNOWN, "");
|
||||
return result;
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>>
|
||||
RustFileTransfer::initialize_icon_transfer(transfer::Transfer::Direction direction,
|
||||
const std::shared_ptr<VirtualFileServer> &ptr,
|
||||
const transfer::AbstractProvider::TransferInfo &info) {
|
||||
auto result = this->create_execute_response<TransferInitError, std::shared_ptr<Transfer>>();
|
||||
result->emplace_fail(TransferInitError::Type::UNKNOWN, "");
|
||||
return result;
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>>
|
||||
RustFileTransfer::initialize_avatar_transfer(transfer::Transfer::Direction direction,
|
||||
const std::shared_ptr<VirtualFileServer> &ptr,
|
||||
const transfer::AbstractProvider::TransferInfo &info) {
|
||||
auto result = this->create_execute_response<TransferInitError, std::shared_ptr<Transfer>>();
|
||||
result->emplace_fail(TransferInitError::Type::UNKNOWN, "");
|
||||
return result;
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<TransferListError, std::vector<ActiveFileTransfer>>>
|
||||
RustFileTransfer::list_transfer() {
|
||||
auto result = this->create_execute_response<TransferListError, std::vector<ActiveFileTransfer>>();
|
||||
result->emplace_fail(TransferListError::UNKNOWN);
|
||||
return result;
|
||||
}
|
||||
|
||||
std::shared_ptr<ExecuteResponse<TransferActionError>>
|
||||
RustFileTransfer::stop_transfer(const std::shared_ptr<VirtualFileServer> &ptr, transfer::transfer_id id,
|
||||
bool b) {
|
||||
auto result = this->create_execute_response<TransferActionError>();
|
||||
result->emplace_fail(TransferActionError{TransferActionError::Type::UNKNOWN_TRANSFER});
|
||||
return result;
|
||||
}
|
||||
|
||||
RustFileProvider::RustFileProvider() :
|
||||
file_system_{new RustFileSystem{}},
|
||||
file_transfer_{new RustFileTransfer{}}
|
||||
{}
|
||||
|
||||
RustFileProvider::~RustFileProvider() {
|
||||
delete this->file_transfer_;
|
||||
delete this->file_system_;
|
||||
}
|
||||
|
||||
std::string RustFileProvider::file_base_path() const {
|
||||
return "TODO!"; /* FIXME! */
|
||||
}
|
||||
|
||||
filesystem::AbstractProvider & RustFileProvider::file_system() {
|
||||
return *this->file_system_;
|
||||
}
|
||||
|
||||
transfer::AbstractProvider & RustFileProvider::file_transfer() {
|
||||
return *this->file_transfer_;
|
||||
}
|
||||
|
||||
std::shared_ptr<VirtualFileServer> RustFileProvider::register_server(ServerId server_id) {
|
||||
auto server = this->find_virtual_server(server_id);
|
||||
if(server) return server;
|
||||
|
||||
server = std::make_shared<file::RustVirtualFileServer>(server_id, std::to_string(server_id));
|
||||
libteaspeak_file_system_register_server(server->unique_id().c_str());
|
||||
{
|
||||
std::lock_guard slock{this->servers_mutex};
|
||||
this->servers_.push_back(server);
|
||||
}
|
||||
|
||||
return server;
|
||||
}
|
||||
|
||||
void RustFileProvider::unregister_server(ServerId server_id, bool delete_files) {
|
||||
auto server_unique_id = std::to_string(server_id);
|
||||
std::shared_ptr<VirtualFileServer> server{};
|
||||
|
||||
{
|
||||
std::lock_guard slock{this->servers_mutex};
|
||||
auto it = std::find_if(this->servers_.begin(), this->servers_.end(), [&](const std::shared_ptr<VirtualFileServer>& server) {
|
||||
return server->unique_id() == server_unique_id;
|
||||
});
|
||||
|
||||
if(it == this->servers_.end()) {
|
||||
return;
|
||||
}
|
||||
|
||||
server = *it;
|
||||
this->servers_.erase(it);
|
||||
}
|
||||
|
||||
libteaspeak_file_system_unregister_server(server->unique_id().c_str(), delete_files);
|
||||
}
|
||||
|
||||
void RustVirtualFileServer::max_networking_download_bandwidth(int64_t value) {
|
||||
VirtualFileServer::max_networking_download_bandwidth(value);
|
||||
}
|
||||
|
||||
void RustVirtualFileServer::max_networking_upload_bandwidth(int64_t value) {
|
||||
VirtualFileServer::max_networking_upload_bandwidth(value);
|
||||
}
|
||||
|
||||
|
||||
|
||||
#define log(...) \
|
||||
switch(level) { \
|
||||
case 0: \
|
||||
logTrace(__VA_ARGS__); \
|
||||
break; \
|
||||
case 1: \
|
||||
debugMessage(__VA_ARGS__); \
|
||||
break; \
|
||||
case 2: \
|
||||
logMessage(__VA_ARGS__); \
|
||||
break; \
|
||||
case 3: \
|
||||
logWarning(__VA_ARGS__); \
|
||||
break; \
|
||||
case 4: \
|
||||
logError(__VA_ARGS__); \
|
||||
break; \
|
||||
case 5: \
|
||||
logCritical(__VA_ARGS__); \
|
||||
break; \
|
||||
default: \
|
||||
debugMessage(__VA_ARGS__); \
|
||||
break; \
|
||||
}
|
||||
|
||||
void libteaspeak_file_callback_log(uint8_t level, const void* callback_data_ptr, const char* message_ptr, uint32_t length) {
|
||||
std::string_view message{message_ptr, length};
|
||||
log(LOG_GENERAL, "{}", message);
|
||||
}
|
||||
|
||||
#undef log
|
||||
|
||||
static TeaFileNativeCallbacks native_callbacks{
|
||||
.version = 1,
|
||||
|
||||
.log = libteaspeak_file_callback_log,
|
||||
};
|
||||
|
||||
std::shared_ptr<AbstractFileServer> file_instance{};
|
||||
bool file::initialize(std::string& error, const std::string& host_names, uint16_t port) {
|
||||
logMessage(LOG_FT, "Initializing file server with version {}", libteaspeak_file_version());
|
||||
|
||||
auto error_ptr = libteaspeak_file_initialize(&native_callbacks, sizeof native_callbacks);
|
||||
if(error_ptr) {
|
||||
error = error_ptr;
|
||||
libteaspeak_free_str(error_ptr);
|
||||
return false;
|
||||
}
|
||||
|
||||
/* FIXME: Start server */
|
||||
|
||||
file_instance = std::make_shared<RustFileProvider>();
|
||||
return true;
|
||||
}
|
||||
|
||||
void file::finalize() {
|
||||
file_instance = nullptr;
|
||||
libteaspeak_file_finalize();
|
||||
}
|
||||
|
||||
std::shared_ptr<AbstractFileServer> file::server() {
|
||||
return file_instance;
|
||||
}
|
||||
Reference in New Issue
Block a user