initial commit

include/events/consumers/console_consumer.hpp

@@ -0,0 +1,51 @@
+/*
+  Copyright <2018-2022> <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 INCLUDE_EVENTS_CONSUMERS_CONSOLE_CONSUMER_HPP_
+#define INCLUDE_EVENTS_CONSUMERS_CONSOLE_CONSUMER_HPP_
+
+#include "common.hpp"
+#include "events/event_system.hpp"
+
+namespace repertory {
+class console_consumer final {
+  E_CONSUMER();
+
+public:
+  console_consumer() { E_SUBSCRIBE_ALL(process_event); }
+
+public:
+  ~console_consumer() { E_CONSUMER_RELEASE(); }
+
+private:
+  void process_event(const event &e) {
+#ifdef _WIN32
+#ifdef _DEBUG
+    OutputDebugString((e.get_single_line() + "\n").c_str());
+#endif
+#endif
+    if (e.get_event_level() == event_level::error) {
+      std::cerr << e.get_single_line() << std::endl;
+    } else {
+      std::cout << e.get_single_line() << std::endl;
+    }
+  }
+};
+} // namespace repertory
+
+#endif // INCLUDE_EVENTS_CONSUMERS_CONSOLE_CONSUMER_HPP_

include/events/consumers/logging_consumer.hpp

@@ -0,0 +1,62 @@
+/*
+  Copyright <2018-2022> <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 INCLUDE_EVENTS_CONSUMERS_LOGGING_CONSUMER_HPP_
+#define INCLUDE_EVENTS_CONSUMERS_LOGGING_CONSUMER_HPP_
+
+#include "common.hpp"
+#include "events/event_system.hpp"
+
+namespace repertory {
+class logging_consumer {
+  E_CONSUMER();
+
+public:
+  logging_consumer(const std::string &log_directory, const event_level &level);
+
+  ~logging_consumer();
+
+private:
+  const std::uint8_t MAX_LOG_FILES = 5;
+  const std::uint64_t MAX_LOG_FILE_SIZE = (1024 * 1024 * 5);
+
+private:
+  event_level event_level_ = event_level::normal;
+  const std::string log_directory_;
+  const std::string log_path_;
+  bool logging_active_ = true;
+  std::mutex log_mutex_;
+  std::condition_variable log_notify_;
+  std::deque<std::shared_ptr<event>> event_queue_;
+  std::unique_ptr<std::thread> logging_thread_;
+  FILE *log_file_ = nullptr;
+
+private:
+  void check_log_roll(const size_t &count);
+
+  void close_log_file();
+
+  void logging_thread(const bool &drain = false);
+
+  void process_event(const event &event);
+
+  void reopen_log_file();
+};
+} // namespace repertory
+
+#endif // INCLUDE_EVENTS_CONSUMERS_LOGGING_CONSUMER_HPP_

include/events/event.hpp

@@ -0,0 +1,63 @@
+/*
+  Copyright <2018-2022> <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 INCLUDE_EVENTS_EVENT_HPP_
+#define INCLUDE_EVENTS_EVENT_HPP_
+
+#include "common.hpp"
+
+namespace repertory {
+enum class event_level { error, warn, normal, debug, verbose };
+
+event_level event_level_from_string(std::string level);
+
+std::string event_level_to_string(const event_level &level);
+
+class event {
+protected:
+  explicit event(const bool &allow_async) : allow_async_(allow_async) {}
+
+  event(const std::stringstream &ss, json j, const bool &allow_async)
+      : allow_async_(allow_async), ss_(ss.str()), j_(std::move(j)) {}
+
+public:
+  virtual ~event() = default;
+
+private:
+  const bool allow_async_;
+
+protected:
+  std::stringstream ss_;
+  json j_;
+
+public:
+  virtual std::shared_ptr<event> clone() const = 0;
+
+  bool get_allow_async() const { return allow_async_; }
+
+  virtual event_level get_event_level() const = 0;
+
+  json get_json() const { return j_; }
+
+  virtual std::string get_name() const = 0;
+
+  virtual std::string get_single_line() const = 0;
+};
+} // namespace repertory
+
+#endif // INCLUDE_EVENTS_EVENT_HPP_

include/events/event_system.hpp

@@ -0,0 +1,243 @@
+/*
+  Copyright <2018-2022> <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 INCLUDE_EVENTS_EVENT_SYSTEM_HPP_
+#define INCLUDE_EVENTS_EVENT_SYSTEM_HPP_
+
+#include "common.hpp"
+#include "events/event.hpp"
+#include "events/t_event_system.hpp"
+#include "utils/string_utils.hpp"
+
+namespace repertory {
+typedef t_event_system<event> event_system;
+typedef event_system::event_consumer event_consumer;
+
+#define E_CAST(t) ((std::string)t)
+#define E_DOUBLE(d) utils::string::from_double(d)
+#define E_DOUBLE_PRECISE(d)                                                                        \
+  ([](const double &d) -> std::string {                                                            \
+    std::stringstream ss;                                                                          \
+    ss << std::fixed << std::setprecision(2) << d;                                                 \
+    return ss.str();                                                                               \
+  })(d)
+#define E_FROM_BOOL(t) utils::string::from_bool(t)
+#define E_FROM_EXCEPTION(e) std::string(e.what() ? e.what() : "")
+#define E_FROM_INT32(t) utils::string::from_int32(t)
+#define E_FROM_INT64(t) utils::string::from_int64(t)
+#define E_FROM_UINT16(t) utils::string::from_uint16(t)
+#define E_FROM_STRING_ARRAY(a)                                                                     \
+  ([](const auto &array) -> std::string {                                                          \
+    std::stringstream ret;                                                                         \
+    for (const auto &item : array) {                                                               \
+      ret << (std::string(item) + " ");                                                            \
+    }                                                                                              \
+    return std::string(ret).TrimRight();                                                           \
+  })(a)
+
+#define E_PERCENT(d)                                                                               \
+  ([](const double &d) -> std::string {                                                            \
+    std::stringstream ss;                                                                          \
+    ss << std::fixed << std::setprecision(2) << d;                                                 \
+    ss << "%";                                                                                     \
+    return ss;                                                                                     \
+  })(d)
+#define E_STRING(t) t
+#define E_FROM_UINT8(t) utils::string::from_uint8(t)
+#define E_FROM_UINT32(t) utils::string::from_uint32(t)
+#define E_FROM_UINT64(t) utils::string::from_uint64(t)
+#define E_FROM_SIZE_T(t) std::to_string(t)
+#define E_FROM_API_FILE_ERROR(e) api_error_to_string(e)
+
+#define E_PROP(type, name, short_name, ts)                                                         \
+private:                                                                                           \
+  void init_##short_name(const type &tv) {                                                         \
+    ss_ << "|" << #short_name << "|" << ts(tv);                                                    \
+    j_[#name] = ts(tv);                                                                            \
+  }                                                                                                \
+                                                                                                   \
+public:                                                                                            \
+  json get_##name() const { return j_[#name]; }
+
+#define E_BEGIN(name, el)                                                                          \
+  class name final : public virtual event {                                                        \
+  private:                                                                                         \
+    name(const std::stringstream &ss, const json &j, const bool &allow_async)                      \
+        : event(ss, j, allow_async) {}                                                             \
+                                                                                                   \
+  public:                                                                                          \
+    ~name() override = default;                                                                    \
+                                                                                                   \
+  public:                                                                                          \
+    static const event_level level = event_level::el;                                              \
+                                                                                                   \
+  public:                                                                                          \
+    std::string get_name() const override { return #name; }                                        \
+                                                                                                   \
+    event_level get_event_level() const override { return name::level; }                           \
+                                                                                                   \
+    std::string get_single_line() const override {                                                 \
+      const auto s = ss_.str();                                                                    \
+      return get_name() + (s.empty() ? "" : s);                                                    \
+    }                                                                                              \
+                                                                                                   \
+    std::shared_ptr<event> clone() const override {                                                \
+      return std::shared_ptr<name>(new name(ss_, j_, get_allow_async()));                          \
+    }
+#define E_END() }
+
+#define E_SIMPLE(event_name, el, allow_async)                                                      \
+  E_BEGIN(event_name, el)                                                                          \
+public:                                                                                            \
+  event_name() : event(allow_async) {}                                                             \
+  E_END()
+
+#define E_SIMPLE1(event_name, el, allow_async, type, name, short_name, tc)                         \
+  E_BEGIN(event_name, el)                                                                          \
+  explicit event_name(const type &tv) : event(allow_async) { init_##short_name(tv); }              \
+  E_PROP(type, name, short_name, tc)                                                               \
+  E_END()
+
+#define E_SIMPLE2(event_name, el, allow_async, type, name, short_name, tc, type2, name2,           \
+                  short_name2, tc2)                                                                \
+  E_BEGIN(event_name, el)                                                                          \
+  explicit event_name(const type &tv, const type2 &tv2) : event(allow_async) {                     \
+    init_##short_name(tv);                                                                         \
+    init_##short_name2(tv2);                                                                       \
+  }                                                                                                \
+  E_PROP(type, name, short_name, tc)                                                               \
+  E_PROP(type2, name2, short_name2, tc2)                                                           \
+  E_END()
+
+#define E_SIMPLE3(event_name, el, allow_async, type, name, short_name, tc, type2, name2,           \
+                  short_name2, tc2, type3, name3, short_name3, tc3)                                \
+  E_BEGIN(event_name, el)                                                                          \
+  explicit event_name(const type &tv, const type2 &tv2, const type3 &tv3) : event(allow_async) {   \
+    init_##short_name(tv);                                                                         \
+    init_##short_name2(tv2);                                                                       \
+    init_##short_name3(tv3);                                                                       \
+  }                                                                                                \
+  E_PROP(type, name, short_name, tc)                                                               \
+  E_PROP(type2, name2, short_name2, tc2)                                                           \
+  E_PROP(type3, name3, short_name3, tc3)                                                           \
+  E_END()
+
+#define E_SIMPLE4(event_name, el, allow_async, type, name, short_name, tc, type2, name2,           \
+                  short_name2, tc2, type3, name3, short_name3, tc3, type4, name4, short_name4,     \
+                  tc4)                                                                             \
+  E_BEGIN(event_name, el)                                                                          \
+  explicit event_name(const type &tv, const type2 &tv2, const type3 &tv3, const type4 &tv4)        \
+      : event(allow_async) {                                                                       \
+    init_##short_name(tv);                                                                         \
+    init_##short_name2(tv2);                                                                       \
+    init_##short_name3(tv3);                                                                       \
+    init_##short_name4(tv4);                                                                       \
+  }                                                                                                \
+  E_PROP(type, name, short_name, tc)                                                               \
+  E_PROP(type2, name2, short_name2, tc2)                                                           \
+  E_PROP(type3, name3, short_name3, tc3)                                                           \
+  E_PROP(type4, name4, short_name4, tc4)                                                           \
+  E_END()
+
+#define E_SIMPLE5(event_name, el, allow_async, type, name, short_name, tc, type2, name2,           \
+                  short_name2, tc2, type3, name3, short_name3, tc3, type4, name4, short_name4,     \
+                  tc4, type5, name5, short_name5, tc5)                                             \
+  E_BEGIN(event_name, el)                                                                          \
+  explicit event_name(const type &tv, const type2 &tv2, const type3 &tv3, const type4 &tv4,        \
+                      const type5 &tv5)                                                            \
+      : event(allow_async) {                                                                       \
+    init_##short_name(tv);                                                                         \
+    init_##short_name2(tv2);                                                                       \
+    init_##short_name3(tv3);                                                                       \
+    init_##short_name4(tv4);                                                                       \
+    init_##short_name5(tv5);                                                                       \
+  }                                                                                                \
+  E_PROP(type, name, short_name, tc)                                                               \
+  E_PROP(type2, name2, short_name2, tc2)                                                           \
+  E_PROP(type3, name3, short_name3, tc3)                                                           \
+  E_PROP(type4, name4, short_name4, tc4)                                                           \
+  E_PROP(type5, name5, short_name5, tc5)                                                           \
+  E_END()
+
+#define E_SIMPLE6(event_name, el, allow_async, type, name, short_name, tc, type2, name2,           \
+                  short_name2, tc2, type3, name3, short_name3, tc3, type4, name4, short_name4,     \
+                  tc4, type5, name5, short_name5, tc5, type6, name6, short_name6, tc6)             \
+  E_BEGIN(event_name, el)                                                                          \
+  explicit event_name(const type &tv, const type2 &tv2, const type3 &tv3, const type4 &tv4,        \
+                      const type5 &tv5, const type6 &tv6)                                          \
+      : event(allow_async) {                                                                       \
+    init_##short_name(tv);                                                                         \
+    init_##short_name2(tv2);                                                                       \
+    init_##short_name3(tv3);                                                                       \
+    init_##short_name4(tv4);                                                                       \
+    init_##short_name5(tv5);                                                                       \
+    init_##short_name6(tv6);                                                                       \
+  }                                                                                                \
+  E_PROP(type, name, short_name, tc)                                                               \
+  E_PROP(type2, name2, short_name2, tc2)                                                           \
+  E_PROP(type3, name3, short_name3, tc3)                                                           \
+  E_PROP(type4, name4, short_name4, tc4)                                                           \
+  E_PROP(type5, name5, short_name5, tc5)                                                           \
+  E_PROP(type6, name6, short_name6, tc6)                                                           \
+  E_END()
+
+#define E_SIMPLE7(event_name, el, allow_async, type, name, short_name, tc, type2, name2,           \
+                  short_name2, tc2, type3, name3, short_name3, tc3, type4, name4, short_name4,     \
+                  tc4, type5, name5, short_name5, tc5, type6, name6, short_name6, tc6, type7,      \
+                  name7, short_name7, tc7)                                                         \
+  E_BEGIN(event_name, el)                                                                          \
+  explicit event_name(const type &tv, const type2 &tv2, const type3 &tv3, const type4 &tv4,        \
+                      const type5 &tv5, const type6 &tv6, const type7 &tv7)                        \
+      : event(allow_async) {                                                                       \
+    init_##short_name(tv);                                                                         \
+    init_##short_name2(tv2);                                                                       \
+    init_##short_name3(tv3);                                                                       \
+    init_##short_name4(tv4);                                                                       \
+    init_##short_name5(tv5);                                                                       \
+    init_##short_name6(tv6);                                                                       \
+    init_##short_name7(tv7);                                                                       \
+  }                                                                                                \
+  E_PROP(type, name, short_name, tc)                                                               \
+  E_PROP(type2, name2, short_name2, tc2)                                                           \
+  E_PROP(type3, name3, short_name3, tc3)                                                           \
+  E_PROP(type4, name4, short_name4, tc4)                                                           \
+  E_PROP(type5, name5, short_name5, tc5)                                                           \
+  E_PROP(type6, name6, short_name6, tc6)                                                           \
+  E_PROP(type7, name7, short_name7, tc7)                                                           \
+  E_END()
+
+#define E_CONSUMER()                                                                               \
+private:                                                                                           \
+  std::vector<std::shared_ptr<repertory::event_consumer>> event_consumers_
+
+#define E_CONSUMER_RELEASE() event_consumers_.clear()
+
+#define E_SUBSCRIBE(name, callback)                                                                \
+  event_consumers_.emplace_back(                                                                   \
+      std::make_shared<repertory::event_consumer>(#name, [this](const event &e) { callback(e); }))
+
+#define E_SUBSCRIBE_EXACT(name, callback)                                                          \
+  event_consumers_.emplace_back(std::make_shared<repertory::event_consumer>(                       \
+      #name, [this](const event &e) { callback(dynamic_cast<const name &>(e)); }))
+
+#define E_SUBSCRIBE_ALL(callback)                                                                  \
+  event_consumers_.emplace_back(                                                                   \
+      std::make_shared<repertory::event_consumer>([this](const event &e) { callback(e); }))
+} // namespace repertory
+
+#endif // INCLUDE_EVENTS_EVENT_SYSTEM_HPP_

include/events/events.hpp

@@ -0,0 +1,417 @@
+/*
+  Copyright <2018-2022> <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 INCLUDE_EVENTS_EVENTS_HPP_
+#define INCLUDE_EVENTS_EVENTS_HPP_
+
+#include "common.hpp"
+#include "events/event_system.hpp"
+#include "types/repertory.hpp"
+#include "utils/utils.hpp"
+
+namespace repertory {
+// clang-format off
+E_SIMPLE3(cache_file_processed, normal, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING,
+  api_error, result, res, E_FROM_API_FILE_ERROR
+);
+
+E_SIMPLE2(comm_auth_begin, normal, true,
+  std::string, url, url, E_STRING,
+  std::string, user, user, E_STRING
+);
+
+E_SIMPLE4(comm_auth_end, normal, true,
+  std::string, url, url, E_STRING,
+  std::string, user, user, E_STRING,
+  CURLcode, curl, curl, E_FROM_INT32,
+  int, http, http, E_FROM_INT32
+);
+
+E_SIMPLE2(comm_auth_logout_begin, normal, true,
+  std::string, url, url, E_STRING,
+  std::string, user, user, E_STRING
+);
+
+E_SIMPLE4(comm_auth_logout_end, normal, true,
+  std::string, url, url, E_STRING,
+  std::string, user, user, E_STRING,
+  CURLcode, curl, curl, E_FROM_INT32,
+  int, http, http, E_FROM_INT32
+);
+
+E_SIMPLE1(comm_get_begin, verbose, true,
+  std::string, url, url, E_STRING
+);
+
+E_SIMPLE4(comm_get_end, verbose, true,
+  std::string, url, url, E_STRING,
+  CURLcode, curl, curl, E_FROM_INT32,
+  int, http, http, E_FROM_INT32,
+  std::string, result, res, E_STRING
+);
+
+E_SIMPLE1(comm_get_range_begin, verbose, true,
+  std::string, url, url, E_STRING
+);
+
+E_SIMPLE4(comm_get_range_end, verbose, true,
+  std::string, url, url, E_STRING,
+  CURLcode, curl, curl, E_FROM_INT32,
+  int, http, http, E_FROM_INT32,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE1(comm_get_raw_begin, verbose, true,
+  std::string, url, url, E_STRING
+);
+
+E_SIMPLE4(comm_get_raw_end, verbose, true,
+  std::string, url, url, E_STRING,
+  CURLcode, curl, curl, E_FROM_INT32,
+  int, http, http, E_FROM_INT32,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE2(comm_post_begin, verbose, true,
+  std::string, url, url, E_STRING,
+  std::string, fields, fields, E_STRING
+);
+
+E_SIMPLE4(comm_post_end, verbose, true,
+  std::string, url, url, E_STRING,
+  CURLcode, curl, curl, E_FROM_INT32,
+  int, http, http, E_FROM_INT32,
+  std::string, result, res, E_STRING
+);
+
+E_SIMPLE2(comm_duration, normal, true,
+  std::string, url, url, E_STRING,
+  std::string, duration, duration, E_STRING
+);
+
+E_SIMPLE1(comm_post_file_begin, debug, true,
+  std::string, url, url, E_STRING
+);
+
+E_SIMPLE4(comm_post_file_end, debug, true,
+  std::string, url, url, E_STRING,
+  CURLcode, curl, curl, E_FROM_INT32,
+  int, http, http, E_FROM_INT32,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE1(comm_post_multi_part_file_begin, debug, true,
+  std::string, url, url, E_STRING
+);
+
+E_SIMPLE4(comm_post_multi_part_file_end, debug, true,
+  std::string, url, url, E_STRING,
+  CURLcode, curl, curl, E_FROM_INT32,
+  int, http, http, E_FROM_INT32,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE4(comm_tus_upload_begin, debug, true,
+  std::string, file_name, fn, E_STRING,
+  std::string, url, url, E_STRING,
+  std::uint64_t, remain, rem, E_FROM_UINT64,
+  std::uint64_t, offset, off, E_FROM_UINT64
+);
+
+E_SIMPLE6(comm_tus_upload_end, debug, true,
+  std::string, file_name, fn, E_STRING,
+  std::string, url, url, E_STRING,
+  std::uint64_t, remain, rem, E_FROM_UINT64,
+  std::uint64_t, offset, OFF, E_FROM_UINT64,
+  CURLcode, curl, curl, E_FROM_INT32,
+  int, http, http, E_FROM_INT32
+);
+
+E_SIMPLE2(comm_tus_upload_create_begin, debug, true,
+  std::string, file_name, fn, E_STRING,
+  std::string, url, url, E_STRING
+);
+
+E_SIMPLE4(comm_tus_upload_create_end, debug, true,
+  std::string, file_name, fn, E_STRING,
+  std::string, url, url, E_STRING,
+  CURLcode, curl, curl, E_FROM_INT32,
+  int, http, http, E_FROM_INT32
+);
+
+E_SIMPLE3(debug_log, debug, true,
+  std::string, function, func, E_STRING,
+  std::string, api_path, ap, E_STRING,
+  std::string, data, data, E_STRING
+);
+
+E_SIMPLE1(directory_removed, normal, true,
+  std::string, api_path, ap, E_STRING
+);
+
+E_SIMPLE2(directory_remove_failed, error, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE2(drive_mount_failed, error, true,
+  std::string, location, loc, E_STRING,
+  std::string, result, res, E_STRING
+);
+
+E_SIMPLE1(drive_mounted, normal, true,
+  std::string, location, loc, E_STRING
+);
+
+E_SIMPLE1(drive_mount_result, normal, true,
+  std::string, result, res, E_STRING
+);
+
+E_SIMPLE1(drive_unmount_pending, normal, true,
+  std::string, location, loc, E_STRING
+);
+
+E_SIMPLE1(drive_unmounted, normal, true,
+  std::string, location, loc, E_STRING
+);
+
+E_SIMPLE1(event_level_changed, normal, true,
+  std::string, new_event_level, level, E_STRING
+);
+
+E_SIMPLE1(failed_upload_queued, error, true,
+  std::string, api_path, ap, E_STRING
+);
+
+E_SIMPLE1(failed_upload_removed, warn, true,
+  std::string, api_path, ap, E_STRING
+);
+
+E_SIMPLE1(failed_upload_retry, normal, true,
+  std::string, api_path, ap, E_STRING
+);
+
+E_SIMPLE2(file_get_failed, error, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE1(file_get_api_list_failed, error, true,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE1(file_pinned, normal, true,
+  std::string, api_path, ap, E_STRING
+);
+
+E_SIMPLE3(file_read_bytes_failed, error, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, error, err, E_STRING,
+  std::size_t, retry, retry, E_FROM_SIZE_T
+);
+
+E_SIMPLE1(file_removed, normal, true,
+  std::string, api_path, ap, E_STRING
+);
+
+E_SIMPLE2(file_removed_externally, warn, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING
+);
+
+E_SIMPLE2(file_remove_failed, error, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE3(file_rename_failed, error, true,
+  std::string, from_api_path, FROM, E_STRING,
+  std::string, to_api_path, TO, E_STRING,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE2(file_get_size_failed, error, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE3(filesystem_item_added, normal, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, parent, parent, E_STRING,
+  bool, directory, dir, E_FROM_BOOL
+);
+
+E_SIMPLE4(filesystem_item_closed, verbose, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING,
+  bool, directory, dir, E_FROM_BOOL,
+  bool, changed, changed, E_FROM_BOOL
+);
+
+E_SIMPLE5(filesystem_item_handle_closed, verbose, true,
+  std::string, api_path, ap, E_STRING,
+  std::uint64_t, handle, handle, E_FROM_UINT64,
+  std::string, source, src, E_STRING,
+  bool, directory, dir, E_FROM_BOOL,
+  bool, changed, changed, E_FROM_BOOL
+);
+
+E_SIMPLE2(filesystem_item_evicted, normal, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING
+);
+
+E_SIMPLE2(filesystem_item_get_failed, error, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE3(filesystem_item_opened, verbose, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING,
+  bool, directory, dir, E_FROM_BOOL
+);
+
+E_SIMPLE1(file_unpinned, normal, true,
+  std::string, api_path, ap, E_STRING
+);
+
+E_SIMPLE2(file_upload_begin, normal, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING
+);
+
+E_SIMPLE2(file_upload_completed, normal, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING
+);
+
+E_SIMPLE3(file_upload_end, normal, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING,
+  api_error, result, res, E_FROM_API_FILE_ERROR
+);
+
+E_SIMPLE3(file_upload_failed, error, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING,
+  std::string, error, err, E_STRING
+);
+
+E_SIMPLE2(file_upload_not_found, warn, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING
+);
+
+E_SIMPLE2(file_upload_queued, normal, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING
+);
+
+E_SIMPLE2(file_upload_removed, debug, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING
+);
+
+E_SIMPLE2(file_upload_retry, normal, true,
+  std::string, api_path, ap, E_STRING,
+  std::string, source, src, E_STRING
+);
+
+E_SIMPLE(item_scan_begin, normal, true);
+
+E_SIMPLE(item_scan_end, normal, true);
+
+E_SIMPLE1(orphaned_file_deleted, warn, true,
+  std::string, source, src, E_STRING
+);
+
+E_SIMPLE1(orphaned_file_detected, warn, true,
+  std::string, source, src, E_STRING
+);
+
+E_SIMPLE2(orphaned_file_processed, warn, true,
+  std::string, source, src, E_STRING,
+  std::string, dest, dest, E_STRING
+);
+
+E_SIMPLE3(orphaned_file_processing_failed, error, true,
+  std::string, source, src, E_STRING,
+  std::string, dest, dest, E_STRING,
+  std::string, result, res, E_STRING
+);
+
+E_SIMPLE1(polling_item_begin, debug, true,
+  std::string, item_name, item, E_STRING
+);
+
+E_SIMPLE1(polling_item_end, debug, true,
+  std::string, item_name, item, E_STRING
+);
+
+E_SIMPLE2(provider_offline, error, true,
+  std::string, host_name_or_ip, host, E_STRING,
+  std::uint16_t, port, port, E_FROM_UINT16
+);
+
+E_SIMPLE2(repertory_exception, error, true,
+  std::string, function, func, E_STRING,
+  std::string, message, msg, E_STRING
+);
+
+E_SIMPLE1(rpc_server_exception, error, true,
+  std::string, exception, exception, E_STRING
+);
+
+E_SIMPLE1(service_shutdown, debug, true,
+  std::string, service, svc, E_STRING
+);
+
+E_SIMPLE3(skynet_import_decryption_failed, error, true,
+  std::string, skylink, skylink, E_STRING,
+  std::string, sub_file, sf, E_STRING,
+  api_error, result, res, E_FROM_API_FILE_ERROR
+);
+
+E_SIMPLE3(skynet_import_directory_failed, error, true,
+  std::string, skylink, skylink, E_STRING,
+  std::string, sub_directory, sd, E_STRING,
+  api_error, result, res, E_FROM_API_FILE_ERROR
+);
+
+E_SIMPLE3(skynet_import_file_failed, error, true,
+  std::string, skylink, skylink, E_STRING,
+  std::string, sub_file, sf, E_STRING,
+  api_error, result, res, E_FROM_API_FILE_ERROR
+);
+
+E_SIMPLE(skynet_portal_list_changed, normal, true);
+
+E_SIMPLE(unmount_requested, normal, true);
+#ifndef _WIN32
+E_SIMPLE2(unmount_result, normal, true,
+  std::string, location, loc, E_STRING,
+  std::string, result, res, E_STRING
+);
+#endif
+// clang-format on
+} // namespace repertory
+
+#endif // INCLUDE_EVENTS_EVENTS_HPP_

include/events/t_event_system.hpp

@@ -0,0 +1,178 @@
+/*
+  Copyright <2018-2022> <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 INCLUDE_EVENTS_T_EVENT_SYSTEM_HPP_
+#define INCLUDE_EVENTS_T_EVENT_SYSTEM_HPP_
+
+#include "common.hpp"
+#include "events/event.hpp"
+#include "utils/utils.hpp"
+
+namespace repertory {
+template <typename event_type> class t_event_system final {
+public:
+  t_event_system(const t_event_system &) = delete;
+  t_event_system(t_event_system &&) = delete;
+  t_event_system &operator=(const t_event_system &) = delete;
+  t_event_system &operator=(t_event_system &&) = delete;
+
+protected:
+  t_event_system() = default;
+
+  ~t_event_system() { stop(); }
+
+public:
+  class event_consumer final {
+  public:
+    explicit event_consumer(std::function<void(const event &)> callback)
+        : callback_(std::move(callback)) {
+      t_event_system::instance().attach(this);
+    }
+
+    event_consumer(const std::string &event_name, std::function<void(const event &)> callback)
+        : callback_(std::move(callback)) {
+      t_event_system::instance().attach(event_name, this);
+    }
+
+    ~event_consumer() { t_event_system::instance().release(this); }
+
+  private:
+    std::function<void(const event &)> callback_;
+
+  public:
+    void notify_event(const event &event) { callback_(event); }
+  };
+
+private:
+  static t_event_system event_system_;
+
+public:
+  static t_event_system &instance();
+
+private:
+  std::unordered_map<std::string, std::deque<event_consumer *>> event_consumers_;
+  std::recursive_mutex consumer_mutex_;
+  std::vector<std::shared_ptr<event_type>> event_list_;
+  std::condition_variable event_notify_;
+  std::mutex event_mutex_;
+  std::unique_ptr<std::thread> event_thread_;
+  std::mutex run_mutex_;
+  bool stop_requested_ = false;
+
+private:
+  void process_events() {
+    std::vector<std::shared_ptr<event_type>> events;
+    {
+      unique_mutex_lock l(event_mutex_);
+      if (not stop_requested_ && event_list_.empty()) {
+        event_notify_.wait_for(l, 5s);
+      }
+
+      if (not event_list_.empty()) {
+        events.insert(events.end(), event_list_.begin(), event_list_.end());
+        event_list_.clear();
+      }
+    }
+
+    const auto notify_events = [this](const std::string &name, const event_type &event) {
+      std::deque<std::future<void>> futures;
+      recur_mutex_lock l(consumer_mutex_);
+      if (event_consumers_.find(name) != event_consumers_.end()) {
+        for (auto *ec : event_consumers_[name]) {
+          if (event.get_allow_async()) {
+            futures.emplace_back(
+                std::async(std::launch::async, [ec, &event]() { ec->notify_event(event); }));
+          } else {
+            ec->notify_event(event);
+          }
+        }
+      }
+
+      while (not futures.empty()) {
+        futures.front().get();
+        futures.pop_front();
+      }
+    };
+
+    for (const auto &e : events) {
+      notify_events("", *e.get());
+      notify_events(e->get_name(), *e.get());
+    }
+  }
+
+  void queue_event(event_type *e) {
+    mutex_lock l(event_mutex_);
+    event_list_.emplace_back(std::shared_ptr<event_type>(e));
+    event_notify_.notify_all();
+  }
+
+public:
+  void attach(event_consumer *ec) {
+    recur_mutex_lock l(consumer_mutex_);
+    event_consumers_[""].push_back(ec);
+  }
+
+  void attach(const std::string &event_name, event_consumer *ec) {
+    recur_mutex_lock l(consumer_mutex_);
+    event_consumers_[event_name].push_back(ec);
+  }
+
+  template <typename t, typename... args> void raise(args &&...a) {
+    queue_event(new t(std::forward<args>(a)...));
+  }
+
+  void release(event_consumer *ec) {
+    recur_mutex_lock l(consumer_mutex_);
+    auto it =
+        std::find_if(event_consumers_.begin(), event_consumers_.end(), [&](const auto &kv) -> bool {
+          return utils::collection_includes(kv.second, ec);
+        });
+
+    if (it != event_consumers_.end()) {
+      auto &q = (*it).second;
+      utils::remove_element_from(q, ec);
+    }
+  }
+
+  void start() {
+    mutex_lock l(run_mutex_);
+    if (not event_thread_) {
+      stop_requested_ = false;
+      event_thread_ = std::make_unique<std::thread>([this]() {
+        while (not stop_requested_) {
+          process_events();
+        }
+      });
+    }
+  }
+
+  void stop() {
+    mutex_lock l(run_mutex_);
+    if (event_thread_) {
+      stop_requested_ = true;
+      event_notify_.notify_all();
+      event_thread_->join();
+      event_thread_.reset();
+      process_events();
+      stop_requested_ = false;
+    }
+  }
+};
+} // namespace repertory
+
+#endif // INCLUDE_EVENTS_T_EVENT_SYSTEM_HPP_