Stuff.

src/command_local.cc

@@ -117,7 +117,7 @@ group_insert(const torrent::Object::list_type& args) {
   rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.enable", "simple",
                                                               "schedule=group." + name + ".ratio,5,60,on_ratio=" + name));
   rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.disable", "simple",
-                                                              "schedule.remove=group." + name + ".ratio"));
+                                                              "schedule_remove=group." + name + ".ratio"));
   rpc::commands.call("method.insert", rpc::create_object_list("group."  + name + ".ratio.command", "simple",
                                                               "d.try_close= ;d.ignore_commands.set=1"));
   rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".view", "string", view));

src/input/input_event.h

@@ -2,11 +2,12 @@
 #define RTORRENT_INPUT_INPUT_EVENT_H
 
 #include <functional>
-#include <torrent/system/event.h>
+
+#include <torrent/event.h>
 
 namespace input {
 
-class InputEvent : public torrent::system::Event {
+class InputEvent : public torrent::Event {
 public:
   typedef std::function<void (int)> slot_int;
 

src/main.cc

@@ -112,7 +112,8 @@ main(int argc, char** argv) {
 
     torrent::log_initialize();
 
-    torrent::runtime::initialize_worker_process_and_main_thread();
+    // TODO: Create a fake thread object for initializing other processes and enabling logging.
+    torrent::initialize_main_thread();
 
     // Block SIGCHLD until all threads are created, then unblock on main-thread, to avoid SIGCHLD
     // interrupting other threads.
@@ -357,27 +358,6 @@ main(int argc, char** argv) {
     CMD_REDIRECT("to_xb",                 "convert.xb");
     CMD_REDIRECT("to_throttle",           "convert.throttle");
 
-    // TODO: Deprecate these at some point a while after 1.1 release.
-
-    CMD_REDIRECT("d.multicall2",                   "d.multicall");
-    CMD_REDIRECT("network.open_sockets",           "system.sockets.size");
-    CMD_REDIRECT("network.max_open_sockets",       "system.sockets.max_size");
-    CMD_REDIRECT("network.max_open_sockets.set",   "system.sockets.max_size.set");
-    CMD_REDIRECT("network.http.proxy_address",     "network.proxy.http");
-    CMD_REDIRECT("network.http.proxy_address.set", "network.proxy.http.set");
-
-    rpc::rpc.mark_safe("d.multicall2");
-    rpc::rpc.mark_safe("network.max_open_sockets");
-    rpc::rpc.mark_safe("network.http.proxy_address");
-
-    CMD2_ANY_VALUE_V("network.http.max_total_connections.set", [](auto, auto) {
-        lt_log_print(torrent::LOG_WARN, "network.http.max_total_connections.set is deprecated, use system.sockets.http.min_alloc.set instead.");
-      });
-
-    CMD2_ANY_VALUE_V("network.max_open_files.set", [](auto, auto) {
-        lt_log_print(torrent::LOG_WARN, "network.max_open_files.set is deprecated, use system.sockets.files.min_alloc.set instead.");
-      });
-
     // if (rpc::call_command_value("method.use_intermediate") == 1) {
 
     // } else if (rpc::call_command_value("method.use_intermediate") == 2) {
@@ -385,27 +365,9 @@ main(int argc, char** argv) {
     // }
 
     if (rpc::call_command_value("method.use_deprecated") == 1) {
-      CMD_REDIRECT("execute2",         "execute");
-      CMD_REDIRECT("schedule2",        "schedule");
-      CMD_REDIRECT("schedule_remove2", "schedule.remove");
-
-      CMD_REDIRECT("bind",                  "network.bind_address.set");
-      CMD_REDIRECT("ip",                    "network.local_address.set");
-      CMD_REDIRECT("port_range",            "network.port_range.set");
-
-      // TODO: Check if dht is on by default.
-      CMD_REDIRECT("dht",                   "dht.mode.set");
-
-      CMD_REDIRECT("port_random",           "network.port_random.set");
+      CMD_REDIRECT("port_random",           "network.listen.port.random.set");
       CMD_REDIRECT("proxy_address",         "network.proxy_address.set");
 
-      CMD_REDIRECT("key_layout",            "keys.layout.set");
-
-      CMD_REDIRECT("torrent_list_layout",   "ui.torrent_list.layout.set");
-
-      CMD2_VAR_STRING("dht.throttle.name",   "deprecated");
-      rpc::rpc.mark_safe("dht.throttle.name");
-
       CMD_REDIRECT("network.http.max_open",     "network.http.max_total_connections");
       CMD_REDIRECT("network.http.max_open.set", "network.http.max_total_connections.set");
 
@@ -430,6 +392,27 @@ main(int argc, char** argv) {
       CMD_REDIRECT("network.port_random.set", "network.listen.port.random.set");
       CMD_REDIRECT("network.port_range",      "network.listen.port.range");
       CMD_REDIRECT("network.port_range.set",  "network.listen.port.range.set");
+
+      // TODO: Deprecate these at some point a while after 1.1 release.
+
+      CMD_REDIRECT("d.multicall2",                   "d.multicall");
+      CMD_REDIRECT("network.open_sockets",           "system.sockets.size");
+      CMD_REDIRECT("network.max_open_sockets",       "system.sockets.max_size");
+      CMD_REDIRECT("network.max_open_sockets.set",   "system.sockets.max_size.set");
+      CMD_REDIRECT("network.http.proxy_address",     "network.proxy.http");
+      CMD_REDIRECT("network.http.proxy_address.set", "network.proxy.http.set");
+
+      rpc::rpc.mark_safe("d.multicall2");
+      rpc::rpc.mark_safe("network.max_open_sockets");
+      rpc::rpc.mark_safe("network.http.proxy_address");
+
+      CMD2_ANY_VALUE_V("network.http.max_total_connections.set", [](auto, auto) {
+          lt_log_print(torrent::LOG_WARN, "network.http.max_total_connections.set is deprecated, use system.sockets.http.min_alloc.set instead.");
+        });
+
+      CMD2_ANY_VALUE_V("network.max_open_files.set", [](auto, auto) {
+          lt_log_print(torrent::LOG_WARN, "network.max_open_files.set is deprecated, use system.sockets.files.min_alloc.set instead.");
+        });
     }
 
     {

src/rpc/scgi.h

@@ -3,13 +3,13 @@
 
 #include <array>
 #include <memory>
-#include <torrent/system/event.h>
+#include <torrent/event.h>
 
 #include "rpc/scgi_task.h"
 
 namespace rpc {
 
-class SCgi : public torrent::system::Event {
+class SCgi : public torrent::Event {
 public:
   static const int max_tasks = 100;
 

src/rpc/scgi_task.h

@@ -4,13 +4,13 @@
 #include <memory>
 #include <mutex>
 #include <vector>
-#include <torrent/system/event.h>
+#include <torrent/event.h>
 
 namespace rpc {
 
 class SCgi;
 
-class SCgiTask : public torrent::system::Event {
+class SCgiTask : public torrent::Event {
 public:
   static constexpr int default_buffer_size = 8191;
   static constexpr int max_header_size     = 2000;

test/helpers/mock_compare.h

@@ -2,10 +2,9 @@
 #define LIBTORRENT_HELPERS_MOCK_COMPARE_H
 
 #include <algorithm>
-#include <map>
 #include <type_traits>
+#include <torrent/event.h>
 #include <torrent/net/socket_address.h>
-#include <torrent/system/event.h>
 
 // Compare arguments to mock functions with what is expected. The lhs
 // are the expected arguments, rhs are the ones called with.
@@ -14,13 +13,13 @@ template <typename Arg>
 inline bool mock_compare_arg(Arg lhs, Arg rhs) { return lhs == rhs; }
 
 template <int I, typename A, typename... Args>
-std::enable_if_t<I == 1, int>
+typename std::enable_if<I == 1, int>::type
 mock_compare_tuple(const std::tuple<A, Args...>& lhs, const std::tuple<Args...>& rhs) {
   return mock_compare_arg(std::get<I>(lhs), std::get<I - 1>(rhs)) ? 0 : 1;
 }
 
 template <int I, typename A, typename... Args>
-std::enable_if_t<1 < I, int>
+typename std::enable_if<1 < I, int>::type
 mock_compare_tuple(const std::tuple<A, Args...>& lhs, const std::tuple<Args...>& rhs) {
   auto res = mock_compare_tuple<I - 1>(lhs, rhs);
 
@@ -71,37 +70,24 @@ void mock_compare_add(T* v) {
 // Specialize:
 //
 
-constexpr int mock_compare_gt_two_int = -0xFD30;
-
-template <>
-inline bool mock_compare_arg<int>(int lhs, int rhs) {
-  if (lhs == mock_compare_gt_two_int)
-    return rhs > 2;
-  if (rhs == mock_compare_gt_two_int)
-    return lhs > 2;
-
-  return lhs == rhs;
-}
-
 template <>
 inline bool mock_compare_arg<sockaddr*>(sockaddr* lhs, sockaddr* rhs) {
   return lhs != nullptr && rhs != nullptr && torrent::sa_equal(lhs, rhs);
 }
-
 template <>
 inline bool mock_compare_arg<const sockaddr*>(const sockaddr* lhs, const sockaddr* rhs) {
   return lhs != nullptr && rhs != nullptr && torrent::sa_equal(lhs, rhs);
 }
 
 template <>
-inline bool mock_compare_arg<torrent::system::Event*>(torrent::system::Event* lhs, torrent::system::Event* rhs) {
-  if (mock_compare_map<torrent::system::Event>::is_key(lhs)) {
-    if (!mock_compare_map<torrent::system::Event>::has_value(rhs)) {
-      mock_compare_map<torrent::system::Event>::values[lhs] = rhs;
+inline bool mock_compare_arg<torrent::Event*>(torrent::Event* lhs, torrent::Event* rhs) {
+  if (mock_compare_map<torrent::Event>::is_key(lhs)) {
+    if (!mock_compare_map<torrent::Event>::has_value(rhs)) {
+      mock_compare_map<torrent::Event>::values[lhs] = rhs;
       return true;
     }
 
-    return mock_compare_map<torrent::system::Event>::has_key(lhs) && mock_compare_map<torrent::system::Event>::get(lhs) == rhs;
+    return mock_compare_map<torrent::Event>::has_key(lhs) && mock_compare_map<torrent::Event>::get(lhs) == rhs;
   }
 
   return lhs == rhs;

test/helpers/mock_function.cc

@@ -6,9 +6,9 @@
 #include <iostream>
 #include <unistd.h>
 
+#include "torrent/event.h"
 #include "torrent/net/socket_address.h"
 #include "torrent/net/fd.h"
-#include "torrent/system/event.h"
 #include "torrent/utils/log.h"
 #include "torrent/utils/random.h"
 
@@ -32,7 +32,7 @@ mock_clear(bool ignore_assert) {
   MOCK_CLEANUP_MAP(torrent::random_uniform_uint16);
   MOCK_CLEANUP_MAP(torrent::random_uniform_uint32);
 
-  mock_compare_map<torrent::system::Event>::values.clear();
+  mock_compare_map<torrent::Event>::values.clear();
 }
 } // namespace
 
@@ -55,9 +55,7 @@ mock_redirect_defaults([[maybe_unused]] mock_redirect_flags flags) {
 
   mock_redirect(torrent::fd__close, std::function<int(int fildes)>([](int fildes) { return ::close(fildes); }));
   mock_redirect(torrent::fd__fcntl_int, std::function<int(int fildes, int cmd, int arg)>([](int fildes, int cmd, int arg) { return ::fcntl(fildes, cmd, arg); }));
-  mock_redirect(torrent::fd__setsockopt_int, std::function<int(int socket, int level, int option_name, int option_value)>([](int socket, int level, int option_name, int option_value) {
-      return ::setsockopt(socket, level, option_name, &option_value, sizeof(int));
-    }));
+  mock_redirect(torrent::fd__setsockopt_int, std::function<int(int socket, int level, int option_name, int option_value)>([](int socket, int level, int option_name, int option_value) { return ::setsockopt(socket, level, option_name, &option_value, sizeof(int)); }));
   mock_redirect(torrent::fd__socket, std::function<int(int domain, int type, int protocol)>([](int domain, int type, int protocol) { return ::socket(domain, type, protocol); }));
 }
 
@@ -114,6 +112,69 @@ int fd__socket(int domain, int type, int protocol) {
   return mock_call<int>(__func__, &torrent::fd__socket, domain, type, protocol);
 }
 
+//
+// Mock functions for 'torrent/common.h':
+//
+
+namespace this_thread {
+
+void event_open(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_open, event);
+}
+
+void event_open_and_count(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_open_and_count, event);
+}
+
+void event_close_and_count(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_close_and_count, event);
+}
+
+void event_closed_and_count(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_closed_and_count, event);
+}
+
+void event_insert_read(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_insert_read, event);
+}
+
+void event_insert_write(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_insert_write, event);
+}
+
+void event_insert_error(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_insert_error, event);
+}
+
+void event_remove_read(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_remove_read, event);
+}
+
+void event_remove_write(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_remove_write, event);
+}
+
+void event_remove_error(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_remove_error, event);
+}
+
+void event_remove_and_close(Event* event) {
+  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
+  return mock_call<void>(__func__, &torrent::this_thread::event_remove_and_close, event);
+}
+
+}
+
 //
 // Mock functions for 'torrent/utils/random.h':
 //