move timeout to utils

repertory/librepertory/src/comm/packet/packet_client.cpp

@@ -93,7 +93,7 @@ auto packet_client::check_version(std::uint32_t client_version,
     boost::asio::io_context ctx{};
     client cli(ctx);
 
-    timeout connect_timeout(
+    utils::timeout connect_timeout(
         [&cli]() {
           event_system::instance().raise<packet_client_timeout>("connect",
                                                                 function_name);
@@ -131,7 +131,7 @@ auto packet_client::connect(client &cli) -> bool {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
-    timeout connect_timeout(
+    utils::timeout connect_timeout(
         [&cli]() {
           event_system::instance().raise<packet_client_timeout>("connect",
                                                                 function_name);
@@ -257,7 +257,7 @@ void packet_client::put_client(std::shared_ptr<client> &cli) {
 void packet_client::read_data(client &cli, data_buffer &buffer) const {
   REPERTORY_USES_FUNCTION_NAME();
 
-  timeout read_timeout(
+  utils::timeout read_timeout(
       [&cli]() {
         event_system::instance().raise<packet_client_timeout>("response",
                                                               function_name);
@@ -401,7 +401,7 @@ auto packet_client::send(std::string_view method, packet &request,
 void packet_client::write_data(client &cli, const packet &request) const {
   REPERTORY_USES_FUNCTION_NAME();
 
-  timeout write_timeout(
+  utils::timeout write_timeout(
       [&cli]() {
         event_system::instance().raise<packet_client_timeout>("request",
                                                               function_name);

repertory/librepertory/src/comm/packet/packet_server.cpp

@@ -114,8 +114,9 @@ auto packet_server::handshake(std::shared_ptr<connection> conn) const -> bool {
       }
     };
 
-    timeout write_timeout(timeout_handler, std::chrono::milliseconds(
+    utils::timeout write_timeout(
-                                               server_handshake_timeout_ms));
+        timeout_handler,
+        std::chrono::milliseconds(server_handshake_timeout_ms));
 
     auto bytes_written = boost::asio::write(
         conn->socket, boost::asio::buffer(boost::asio::buffer(buffer)));
@@ -124,8 +125,9 @@ auto packet_server::handshake(std::shared_ptr<connection> conn) const -> bool {
     if (bytes_written == buffer.size()) {
       conn->buffer.resize(to_read);
 
-      timeout read_timeout(timeout_handler, std::chrono::milliseconds(
+      utils::timeout read_timeout(
-                                                server_handshake_timeout_ms));
+          timeout_handler,
+          std::chrono::milliseconds(server_handshake_timeout_ms));
 
       std::uint32_t total_read{};
       while ((total_read < to_read) && conn->socket.is_open()) {

repertory/librepertory/src/drives/winfsp/winfsp_drive.cpp

@@ -136,7 +136,7 @@ auto winfsp_drive::winfsp_service::OnStart(ULONG /*Argc*/, PWSTR * /*Argv*/)
 auto winfsp_drive::winfsp_service::OnStop() -> NTSTATUS {
   REPERTORY_USES_FUNCTION_NAME();
 
-  timeout stop_timeout(
+  utils::timeout stop_timeout(
       []() {
         event_system::instance().raise<drive_stop_timed_out>(function_name);
         app_config::set_stop_requested();

support/include/utils/timeout.hpp

@@ -1,57 +1,59 @@
-/*
+/*
-  Copyright <2018-2025> <scott.e.graves@protonmail.com>
+  Copyright <2018-2025> <scott.e.graves@protonmail.com>
-
+
-  Permission is hereby granted, free of charge, to any person obtaining a copy
+  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
+  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
+  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
+  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
+  furnished to do so, subject to the following conditions:
-
+
-  The above copyright notice and this permission notice shall be included in all
+  The above copyright notice and this permission notice shall be included in all
-  copies or substantial portions of the Software.
+  copies or substantial portions of the Software.
-
+
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  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
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
+  SOFTWARE.
-*/
+*/
-#ifndef REPERTORY_INCLUDE_UTILS_TIMEOUT_HPP_
+#ifndef REPERTORY_INCLUDE_UTILS_TIMEOUT_HPP_
-#define REPERTORY_INCLUDE_UTILS_TIMEOUT_HPP_
+#define REPERTORY_INCLUDE_UTILS_TIMEOUT_HPP_
-
+
-namespace repertory {
+#include "utils/config.hpp"
-class timeout final {
+
-public:
+namespace repertory::utils {
-  using callback_t = std::function<void()>;
+class timeout final {
-
+public:
-public:
+  using callback_t = std::function<void()>;
-  timeout(const timeout &) noexcept = delete;
+
-  timeout(timeout &&) noexcept = delete;
+public:
-  auto operator=(const timeout &) noexcept -> timeout & = delete;
+  timeout(const timeout &) noexcept = delete;
-  auto operator=(timeout &&) noexcept -> timeout & = delete;
+  timeout(timeout &&) noexcept = delete;
-
+  auto operator=(const timeout &) noexcept -> timeout & = delete;
-public:
+  auto operator=(timeout &&) noexcept -> timeout & = delete;
-  timeout(callback_t timeout_callback,
+
-          std::chrono::system_clock::duration duration);
+public:
-
+  timeout(callback_t timeout_callback,
-  ~timeout();
+          std::chrono::system_clock::duration duration);
-
+
-private:
+  ~timeout();
-  std::chrono::system_clock::duration duration_;
+
-  callback_t timeout_callback_;
+private:
-  std::atomic<bool> timeout_killed_{false};
+  std::chrono::system_clock::duration duration_;
-  std::unique_ptr<std::thread> timeout_thread_{nullptr};
+  callback_t timeout_callback_;
-  std::mutex timeout_mutex_;
+  std::atomic<bool> timeout_killed_{false};
-  std::condition_variable timeout_notify_;
+  std::unique_ptr<std::thread> timeout_thread_{nullptr};
-
+  std::mutex timeout_mutex_;
-public:
+  std::condition_variable timeout_notify_;
-  void disable();
+
-
+public:
-  void reset();
+  void disable();
-};
+
-} // namespace repertory
+  void reset();
-
+};
-#endif // REPERTORY_INCLUDE_UTILS_TIMEOUT_HPP_
+} // namespace repertory::utils
+
+#endif // REPERTORY_INCLUDE_UTILS_TIMEOUT_HPP_

support/src/utils/timeout.cpp

@@ -1,82 +1,82 @@
-/*
+/*
-  Copyright <2018-2025> <scott.e.graves@protonmail.com>
+  Copyright <2018-2025> <scott.e.graves@protonmail.com>
-
+
-  Permission is hereby granted, free of charge, to any person obtaining a copy
+  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
+  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
+  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
+  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
+  furnished to do so, subject to the following conditions:
-
+
-  The above copyright notice and this permission notice shall be included in all
+  The above copyright notice and this permission notice shall be included in all
-  copies or substantial portions of the Software.
+  copies or substantial portions of the Software.
-
+
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  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
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
+  SOFTWARE.
-*/
+*/
-#include "utils/timeout.hpp"
+#include "utils/timeout.hpp"
-
+
-namespace repertory {
+namespace repertory::utils {
-timeout::timeout(callback_t timeout_callback,
+timeout::timeout(callback_t timeout_callback,
-                 std::chrono::system_clock::duration duration)
+                 std::chrono::system_clock::duration duration)
-    : duration_(duration),
+    : duration_(duration),
-      timeout_callback_(std::move(timeout_callback)),
+      timeout_callback_(std::move(timeout_callback)),
-      timeout_killed_(duration <= std::chrono::system_clock::duration::zero()) {
+      timeout_killed_(duration <= std::chrono::system_clock::duration::zero()) {
-  if (timeout_killed_) {
+  if (timeout_killed_) {
-    return;
+    return;
-  }
+  }
-
+
-  timeout_thread_ = std::make_unique<std::thread>([this]() {
+  timeout_thread_ = std::make_unique<std::thread>([this]() {
-    std::unique_lock<std::mutex> loc_lock(timeout_mutex_);
+    std::unique_lock<std::mutex> loc_lock(timeout_mutex_);
-
+
-    while (not timeout_killed_) {
+    while (not timeout_killed_) {
-      auto res = timeout_notify_.wait_for(loc_lock, duration_);
+      auto res = timeout_notify_.wait_for(loc_lock, duration_);
-      if (res != std::cv_status::timeout) {
+      if (res != std::cv_status::timeout) {
-        continue;
+        continue;
-      }
+      }
-
+
-      if (timeout_killed_) {
+      if (timeout_killed_) {
-        return;
+        return;
-      }
+      }
-
+
-      timeout_killed_ = true;
+      timeout_killed_ = true;
-      loc_lock.unlock();
+      loc_lock.unlock();
-
+
-      try {
+      try {
-        timeout_callback_();
+        timeout_callback_();
-      } catch (...) {
+      } catch (...) {
-      }
+      }
-      return;
+      return;
-    }
+    }
-  });
+  });
-}
+}
-
+
-timeout::~timeout() { disable(); }
+timeout::~timeout() { disable(); }
-
+
-void timeout::disable() {
+void timeout::disable() {
-  unique_mutex_lock lock(timeout_mutex_);
+  unique_mutex_lock lock(timeout_mutex_);
-  std::unique_ptr<std::thread> timeout_thread{nullptr};
+  std::unique_ptr<std::thread> timeout_thread{nullptr};
-  std::swap(timeout_thread, timeout_thread_);
+  std::swap(timeout_thread, timeout_thread_);
-
+
-  if (not timeout_thread) {
+  if (not timeout_thread) {
-    timeout_notify_.notify_all();
+    timeout_notify_.notify_all();
-    return;
+    return;
-  }
+  }
-
+
-  timeout_killed_ = true;
+  timeout_killed_ = true;
-  timeout_notify_.notify_all();
+  timeout_notify_.notify_all();
-  lock.unlock();
+  lock.unlock();
-
+
-  timeout_thread->join();
+  timeout_thread->join();
-}
+}
-
+
-void timeout::reset() {
+void timeout::reset() {
-  mutex_lock lock(timeout_mutex_);
+  mutex_lock lock(timeout_mutex_);
-  timeout_notify_.notify_all();
+  timeout_notify_.notify_all();
-}
+}
-} // namespace repertory
+} // namespace repertory::utils