BlockStorage/repertory
1
0
Fork 0
Code Issues 8 Pull Requests Releases 6 Wiki Activity

Compare commits

base: BlockStorage:03485935b7bd71e23bc150c4fdf07c2b45b7a295
Branches Tags
BlockStorage:v2.0.6-release-develop BlockStorage:master BlockStorage:v2.1.0-rc-develop
BlockStorage:v2.0.5-rc BlockStorage:v2.0.4-rc BlockStorage:v2.0.3-rc BlockStorage:v2.0.2-rc BlockStorage:v2.0.1-rc BlockStorage:v2.0.0-rc
..
compare: BlockStorage:v2.0.3-rc
Branches Tags
BlockStorage:v2.0.6-release-develop BlockStorage:master BlockStorage:v2.1.0-rc-develop
BlockStorage:v2.0.5-rc BlockStorage:v2.0.4-rc BlockStorage:v2.0.3-rc BlockStorage:v2.0.2-rc BlockStorage:v2.0.1-rc BlockStorage:v2.0.0-rc

1 Commits
03485935b7 ... v2.0.3-rc

Author SHA1 Message Date
Scott E. Graves
fa439c634f v2.0.3-rc (#32)
Some checks reported errors
BlockStorage/repertory/pipeline/head Something is wrong with the build of this commit
Details 
# Changelog

## v2.0.3-rc

### Issues

* \#28 \[bug\] Address slow directory responses in S3 mounts for deeply nested directories
* \#29 \[bug\] S3 error responses are not being logged
* \#30 \[bug\] Sia provider error responses are not logged
* \#31 \[bug\] S3 provider should limit max key size to 1024

### Changes from v2.0.2-rc

* Always use direct for read-only providers
* Fixed externally removed files not being processed during cleanup
* Fixed http headers not being added for requests
* Fixed incorrect `stat` values for remote mounts
* Fixed invalid directory nullptr error on remote mounts
* Fixed memory leak in event system
* Refactored application shutdown
* Refactored event system
* Updated build system to Alpine 3.21.0
* Updated build system to MinGW-w64 12.0.0
* Updated copyright to 2018-2025

Reviewed-on: #32
 2025-02-11 17:26:24 -06:00
144 changed files with 2623 additions and 1253 deletions
Expand all files Collapse all files

4
.cspell/words.txt
View File

@ -128,6 +128,7 @@ libcurl
libdsm
libevent
libexample
libexpat
libfuse3
libgmock
libgtest
@ -140,10 +141,12 @@ libuuid
libuuid_include_dirs
libvlc
linkflags
localappdata
lptr
lpwstr
markdownlint
mbig
minio
msvc
msvcr120
msys2
@ -200,6 +203,7 @@ stduuid_project
strequal
ularge_integer
uring
url
userenv
utimens_impl
utimensat

5
CHANGELOG.md
View File

@ -4,10 +4,6 @@
### Issues
* ~~\#12 \[Unit Test\] Complete all providers unit tests~~
* ~~\#20 Add support to evict open files~~
* ~~\#21 \[Unit Test \] Complete WinFSP unit tests~~
* ~~\#22 \[Unit Test\] Complete FUSE unit tests~~
* \#28 \[bug\] Address slow directory responses in S3 mounts for deeply nested directories
* \#29 \[bug\] S3 error responses are not being logged
* \#30 \[bug\] Sia provider error responses are not logged
@ -16,6 +12,7 @@
### Changes from v2.0.2-rc
* Always use direct for read-only providers
* Fixed externally removed files not being processed during cleanup
* Fixed http headers not being added for requests
* Fixed incorrect `stat` values for remote mounts
* Fixed invalid directory nullptr error on remote mounts

5
CMakeLists.txt
View File

@ -3,6 +3,10 @@ cmake_minimum_required(VERSION 3.27)
cmake_policy(SET CMP0135 NEW)
cmake_policy(SET CMP0144 NEW)
if (NOT PROJECT_INTERFACE)
message(FATAL_ERROR "Project must be compiled via 'make_win32.cmd'/'make_win32.sh' or 'make_unix.sh' build scripts. Invoking 'cmake' directly is not supported.")
endif()
project(${PROJECT_NAME}
DESCRIPTION ${PROJECT_DESC}
HOMEPAGE_URL ${PROJECT_URL}
@ -158,6 +162,7 @@ endif()
-DPROJECT_FUSE=${PROJECT_FUSE}
-DPROJECT_FUSE_INCLUDE_DIRS=${PROJECT_FUSE_INCLUDE_DIRS}
-DPROJECT_GIT_REV=${PROJECT_GIT_REV}
-DPROJECT_INTERFACE=1
-DPROJECT_IS_ALPINE=${PROJECT_IS_ALPINE}
-DPROJECT_IS_ARM64=${PROJECT_IS_ARM64}
-DPROJECT_IS_MINGW=${PROJECT_IS_MINGW}

126
README.md
View File

@ -1,23 +1,22 @@
# Repertory
Repertory allows you to mount AWS S3 and Sia via FUSE on Linux ~~/OS X~~ or via WinFSP
Repertory allows you to mount S3 and Sia via FUSE on Linux or via WinFSP
on Windows.
## Details and Features
* Optimized for [Plex Media Server](https://www.plex.tv/)
* Single application to mount AWS S3 and/or Sia
* Remote mounting of Repertory instances on Linux ~~, OS X~~ and Windows
* Securely share your mounts over TCP/IP (`XChaCha20-Poly1305` stream cipher)
* Cross-platform support (Linux 64-bit, Linux arm64/aarch64, ~~OS X,~~ Windows 64-bit)
* Single application to mount S3 and/or Sia
* Remote mounting of Repertory instances on Linux and Windows
* Securely share your mounts over TCP/IP via `XChaCha20-Poly1305` with other systems on your network or over the internet.
* Cross-platform support (Linux 64-bit, Linux arm64/aarch64, Windows 64-bit)
* Optionally encrypt file names and file data via `XChaCha20-Poly1305` in S3 mounts
## Minimum Requirements
* [Sia renterd](https://github.com/SiaFoundation/renterd/releases) v0.4.0+ for Sia support
* Only 64-bit operating systems are supported
* By default, Linux requires `fusermount3`; otherwise, `repertory` must be manually compiled with `libfuse2` support
* ~~OS X requires the following dependency to be installed:~~
* ~~[FUSE for macOS v4.5.0](https://github.com/osxfuse/osxfuse/releases/download/macfuse-4.5.0/macfuse-4.5.0.dmg)~~
* Windows requires the following dependencies to be installed:
* [WinFSP 2023](https://github.com/winfsp/winfsp/releases/download/v2.0/winfsp-2.0.23075.msi)
@ -25,47 +24,103 @@ on Windows.
* Linux `arm64/aarch64`
* Linux `amd64`
* ~~OS X Mojave and above~~
* Windows 64-bit 10, 11
## Usage
### Sia
* Initial Configuration
* Sia steps:
* Set the appropriate bucket name and `renterd` API password in `repertory` configuration:
* To use `default` as the bucket name and configuration name:
* `repertory -set HostConfig.ApiPassword '<my password>'`
* To use a different bucket name with `default` as the configuration name:
* `repertory -set HostConfig.ApiPassword '<my password>'`
* `repertory -set SiaConfig.Bucket '<my bucket>'`
* For all other configurations:
* `repertory --name '<my config name>' -set HostConfig.ApiPassword '<my password>'`
* `repertory --name '<my config name>' -set SiaConfig.Bucket '<my bucket name>'`
* To verify/view all configuration options:
* `repertory -dc`
* `repertory --name '<my config name>' -dc`
* Example:
* `repertory --name default -dc`
* Mounting on Linux:
* `repertory /mnt/location`
* `repertory --name '<my config name>' /mnt/location`
* Example:
* `repertory --name default /mnt/location`
* Mounting on Windows:
* `repertory t:`
* `repertory --name '<my config name>' t:`
* Example:
* `repertory --name default t:`
### S3
* Initial Configuration
* S3 steps:
* Set the appropriate base URL:
* `repertory -s3 --name '<my config name>' -set S3Config.URL '<my url>'`
* Example:
* `repertory -s3 --name minio -set S3Config.URL 'http://localhost:9000'`
* Set the appropriate bucket name:
* `repertory -s3 --name '<my config name>' -set S3Config.Bucket '<my bucket name>'`
* Set the appropriate access key:
* `repertory -s3 --name '<my config name>' -set S3Config.AccessKey '<my access key>'`
* Set the appropriate secret key:
* `repertory -s3 --name '<my config name>' -set S3Config.SecretKey '<my secret key>'`
* For Sia and most local S3 gateway instances, enable path style URL's:
* `repertory -s3 --name '<my config name>' -set S3Config.UsePathStyle true`
* Optional steps:
* Set an appropriate region. Default is set to `any`:
* `repertory -s3 --name '<my config name>' -set S3Config.Region '<my region>'`
* Enable encrypted file names and file data. Set a strong, random encryption token and be sure to store it in a secure backup location:
* `repertory -s3 --name '<my config name>' -set S3Config.EncryptionToken '<my strong password>'`
* To verify/view all configuration options:
* `repertory -s3 --name '<my config name>' -dc`
* Example:
* `repertory -s3 --name minio -dc`
* Mounting on Linux:
* `repertory -s3 --name '<my config name>' /mnt/location`
* Example:
* `repertory -s3 --name minio /mnt/location`
* Mounting on Windows:
* `repertory -s3 --name '<my config name>' t:`
* Example:
* `repertory -s3 --name minio t:`
### Notable Options
* `-dc`
* Display mount configuration.
* For Sia, `--name` is optional
* For S3, the `-s3` option is required along with `--name`
* `--help`
* Display all mount utility options.
* Display all mount utility options
* `--name, -na [name]`
* The `--name` option can be set to any valid value allowed as a file name for your filesystem.
* For Sia, the bucket name will be set to the same value if it is empty in the configuration file.
* If the `--name` option is not specified, `default` will be used.
* For S3, the `--name` option is required and does not affect the bucket name.
* `-set SiaConfig.Bucket`
* Set Sia bucket name for the mount.
* Can be used in combination with `--name` to target a unique configuration.
* `-set S3Config.Bucket`
* S3 bucket name for the mount.
* Must be used in combination with `--name` to target a unique configuration.
* Must be used in combination with `-s3`.
* `-dc`
* Display mount configuration
* For Sia, `--name` is optional
* For S3, the `-s3` option is required along with `--name`
### Sia
### Data Directories
* Linux
* `repertory /mnt/location`
* `repertory --name default /mnt/location`
* `~/.local/repertory2`
* Windows
* `repertory.exe t:`
* `repertory.exe --name default t:`
* `%LOCALAPPDATA%\repertory2`
* Example:
* `C:\Users\Tom\AppData\Local\repertory2`
* IMPORTANT:
* It is highly recommended to exclude this folder from any anti-virus/anti-malware applications as severe performance issues may arise.
* Excluding the mounted drive letter is also highly recommended.
### S3
## Remote Mounting
* Linux
* `repertory --name storj -s3 /mnt/location`
* Windows
* `repertory.exe --name storj -s3 t:`
`Repertory` allows local mounts to be shared with other computers on your network.
This option is referred to as remote mounting. Instructions TBD.
## Compiling
@ -94,17 +149,26 @@ on Windows.
## Credits
* [binutils](https://www.gnu.org/software/binutils/)
* [boost c++ libraries](https://www.boost.org/)
* [cpp-httplib](https://github.com/yhirose/cpp-httplib)
* [curl](https://curl.haxx.se/)
* ~~[FUSE for macOS](https://osxfuse.github.io/)~~
* [docker](https://www.docker.com/)
* [Google Test](https://github.com/google/googletest)
* [ICU](https://icu.unicode.org/)
* [JSON for Modern C++](https://github.com/nlohmann/json)
* [libexpat](https://github.com/libexpat/libexpat)
* [libfuse](https://github.com/libfuse/libfuse)
* [libsodium](https://doc.libsodium.org/)
* [mingw-w64](https://www.mingw-w64.org/)
* [MSYS2](https://www.msys2.org)
* [OpenSSL](https://www.openssl.org/)
* [pkg-config](https://www.freedesktop.org/wiki/Software/pkg-config/)
* [pugixml](https://pugixml.org/)
* [RocksDB](https://rocksdb.org)
* [ScPrime](https://scpri.me/)
* [Sia Decentralized Cloud Storage](https://sia.tech/)
* [spdlog](https://github.com/gabime/spdlog)
* [SQLite](https://www.sqlite.org)
* [stduuid](https://github.com/mariusbancila/stduuid)
* [Storj](https://storj.io/)

12
cmake/versions.cmake
View File

@ -1,15 +1,15 @@
set(BINUTILS_VERSION 2.43)
set(BOOST2_MAJOR_VERSION 1)
set(BOOST2_MINOR_VERSION 76)
set(BOOST2_PATCH_VERSION 0)
set(BOOST_MAJOR_VERSION 1)
set(BOOST_MINOR_VERSION 87)
set(BOOST_PATCH_VERSION 0)
set(BOOST2_MAJOR_VERSION 1)
set(BOOST2_MINOR_VERSION 76)
set(BOOST2_PATCH_VERSION 0)
set(CPP_HTTPLIB_VERSION 0.18.1)
set(CURL2_VERSION 8_11_0)
set(CURL_VERSION 8.11.0)
set(EXPAT2_VERSION 2_6_4)
set(CURL2_VERSION 8_11_0)
set(EXPAT_VERSION 2.6.4)
set(EXPAT2_VERSION 2_6_4)
set(GCC_VERSION 14.2.0)
set(GTEST_VERSION 1.15.2)
set(ICU_VERSION 76-1)
@ -22,7 +22,7 @@ set(PKG_CONFIG_VERSION 0.29.2)
set(PUGIXML_VERSION 1.14)
set(ROCKSDB_VERSION 9.7.4)
set(SPDLOG_VERSION 1.15.0)
set(SQLITE2_VERSION 3.46.1)
set(SQLITE_VERSION 3460100)
set(SQLITE2_VERSION 3.46.1)
set(STDUUID_VERSION 1.2.3)
set(ZLIB_VERSION 1.3.1)

4
repertory/librepertory/include/comm/curl/curl_comm.hpp
View File

@ -25,7 +25,7 @@
#include "app_config.hpp"
#include "comm/curl/multi_request.hpp"
#include "comm/i_http_comm.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/curl_error.hpp"
#include "utils/encryption.hpp"
@ -225,7 +225,7 @@ public:
}
if (curl_code != CURLE_OK) {
event_system2::instance().raise<curl_error>(curl_code, function_name,
event_system::instance().raise<curl_error>(curl_code, function_name,
url);
return false;
}

4
repertory/librepertory/include/drives/fuse/fuse_base.hpp
View File

@ -23,7 +23,7 @@
#define REPERTORY_INCLUDE_DRIVES_FUSE_FUSE_BASE_HPP_
#if !defined(_WIN32)
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "types/repertory.hpp"
namespace repertory {
@ -31,7 +31,7 @@ class app_config;
class i_provider;
class fuse_base {
E_CONSUMER2();
E_CONSUMER();
public:
explicit fuse_base(app_config &config);

2
repertory/librepertory/include/drives/fuse/remotefuse/remote_client.hpp
View File

@ -24,7 +24,7 @@
#include "comm/packet/packet_client.hpp"
#include "drives/fuse/remotefuse/i_remote_instance.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "types/remote.hpp"
namespace repertory {

2
repertory/librepertory/include/drives/fuse/remotefuse/remote_fuse_drive.hpp
View File

@ -25,7 +25,7 @@
#include "drives/fuse/fuse_base.hpp"
#include "drives/fuse/remotefuse/i_remote_instance.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
namespace repertory {
class app_config;

18
repertory/librepertory/include/drives/remote/remote_server_base.hpp
View File

@ -29,7 +29,7 @@
#include "drives/fuse/remotefuse/i_remote_instance.hpp"
#include "drives/remote/remote_open_file_table.hpp"
#include "drives/winfsp/remotewinfsp/i_remote_instance.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/service_start_begin.hpp"
#include "events/types/service_start_end.hpp"
#include "events/types/service_stop_begin.hpp"
@ -58,7 +58,10 @@ public:
drive_(drv),
mount_location_(std::move(mount_location)),
client_pool_(config.get_remote_mount().client_pool_size) {
event_system2::instance().raise<service_start_begin>("remote_server_base");
REPERTORY_USES_FUNCTION_NAME();
event_system::instance().raise<service_start_begin>(function_name,
"remote_server_base");
handler_lookup_.insert(
{"::winfsp_can_delete",
[this](std::uint32_t, const std::string &, std::uint64_t,
@ -1375,14 +1378,19 @@ public:
method, request, response,
message_complete);
});
event_system2::instance().raise<service_start_end>("remote_server_base");
event_system::instance().raise<service_start_end>(function_name,
"remote_server_base");
}
~remote_server_base() override {
event_system2::instance().raise<service_stop_begin>("remote_server_base");
REPERTORY_USES_FUNCTION_NAME();
event_system::instance().raise<service_stop_begin>(function_name,
"remote_server_base");
client_pool_.shutdown();
packet_server_.reset();
event_system2::instance().raise<service_stop_end>("remote_server_base");
event_system::instance().raise<service_stop_end>(function_name,
"remote_server_base");
}
public:

6
repertory/librepertory/include/drives/winfsp/remotewinfsp/remote_winfsp_drive.hpp
View File

@ -24,7 +24,7 @@
#if defined(_WIN32)
#include "drives/winfsp/remotewinfsp/i_remote_instance.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
namespace repertory {
class app_config;
@ -32,13 +32,13 @@ class lock_data;
class server;
namespace remote_winfsp {
class remote_winfsp_drive final : public virtual FileSystemBase {
E_CONSUMER2();
E_CONSUMER();
public:
remote_winfsp_drive(app_config &config, remote_instance_factory factory,
lock_data &lock);
~remote_winfsp_drive() override { E_CONSUMER2_RELEASE(); }
~remote_winfsp_drive() override { E_CONSUMER_RELEASE(); }
public:
class winfsp_service : virtual public Service {

6
repertory/librepertory/include/drives/winfsp/winfsp_drive.hpp
View File

@ -26,7 +26,7 @@
#include "drives/eviction.hpp"
#include "drives/winfsp/i_winfsp_drive.hpp"
#include "drives/winfsp/remotewinfsp/remote_server.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "file_manager/file_manager.hpp"
#include "rpc/server/full_server.hpp"
@ -37,12 +37,12 @@ class i_provider;
class winfsp_drive final : public virtual i_winfsp_drive,
public virtual FileSystemBase {
E_CONSUMER2();
E_CONSUMER();
public:
winfsp_drive(app_config &config, lock_data &lockData, i_provider &provider);
~winfsp_drive() override { E_CONSUMER2_RELEASE(); }
~winfsp_drive() override { E_CONSUMER_RELEASE(); }
private:
class winfsp_service final : virtual public Service {

6
repertory/librepertory/include/events/consumers/console_consumer.hpp
View File

@ -22,12 +22,12 @@
#ifndef REPERTORY_INCLUDE_EVENTS_CONSUMERS_CONSOLE_CONSUMER_HPP_
#define REPERTORY_INCLUDE_EVENTS_CONSUMERS_CONSOLE_CONSUMER_HPP_
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "types/repertory.hpp"
namespace repertory {
class console_consumer final {
E_CONSUMER2();
E_CONSUMER();
public:
console_consumer();
@ -37,7 +37,7 @@ public:
~console_consumer();
private:
static void process_event2(const i_event &evt);
static void process_event(const i_event &evt);
};
} // namespace repertory

6
repertory/librepertory/include/events/consumers/logging_consumer.hpp
View File

@ -22,12 +22,12 @@
#ifndef REPERTORY_INCLUDE_EVENTS_CONSUMERS_LOGGING_CONSUMER_HPP_
#define REPERTORY_INCLUDE_EVENTS_CONSUMERS_LOGGING_CONSUMER_HPP_
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "types/repertory.hpp"
namespace repertory {
class logging_consumer final {
E_CONSUMER2();
E_CONSUMER();
public:
logging_consumer(event_level level, std::string log_directory);
@ -40,7 +40,7 @@ private:
5ULL};
private:
static void process_event2(const i_event &evt);
static void process_event(const i_event &evt);
};
} // namespace repertory

79
repertory/librepertory/include/events/event_system2.hpp → repertory/librepertory/include/events/event_system.hpp
View File

@ -19,13 +19,13 @@
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_EVENT_SYSTEM2_HPP_
#define REPERTORY_INCLUDE_EVENTS_EVENT_SYSTEM2_HPP_
#ifndef REPERTORY_INCLUDE_EVENTS_EVENT_SYSTEM_HPP_
#define REPERTORY_INCLUDE_EVENTS_EVENT_SYSTEM_HPP_
namespace repertory {
class i_event;
class event_system2 final {
class event_system final {
private:
static constexpr const std::uint8_t max_queue_retry{
30U,
@ -40,37 +40,37 @@ private:
};
public:
event_system2(const event_system2 &) = delete;
event_system2(event_system2 &&) = delete;
auto operator=(const event_system2 &) -> event_system2 & = delete;
auto operator=(event_system2 &&) -> event_system2 & = delete;
event_system(const event_system &) = delete;
event_system(event_system &&) = delete;
auto operator=(const event_system &) -> event_system & = delete;
auto operator=(event_system &&) -> event_system & = delete;
protected:
event_system2() = default;
event_system() = default;
~event_system2() { stop(); }
~event_system() { stop(); }
public:
class event_consumer2 final {
class event_consumer final {
public:
explicit event_consumer2(std::function<void(const i_event &)> callback)
explicit event_consumer(std::function<void(const i_event &)> callback)
: callback_(std::move(callback)) {
event_system2::instance().attach(this);
event_system::instance().attach(this);
}
event_consumer2(std::string_view event_name,
std::function<void(const i_event &)> callback)
event_consumer(std::string_view event_name,
std::function<void(const i_event &)> callback)
: callback_(std::move(callback)) {
event_system2::instance().attach(event_name, this);
event_system::instance().attach(event_name, this);
}
~event_consumer2() { event_system2::instance().release(this); }
~event_consumer() { event_system::instance().release(this); }
public:
event_consumer2(const event_consumer2 &) = delete;
event_consumer2(event_consumer2 &&) = delete;
auto operator=(const event_consumer2 &) -> event_consumer2 & = delete;
auto operator=(event_consumer2 &&) -> event_consumer2 & = delete;
event_consumer(const event_consumer &) = delete;
event_consumer(event_consumer &&) = delete;
auto operator=(const event_consumer &) -> event_consumer & = delete;
auto operator=(event_consumer &&) -> event_consumer & = delete;
private:
std::function<void(const i_event &)> callback_;
@ -80,13 +80,13 @@ public:
};
private:
static event_system2 instance_;
static event_system instance_;
public:
[[nodiscard]] static auto instance() -> event_system2 &;
[[nodiscard]] static auto instance() -> event_system &;
private:
std::unordered_map<std::string, std::deque<event_consumer2 *>>
std::unordered_map<std::string, std::deque<event_consumer *>>
event_consumers_;
std::recursive_mutex consumer_mutex_;
std::vector<std::shared_ptr<i_event>> event_list_;
@ -104,43 +104,38 @@ private:
void queue_event(std::shared_ptr<i_event> evt);
public:
void attach(event_consumer2 *consumer);
void attach(event_consumer *consumer);
void attach(std::string_view event_name, event_consumer2 *consumer);
void attach(std::string_view event_name, event_consumer *consumer);
template <typename evt_t, typename... arg_t> void raise(arg_t &&...args) {
queue_event(std::make_shared<evt_t>(std::forward<arg_t>(args)...));
}
void release(event_consumer2 *consumer);
void release(event_consumer *consumer);
void start();
void stop();
};
using event_consumer2 = event_system2::event_consumer2;
using event_consumer = event_system2::event_consumer2;
using event_consumer = event_system::event_consumer;
#define E_CONSUMER2() \
#define E_CONSUMER() \
private: \
std::vector<std::shared_ptr<repertory::event_consumer2>> event_consumers2_
std::vector<std::shared_ptr<repertory::event_consumer>> event_consumers_
#define E_CONSUMER2_RELEASE() event_consumers2_.clear()
#define E_CONSUMER_RELEASE() event_consumers_.clear()
#define E_SUBSCRIBE2(name, callback) \
event_consumers2_.emplace_back(std::make_shared<repertory::event_consumer2>( \
#name, [this](const i_event &evt) { callback(evt); }))
#define E_SUBSCRIBE2_EXACT(name, callback) \
event_consumers2_.emplace_back(std::make_shared<repertory::event_consumer2>( \
#name, [this](const i_event &evt) { \
callback(dynamic_cast<const name &>(evt)); \
#define E_SUBSCRIBE(event, callback) \
event_consumers_.emplace_back(std::make_shared<repertory::event_consumer>( \
event::name, [this](const i_event &evt) { \
callback(dynamic_cast<const event &>(evt)); \
}))
#define E_SUBSCRIBE2_ALL(callback) \
event_consumers2_.emplace_back(std::make_shared<repertory::event_consumer2>( \
#define E_SUBSCRIBE_ALL(callback) \
event_consumers_.emplace_back(std::make_shared<repertory::event_consumer>( \
[this](const i_event &evt) { callback(evt); }))
} // namespace repertory
#endif // REPERTORY_INCLUDE_EVENTS_EVENT_SYSTEM2_HPP_
#endif // REPERTORY_INCLUDE_EVENTS_EVENT_SYSTEM_HPP_

120
repertory/librepertory/include/events/events.hpp
View File

@ -1,120 +0,0 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_EVENTS_HPP_
#define REPERTORY_INCLUDE_EVENTS_EVENTS_HPP_
#include "types/repertory.hpp"
namespace repertory {
// clang-format off
E_SIMPLE2(download_restored, info,
std::string, api_path, ap, E_FROM_STRING,
std::string, dest_path, dest, E_FROM_STRING
);
E_SIMPLE3(download_restore_failed, error,
std::string, api_path, ap, E_FROM_STRING,
std::string, dest_path, dest, E_FROM_STRING,
std::string, error, err, E_FROM_STRING
);
E_SIMPLE3(download_resume_add_failed, error,
std::string, api_path, ap, E_FROM_STRING,
std::string, dest_path, dest, E_FROM_STRING,
std::string, error, err, E_FROM_STRING
);
E_SIMPLE2(download_resume_added, debug,
std::string, api_path, ap, E_FROM_STRING,
std::string, dest_path, dest, E_FROM_STRING
);
E_SIMPLE2(download_resume_removed, debug,
std::string, api_path, ap, E_FROM_STRING,
std::string, dest_path, dest, E_FROM_STRING
);
E_SIMPLE1(item_timeout, trace,
std::string, api_path, ap, E_FROM_STRING
);
E_SIMPLE3(download_type_selected, debug,
std::string, api_path, ap, E_FROM_STRING,
std::string, source, src, E_FROM_STRING,
download_type, download_type, type, E_FROM_DOWNLOAD_TYPE
);
E_SIMPLE3(fuse_event, debug,
std::string, function, func, E_FROM_STRING,
std::string, api_path, ap, E_FROM_STRING,
int, result, res, E_FROM_INT32
);
E_SIMPLE1(fuse_args_parsed, info,
std::string, arguments, args, E_FROM_STRING
);
E_SIMPLE2(invalid_cache_size, warn,
std::uint64_t, cache_size, sz, E_FROM_UINT64,
std::uint64_t, by, by, E_FROM_UINT64
);
E_SIMPLE2(max_cache_size_reached, warn,
std::uint64_t, cache_size, sz, E_FROM_UINT64,
std::uint64_t, max_cache_size, max, E_FROM_UINT64
);
E_SIMPLE2(packet_client_timeout, error,
std::string, event_name, en, E_FROM_STRING,
std::string, message, msg, E_FROM_STRING
);
//FUSE
E_SIMPLE3(remote_fuse_server_event, debug,
std::string, function, func, E_FROM_STRING,
std::string, api_path, ap, E_FROM_STRING,
packet::error_type, result, res, E_FROM_INT32
);
//WINFSP
E_SIMPLE3(winfsp_event, debug,
std::string, function, func, E_FROM_STRING,
std::string, api_path, ap, E_FROM_STRING,
NTSTATUS, result, res, E_FROM_INT32
);
E_SIMPLE(drive_stop_begin, info);
E_SIMPLE(drive_stop_end, info);
E_SIMPLE(drive_stop_timed_out, info);
E_SIMPLE3(remote_winfsp_client_event, debug,
std::string, function, func, E_FROM_STRING,
std::string, api_path, ap, E_FROM_STRING,
packet::error_type, result, res, E_FROM_INT32
);
E_SIMPLE3(remote_winfsp_server_event, debug,
std::string, function, FUNC, E_FROM_STRING,
std::string, api_path, AP, E_FROM_STRING,
packet::error_type, result, RES, E_FROM_INT32
);
// clang-format on
} // namespace repertory
#endif // REPERTORY_INCLUDE_EVENTS_EVENTS_HPP_

3
repertory/librepertory/include/events/types/curl_error.hpp
View File

@ -33,6 +33,7 @@ struct curl_error final : public i_event {
function_name(std::string{function_name_}),
url(std::move(url_)) {}
static constexpr const event_level level{event_level::error};
static constexpr const std::string_view name{"curl_error"};
CURLcode code{};
@ -40,7 +41,7 @@ struct curl_error final : public i_event {
std::string url;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::error;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/debug_log.hpp
View File

@ -31,13 +31,14 @@ struct debug_log final : public i_event {
debug_log(std::string_view function_name_, std::string msg_)
: function_name(std::string(function_name_)), msg(std::move(msg_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"debug_log"};
std::string function_name;
std::string msg;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/directory_remove_failed.hpp
View File

@ -34,6 +34,7 @@ struct directory_remove_failed final : public i_event {
error(error_),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::error};
static constexpr const std::string_view name{"directory_remove_failed"};
std::string api_path;
@ -41,7 +42,7 @@ struct directory_remove_failed final : public i_event {
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::error;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/directory_removed.hpp
View File

@ -32,13 +32,14 @@ struct directory_removed final : public i_event {
: api_path(std::move(api_path_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"directory_removed"};
std::string api_path;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/directory_removed_externally.hpp
View File

@ -35,6 +35,7 @@ struct directory_removed_externally final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"directory_removed_externally"};
std::string api_path;
@ -42,7 +43,7 @@ struct directory_removed_externally final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::warn;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/download_begin.hpp
View File

@ -34,6 +34,7 @@ struct download_begin final : public i_event {
dest_path(std::move(dest_path_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"download_begin"};
std::string api_path;
@ -41,7 +42,7 @@ struct download_begin final : public i_event {
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/download_end.hpp
View File

@ -35,6 +35,7 @@ struct download_end final : public i_event {
error(error_),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"download_end"};
std::string api_path;
@ -43,7 +44,7 @@ struct download_end final : public i_event {
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/download_progress.hpp
View File

@ -35,6 +35,7 @@ struct download_progress final : public i_event {
function_name(std::string(function_name_)),
progress(progress_) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"download_progress"};
std::string api_path;
@ -43,7 +44,7 @@ struct download_progress final : public i_event {
double progress{};
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

81
repertory/librepertory/include/events/types/download_restore_failed.hpp Normal file
View File

@ -0,0 +1,81 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESTORE_FAILED_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESTORE_FAILED_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct download_restore_failed final : public i_event {
download_restore_failed() = default;
download_restore_failed(std::string api_path_, std::string dest_path_,
std::string error_, std::string_view function_name_)
: api_path(std::move(api_path_)),
dest_path(std::move(dest_path_)),
error(std::move(error_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::error};
static constexpr const std::string_view name{"download_restore_failed"};
std::string api_path;
std::string dest_path;
std::string error;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}|dp|{}|error|{}", name, function_name,
api_path, dest_path, error);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::download_restore_failed> {
static void to_json(json &data,
const repertory::download_restore_failed &value) {
data["api_path"] = value.api_path;
data["dest_path"] = value.dest_path;
data["error"] = value.error;
data["function_name"] = value.function_name;
}
static void from_json(const json &data,
repertory::download_restore_failed &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("dest_path").get_to<std::string>(value.dest_path);
data.at("error").get_to<std::string>(value.error);
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESTORE_FAILED_HPP_

75
repertory/librepertory/include/events/types/download_restored.hpp Normal file
View File

@ -0,0 +1,75 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESTORED_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESTORED_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct download_restored final : public i_event {
download_restored() = default;
download_restored(std::string api_path_, std::string dest_path_,
std::string_view function_name_)
: api_path(std::move(api_path_)),
dest_path(std::move(dest_path_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"download_restored"};
std::string api_path;
std::string dest_path;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}|dp|{}", name, function_name, api_path,
dest_path);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::download_restored> {
static void to_json(json &data, const repertory::download_restored &value) {
data["api_path"] = value.api_path;
data["dest_path"] = value.dest_path;
data["function_name"] = value.function_name;
}
static void from_json(const json &data, repertory::download_restored &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("dest_path").get_to<std::string>(value.dest_path);
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESTORED_HPP_

82
repertory/librepertory/include/events/types/download_resume_add_failed.hpp Normal file
View File

@ -0,0 +1,82 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESUME_ADD_FAILED_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESUME_ADD_FAILED_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct download_resume_add_failed final : public i_event {
download_resume_add_failed() = default;
download_resume_add_failed(std::string api_path_, std::string dest_path_,
std::string error_,
std::string_view function_name_)
: api_path(std::move(api_path_)),
dest_path(std::move(dest_path_)),
error(std::move(error_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::error};
static constexpr const std::string_view name{"download_resume_add_failed"};
std::string api_path;
std::string dest_path;
std::string error;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}|dp|{}|error|{}", name, function_name,
api_path, dest_path, error);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::download_resume_add_failed> {
static void to_json(json &data,
const repertory::download_resume_add_failed &value) {
data["api_path"] = value.api_path;
data["dest_path"] = value.dest_path;
data["error"] = value.error;
data["function_name"] = value.function_name;
}
static void from_json(const json &data,
repertory::download_resume_add_failed &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("dest_path").get_to<std::string>(value.dest_path);
data.at("error").get_to<std::string>(value.error);
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESUME_ADD_FAILED_HPP_

77
repertory/librepertory/include/events/types/download_resume_added.hpp Normal file
View File

@ -0,0 +1,77 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESUME_ADDED_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESUME_ADDED_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct download_resume_added final : public i_event {
download_resume_added() = default;
download_resume_added(std::string api_path_, std::string dest_path_,
std::string_view function_name_)
: api_path(std::move(api_path_)),
dest_path(std::move(dest_path_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"download_resume_added"};
std::string api_path;
std::string dest_path;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}|dp|{}", name, function_name, api_path,
dest_path);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::download_resume_added> {
static void to_json(json &data,
const repertory::download_resume_added &value) {
data["api_path"] = value.api_path;
data["dest_path"] = value.dest_path;
data["function_name"] = value.function_name;
}
static void from_json(const json &data,
repertory::download_resume_added &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("dest_path").get_to<std::string>(value.dest_path);
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESUME_ADDED_HPP_

77
repertory/librepertory/include/events/types/download_resume_removed.hpp Normal file
View File

@ -0,0 +1,77 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESUME_REMOVED_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESUME_REMOVED_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct download_resume_removed final : public i_event {
download_resume_removed() = default;
download_resume_removed(std::string api_path_, std::string dest_path_,
std::string_view function_name_)
: api_path(std::move(api_path_)),
dest_path(std::move(dest_path_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"download_resume_removed"};
std::string api_path;
std::string dest_path;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}|dp|{}", name, function_name, api_path,
dest_path);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::download_resume_removed> {
static void to_json(json &data,
const repertory::download_resume_removed &value) {
data["api_path"] = value.api_path;
data["dest_path"] = value.dest_path;
data["function_name"] = value.function_name;
}
static void from_json(const json &data,
repertory::download_resume_removed &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("dest_path").get_to<std::string>(value.dest_path);
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_RESUME_REMOVED_HPP_

82
repertory/librepertory/include/events/types/download_type_selected.hpp Normal file
View File

@ -0,0 +1,82 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_TYPE_SELECTED_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_TYPE_SELECTED_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct download_type_selected final : public i_event {
download_type_selected() = default;
download_type_selected(std::string api_path_, std::string dest_path_,
std::string_view function_name_, download_type type_)
: api_path(std::move(api_path_)),
dest_path(std::move(dest_path_)),
function_name(std::string(function_name_)),
type(type_) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"download_type_selected"};
std::string api_path;
std::string dest_path;
std::string function_name;
download_type type{};
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}|dp|{}|type|{}", name, function_name,
api_path, dest_path, download_type_to_string(type));
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::download_type_selected> {
static void to_json(json &data,
const repertory::download_type_selected &value) {
data["api_path"] = value.api_path;
data["dest_path"] = value.dest_path;
data["function_name"] = value.function_name;
data["type"] = repertory::download_type_to_string(value.type);
}
static void from_json(const json &data,
repertory::download_type_selected &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("dest_path").get_to<std::string>(value.dest_path);
data.at("function_name").get_to<std::string>(value.function_name);
value.type = repertory::download_type_from_string(
data.at("type").get<std::string>());
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_DOWNLOAD_TYPE_SELECTED_HPP_

21
repertory/librepertory/include/events/types/drive_mount_failed.hpp
View File

@ -29,20 +29,21 @@
namespace repertory {
struct drive_mount_failed final : public i_event {
drive_mount_failed() = default;
drive_mount_failed(std::string_view function_name_,
std::string mount_location_, NTSTATUS status_)
: function_name(std::string(function_name_)),
mount_location(std::move(mount_location_)),
status(status_) {}
drive_mount_failed(NTSTATUS error_, std::string_view function_name_,
std::string mount_location_)
: error(error_),
function_name(std::string(function_name_)),
mount_location(std::move(mount_location_)) {}
static constexpr const event_level level{event_level::error};
static constexpr const std::string_view name{"drive_mount_failed"};
NTSTATUS error{};
std::string function_name;
std::string mount_location;
NTSTATUS status{};
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::error;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
@ -51,7 +52,7 @@ struct drive_mount_failed final : public i_event {
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|location|{}|status|{}", name, function_name,
mount_location, status);
mount_location, error);
}
};
} // namespace repertory
@ -59,16 +60,16 @@ struct drive_mount_failed final : public i_event {
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::drive_mount_failed> {
static void to_json(json &data, const repertory::drive_mount_failed &value) {
data["error"] = value.error;
data["function_name"] = value.function_name;
data["mount_location"] = value.mount_location;
data["status"] = value.status;
}
static void from_json(const json &data,
repertory::drive_mount_failed &value) {
data.at("error").get_to<NTSTATUS>(value.error);
data.at("function_name").get_to<std::string>(value.function_name);
data.at("mount_location").get_to<std::string>(value.mount_location);
data.at("status").get_to<NTSTATUS>(value.status);
}
};
NLOHMANN_JSON_NAMESPACE_END

3
repertory/librepertory/include/events/types/drive_mount_result.hpp
View File

@ -34,6 +34,7 @@ struct drive_mount_result final : public i_event {
mount_location(std::move(mount_location_)),
result(std::move(result_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"drive_mount_result"};
std::string function_name;
@ -41,7 +42,7 @@ struct drive_mount_result final : public i_event {
std::string result;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/drive_mounted.hpp
View File

@ -32,13 +32,14 @@ struct drive_mounted final : public i_event {
: function_name(std::string(function_name_)),
mount_location(std::move(mount_location_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"drive_mounted"};
std::string function_name;
std::string mount_location;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

67
repertory/librepertory/include/events/types/drive_stop_timed_out.hpp Normal file
View File

@ -0,0 +1,67 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_DRIVE_STOP_TIMED_OUT_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_DRIVE_STOP_TIMED_OUT_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct drive_stop_timed_out final : public i_event {
drive_stop_timed_out() = default;
drive_stop_timed_out(std::string_view function_name_)
: function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"drive_stop_timed_out"};
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}", name, function_name);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::drive_stop_timed_out> {
static void to_json(json &data,
const repertory::drive_stop_timed_out &value) {
data["function_name"] = value.function_name;
}
static void from_json(const json &data,
repertory::drive_stop_timed_out &value) {
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_DRIVE_STOP_TIMED_OUT_HPP_

3
repertory/librepertory/include/events/types/drive_unmount_pending.hpp
View File

@ -33,13 +33,14 @@ struct drive_unmount_pending final : public i_event {
: function_name(std::string(function_name_)),
mount_location(std::move(mount_location_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"drive_unmount_pending"};
std::string function_name;
std::string mount_location;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/drive_unmounted.hpp
View File

@ -32,13 +32,14 @@ struct drive_unmounted final : public i_event {
: function_name(std::string(function_name_)),
mount_location(std::move(mount_location_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"drive_unmounted"};
std::string function_name;
std::string mount_location;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

17
repertory/librepertory/include/events/types/event_level_changed.hpp
View File

@ -28,16 +28,17 @@
namespace repertory {
struct event_level_changed final : public i_event {
event_level_changed() = default;
event_level_changed(std::string_view function_name_, event_level level_)
: function_name(std::string(function_name_)), level(level_) {}
event_level_changed(std::string_view function_name_, event_level new_level_)
: function_name(std::string(function_name_)), new_level(new_level_) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"event_level_changed"};
std::string function_name;
event_level level{};
event_level new_level{};
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
@ -46,7 +47,7 @@ struct event_level_changed final : public i_event {
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|level|{}", name, function_name,
event_level_to_string(level));
event_level_to_string(new_level));
}
};
} // namespace repertory
@ -54,14 +55,14 @@ struct event_level_changed final : public i_event {
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::event_level_changed> {
static void to_json(json &data, const repertory::event_level_changed &value) {
data["event_level"] = repertory::event_level_to_string(value.level);
data["new_level"] = repertory::event_level_to_string(value.new_level);
data["function_name"] = value.function_name;
}
static void from_json(const json &data,
repertory::event_level_changed &value) {
value.level = repertory::event_level_from_string(
data.at("event_level").get<std::string>());
value.new_level = repertory::event_level_from_string(
data.at("new_level").get<std::string>());
data.at("function_name").get_to<std::string>(value.function_name);
}
};

3
repertory/librepertory/include/events/types/file_pinned.hpp
View File

@ -32,13 +32,14 @@ struct file_pinned final : public i_event {
: api_path(std::move(api_path_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"file_pinned"};
std::string api_path;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/file_remove_failed.hpp
View File

@ -34,6 +34,7 @@ struct file_remove_failed final : public i_event {
error(error_),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::error};
static constexpr const std::string_view name{"file_remove_failed"};
std::string api_path;
@ -41,7 +42,7 @@ struct file_remove_failed final : public i_event {
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::error;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/file_removed.hpp
View File

@ -32,13 +32,14 @@ struct file_removed final : public i_event {
: api_path(std::move(api_path_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"file_removed"};
std::string api_path;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/file_removed_externally.hpp
View File

@ -35,6 +35,7 @@ struct file_removed_externally final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"file_removed_externally"};
std::string api_path;
@ -42,7 +43,7 @@ struct file_removed_externally final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::warn;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/file_unpinned.hpp
View File

@ -32,13 +32,14 @@ struct file_unpinned final : public i_event {
: api_path(std::move(api_path_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"file_unpinned"};
std::string api_path;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/file_upload_completed.hpp
View File

@ -37,6 +37,7 @@ struct file_upload_completed final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"file_upload_completed"};
std::string api_path;
@ -46,7 +47,7 @@ struct file_upload_completed final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/file_upload_failed.hpp
View File

@ -35,6 +35,7 @@ struct file_upload_failed final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"file_upload_failed"};
std::string api_path;
@ -43,7 +44,7 @@ struct file_upload_failed final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::warn;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/file_upload_not_found.hpp
View File

@ -34,6 +34,7 @@ struct file_upload_not_found final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"file_upload_not_found"};
std::string api_path;
@ -41,7 +42,7 @@ struct file_upload_not_found final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::warn;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/file_upload_queued.hpp
View File

@ -34,6 +34,7 @@ struct file_upload_queued final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"file_upload_queued"};
std::string api_path;
@ -41,7 +42,7 @@ struct file_upload_queued final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/file_upload_removed.hpp
View File

@ -32,13 +32,14 @@ struct file_upload_removed final : public i_event {
: api_path(std::move(api_path_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"file_upload_removed"};
std::string api_path;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

16
repertory/librepertory/include/events/types/file_upload_retry.hpp
View File

@ -28,22 +28,23 @@
namespace repertory {
struct file_upload_retry final : public i_event {
file_upload_retry() = default;
file_upload_retry(std::string api_path_, std::string error_,
file_upload_retry(std::string api_path_, api_error error_,
std::string_view function_name_, std::string source_path_)
: api_path(std::move(api_path_)),
error(std::move(error_)),
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"file_upload_retry"};
std::string api_path;
std::string error;
api_error error{};
std::string function_name;
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::warn;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
@ -51,8 +52,8 @@ struct file_upload_retry final : public i_event {
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}|error|{}|sp|{}", name, function_name,
api_path, error, source_path);
return fmt::format("{}|func|{}|ap|{}|sp|{}|error|{}", name, function_name,
api_path, source_path, api_error_to_string(error));
}
};
} // namespace repertory
@ -61,14 +62,15 @@ NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::file_upload_retry> {
static void to_json(json &data, const repertory::file_upload_retry &value) {
data["api_path"] = value.api_path;
data["error"] = value.error;
data["error"] = repertory::api_error_to_string(value.error);
data["function_name"] = value.function_name;
data["source_path"] = value.source_path;
}
static void from_json(const json &data, repertory::file_upload_retry &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("error").get_to<std::string>(value.error);
value.error =
repertory::api_error_from_string(data.at("error").get<std::string>());
data.at("function_name").get_to<std::string>(value.function_name);
data.at("source_path").get_to<std::string>(value.source_path);
}

3
repertory/librepertory/include/events/types/filesystem_item_added.hpp
View File

@ -35,6 +35,7 @@ struct filesystem_item_added final : public i_event {
directory(directory_),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"filesystem_item_added"};
std::string api_parent;
@ -43,7 +44,7 @@ struct filesystem_item_added final : public i_event {
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/filesystem_item_closed.hpp
View File

@ -37,6 +37,7 @@ struct filesystem_item_closed final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::trace};
static constexpr const std::string_view name{"filesystem_item_closed"};
std::string api_path;
@ -46,7 +47,7 @@ struct filesystem_item_closed final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::trace;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/filesystem_item_evicted.hpp
View File

@ -35,6 +35,7 @@ struct filesystem_item_evicted final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"filesystem_item_evicted"};
std::string api_path;
@ -42,7 +43,7 @@ struct filesystem_item_evicted final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/filesystem_item_handle_closed.hpp
View File

@ -39,6 +39,7 @@ struct filesystem_item_handle_closed final : public i_event {
handle(handle_),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::trace};
static constexpr const std::string_view name{"filesystem_item_handle_closed"};
std::string api_path;
@ -49,7 +50,7 @@ struct filesystem_item_handle_closed final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::trace;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/filesystem_item_handle_opened.hpp
View File

@ -37,6 +37,7 @@ struct filesystem_item_handle_opened final : public i_event {
handle(handle_),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::trace};
static constexpr const std::string_view name{"filesystem_item_handle_opened"};
std::string api_path;
@ -46,7 +47,7 @@ struct filesystem_item_handle_opened final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::trace;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/filesystem_item_opened.hpp
View File

@ -36,6 +36,7 @@ struct filesystem_item_opened final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::trace};
static constexpr const std::string_view name{"filesystem_item_opened"};
std::string api_path;
@ -44,7 +45,7 @@ struct filesystem_item_opened final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::trace;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

70
repertory/librepertory/include/events/types/fuse_args_parsed.hpp Normal file
View File

@ -0,0 +1,70 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_FUSE_ARGS_PARSED_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_FUSE_ARGS_PARSED_HPP_
#if !defined(_WIN32)
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct fuse_args_parsed final : public i_event {
fuse_args_parsed() = default;
fuse_args_parsed(std::string_view args_, std::string_view function_name_)
: args(std::move(args_)), function_name(std::string{function_name_}) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"fuse_args_parsed"};
std::string args;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|args|{}", name, function_name, args);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::fuse_args_parsed> {
static void to_json(json &data, const repertory::fuse_args_parsed &value) {
data["args"] = value.args;
data["function_name"] = value.function_name;
}
static void from_json(const json &data, repertory::fuse_args_parsed &value) {
data.at("args").get_to<std::string>(value.args);
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // !defined(_WIN32)
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_FUSE_ARGS_PARSED_HPP_

77
repertory/librepertory/include/events/types/fuse_event.hpp Normal file
View File

@ -0,0 +1,77 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_FUSE_EVENT_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_FUSE_EVENT_HPP_
#if !defined(_WIN32)
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct fuse_event final : public i_event {
fuse_event() = default;
fuse_event(std::string_view api_path_, std::int32_t error_,
std::string_view function_name_)
: api_path(std::string{api_path_}),
error(error_),
function_name(std::string{function_name_}) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"fuse_event"};
std::string api_path;
std::int32_t error{};
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}|error|{}", name, function_name,
api_path, error);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::fuse_event> {
static void to_json(json &data, const repertory::fuse_event &value) {
data["api_path"] = value.api_path;
data["error"] = value.error;
data["function_name"] = value.function_name;
}
static void from_json(const json &data, repertory::fuse_event &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("error").get_to<std::int32_t>(value.error);
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // !defined(_WIN32)
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_FUSE_EVENT_HPP_

76
repertory/librepertory/include/events/types/invalid_cache_size.hpp Normal file
View File

@ -0,0 +1,76 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_INVALID_CACHE_SIZE_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_INVALID_CACHE_SIZE_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct invalid_cache_size final : public i_event {
invalid_cache_size() = default;
invalid_cache_size(std::uint64_t cache_size_, std::string_view function_name_,
std::uint64_t invalid_size_)
: cache_size(cache_size_),
function_name(std::string{function_name_}),
invalid_size(invalid_size_) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"invalid_cache_size"};
std::uint64_t cache_size{};
std::string function_name;
std::uint64_t invalid_size{};
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|size|{}|by|{}", name, function_name,
cache_size, invalid_size);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::invalid_cache_size> {
static void to_json(json &data, const repertory::invalid_cache_size &value) {
data["cache_size"] = value.cache_size;
data["function_name"] = value.function_name;
data["invalid_size"] = value.invalid_size;
}
static void from_json(const json &data,
repertory::invalid_cache_size &value) {
data.at("cache_size").get_to<std::uint64_t>(value.cache_size);
data.at("function_name").get_to<std::string>(value.function_name);
data.at("invalid_size").get_to<std::uint64_t>(value.invalid_size);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_INVALID_CACHE_SIZE_HPP_

69
repertory/librepertory/include/events/types/item_timeout.hpp Normal file
View File

@ -0,0 +1,69 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_ITEM_TIMEOUT_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_ITEM_TIMEOUT_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct item_timeout final : public i_event {
item_timeout() = default;
item_timeout(std::string api_path_, std::string_view function_name_)
: api_path(std::move(api_path_)),
function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::trace};
static constexpr const std::string_view name{"item_timeout"};
std::string api_path;
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}", name, function_name, api_path);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::item_timeout> {
static void to_json(json &data, const repertory::item_timeout &value) {
data["api_path"] = value.api_path;
data["function_name"] = value.function_name;
}
static void from_json(const json &data, repertory::item_timeout &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_ITEM_TIMEOUT_HPP_

78
repertory/librepertory/include/events/types/max_cache_size_reached.hpp Normal file
View File

@ -0,0 +1,78 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_MAX_CACHE_SIZE_REACHED_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_MAX_CACHE_SIZE_REACHED_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct max_cache_size_reached final : public i_event {
max_cache_size_reached() = default;
max_cache_size_reached(std::uint64_t cache_size_,
std::string_view function_name_,
std::uint64_t max_cache_size_)
: cache_size(cache_size_),
function_name(std::string{function_name_}),
max_cache_size(max_cache_size_) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"max_cache_size_reached"};
std::uint64_t cache_size{};
std::string function_name;
std::uint64_t max_cache_size{};
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|size|{}|max|{}", name, function_name,
cache_size, max_cache_size);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::max_cache_size_reached> {
static void to_json(json &data,
const repertory::max_cache_size_reached &value) {
data["cache_size"] = value.cache_size;
data["function_name"] = value.function_name;
data["max_cache_size"] = value.max_cache_size;
}
static void from_json(const json &data,
repertory::max_cache_size_reached &value) {
data.at("cache_size").get_to<std::uint64_t>(value.cache_size);
data.at("function_name").get_to<std::string>(value.function_name);
data.at("max_cache_size").get_to<std::uint64_t>(value.max_cache_size);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_MAX_CACHE_SIZE_REACHED_HPP_

3
repertory/librepertory/include/events/types/orphaned_file_detected.hpp
View File

@ -33,13 +33,14 @@ struct orphaned_file_detected final : public i_event {
: function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"orphaned_file_detected"};
std::string function_name;
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

6
repertory/librepertory/include/events/types/orphaned_file_processing_failed.hpp
View File

@ -36,8 +36,10 @@ struct orphaned_file_processing_failed final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::error};
static constexpr const std::string_view name{
"orphaned_file_processing_failed"};
"orphaned_file_processing_failed",
};
std::string dest_path;
std::string error;
@ -45,7 +47,7 @@ struct orphaned_file_processing_failed final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/orphaned_source_file_detected.hpp
View File

@ -33,13 +33,14 @@ struct orphaned_source_file_detected final : public i_event {
: function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"orphaned_source_file_detected"};
std::string function_name;
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/orphaned_source_file_removed.hpp
View File

@ -33,13 +33,14 @@ struct orphaned_source_file_removed final : public i_event {
: function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"orphaned_source_file_removed"};
std::string function_name;
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

77
repertory/librepertory/include/events/types/packet_client_timeout.hpp Normal file
View File

@ -0,0 +1,77 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_PACKET_CLIENT_TIMEOUT_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_PACKET_CLIENT_TIMEOUT_HPP_
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct packet_client_timeout final : public i_event {
packet_client_timeout() = default;
packet_client_timeout(std::string event_name_,
std::string_view function_name_, std::string msg_)
: event_name(std::move(event_name_)),
function_name(std::string(function_name_)),
msg(std::move(msg_)) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"packet_client_timeout"};
std::string event_name;
std::string function_name;
std::string msg;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|event|{}|msg|{}", name, function_name,
event_name, msg);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::packet_client_timeout> {
static void to_json(json &data,
const repertory::packet_client_timeout &value) {
data["event_name"] = value.event_name;
data["function_name"] = value.function_name;
data["msg"] = value.msg;
}
static void from_json(const json &data,
repertory::packet_client_timeout &value) {
data.at("event_name").get_to<std::string>(value.event_name);
data.at("function_name").get_to<std::string>(value.function_name);
data.at("msg").get_to<std::string>(value.msg);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_PACKET_CLIENT_TIMEOUT_HPP_

3
repertory/librepertory/include/events/types/polling_item_begin.hpp
View File

@ -32,13 +32,14 @@ struct polling_item_begin final : public i_event {
: function_name(std::string(function_name_)),
item_name(std::move(item_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"polling_item_begin"};
std::string function_name;
std::string item_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/polling_item_end.hpp
View File

@ -32,13 +32,14 @@ struct polling_item_end final : public i_event {
: function_name(std::string(function_name_)),
item_name(std::move(item_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"polling_item_end"};
std::string function_name;
std::string item_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/provider_offline.hpp
View File

@ -34,6 +34,7 @@ struct provider_offline final : public i_event {
host_name_or_ip(std::move(host_name_or_ip_)),
port(port_) {}
static constexpr const event_level level{event_level::warn};
static constexpr const std::string_view name{"provider_offline"};
std::string function_name;
@ -41,7 +42,7 @@ struct provider_offline final : public i_event {
std::uint16_t port{};
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/provider_upload_begin.hpp
View File

@ -34,6 +34,7 @@ struct provider_upload_begin final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"provider_upload_begin"};
std::string api_path;
@ -41,7 +42,7 @@ struct provider_upload_begin final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::warn;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/provider_upload_end.hpp
View File

@ -35,6 +35,7 @@ struct provider_upload_end final : public i_event {
function_name(std::string(function_name_)),
source_path(std::move(source_path_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"provider_upload_end"};
std::string api_path;
@ -43,7 +44,7 @@ struct provider_upload_end final : public i_event {
std::string source_path;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

77
repertory/librepertory/include/events/types/remote_server_event.hpp Normal file
View File

@ -0,0 +1,77 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_REMOTE_SERVER_EVENT_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_REMOTE_SERVER_EVENT_HPP_
#include "comm/packet/packet.hpp"
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct remote_server_event final : public i_event {
remote_server_event() = default;
remote_server_event(std::string api_path_, packet::error_type error_,
std::string_view function_name_)
: api_path(std::move(api_path_)),
error(error_),
function_name(std::string{function_name_}) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"remote_server_event"};
std::string api_path;
packet::error_type error{};
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}|error|{}", name, function_name,
api_path, error);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::remote_server_event> {
static void to_json(json &data, const repertory::remote_server_event &value) {
data["api_path"] = value.api_path;
data["error"] = value.error;
data["function_name"] = value.function_name;
}
static void from_json(const json &data,
repertory::remote_server_event &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("error").get_to<repertory::packet::error_type>(value.error);
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_REMOTE_SERVER_EVENT_HPP_

3
repertory/librepertory/include/events/types/repertory_exception.hpp
View File

@ -31,13 +31,14 @@ struct repertory_exception final : public i_event {
repertory_exception(std::string_view function_name_, std::string msg_)
: function_name(std::string(function_name_)), msg(std::move(msg_)) {}
static constexpr const event_level level{event_level::error};
static constexpr const std::string_view name{"repertory_exception"};
std::string function_name;
std::string msg;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::error;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/service_start_begin.hpp
View File

@ -33,13 +33,14 @@ struct service_start_begin final : public i_event {
: function_name(std::string(function_name_)),
service_name(std::move(service_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"service_start_begin"};
std::string function_name;
std::string service_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/service_start_end.hpp
View File

@ -32,13 +32,14 @@ struct service_start_end final : public i_event {
: function_name(std::string(function_name_)),
service_name(std::move(service_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"service_start_end"};
std::string function_name;
std::string service_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/service_stop_begin.hpp
View File

@ -32,13 +32,14 @@ struct service_stop_begin final : public i_event {
: function_name(std::string(function_name_)),
service_name(std::move(service_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"service_stop_begin"};
std::string function_name;
std::string service_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/service_stop_end.hpp
View File

@ -32,13 +32,14 @@ struct service_stop_end final : public i_event {
: function_name(std::string(function_name_)),
service_name(std::move(service_name_)) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"service_stop_end"};
std::string function_name;
std::string service_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::debug;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/unmount_requested.hpp
View File

@ -31,12 +31,13 @@ struct unmount_requested final : public i_event {
unmount_requested(std::string_view function_name_)
: function_name(std::string(function_name_)) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"unmount_requested"};
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

3
repertory/librepertory/include/events/types/unmount_result.hpp
View File

@ -35,6 +35,7 @@ struct unmount_result final : public i_event {
mount_location(std::move(mount_location_)),
result(result_) {}
static constexpr const event_level level{event_level::info};
static constexpr const std::string_view name{"unmount_result"};
std::string function_name;
@ -42,7 +43,7 @@ struct unmount_result final : public i_event {
std::int32_t result{};
[[nodiscard]] auto get_event_level() const -> event_level override {
return event_level::info;
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {

77
repertory/librepertory/include/events/types/winfsp_event.hpp Normal file
View File

@ -0,0 +1,77 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef REPERTORY_INCLUDE_EVENTS_TYPES_WINFSP_EVENT_HPP_
#define REPERTORY_INCLUDE_EVENTS_TYPES_WINFSP_EVENT_HPP_
#if defined(_WIN32)
#include "events/i_event.hpp"
#include "types/repertory.hpp"
namespace repertory {
struct winfsp_event final : public i_event {
winfsp_event() = default;
winfsp_event(std::string api_path_, NTSTATUS error_,
std::string_view function_name_)
: api_path(std::move(api_path_)),
error(error_),
function_name(std::string{function_name_}) {}
static constexpr const event_level level{event_level::debug};
static constexpr const std::string_view name{"winfsp_event"};
std::string api_path;
NTSTATUS error{};
std::string function_name;
[[nodiscard]] auto get_event_level() const -> event_level override {
return level;
}
[[nodiscard]] auto get_name() const -> std::string_view override {
return name;
}
[[nodiscard]] auto get_single_line() const -> std::string override {
return fmt::format("{}|func|{}|ap|{}|error|{}", name, function_name,
api_path, error);
}
};
} // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::winfsp_event> {
static void to_json(json &data, const repertory::winfsp_event &value) {
data["api_path"] = value.api_path;
data["error"] = value.error;
data["function_name"] = value.function_name;
}
static void from_json(const json &data, repertory::winfsp_event &value) {
data.at("api_path").get_to<std::string>(value.api_path);
data.at("error").get_to<NTSTATUS>(value.error);
data.at("function_name").get_to<std::string>(value.function_name);
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // defined(_WIN32)
#endif // REPERTORY_INCLUDE_EVENTS_TYPES_WINFSP_EVENT_HPP_

4
repertory/librepertory/include/file_manager/file_manager.hpp
View File

@ -23,7 +23,7 @@
#define REPERTORY_INCLUDE_FILE_MANAGER_FILE_MANAGER_HPP_
#include "db/i_file_mgr_db.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/file_upload_completed.hpp"
#include "file_manager/i_file_manager.hpp"
#include "file_manager/i_open_file.hpp"
@ -37,7 +37,7 @@ class app_config;
class i_provider;
class file_manager final : public i_file_manager, public i_upload_manager {
E_CONSUMER2();
E_CONSUMER();
private:
static constexpr const std::chrono::seconds queue_wait_secs{

16
repertory/librepertory/include/rpc/client/client.hpp
View File

@ -31,18 +31,18 @@ public:
private:
const rpc_host_info host_info_;
std::atomic<std::uint32_t> request_id_;
std::atomic<std::uint32_t> request_id_{0U};
public:
[[nodiscard]] auto get_drive_information() -> rpc_response;
[[nodiscard]] auto get_config() -> rpc_response;
[[nodiscard]] auto
get_config_value_by_name(const std::string &name) -> rpc_response;
[[nodiscard]] auto get_config_value_by_name(const std::string &name)
-> rpc_response;
[[nodiscard]] auto
get_directory_items(const std::string &api_path) -> rpc_response;
[[nodiscard]] auto get_directory_items(const std::string &api_path)
-> rpc_response;
[[nodiscard]] auto get_open_files() -> rpc_response;
@ -52,9 +52,9 @@ public:
[[nodiscard]] auto pinned_status(const std::string &api_file) -> rpc_response;
[[nodiscard]] auto
set_config_value_by_name(const std::string &name,
const std::string &value) -> rpc_response;
[[nodiscard]] auto set_config_value_by_name(const std::string &name,
const std::string &value)
-> rpc_response;
[[nodiscard]] auto unmount() -> rpc_response;

3
repertory/librepertory/include/types/repertory.hpp
View File

@ -43,7 +43,8 @@ constexpr const auto max_orphaned_file_retention_days{std::uint16_t(31U)};
constexpr const auto max_ring_buffer_file_size{std::uint16_t(1024U)};
constexpr const auto max_s3_object_name_length{1024U};
constexpr const auto min_cache_size_bytes{
std::uint64_t(100UL * 1024UL * 1024UL)};
std::uint64_t(100UL * 1024UL * 1024UL),
};
constexpr const auto min_download_timeout_secs{std::uint8_t(5U)};
constexpr const auto min_online_check_retry_secs{std::uint16_t(15U)};
constexpr const auto min_orphaned_file_retention_days{std::uint16_t(1U)};

4
repertory/librepertory/include/utils/timeout.hpp
View File

@ -32,13 +32,13 @@ public:
public:
timeout(std::function<void()> timeout_callback,
const std::chrono::system_clock::duration &duration = 10s);
std::chrono::system_clock::duration duration);
~timeout() { disable(); }
private:
std::atomic<bool> timeout_killed_;
std::unique_ptr<std::thread> timeout_thread_;
std::unique_ptr<std::thread> timeout_thread_{nullptr};
std::mutex timeout_mutex_;
std::condition_variable timeout_notify_;

4
repertory/librepertory/src/app_config.cpp
View File

@ -21,7 +21,7 @@
*/
#include "app_config.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/event_level_changed.hpp"
#include "file_manager/cache_size_mgr.hpp"
#include "platform/platform.hpp"
@ -1149,7 +1149,7 @@ void app_config::set_event_level(const event_level &value) {
REPERTORY_USES_FUNCTION_NAME();
if (set_value(event_level_, value)) {
event_system2::instance().raise<event_level_changed>(function_name, value);
event_system::instance().raise<event_level_changed>(function_name, value);
}
}

16
repertory/librepertory/src/comm/packet/client_pool.cpp
View File

@ -21,7 +21,7 @@
*/
#include "comm/packet/client_pool.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/service_start_begin.hpp"
#include "events/types/service_start_end.hpp"
#include "events/types/service_stop_begin.hpp"
@ -46,7 +46,8 @@ void client_pool::pool::execute(
client_pool::pool::pool(std::uint8_t pool_size) {
REPERTORY_USES_FUNCTION_NAME();
event_system2::instance().raise<service_start_begin>("client_pool");
event_system::instance().raise<service_start_begin>(function_name,
"client_pool");
for (std::uint8_t i = 0U; i < pool_size; i++) {
pool_queues_.emplace_back(std::make_unique<work_queue>());
@ -109,7 +110,8 @@ client_pool::pool::pool(std::uint8_t pool_size) {
});
}
event_system2::instance().raise<service_start_end>("client_pool");
event_system::instance().raise<service_start_end>(function_name,
"client_pool");
}
void client_pool::pool::shutdown() {
@ -151,11 +153,14 @@ void client_pool::remove_client(const std::string &client_id) {
}
void client_pool::shutdown() {
REPERTORY_USES_FUNCTION_NAME();
if (shutdown_) {
return;
}
event_system2::instance().raise<service_stop_begin>("client_pool");
event_system::instance().raise<service_stop_begin>(function_name,
"client_pool");
unique_mutex_lock pool_lock(pool_mutex_);
if (not shutdown_) {
shutdown_ = true;
@ -165,6 +170,7 @@ void client_pool::shutdown() {
pool_lookup_.clear();
}
pool_lock.unlock();
event_system2::instance().raise<service_stop_end>("client_pool");
event_system::instance().raise<service_stop_end>(function_name,
"client_pool");
}
} // namespace repertory

23
repertory/librepertory/src/comm/packet/packet_client.cpp
View File

@ -21,7 +21,8 @@
*/
#include "comm/packet/packet_client.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/packet_client_timeout.hpp"
#include "platform/platform.hpp"
#include "types/repertory.hpp"
#include "utils/collection.hpp"
@ -105,8 +106,8 @@ void packet_client::put_client(std::shared_ptr<client> &cli) {
}
}
auto packet_client::read_packet(client &cli,
packet &response) const -> packet::error_type {
auto packet_client::read_packet(client &cli, packet &response) const
-> packet::error_type {
data_buffer buffer(sizeof(std::uint32_t));
const auto read_buffer = [&]() {
std::uint32_t offset{};
@ -147,8 +148,8 @@ void packet_client::resolve() {
.resolve(cfg_.host_name_or_ip, std::to_string(cfg_.api_port));
}
auto packet_client::send(std::string_view method,
std::uint32_t &service_flags) -> packet::error_type {
auto packet_client::send(std::string_view method, std::uint32_t &service_flags)
-> packet::error_type {
packet request;
return send(method, request, service_flags);
}
@ -160,8 +161,8 @@ auto packet_client::send(std::string_view method, packet &request,
}
auto packet_client::send(std::string_view method, packet &request,
packet &response,
std::uint32_t &service_flags) -> packet::error_type {
packet &response, std::uint32_t &service_flags)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto success = false;
@ -183,8 +184,8 @@ auto packet_client::send(std::string_view method, packet &request,
timeout request_timeout(
[method, current_client]() {
event_system2::instance().raise<packet_client_timeout>(
"request", std::string{method});
event_system::instance().raise<packet_client_timeout>(
"request", function_name, std::string{method});
packet_client::close(*current_client);
},
std::chrono::milliseconds(cfg_.send_timeout_ms));
@ -205,8 +206,8 @@ auto packet_client::send(std::string_view method, packet &request,
timeout response_timeout(
[method, current_client]() {
event_system2::instance().raise<packet_client_timeout>(
"response", std::string{method});
event_system::instance().raise<packet_client_timeout>(
"response", function_name, std::string{method});
packet_client::close(*current_client);
},
std::chrono::milliseconds(cfg_.recv_timeout_ms));

18
repertory/librepertory/src/comm/packet/packet_server.cpp
View File

@ -22,7 +22,7 @@
#include "comm/packet/packet_server.hpp"
#include "comm/packet/packet.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/service_start_begin.hpp"
#include "events/types/service_start_end.hpp"
#include "events/types/service_stop_begin.hpp"
@ -40,13 +40,20 @@ packet_server::packet_server(std::uint16_t port, std::string token,
: encryption_token_(std::move(token)),
closed_(std::move(closed)),
message_handler_(std::move(message_handler)) {
event_system2::instance().raise<service_start_begin>("packet_server");
REPERTORY_USES_FUNCTION_NAME();
event_system::instance().raise<service_start_begin>(function_name,
"packet_server");
initialize(port, pool_size);
event_system2::instance().raise<service_start_end>("packet_server");
event_system::instance().raise<service_start_end>(function_name,
"packet_server");
}
packet_server::~packet_server() {
event_system2::instance().raise<service_stop_begin>("packet_server");
REPERTORY_USES_FUNCTION_NAME();
event_system::instance().raise<service_stop_begin>(function_name,
"packet_server");
std::thread([this]() {
for (std::size_t i = 0U; i < service_threads_.size(); i++) {
io_context_.stop();
@ -55,7 +62,8 @@ packet_server::~packet_server() {
server_thread_->join();
server_thread_.reset();
event_system2::instance().raise<service_stop_end>("packet_server");
event_system::instance().raise<service_stop_end>(function_name,
"packet_server");
}
void packet_server::add_client(connection &conn, const std::string &client_id) {

19
repertory/librepertory/src/db/impl/rdb_file_db.cpp
View File

@ -191,6 +191,10 @@ void rdb_file_db::enumerate_item_list(
list.clear();
}
}
if (not list.empty()) {
callback(list);
}
}
auto rdb_file_db::get_api_path(const std::string &source_path,
@ -203,9 +207,8 @@ auto rdb_file_db::get_api_path(const std::string &source_path,
});
}
auto rdb_file_db::get_directory_api_path(const std::string &source_path,
std::string &api_path) const
-> api_error {
auto rdb_file_db::get_directory_api_path(
const std::string &source_path, std::string &api_path) const -> api_error {
REPERTORY_USES_FUNCTION_NAME();
auto result = perform_action(function_name, [&]() -> rocksdb::Status {
@ -228,9 +231,8 @@ auto rdb_file_db::get_directory_api_path(const std::string &source_path,
: result;
}
auto rdb_file_db::get_directory_source_path(const std::string &api_path,
std::string &source_path) const
-> api_error {
auto rdb_file_db::get_directory_source_path(
const std::string &api_path, std::string &source_path) const -> api_error {
REPERTORY_USES_FUNCTION_NAME();
auto result = perform_action(function_name, [&]() -> rocksdb::Status {
@ -291,9 +293,8 @@ auto rdb_file_db::get_file_data(const std::string &api_path,
return result;
}
auto rdb_file_db::get_file_source_path(const std::string &api_path,
std::string &source_path) const
-> api_error {
auto rdb_file_db::get_file_source_path(
const std::string &api_path, std::string &source_path) const -> api_error {
REPERTORY_USES_FUNCTION_NAME();
auto result = perform_action(function_name, [&]() -> rocksdb::Status {

11
repertory/librepertory/src/db/impl/rdb_meta_db.cpp
View File

@ -81,6 +81,10 @@ void rdb_meta_db::enumerate_api_path_list(
callback(list);
list.clear();
}
if (not list.empty()) {
callback(list);
}
}
auto rdb_meta_db::get_api_path(const std::string &source_path,
@ -314,10 +318,9 @@ void rdb_meta_db::remove_api_path(const std::string &api_path) {
}
}
auto rdb_meta_db::remove_api_path(const std::string &api_path,
const std::string &source_path,
rocksdb::Transaction *txn)
-> rocksdb::Status {
auto rdb_meta_db::remove_api_path(
const std::string &api_path, const std::string &source_path,
rocksdb::Transaction *txn) -> rocksdb::Status {
auto txn_res = txn->Delete(pinned_family_, api_path);
if (not txn_res.ok()) {
return txn_res;

34
repertory/librepertory/src/db/impl/sqlite_file_db.cpp
View File

@ -65,9 +65,8 @@ sqlite_file_db::sqlite_file_db(const app_config &cfg) {
sqlite_file_db::~sqlite_file_db() { db_.reset(); }
auto sqlite_file_db::add_directory(const std::string &api_path,
const std::string &source_path)
-> api_error {
auto sqlite_file_db::add_directory(
const std::string &api_path, const std::string &source_path) -> api_error {
REPERTORY_USES_FUNCTION_NAME();
auto result = utils::db::sqlite::db_insert{*db_, file_table}
@ -158,6 +157,10 @@ void sqlite_file_db::enumerate_item_list(
list.clear();
}
}
if (not list.empty()) {
callback(list);
}
}
auto sqlite_file_db::get_api_path(const std::string &source_path,
@ -179,9 +182,8 @@ auto sqlite_file_db::get_api_path(const std::string &source_path,
return api_error::item_not_found;
}
auto sqlite_file_db::get_directory_api_path(const std::string &source_path,
std::string &api_path) const
-> api_error {
auto sqlite_file_db::get_directory_api_path(
const std::string &source_path, std::string &api_path) const -> api_error {
auto result = utils::db::sqlite::db_select{*db_, file_table}
.column("api_path")
.where("source_path")
@ -202,9 +204,8 @@ auto sqlite_file_db::get_directory_api_path(const std::string &source_path,
return api_error::directory_not_found;
}
auto sqlite_file_db::get_directory_source_path(const std::string &api_path,
std::string &source_path) const
-> api_error {
auto sqlite_file_db::get_directory_source_path(
const std::string &api_path, std::string &source_path) const -> api_error {
auto result = utils::db::sqlite::db_select{*db_, file_table}
.column("source_path")
.where("api_path")
@ -225,9 +226,8 @@ auto sqlite_file_db::get_directory_source_path(const std::string &api_path,
return api_error::directory_not_found;
}
auto sqlite_file_db::get_file_api_path(const std::string &source_path,
std::string &api_path) const
-> api_error {
auto sqlite_file_db::get_file_api_path(
const std::string &source_path, std::string &api_path) const -> api_error {
auto result = utils::db::sqlite::db_select{*db_, file_table}
.column("api_path")
.where("source_path")
@ -286,9 +286,8 @@ auto sqlite_file_db::get_file_data(const std::string &api_path,
return api_error::item_not_found;
}
auto sqlite_file_db::get_file_source_path(const std::string &api_path,
std::string &source_path) const
-> api_error {
auto sqlite_file_db::get_file_source_path(
const std::string &api_path, std::string &source_path) const -> api_error {
auto result = utils::db::sqlite::db_select{*db_, file_table}
.column("source_path")
.where("api_path")
@ -330,9 +329,8 @@ auto sqlite_file_db::get_item_list(stop_type_callback stop_requested_cb) const
return ret;
}
auto sqlite_file_db::get_source_path(const std::string &api_path,
std::string &source_path) const
-> api_error {
auto sqlite_file_db::get_source_path(
const std::string &api_path, std::string &source_path) const -> api_error {
auto result = utils::db::sqlite::db_select{*db_, file_table}
.column("source_path")
.where("api_path")

4
repertory/librepertory/src/db/impl/sqlite_meta_db.cpp
View File

@ -95,6 +95,10 @@ void sqlite_meta_db::enumerate_api_path_list(
list.clear();
}
}
if (not list.empty()) {
callback(list);
}
}
auto sqlite_meta_db::get_api_path(const std::string &source_path,

22
repertory/librepertory/src/drives/directory_cache.cpp
View File

@ -39,12 +39,11 @@ auto directory_cache::get_directory(std::uint64_t handle)
-> std::shared_ptr<directory_iterator> {
recur_mutex_lock directory_lock(directory_mutex_);
auto iter =
std::find_if(directory_lookup_.begin(), directory_lookup_.end(),
[handle](auto &&item) -> bool {
auto &&handles = item.second.handles;
return std::find(handles.begin(), handles.end(), handle) !=
item.second.handles.end();
});
std::ranges::find_if(directory_lookup_, [handle](auto &&item) -> bool {
auto &&handles = item.second.handles;
return std::find(handles.begin(), handles.end(), handle) !=
item.second.handles.end();
});
if (iter != directory_lookup_.end()) {
return iter->second.iterator;
}
@ -68,12 +67,11 @@ auto directory_cache::remove_directory(const std::string &api_path)
void directory_cache::remove_directory(std::uint64_t handle) {
recur_mutex_lock directory_lock(directory_mutex_);
auto iter =
std::find_if(directory_lookup_.begin(), directory_lookup_.end(),
[handle](auto &&item) -> bool {
auto &&handles = item.second.handles;
return std::find(handles.begin(), handles.end(), handle) !=
item.second.handles.end();
});
std::ranges::find_if(directory_lookup_, [handle](auto &&item) -> bool {
auto &&handles = item.second.handles;
return std::find(handles.begin(), handles.end(), handle) !=
item.second.handles.end();
});
if (iter == directory_lookup_.end()) {
return;
}

15
repertory/librepertory/src/drives/directory_iterator.cpp
View File

@ -102,10 +102,9 @@ auto directory_iterator::get_directory_item(std::size_t offset,
auto directory_iterator::get_directory_item(const std::string &api_path,
directory_item &di) -> api_error {
auto iter =
std::find_if(items_.begin(), items_.end(), [&](const auto &item) -> bool {
return api_path == item.api_path;
});
auto iter = std::ranges::find_if(items_, [&api_path](auto &&item) -> bool {
return api_path == item.api_path;
});
if (iter == items_.end()) {
return api_error::item_not_found;
}
@ -126,10 +125,10 @@ auto directory_iterator::get_json(std::size_t offset, json &item) -> int {
auto directory_iterator::get_next_directory_offset(
const std::string &api_path) const -> std::size_t {
const auto iter = std::find_if(items_.begin(), items_.end(),
[&api_path](const auto &dir_item) -> bool {
return api_path == dir_item.api_path;
});
const auto iter =
std::ranges::find_if(items_, [&api_path](auto &&dir_item) -> bool {
return api_path == dir_item.api_path;
});
return (iter == items_.end()) ? 0U
: static_cast<std::size_t>(

75
repertory/librepertory/src/drives/fuse/fuse_base.cpp
View File

@ -24,7 +24,9 @@
#include "drives/fuse/fuse_base.hpp"
#include "app_config.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/fuse_args_parsed.hpp"
#include "events/types/fuse_event.hpp"
#include "events/types/unmount_requested.hpp"
#include "events/types/unmount_result.hpp"
#include "initialize.hpp"
@ -90,12 +92,12 @@ fuse_base::fuse_base(app_config &config) : config_(config) {
fuse_ops_.flag_reserved = 0;
#endif // FUSE_USE_VERSION < 30
E_SUBSCRIBE2_EXACT(unmount_requested, [this](const unmount_requested &) {
E_SUBSCRIBE(unmount_requested, [this](const unmount_requested &) {
std::thread([this]() { this->shutdown(); }).detach();
});
}
fuse_base::~fuse_base() { E_CONSUMER2_RELEASE(); }
fuse_base::~fuse_base() { E_CONSUMER_RELEASE(); }
auto fuse_base::access_(const char *path, int mask) -> int {
REPERTORY_USES_FUNCTION_NAME();
@ -118,8 +120,8 @@ auto fuse_base::chflags_(const char *path, uint32_t flags) -> int {
#endif // __APPLE__
#if FUSE_USE_VERSION >= 30
auto fuse_base::chmod_(const char *path, mode_t mode,
struct fuse_file_info *fi) -> int {
auto fuse_base::chmod_(const char *path, mode_t mode, struct fuse_file_info *fi)
-> int {
REPERTORY_USES_FUNCTION_NAME();
return instance().execute_callback(
@ -186,7 +188,7 @@ void fuse_base::display_options(
#if FUSE_USE_VERSION >= 30
fuse_cmdline_help();
#else
struct fuse_operations fuse_ops {};
struct fuse_operations fuse_ops{};
fuse_main(args.size(),
reinterpret_cast<char **>(const_cast<char **>(args.data())),
&fuse_ops, nullptr);
@ -196,7 +198,7 @@ void fuse_base::display_options(
}
void fuse_base::display_version_information(std::vector<const char *> args) {
struct fuse_operations fuse_ops {};
struct fuse_operations fuse_ops{};
fuse_main(static_cast<int>(args.size()),
reinterpret_cast<char **>(const_cast<char **>(args.data())),
&fuse_ops, nullptr);
@ -334,8 +336,8 @@ auto fuse_base::getxtimes_(const char *path, struct timespec *bkuptime,
#endif // __APPLE__
#if FUSE_USE_VERSION >= 30
auto fuse_base::init_(struct fuse_conn_info *conn,
struct fuse_config *cfg) -> void * {
auto fuse_base::init_(struct fuse_conn_info *conn, struct fuse_config *cfg)
-> void * {
REPERTORY_USES_FUNCTION_NAME();
return execute_void_pointer_callback(function_name, [&]() -> void * {
@ -372,13 +374,13 @@ auto fuse_base::init_impl(struct fuse_conn_info *conn) -> void * {
if (not utils::file::change_to_process_directory()) {
utils::error::raise_error(function_name,
"failed to change to process directory");
event_system2::instance().raise<unmount_requested>();
event_system::instance().raise<unmount_requested>();
return this;
}
if (not console_enabled_ && not repertory::project_initialize()) {
utils::error::raise_error(function_name, "failed to initialize repertory");
event_system2::instance().raise<unmount_requested>();
event_system::instance().raise<unmount_requested>();
}
return this;
@ -408,7 +410,7 @@ auto fuse_base::mount(std::vector<std::string> args) -> int {
char *mount_location{nullptr};
#if FUSE_USE_VERSION >= 30
struct fuse_cmdline_opts opts {};
struct fuse_cmdline_opts opts{};
fuse_parse_cmdline(&fa, &opts);
mount_location = opts.mountpoint;
#else
@ -477,8 +479,8 @@ auto fuse_base::read_(const char *path, char *buffer, size_t read_size,
#if FUSE_USE_VERSION >= 30
auto fuse_base::readdir_(const char *path, void *buf,
fuse_fill_dir_t fuse_fill_dir, off_t offset,
struct fuse_file_info *fi,
fuse_readdir_flags flags) -> int {
struct fuse_file_info *fi, fuse_readdir_flags flags)
-> int {
REPERTORY_USES_FUNCTION_NAME();
return instance().execute_callback(
@ -510,8 +512,8 @@ auto fuse_base::release_(const char *path, struct fuse_file_info *fi) -> int {
});
}
auto fuse_base::releasedir_(const char *path,
struct fuse_file_info *fi) -> int {
auto fuse_base::releasedir_(const char *path, struct fuse_file_info *fi)
-> int {
REPERTORY_USES_FUNCTION_NAME();
return instance().execute_callback(
@ -521,8 +523,8 @@ auto fuse_base::releasedir_(const char *path,
}
#if FUSE_USE_VERSION >= 30
auto fuse_base::rename_(const char *from, const char *to,
unsigned int flags) -> int {
auto fuse_base::rename_(const char *from, const char *to, unsigned int flags)
-> int {
REPERTORY_USES_FUNCTION_NAME();
return instance().execute_callback(
@ -601,12 +603,17 @@ auto fuse_base::listxattr_(const char *path, char *buffer, size_t size) -> int {
}
void fuse_base::notify_fuse_args_parsed(const std::vector<std::string> &args) {
event_system2::instance().raise<fuse_args_parsed>(std::accumulate(
args.begin(), args.end(), std::string(),
[](auto &&command_line, auto &&arg) -> auto {
command_line += (command_line.empty() ? arg : (" " + std::string(arg)));
return command_line;
}));
REPERTORY_USES_FUNCTION_NAME();
event_system::instance().raise<fuse_args_parsed>(
std::accumulate(args.begin(), args.end(), std::string(),
[](auto &&command_line, auto &&arg) -> auto {
command_line +=
(command_line.empty() ? arg
: (" " + std::string(arg)));
return command_line;
}),
function_name);
}
auto fuse_base::parse_args(std::vector<std::string> &args) -> int {
@ -700,8 +707,8 @@ void fuse_base::raise_fuse_event(std::string_view function_name,
if (((config_.get_event_level() >= fuse_event::level) && (ret != 0)) ||
(config_.get_event_level() >= event_level::trace)) {
std::string func{function_name};
event_system2::instance().raise<fuse_event>(
utils::string::right_trim(func, '_'), std::string{api_path}, ret);
event_system::instance().raise<fuse_event>(
api_path, ret, utils::string::right_trim(func, '_'));
}
}
@ -753,8 +760,8 @@ void fuse_base::shutdown() {
REPERTORY_USES_FUNCTION_NAME();
auto res = unmount(get_mount_location());
event_system2::instance().raise<unmount_result>(function_name,
get_mount_location(), res);
event_system::instance().raise<unmount_result>(function_name,
get_mount_location(), res);
}
#if defined(__APPLE__)
@ -767,8 +774,8 @@ auto fuse_base::setattr_x_(const char *path, struct setattr_x *attr) -> int {
});
}
auto fuse_base::setbkuptime_(const char *path,
const struct timespec *bkuptime) -> int {
auto fuse_base::setbkuptime_(const char *path, const struct timespec *bkuptime)
-> int {
REPERTORY_USES_FUNCTION_NAME();
return instance().execute_callback(
@ -777,8 +784,8 @@ auto fuse_base::setbkuptime_(const char *path,
});
}
auto fuse_base::setchgtime_(const char *path,
const struct timespec *chgtime) -> int {
auto fuse_base::setchgtime_(const char *path, const struct timespec *chgtime)
-> int {
REPERTORY_USES_FUNCTION_NAME();
return instance().execute_callback(
@ -787,8 +794,8 @@ auto fuse_base::setchgtime_(const char *path,
});
}
auto fuse_base::setcrtime_(const char *path,
const struct timespec *crtime) -> int {
auto fuse_base::setcrtime_(const char *path, const struct timespec *crtime)
-> int {
REPERTORY_USES_FUNCTION_NAME();
return instance().execute_callback(

98
repertory/librepertory/src/drives/fuse/fuse_drive.cpp
View File

@ -30,9 +30,10 @@
#include "drives/fuse/remotefuse/remote_server.hpp"
#include "events/consumers/console_consumer.hpp"
#include "events/consumers/logging_consumer.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/drive_mount_result.hpp"
#include "events/types/drive_mounted.hpp"
#include "events/types/drive_stop_timed_out.hpp"
#include "events/types/drive_unmount_pending.hpp"
#include "events/types/drive_unmounted.hpp"
#include "platform/platform.hpp"
@ -84,8 +85,8 @@ auto fuse_drive::chown_impl(std::string api_path, uid_t uid, gid_t gid,
struct fuse_file_info * /*file_info*/)
-> api_error {
#else
auto fuse_drive::chown_impl(std::string api_path, uid_t uid, gid_t gid)
-> api_error {
auto fuse_drive::chown_impl(std::string api_path, uid_t uid,
gid_t gid) -> api_error {
#endif
return check_and_perform(
api_path, X_OK, [&](api_meta_map &meta) -> api_error {
@ -281,6 +282,7 @@ void fuse_drive::stop_all() {
});
if (future.wait_for(30s) == std::future_status::timeout) {
event_system::instance().raise<drive_stop_timed_out>(function_name);
app_config::set_stop_requested();
future.wait();
}
@ -293,8 +295,8 @@ void fuse_drive::stop_all() {
void fuse_drive::destroy_impl(void *ptr) {
REPERTORY_USES_FUNCTION_NAME();
event_system2::instance().raise<drive_unmount_pending>(function_name,
get_mount_location());
event_system::instance().raise<drive_unmount_pending>(function_name,
get_mount_location());
stop_all();
@ -302,8 +304,8 @@ void fuse_drive::destroy_impl(void *ptr) {
fuse_base::destroy_impl(ptr);
event_system2::instance().raise<drive_unmounted>(function_name,
get_mount_location());
event_system::instance().raise<drive_unmounted>(function_name,
get_mount_location());
}
auto fuse_drive::fallocate_impl(std::string /*api_path*/, int mode,
@ -492,8 +494,8 @@ auto fuse_drive::getattr_impl(std::string api_path, struct stat *unix_st,
struct fuse_file_info * /*file_info*/)
-> api_error {
#else
auto fuse_drive::getattr_impl(std::string api_path, struct stat *unix_st)
-> api_error {
auto fuse_drive::getattr_impl(std::string api_path,
struct stat *unix_st) -> api_error {
#endif
auto parent = utils::path::get_parent_api_path(api_path);
@ -559,8 +561,8 @@ auto fuse_drive::getxtimes_impl(std::string api_path, struct timespec *bkuptime,
#endif // __APPLE__
#if FUSE_USE_VERSION >= 30
auto fuse_drive::init_impl(struct fuse_conn_info *conn, struct fuse_config *cfg)
-> void * {
auto fuse_drive::init_impl(struct fuse_conn_info *conn,
struct fuse_config *cfg) -> void * {
#else
void *fuse_drive::init_impl(struct fuse_conn_info *conn) {
#endif
@ -580,7 +582,7 @@ void *fuse_drive::init_impl(struct fuse_conn_info *conn) {
logging_consumer_ = std::make_unique<logging_consumer>(
config_.get_event_level(), config_.get_log_directory());
event_system2::instance().start();
event_system::instance().start();
was_mounted_ = true;
fm_ = std::make_unique<file_manager>(config_, provider_);
@ -616,8 +618,8 @@ void *fuse_drive::init_impl(struct fuse_conn_info *conn) {
utils::error::raise_error(function_name, "failed to set mount state");
}
event_system2::instance().raise<drive_mounted>(function_name,
get_mount_location());
event_system::instance().raise<drive_mounted>(function_name,
get_mount_location());
} catch (const std::exception &e) {
utils::error::raise_error(function_name, e, "exception during fuse init");
@ -664,13 +666,17 @@ auto fuse_drive::mkdir_impl(std::string api_path, mode_t mode) -> api_error {
}
void fuse_drive::notify_fuse_main_exit(int &ret) {
if (was_mounted_) {
event_system2::instance().raise<drive_mount_result>(
function_name, get_mount_location(), std::to_string(ret));
event_system2::instance().stop();
logging_consumer_.reset();
console_consumer_.reset();
REPERTORY_USES_FUNCTION_NAME();
if (not was_mounted_) {
return;
}
event_system::instance().raise<drive_mount_result>(
function_name, get_mount_location(), std::to_string(ret));
event_system::instance().stop();
logging_consumer_.reset();
console_consumer_.reset();
}
auto fuse_drive::open_impl(std::string api_path,
@ -798,9 +804,8 @@ auto fuse_drive::release_impl(std::string /*api_path*/,
return api_error::success;
}
auto fuse_drive::releasedir_impl(std::string /*api_path*/,
struct fuse_file_info *file_info)
-> api_error {
auto fuse_drive::releasedir_impl(
std::string /*api_path*/, struct fuse_file_info *file_info) -> api_error {
auto iter = directory_cache_->get_directory(file_info->fh);
if (iter == nullptr) {
return api_error::invalid_handle;
@ -818,8 +823,8 @@ auto fuse_drive::rename_directory(const std::string &from_api_path,
}
auto fuse_drive::rename_file(const std::string &from_api_path,
const std::string &to_api_path, bool overwrite)
-> int {
const std::string &to_api_path,
bool overwrite) -> int {
auto res = fm_->rename_file(from_api_path, to_api_path, overwrite);
errno = std::abs(utils::from_api_error(res));
return (res == api_error::success) ? 0 : -1;
@ -829,8 +834,8 @@ auto fuse_drive::rename_file(const std::string &from_api_path,
auto fuse_drive::rename_impl(std::string from_api_path, std::string to_api_path,
unsigned int /*flags*/) -> api_error {
#else
auto fuse_drive::rename_impl(std::string from_api_path, std::string to_api_path)
-> api_error {
auto fuse_drive::rename_impl(std::string from_api_path,
std::string to_api_path) -> api_error {
#endif
auto res = check_parent_access(to_api_path, W_OK | X_OK);
if (res != api_error::success) {
@ -932,15 +937,15 @@ auto fuse_drive::getxattr_impl(std::string api_path, const char *name,
}
#else // __APPLE__
auto fuse_drive::getxattr_impl(std::string api_path, const char *name,
char *value, size_t size, int &attribute_size)
-> api_error {
char *value, size_t size,
int &attribute_size) -> api_error {
return getxattr_common(api_path, name, value, size, attribute_size, nullptr);
}
#endif // __APPLE__
auto fuse_drive::listxattr_impl(std::string api_path, char *buffer, size_t size,
int &required_size, bool &return_size)
-> api_error {
int &required_size,
bool &return_size) -> api_error {
auto check_size = (size == 0);
auto res = check_parent_access(api_path, X_OK);
@ -980,8 +985,8 @@ auto fuse_drive::listxattr_impl(std::string api_path, char *buffer, size_t size,
return res;
}
auto fuse_drive::removexattr_impl(std::string api_path, const char *name)
-> api_error {
auto fuse_drive::removexattr_impl(std::string api_path,
const char *name) -> api_error {
std::string attribute_name;
#if defined(__APPLE__)
auto res = parse_xattr_parameters(name, 0, attribute_name, api_path);
@ -1009,8 +1014,8 @@ auto fuse_drive::setxattr_impl(std::string api_path, const char *name,
uint32_t position) -> api_error {
#else // __APPLE__
auto fuse_drive::setxattr_impl(std::string api_path, const char *name,
const char *value, size_t size, int flags)
-> api_error {
const char *value, size_t size,
int flags) -> api_error {
#endif
std::string attribute_name;
#if defined(__APPLE__)
@ -1088,8 +1093,8 @@ void fuse_drive::set_item_meta(const std::string &api_path,
}
#if defined(__APPLE__)
auto fuse_drive::setattr_x_impl(std::string api_path, struct setattr_x *attr)
-> api_error {
auto fuse_drive::setattr_x_impl(std::string api_path,
struct setattr_x *attr) -> api_error {
bool exists{};
auto res = provider_.is_file(api_path, exists);
if (res != api_error::success) {
@ -1143,7 +1148,7 @@ auto fuse_drive::setattr_x_impl(std::string api_path, struct setattr_x *attr)
ts[0].tv_sec = attr->acctime.tv_sec;
ts[0].tv_nsec = attr->acctime.tv_nsec;
} else {
struct timeval tv{};
struct timeval tv {};
gettimeofday(&tv, NULL);
ts[0].tv_sec = tv.tv_sec;
ts[0].tv_nsec = tv.tv_usec * 1000;
@ -1188,9 +1193,8 @@ auto fuse_drive::setattr_x_impl(std::string api_path, struct setattr_x *attr)
return api_error::success;
}
auto fuse_drive::setbkuptime_impl(std::string api_path,
const struct timespec *bkuptime)
-> api_error {
auto fuse_drive::setbkuptime_impl(
std::string api_path, const struct timespec *bkuptime) -> api_error {
return check_and_perform(
api_path, X_OK, [&](api_meta_map &meta) -> api_error {
auto nanos = bkuptime->tv_nsec +
@ -1226,8 +1230,8 @@ auto fuse_drive::setvolname_impl(const char * /*volname*/) -> api_error {
return api_error::success;
}
auto fuse_drive::statfs_x_impl(std::string /*api_path*/, struct statfs *stbuf)
-> api_error {
auto fuse_drive::statfs_x_impl(std::string /*api_path*/,
struct statfs *stbuf) -> api_error {
if (statfs(&config_.get_cache_directory()[0], stbuf) != 0) {
return api_error::os_error;
}
@ -1252,8 +1256,8 @@ auto fuse_drive::statfs_x_impl(std::string /*api_path*/, struct statfs *stbuf)
return api_error::success;
}
#else // __APPLE__
auto fuse_drive::statfs_impl(std::string /*api_path*/, struct statvfs *stbuf)
-> api_error {
auto fuse_drive::statfs_impl(std::string /*api_path*/,
struct statvfs *stbuf) -> api_error {
if (statvfs(config_.get_cache_directory().data(), stbuf) != 0) {
return api_error::os_error;
}
@ -1337,8 +1341,8 @@ auto fuse_drive::utimens_impl(std::string api_path, const struct timespec tv[2],
struct fuse_file_info * /*file_info*/)
-> api_error {
#else
auto fuse_drive::utimens_impl(std::string api_path, const struct timespec tv[2])
-> api_error {
auto fuse_drive::utimens_impl(std::string api_path,
const struct timespec tv[2]) -> api_error {
#endif
api_meta_map meta;
auto res = provider_.get_item_meta(api_path, meta);

38
repertory/librepertory/src/drives/fuse/fuse_drive_base.cpp
View File

@ -26,6 +26,8 @@
#include "platform/platform.hpp"
#include "providers/i_provider.hpp"
#include "utils/common.hpp"
#include "utils/path.hpp"
#include "utils/string.hpp"
#include "utils/time.hpp"
namespace repertory {
@ -33,8 +35,8 @@ auto fuse_drive_base::access_impl(std::string api_path, int mask) -> api_error {
return check_access(api_path, mask);
}
auto fuse_drive_base::check_access(const std::string &api_path, int mask) const
-> api_error {
auto fuse_drive_base::check_access(const std::string &api_path,
int mask) const -> api_error {
REPERTORY_USES_FUNCTION_NAME();
api_meta_map meta;
@ -135,9 +137,8 @@ auto fuse_drive_base::check_and_perform(
return action(meta);
}
auto fuse_drive_base::check_open_flags(int flags, int mask,
const api_error &fail_error)
-> api_error {
auto fuse_drive_base::check_open_flags(
int flags, int mask, const api_error &fail_error) -> api_error {
return (((flags & mask) == 0) ? api_error::success : fail_error);
}
@ -194,8 +195,8 @@ auto fuse_drive_base::check_parent_access(const std::string &api_path,
return ret;
}
auto fuse_drive_base::check_readable(int flags, const api_error &fail_error)
-> api_error {
auto fuse_drive_base::check_readable(int flags,
const api_error &fail_error) -> api_error {
auto mode = (flags & O_ACCMODE);
return ((mode == O_WRONLY) ? fail_error : api_error::success);
}
@ -253,16 +254,13 @@ auto fuse_drive_base::get_uid_from_meta(const api_meta_map &meta) -> uid_t {
}
#if defined(__APPLE__)
auto fuse_drive_base::parse_xattr_parameters(const char *name,
const uint32_t &position,
std::string &attribute_name,
const std::string &api_path)
-> api_error {
auto fuse_drive_base::parse_xattr_parameters(
const char *name, const uint32_t &position, std::string &attribute_name,
const std::string &api_path) -> api_error {
#else // !defined(__APPLE__)
auto fuse_drive_base::parse_xattr_parameters(const char *name,
std::string &attribute_name,
const std::string &api_path)
-> api_error {
auto fuse_drive_base::parse_xattr_parameters(
const char *name, std::string &attribute_name,
const std::string &api_path) -> api_error {
#endif // defined(__APPLE__)
auto res = api_path.empty() ? api_error::bad_address : api_error::success;
if (res != api_error::success) {
@ -295,11 +293,9 @@ auto fuse_drive_base::parse_xattr_parameters(
std::string &attribute_name, const std::string &api_path) -> api_error {
auto res = parse_xattr_parameters(name, position, attribute_name, api_path);
#else // !defined(__APPLE__)
auto fuse_drive_base::parse_xattr_parameters(const char *name,
const char *value, size_t size,
std::string &attribute_name,
const std::string &api_path)
-> api_error {
auto fuse_drive_base::parse_xattr_parameters(
const char *name, const char *value, size_t size,
std::string &attribute_name, const std::string &api_path) -> api_error {
auto res = parse_xattr_parameters(name, attribute_name, api_path);
#endif // defined(__APPLE__)
if (res != api_error::success) {

16
repertory/librepertory/src/drives/fuse/remotefuse/remote_fuse_drive.cpp
View File

@ -26,7 +26,7 @@
#include "app_config.hpp"
#include "events/consumers/console_consumer.hpp"
#include "events/consumers/logging_consumer.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/drive_mount_result.hpp"
#include "events/types/drive_mounted.hpp"
#include "events/types/drive_unmount_pending.hpp"
@ -93,7 +93,7 @@ auto remote_fuse_drive::create_impl(std::string api_path, mode_t mode,
void remote_fuse_drive::destroy_impl(void *ptr) {
REPERTORY_USES_FUNCTION_NAME();
event_system2::instance().raise<drive_unmount_pending>(function_name,
event_system::instance().raise<drive_unmount_pending>(function_name,
get_mount_location());
if (server_) {
@ -115,7 +115,7 @@ void remote_fuse_drive::destroy_impl(void *ptr) {
utils::error::raise_error(function_name, "failed to set mount state");
}
event_system2::instance().raise<drive_unmounted>(function_name,
event_system::instance().raise<drive_unmounted>(function_name,
get_mount_location());
fuse_base::destroy_impl(ptr);
@ -246,7 +246,7 @@ auto remote_fuse_drive::init_impl(struct fuse_conn_info *conn) -> void * {
}
logging_consumer_ = std::make_shared<logging_consumer>(
config_.get_event_level(), config_.get_log_directory());
event_system2::instance().start();
event_system::instance().start();
if (not lock_data_.set_mount_state(true, get_mount_location(), getpid())) {
utils::error::raise_error(function_name, "failed to set mount state");
@ -258,11 +258,11 @@ auto remote_fuse_drive::init_impl(struct fuse_conn_info *conn) -> void * {
if (remote_instance_->fuse_init() != 0) {
utils::error::raise_error(function_name,
"failed to connect to remote server");
event_system2::instance().raise<unmount_requested>();
event_system::instance().raise<unmount_requested>();
} else {
server_ = std::make_shared<server>(config_);
server_->start();
event_system2::instance().raise<drive_mounted>(function_name,
event_system::instance().raise<drive_mounted>(function_name,
get_mount_location());
}
@ -279,9 +279,9 @@ void remote_fuse_drive::notify_fuse_main_exit(int &ret) {
REPERTORY_USES_FUNCTION_NAME();
if (was_mounted_) {
event_system2::instance().raise<drive_mount_result>(
event_system::instance().raise<drive_mount_result>(
function_name, get_mount_location(), std::to_string(ret));
event_system2::instance().stop();
event_system::instance().stop();
logging_consumer_.reset();
console_consumer_.reset();
}

176
repertory/librepertory/src/drives/fuse/remotefuse/remote_server.cpp
View File

@ -27,7 +27,8 @@
#include "comm/packet/packet.hpp"
#include "drives/directory_iterator.hpp"
#include "drives/remote/remote_open_file_table.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/remote_server_event.hpp"
#include "platform/platform.hpp"
#include "types/remote.hpp"
#include "types/repertory.hpp"
@ -36,15 +37,15 @@
#include "utils/file.hpp"
#include "utils/path.hpp"
#include "utils/time.hpp"
#include "utils/utils.hpp"
namespace repertory::remote_fuse {
#define RAISE_REMOTE_FUSE_SERVER_EVENT(func, file, ret) \
if (config_.get_enable_drive_events() && \
(((config_.get_event_level() >= remote_fuse_server_event::level) && \
(((config_.get_event_level() >= remote_server_event::level) && \
((ret) < 0)) || \
(config_.get_event_level() >= event_level::trace))) \
event_system2::instance().raise<remote_fuse_server_event>(std::string{func}, \
file, ret)
event_system::instance().raise<remote_server_event>(file, ret, func)
remote_server::remote_server(app_config &config, i_fuse_drive &drive,
const std::string &mount_location)
@ -200,8 +201,8 @@ auto remote_server::fuse_access(const char *path, const std::int32_t &mask)
return ret;
}
auto remote_server::fuse_chflags(const char *path,
std::uint32_t flags) -> packet::error_type {
auto remote_server::fuse_chflags(const char *path, std::uint32_t flags)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto api_path = utils::path::create_api_path(path);
@ -313,9 +314,10 @@ length); ret = ((res < 0) ? -errno : 0); #endif
return ret;
}*/
auto remote_server::fuse_fgetattr(
const char *path, remote::stat &r_stat, bool &directory,
const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_fgetattr(const char *path, remote::stat &r_stat,
bool &directory,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
r_stat = {};
@ -325,7 +327,7 @@ auto remote_server::fuse_fgetattr(
auto res = has_open_info(static_cast<native_handle>(handle), EBADF);
if (res == 0) {
directory = utils::file::directory(file_path).exists();
struct stat64 unix_st {};
struct stat64 unix_st{};
res = fstat64(static_cast<native_handle>(handle), &unix_st);
if (res == 0) {
populate_stat(unix_st, r_stat);
@ -337,9 +339,10 @@ auto remote_server::fuse_fgetattr(
return ret;
}
auto remote_server::fuse_fsetattr_x(
const char *path, const remote::setattr_x &attr,
const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_fsetattr_x(const char *path,
const remote::setattr_x &attr,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto api_path = utils::path::create_api_path(path);
@ -455,9 +458,10 @@ auto remote_server::fuse_fsync(const char *path, const std::int32_t &datasync,
return ret;
}
auto remote_server::fuse_ftruncate(
const char *path, const remote::file_offset &size,
const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_ftruncate(const char *path,
const remote::file_offset &size,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto file_path = construct_path(path);
@ -485,7 +489,7 @@ auto remote_server::fuse_getattr(const char *path, remote::stat &r_stat,
directory = utils::file::directory(file_path).exists();
struct stat64 unix_st {};
struct stat64 unix_st{};
auto res = stat64(file_path.c_str(), &unix_st);
if (res == 0) {
populate_stat(unix_st, r_stat);
@ -550,9 +554,10 @@ STATUS_NOT_IMPLEMENTED; #endif RAISE_REMOTE_FUSE_SERVER_EVENT(function_name,
file_path, ret); return ret;
}*/
auto remote_server::fuse_getxtimes(
const char *path, remote::file_time &bkuptime,
remote::file_time &crtime) -> packet::error_type {
auto remote_server::fuse_getxtimes(const char *path,
remote::file_time &bkuptime,
remote::file_time &crtime)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto api_path = utils::path::create_api_path(path);
@ -657,10 +662,11 @@ auto remote_server::fuse_opendir(const char *path, remote::file_handle &handle)
return ret;
}
auto remote_server::fuse_read(
const char *path, char *buffer, const remote::file_size &read_size,
const remote::file_offset &read_offset,
const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_read(const char *path, char *buffer,
const remote::file_size &read_size,
const remote::file_offset &read_offset,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto file_path = construct_path(path);
@ -681,8 +687,8 @@ auto remote_server::fuse_read(
return static_cast<packet::error_type>(ret);
}
auto remote_server::fuse_rename(const char *from,
const char *to) -> packet::error_type {
auto remote_server::fuse_rename(const char *from, const char *to)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto from_path = utils::path::combine(mount_location_, {from});
@ -720,8 +726,9 @@ auto remote_server::fuse_readdir(const char *path,
return ret;
}
auto remote_server::fuse_release(
const char *path, const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_release(const char *path,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet::error_type ret = 0;
@ -738,8 +745,9 @@ auto remote_server::fuse_release(
return ret;
}
auto remote_server::fuse_releasedir(
const char *path, const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_releasedir(const char *path,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto file_path = construct_path(path);
@ -784,8 +792,9 @@ auto remote_server::fuse_setattr_x(const char *path, remote::setattr_x &attr)
return ret;
}
auto remote_server::fuse_setbkuptime(
const char *path, const remote::file_time &bkuptime) -> packet::error_type {
auto remote_server::fuse_setbkuptime(const char *path,
const remote::file_time &bkuptime)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto api_path = utils::path::create_api_path(path);
@ -804,8 +813,9 @@ auto remote_server::fuse_setbkuptime(
return ret;
}
auto remote_server::fuse_setchgtime(
const char *path, const remote::file_time &chgtime) -> packet::error_type {
auto remote_server::fuse_setchgtime(const char *path,
const remote::file_time &chgtime)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto api_path = utils::path::create_api_path(path);
@ -824,8 +834,9 @@ auto remote_server::fuse_setchgtime(
return ret;
}
auto remote_server::fuse_setcrtime(
const char *path, const remote::file_time &crtime) -> packet::error_type {
auto remote_server::fuse_setcrtime(const char *path,
const remote::file_time &crtime)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto api_path = utils::path::create_api_path(path);
@ -916,8 +927,9 @@ auto remote_server::fuse_statfs_x(const char *path, std::uint64_t bsize,
return 0;
}
auto remote_server::fuse_truncate(
const char *path, const remote::file_offset &size) -> packet::error_type {
auto remote_server::fuse_truncate(const char *path,
const remote::file_offset &size)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto file_path = construct_path(path);
@ -938,8 +950,8 @@ auto remote_server::fuse_unlink(const char *path) -> packet::error_type {
}
auto remote_server::fuse_utimens(const char *path, const remote::file_time *tv,
std::uint64_t op0,
std::uint64_t op1) -> packet::error_type {
std::uint64_t op0, std::uint64_t op1)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto file_path = construct_path(path);
@ -966,10 +978,11 @@ auto remote_server::fuse_utimens(const char *path, const remote::file_time *tv,
return ret;
}
auto remote_server::fuse_write(
const char *path, const char *buffer, const remote::file_size &write_size,
const remote::file_offset &write_offset,
const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_write(const char *path, const char *buffer,
const remote::file_size &write_size,
const remote::file_offset &write_offset,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto file_path = construct_path(path);
@ -999,8 +1012,8 @@ auto remote_server::fuse_write_base64(
}
// WinFSP Layer
auto remote_server::winfsp_can_delete(PVOID file_desc,
PWSTR file_name) -> packet::error_type {
auto remote_server::winfsp_can_delete(PVOID file_desc, PWSTR file_name)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto relative_path = utils::string::to_utf8(file_name);
@ -1025,8 +1038,8 @@ auto remote_server::winfsp_can_delete(PVOID file_desc,
}
auto remote_server::winfsp_cleanup(PVOID /*file_desc*/, PWSTR file_name,
UINT32 flags,
BOOLEAN &was_deleted) -> packet::error_type {
UINT32 flags, BOOLEAN &was_deleted)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto relative_path = utils::string::to_utf8(file_name);
@ -1103,8 +1116,8 @@ auto remote_server::winfsp_create(PWSTR file_name, UINT32 create_options,
UINT32 granted_access, UINT32 attributes,
UINT64 /*allocation_size*/, PVOID *file_desc,
remote::file_info *file_info,
std::string &normalized_name,
BOOLEAN &exists) -> packet::error_type {
std::string &normalized_name, BOOLEAN &exists)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto relative_path = utils::string::to_utf8(file_name);
@ -1176,8 +1189,9 @@ auto remote_server::winfsp_flush(PVOID file_desc, remote::file_info *file_info)
return ret;
}
auto remote_server::winfsp_get_file_info(
PVOID file_desc, remote::file_info *file_info) -> packet::error_type {
auto remote_server::winfsp_get_file_info(PVOID file_desc,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto handle = reinterpret_cast<remote::file_handle>(file_desc);
@ -1220,9 +1234,10 @@ auto remote_server::winfsp_get_security_by_name(
return ret;
}
auto remote_server::winfsp_get_volume_info(
UINT64 &total_size, UINT64 &free_size,
std::string &volume_label) -> packet::error_type {
auto remote_server::winfsp_get_volume_info(UINT64 &total_size,
UINT64 &free_size,
std::string &volume_label)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
drive_.get_volume_info(total_size, free_size, volume_label);
@ -1239,10 +1254,11 @@ auto remote_server::winfsp_mounted(const std::wstring &location)
return STATUS_SUCCESS;
}
auto remote_server::winfsp_open(
PWSTR file_name, UINT32 create_options, UINT32 granted_access,
PVOID *file_desc, remote::file_info *file_info,
std::string &normalized_name) -> packet::error_type {
auto remote_server::winfsp_open(PWSTR file_name, UINT32 create_options,
UINT32 granted_access, PVOID *file_desc,
remote::file_info *file_info,
std::string &normalized_name)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto relative_path = utils::string::to_utf8(file_name);
@ -1283,10 +1299,11 @@ auto remote_server::winfsp_open(
return ret;
}
auto remote_server::winfsp_overwrite(
PVOID file_desc, UINT32 attributes, BOOLEAN replace_attributes,
UINT64 /*allocation_size*/,
remote::file_info *file_info) -> packet::error_type {
auto remote_server::winfsp_overwrite(PVOID file_desc, UINT32 attributes,
BOOLEAN replace_attributes,
UINT64 /*allocation_size*/,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto handle = reinterpret_cast<remote::file_handle>(file_desc);
@ -1402,9 +1419,10 @@ auto remote_server::winfsp_read_directory(PVOID file_desc, PWSTR /*pattern*/,
return ret;
}
auto remote_server::winfsp_rename(
PVOID /*file_desc*/, PWSTR file_name, PWSTR new_file_name,
BOOLEAN replace_if_exists) -> packet::error_type {
auto remote_server::winfsp_rename(PVOID /*file_desc*/, PWSTR file_name,
PWSTR new_file_name,
BOOLEAN replace_if_exists)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto relative_path = utils::string::to_utf8(file_name);
@ -1498,9 +1516,10 @@ auto remote_server::winfsp_set_basic_info(
return ret;
}
auto remote_server::winfsp_set_file_size(
PVOID file_desc, UINT64 new_size, BOOLEAN set_allocation_size,
remote::file_info *file_info) -> packet::error_type {
auto remote_server::winfsp_set_file_size(PVOID file_desc, UINT64 new_size,
BOOLEAN set_allocation_size,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto handle = reinterpret_cast<remote::file_handle>(file_desc);
@ -1536,10 +1555,12 @@ auto remote_server::winfsp_unmounted(const std::wstring &location)
return STATUS_SUCCESS;
}
auto remote_server::winfsp_write(
PVOID file_desc, PVOID buffer, UINT64 offset, UINT32 length,
BOOLEAN write_to_end, BOOLEAN constrained_io, PUINT32 bytes_transferred,
remote::file_info *file_info) -> packet::error_type {
auto remote_server::winfsp_write(PVOID file_desc, PVOID buffer, UINT64 offset,
UINT32 length, BOOLEAN write_to_end,
BOOLEAN constrained_io,
PUINT32 bytes_transferred,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
*bytes_transferred = 0;
@ -1587,8 +1608,9 @@ auto remote_server::winfsp_write(
return ret;
}
auto remote_server::json_create_directory_snapshot(
const std::string &path, json &json_data) -> packet::error_type {
auto remote_server::json_create_directory_snapshot(const std::string &path,
json &json_data)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto api_path = utils::path::create_api_path(path);
@ -1647,8 +1669,8 @@ auto remote_server::json_read_directory_snapshot(
}
auto remote_server::json_release_directory_snapshot(
const std::string &path,
const remote::file_handle &handle) -> packet::error_type {
const std::string &path, const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
const auto file_path = construct_path(path);

2
repertory/librepertory/src/drives/remote/remote_open_file_table.cpp
View File

@ -21,7 +21,7 @@
*/
#include "drives/remote/remote_open_file_table.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "utils/collection.hpp"
#include "utils/config.hpp"
#include "utils/utils.hpp"

147
repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_client.cpp
View File

@ -23,7 +23,7 @@
#include "app_config.hpp"
#include "drives/winfsp/remotewinfsp/i_remote_instance.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/drive_mounted.hpp"
#include "events/types/drive_unmount_pending.hpp"
#include "events/types/drive_unmounted.hpp"
@ -32,19 +32,11 @@
#include "version.hpp"
namespace repertory::remote_winfsp {
#define RAISE_REMOTE_WINFSP_CLIENT_EVENT(func, file, ret) \
if (config_.get_enable_drive_events() && \
(((config_.get_event_level() >= remote_winfsp_client_event::level) && \
((ret) != STATUS_SUCCESS)) || \
(config_.get_event_level() >= event_level::trace))) \
event_system2::instance().raise<remote_winfsp_client_event>( \
std::string{func}, file, ret)
remote_client::remote_client(const app_config &config)
: config_(config), packet_client_(config.get_remote_config()) {}
auto remote_client::winfsp_can_delete(PVOID file_desc,
PWSTR file_name) -> packet::error_type {
auto remote_client::winfsp_can_delete(PVOID file_desc, PWSTR file_name)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -56,14 +48,12 @@ auto remote_client::winfsp_can_delete(PVOID file_desc,
packet_client_.send(function_name, request, service_flags),
};
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name,
utils::path::create_api_path(utils::string::to_utf8(file_name)), ret);
return ret;
}
auto remote_client::json_create_directory_snapshot(
const std::string &path, json &json_data) -> packet::error_type {
auto remote_client::json_create_directory_snapshot(const std::string &path,
json &json_data)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -78,7 +68,6 @@ auto remote_client::json_create_directory_snapshot(
ret = packet::decode_json(response, json_data);
}
RAISE_REMOTE_WINFSP_CLIENT_EVENT(function_name, path, ret);
return ret;
}
@ -101,13 +90,12 @@ auto remote_client::json_read_directory_snapshot(
ret = packet::decode_json(response, json_data);
}
RAISE_REMOTE_WINFSP_CLIENT_EVENT(function_name, path, ret);
return ret;
}
auto remote_client::json_release_directory_snapshot(
const std::string &path,
const remote::file_handle &handle) -> packet::error_type {
const std::string &path, const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -119,13 +107,12 @@ auto remote_client::json_release_directory_snapshot(
packet_client_.send(function_name, request, service_flags),
};
RAISE_REMOTE_WINFSP_CLIENT_EVENT(function_name, path, ret);
return ret;
}
auto remote_client::winfsp_cleanup(PVOID file_desc, PWSTR file_name,
UINT32 flags,
BOOLEAN &was_deleted) -> packet::error_type {
UINT32 flags, BOOLEAN &was_deleted)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto handle{
@ -154,7 +141,6 @@ auto remote_client::winfsp_cleanup(PVOID file_desc, PWSTR file_name,
remove_all(file_path);
}
RAISE_REMOTE_WINFSP_CLIENT_EVENT(function_name, file_path, ret);
return ret;
}
@ -179,7 +165,6 @@ auto remote_client::winfsp_close(PVOID file_desc) -> packet::error_type {
if ((ret == STATUS_SUCCESS) ||
(ret == static_cast<packet::error_type>(STATUS_INVALID_HANDLE))) {
remove_open_info(handle);
RAISE_REMOTE_WINFSP_CLIENT_EVENT(function_name, file_path, ret);
}
}
@ -190,8 +175,8 @@ auto remote_client::winfsp_create(PWSTR file_name, UINT32 create_options,
UINT32 granted_access, UINT32 attributes,
UINT64 allocation_size, PVOID *file_desc,
remote::file_info *file_info,
std::string &normalized_name,
BOOLEAN &exists) -> packet::error_type {
std::string &normalized_name, BOOLEAN &exists)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -230,8 +215,6 @@ auto remote_client::winfsp_create(PWSTR file_name, UINT32 create_options,
}
}
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name, get_open_file_path(to_handle(*file_desc)), ret);
return ret;
}
@ -249,8 +232,6 @@ auto remote_client::winfsp_flush(PVOID file_desc, remote::file_info *file_info)
};
DECODE_OR_IGNORE(&response, *file_info);
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name, get_open_file_path(to_handle(file_desc)), ret);
return ret;
}
@ -265,8 +246,9 @@ auto remote_client::winfsp_get_dir_buffer([[maybe_unused]] PVOID file_desc,
return static_cast<packet::error_type>(STATUS_INVALID_HANDLE);
}
auto remote_client::winfsp_get_file_info(
PVOID file_desc, remote::file_info *file_info) -> packet::error_type {
auto remote_client::winfsp_get_file_info(PVOID file_desc,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -279,14 +261,14 @@ auto remote_client::winfsp_get_file_info(
};
DECODE_OR_IGNORE(&response, *file_info);
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name, get_open_file_path(to_handle(file_desc)), ret);
return ret;
}
auto remote_client::winfsp_get_security_by_name(
PWSTR file_name, PUINT32 attributes, std::uint64_t *descriptor_size,
std::wstring &string_descriptor) -> packet::error_type {
auto remote_client::winfsp_get_security_by_name(PWSTR file_name,
PUINT32 attributes,
std::uint64_t *descriptor_size,
std::wstring &string_descriptor)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -311,14 +293,13 @@ auto remote_client::winfsp_get_security_by_name(
DECODE_OR_IGNORE(&response, *attributes);
}
RAISE_REMOTE_WINFSP_CLIENT_EVENT(function_name,
utils::string::to_utf8(file_name), ret);
return ret;
}
auto remote_client::winfsp_get_volume_info(
UINT64 &total_size, UINT64 &free_size,
std::string &volume_label) -> packet::error_type {
auto remote_client::winfsp_get_volume_info(UINT64 &total_size,
UINT64 &free_size,
std::string &volume_label)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -350,16 +331,16 @@ auto remote_client::winfsp_mounted(const std::wstring &location)
auto mount_location{
utils::string::to_utf8(location),
};
event_system2::instance().raise<drive_mounted>(function_name, mount_location);
event_system::instance().raise<drive_mounted>(function_name, mount_location);
RAISE_REMOTE_WINFSP_CLIENT_EVENT(function_name, mount_location, ret);
return ret;
}
auto remote_client::winfsp_open(
PWSTR file_name, UINT32 create_options, UINT32 granted_access,
PVOID *file_desc, remote::file_info *file_info,
std::string &normalized_name) -> packet::error_type {
auto remote_client::winfsp_open(PWSTR file_name, UINT32 create_options,
UINT32 granted_access, PVOID *file_desc,
remote::file_info *file_info,
std::string &normalized_name)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -390,15 +371,14 @@ auto remote_client::winfsp_open(
}
}
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name, get_open_file_path(to_handle(*file_desc)), ret);
return ret;
}
auto remote_client::winfsp_overwrite(
PVOID file_desc, UINT32 attributes, BOOLEAN replace_attributes,
UINT64 allocation_size,
remote::file_info *file_info) -> packet::error_type {
auto remote_client::winfsp_overwrite(PVOID file_desc, UINT32 attributes,
BOOLEAN replace_attributes,
UINT64 allocation_size,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -414,8 +394,6 @@ auto remote_client::winfsp_overwrite(
};
DECODE_OR_IGNORE(&response, *file_info);
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name, get_open_file_path(to_handle(file_desc)), ret);
return ret;
}
@ -439,17 +417,12 @@ auto remote_client::winfsp_read(PVOID file_desc, PVOID buffer, UINT64 offset,
ret = response.decode(buffer, *bytes_transferred);
#if defined(_WIN32)
if ((ret == STATUS_SUCCESS) &&
(not *bytes_transferred || (*bytes_transferred != length))) {
(not*bytes_transferred || (*bytes_transferred != length))) {
::SetLastError(ERROR_HANDLE_EOF);
}
#endif
}
if (ret != STATUS_SUCCESS) {
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name, get_open_file_path(to_handle(file_desc)), ret);
}
return ret;
}
@ -472,14 +445,13 @@ auto remote_client::winfsp_read_directory(PVOID file_desc, PWSTR pattern,
ret = packet::decode_json(response, item_list);
}
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name, get_open_file_path(to_handle(file_desc)), ret);
return ret;
}
auto remote_client::winfsp_rename(
PVOID file_desc, PWSTR file_name, PWSTR new_file_name,
BOOLEAN replace_if_exists) -> packet::error_type {
auto remote_client::winfsp_rename(PVOID file_desc, PWSTR file_name,
PWSTR new_file_name,
BOOLEAN replace_if_exists)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -493,11 +465,6 @@ auto remote_client::winfsp_rename(
packet_client_.send(function_name, request, service_flags),
};
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name,
utils::path::create_api_path(utils::string::to_utf8(file_name)) + "|" +
utils::path::create_api_path(utils::string::to_utf8(new_file_name)),
ret);
return ret;
}
@ -522,14 +489,13 @@ auto remote_client::winfsp_set_basic_info(
};
DECODE_OR_IGNORE(&response, *file_info);
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name, get_open_file_path(to_handle(file_desc)), ret);
return ret;
}
auto remote_client::winfsp_set_file_size(
PVOID file_desc, UINT64 new_size, BOOLEAN set_allocation_size,
remote::file_info *file_info) -> packet::error_type {
auto remote_client::winfsp_set_file_size(PVOID file_desc, UINT64 new_size,
BOOLEAN set_allocation_size,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -544,8 +510,6 @@ auto remote_client::winfsp_set_file_size(
};
DECODE_OR_IGNORE(&response, *file_info);
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name, get_open_file_path(to_handle(file_desc)), ret);
return ret;
}
@ -556,8 +520,8 @@ auto remote_client::winfsp_unmounted(const std::wstring &location)
auto mount_location{
utils::string::to_utf8(location),
};
event_system2::instance().raise<drive_unmount_pending>(function_name,
mount_location);
event_system::instance().raise<drive_unmount_pending>(function_name,
mount_location);
packet request;
request.encode(location);
@ -565,17 +529,18 @@ auto remote_client::winfsp_unmounted(const std::wstring &location)
auto ret{
packet_client_.send(function_name, request, service_flags),
};
event_system2::instance().raise<drive_unmounted>(function_name,
mount_location);
event_system::instance().raise<drive_unmounted>(function_name,
mount_location);
RAISE_REMOTE_WINFSP_CLIENT_EVENT(function_name, mount_location, ret);
return ret;
}
auto remote_client::winfsp_write(
PVOID file_desc, PVOID buffer, UINT64 offset, UINT32 length,
BOOLEAN write_to_end, BOOLEAN constrained_io, PUINT32 bytes_transferred,
remote::file_info *file_info) -> packet::error_type {
auto remote_client::winfsp_write(PVOID file_desc, PVOID buffer, UINT64 offset,
UINT32 length, BOOLEAN write_to_end,
BOOLEAN constrained_io,
PUINT32 bytes_transferred,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
packet request;
@ -596,10 +561,6 @@ auto remote_client::winfsp_write(
DECODE_OR_IGNORE(&response, *bytes_transferred);
DECODE_OR_IGNORE(&response, *file_info);
if (ret != STATUS_SUCCESS) {
RAISE_REMOTE_WINFSP_CLIENT_EVENT(
function_name, get_open_file_path(to_handle(file_desc)), ret);
}
return ret;
}

175
repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_server.cpp
View File

@ -32,7 +32,8 @@
#include "drives/fuse/remotefuse/i_remote_instance.hpp"
#include "drives/remote/remote_open_file_table.hpp"
#include "drives/winfsp/remotewinfsp/i_remote_instance.hpp"
#include "events/event_system2.hpp"
#include "events/event_system.hpp"
#include "events/types/remote_server_event.hpp"
#include "platform/platform.hpp"
#include "types/remote.hpp"
#include "types/repertory.hpp"
@ -41,15 +42,15 @@
#include "utils/file_utils.hpp"
#include "utils/path.hpp"
#include "utils/time.hpp"
#include "utils/utils.hpp"
namespace repertory::remote_winfsp {
#define RAISE_REMOTE_WINFSP_SERVER_EVENT(func, file, ret) \
if (config_.get_enable_drive_events() && \
(((config_.get_event_level() >= remote_winfsp_server_event::level) && \
(((config_.get_event_level() >= remote_server_event::level) && \
((ret) != STATUS_SUCCESS)) || \
(config_.get_event_level() >= event_level::trace))) \
event_system2::instance().raise<remote_winfsp_server_event>( \
std::string{func}, file, ret)
event_system::instance().raise<remote_server_event>(file, ret, func)
auto remote_server::get_next_handle() -> std::uint64_t {
if (++next_handle_ == 0U) {
@ -141,9 +142,10 @@ auto remote_server::fuse_chmod(const char *path,
return ret;
}
auto remote_server::fuse_chown(
const char *path, const remote::user_id & /*uid*/,
const remote::group_id & /*gid*/) -> packet::error_type {
auto remote_server::fuse_chown(const char *path,
const remote::user_id & /*uid*/,
const remote::group_id & /*gid*/)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -171,9 +173,10 @@ construct_path(path); auto res = HasOpenFileCompatInfo(handle, EBADF); if (res
return ret;
}*/
auto remote_server::fuse_fgetattr(
const char *path, remote::stat &r_stat, bool &directory,
const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_fgetattr(const char *path, remote::stat &r_stat,
bool &directory,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
r_stat = {};
@ -185,7 +188,7 @@ auto remote_server::fuse_fgetattr(
};
if (res == 0) {
directory = utils::file::directory(file_path).exists();
struct _stat64 unix_st {};
struct _stat64 unix_st{};
res = _fstat64(static_cast<int>(handle), &unix_st);
if (res == 0) {
populate_stat(path, directory, r_stat, unix_st);
@ -197,9 +200,10 @@ auto remote_server::fuse_fgetattr(
return ret;
}
auto remote_server::fuse_fsetattr_x(
const char *path, const remote::setattr_x & /*attr*/,
const remote::file_handle & /*handle*/) -> packet::error_type {
auto remote_server::fuse_fsetattr_x(const char *path,
const remote::setattr_x & /*attr*/,
const remote::file_handle & /*handle*/)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -208,9 +212,10 @@ auto remote_server::fuse_fsetattr_x(
return ret;
}
auto remote_server::fuse_fsync(
const char *path, const std::int32_t & /*datasync*/,
const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_fsync(const char *path,
const std::int32_t & /*datasync*/,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -237,9 +242,10 @@ auto remote_server::fuse_fsync(
return ret;
}
auto remote_server::fuse_ftruncate(
const char *path, const remote::file_offset &size,
const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_ftruncate(const char *path,
const remote::file_offset &size,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -279,7 +285,7 @@ auto remote_server::fuse_getattr(const char *path, remote::stat &r_st,
directory = utils::file::directory(file_path).exists();
struct _stat64 st1 {};
struct _stat64 st1{};
auto res{
_stat64(file_path.c_str(), &st1),
};
@ -305,9 +311,10 @@ STATUS_NOT_IMPLEMENTED; RAISE_REMOTE_WINFSP_SERVER_EVENT(function_name,
file_path, ret); return ret;
}*/
auto remote_server::fuse_getxtimes(
const char *path, remote::file_time & /*bkuptime*/,
remote::file_time & /*crtime*/) -> packet::error_type {
auto remote_server::fuse_getxtimes(const char *path,
remote::file_time & /*bkuptime*/,
remote::file_time & /*crtime*/)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -438,10 +445,11 @@ auto remote_server::fuse_open(const char *path, const remote::open_flags &flags,
return ret;
}
auto remote_server::fuse_read(
const char *path, char *buffer, const remote::file_size &read_size,
const remote::file_offset &read_offset,
const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_read(const char *path, char *buffer,
const remote::file_size &read_size,
const remote::file_offset &read_offset,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -472,8 +480,8 @@ auto remote_server::fuse_read(
return ret;
}
auto remote_server::fuse_rename(const char *from,
const char *to) -> packet::error_type {
auto remote_server::fuse_rename(const char *from, const char *to)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto from_path = utils::path::combine(mount_location_, {from});
@ -488,10 +496,11 @@ auto remote_server::fuse_rename(const char *from,
return ret;
}
auto remote_server::fuse_write(
const char *path, const char *buffer, const remote::file_size &write_size,
const remote::file_offset &write_offset,
const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_write(const char *path, const char *buffer,
const remote::file_size &write_size,
const remote::file_offset &write_offset,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -558,8 +567,9 @@ auto remote_server::fuse_readdir(const char *path,
return ret;
}
auto remote_server::fuse_release(
const char *path, const remote::file_handle &handle) -> packet::error_type {
auto remote_server::fuse_release(const char *path,
const remote::file_handle &handle)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -603,8 +613,9 @@ auto remote_server::fuse_rmdir(const char *path) -> packet::error_type {
return ret;
}
auto remote_server::fuse_setattr_x(
const char *path, remote::setattr_x & /*attr*/) -> packet::error_type {
auto remote_server::fuse_setattr_x(const char *path,
remote::setattr_x & /*attr*/)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -716,8 +727,9 @@ auto remote_server::fuse_statfs_x(const char *path, std::uint64_t bsize,
return 0;
}
auto remote_server::fuse_truncate(
const char *path, const remote::file_offset &size) -> packet::error_type {
auto remote_server::fuse_truncate(const char *path,
const remote::file_offset &size)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -764,8 +776,8 @@ auto remote_server::fuse_unlink(const char *path) -> packet::error_type {
}
auto remote_server::fuse_utimens(const char *path, const remote::file_time *tv,
std::uint64_t op0,
std::uint64_t op1) -> packet::error_type {
std::uint64_t op0, std::uint64_t op1)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -824,8 +836,9 @@ auto remote_server::fuse_utimens(const char *path, const remote::file_time *tv,
}
// JSON Layer
auto remote_server::json_create_directory_snapshot(
const std::string &path, json &json_data) -> packet::error_type {
auto remote_server::json_create_directory_snapshot(const std::string &path,
json &json_data)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -883,8 +896,8 @@ auto remote_server::json_read_directory_snapshot(
}
auto remote_server::json_release_directory_snapshot(
const std::string &path,
const remote::file_handle & /*handle*/) -> packet::error_type {
const std::string &path, const remote::file_handle & /*handle*/)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = construct_path(path);
@ -915,8 +928,8 @@ auto remote_server::winfsp_can_delete(PVOID file_desc, PWSTR /*file_name*/)
}
auto remote_server::winfsp_cleanup(PVOID file_desc, PWSTR /*file_name*/,
UINT32 flags,
BOOLEAN &was_deleted) -> packet::error_type {
UINT32 flags, BOOLEAN &was_deleted)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = get_open_file_path(file_desc);
@ -953,8 +966,8 @@ auto remote_server::winfsp_create(PWSTR file_name, UINT32 create_options,
UINT32 granted_access, UINT32 attributes,
UINT64 /*allocation_size*/, PVOID *file_desc,
remote::file_info *file_info,
std::string &normalized_name,
BOOLEAN &exists) -> packet::error_type {
std::string &normalized_name, BOOLEAN &exists)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = utils::string::from_utf8(utils::path::combine(
@ -1022,8 +1035,9 @@ auto remote_server::winfsp_flush(PVOID file_desc, remote::file_info *file_info)
return ret;
}
auto remote_server::winfsp_get_file_info(
PVOID file_desc, remote::file_info *file_info) -> packet::error_type {
auto remote_server::winfsp_get_file_info(PVOID file_desc,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto *handle = reinterpret_cast<HANDLE>(file_desc);
@ -1037,9 +1051,11 @@ auto remote_server::winfsp_get_file_info(
return ret;
}
auto remote_server::winfsp_get_security_by_name(
PWSTR file_name, PUINT32 attributes, std::uint64_t *descriptor_size,
std::wstring &string_descriptor) -> packet::error_type {
auto remote_server::winfsp_get_security_by_name(PWSTR file_name,
PUINT32 attributes,
std::uint64_t *descriptor_size,
std::wstring &string_descriptor)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = utils::string::from_utf8(utils::path::combine(
@ -1078,9 +1094,10 @@ auto remote_server::winfsp_get_security_by_name(
return ret;
}
auto remote_server::winfsp_get_volume_info(
UINT64 &total_size, UINT64 &free_size,
std::string &volume_label) -> packet::error_type {
auto remote_server::winfsp_get_volume_info(UINT64 &total_size,
UINT64 &free_size,
std::string &volume_label)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
drive_.get_volume_info(total_size, free_size, volume_label);
@ -1097,10 +1114,11 @@ auto remote_server::winfsp_mounted(const std::wstring &location)
return STATUS_SUCCESS;
}
auto remote_server::winfsp_open(
PWSTR file_name, UINT32 create_options, UINT32 granted_access,
PVOID *file_desc, remote::file_info *file_info,
std::string &normalized_name) -> packet::error_type {
auto remote_server::winfsp_open(PWSTR file_name, UINT32 create_options,
UINT32 granted_access, PVOID *file_desc,
remote::file_info *file_info,
std::string &normalized_name)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto file_path = utils::string::from_utf8(utils::path::combine(
@ -1136,10 +1154,11 @@ auto remote_server::winfsp_open(
return ret;
}
auto remote_server::winfsp_overwrite(
PVOID file_desc, UINT32 attributes, BOOLEAN replace_attributes,
UINT64 /*allocation_size*/,
remote::file_info *file_info) -> packet::error_type {
auto remote_server::winfsp_overwrite(PVOID file_desc, UINT32 attributes,
BOOLEAN replace_attributes,
UINT64 /*allocation_size*/,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto *handle = reinterpret_cast<HANDLE>(file_desc);
@ -1240,9 +1259,10 @@ auto remote_server::winfsp_read_directory(PVOID file_desc, PWSTR /*pattern*/,
return ret;
}
auto remote_server::winfsp_rename(
PVOID /*file_desc*/, PWSTR file_name, PWSTR new_file_name,
BOOLEAN replace_if_exists) -> packet::error_type {
auto remote_server::winfsp_rename(PVOID /*file_desc*/, PWSTR file_name,
PWSTR new_file_name,
BOOLEAN replace_if_exists)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto from_path = utils::string::from_utf8(utils::path::combine(
@ -1293,9 +1313,10 @@ auto remote_server::winfsp_set_basic_info(
return ret;
}
auto remote_server::winfsp_set_file_size(
PVOID file_desc, UINT64 new_size, BOOLEAN set_allocation_size,
remote::file_info *file_info) -> packet::error_type {
auto remote_server::winfsp_set_file_size(PVOID file_desc, UINT64 new_size,
BOOLEAN set_allocation_size,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto *handle = reinterpret_cast<HANDLE>(file_desc);
@ -1338,10 +1359,12 @@ auto remote_server::winfsp_unmounted(const std::wstring &location)
return STATUS_SUCCESS;
}
auto remote_server::winfsp_write(
PVOID file_desc, PVOID buffer, UINT64 offset, UINT32 length,
BOOLEAN /*write_to_end*/, BOOLEAN constrained_io, PUINT32 bytes_transferred,
remote::file_info *file_info) -> packet::error_type {
auto remote_server::winfsp_write(PVOID file_desc, PVOID buffer, UINT64 offset,
UINT32 length, BOOLEAN /*write_to_end*/,
BOOLEAN constrained_io,
PUINT32 bytes_transferred,
remote::file_info *file_info)
-> packet::error_type {
REPERTORY_USES_FUNCTION_NAME();
auto *handle = reinterpret_cast<HANDLE>(file_desc);

Some files were not shown because too many files have changed in this diff Show More