refactor(sync): remove historical net connectivity dependency

Author: GaspardKirira

CMakeLists.txt

@@ -18,9 +18,6 @@
 #   - vix_sync   : The actual library target (STATIC or INTERFACE)
 #   - vix::sync  : Namespaced alias for consumers
 #
-# Public Dependencies:
-#   - vix::net
-#
 # Options:
 #   - VIX_ENABLE_SANITIZERS : Inherit sanitizers from the parent project
 #
@@ -41,31 +38,6 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 # Sources discovery
 file(GLOB_RECURSE SYNC_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
 
-# Net dependency
-option(VIX_SYNC_FETCH_NET "Auto-fetch vix::net if missing" ON)
-
-if (NOT TARGET vix::net)
-  if (EXISTS "${CMAKE_CURRENT_LIST_DIR}/../net/CMakeLists.txt")
-    message(STATUS "[sync] Adding net from umbrella: ../net")
-    add_subdirectory("${CMAKE_CURRENT_LIST_DIR}/../net" "net")
-  elseif (VIX_SYNC_FETCH_NET)
-    include(FetchContent)
-    message(STATUS "[sync] Fetching vix::net via FetchContent")
-    FetchContent_Declare(vix_net
-      GIT_REPOSITORY https://github.com/vixcpp/net.git
-      GIT_TAG        dev
-    )
-    FetchContent_MakeAvailable(vix_net)
-  else()
-    message(FATAL_ERROR "vix::net not found. Enable VIX_SYNC_FETCH_NET=ON or provide the target before sync.")
-  endif()
-endif()
-
-set(VIX_NET_TARGET vix::net)
-if (NOT TARGET ${VIX_NET_TARGET} AND TARGET vix::net)
-  set(VIX_NET_TARGET vix::net)
-endif()
-
 # JSON dependency (needed by FileOutboxStore.cpp via <vix/json/...>)
 option(VIX_SYNC_FETCH_JSON "Auto-fetch vix::json if missing" ON)
 
@@ -132,7 +104,6 @@ endif()
 
   target_link_libraries(vix_sync
     PUBLIC
-      ${VIX_NET_TARGET}
       ${VIX_JSON_TARGET}
   )
 
@@ -172,7 +143,6 @@ else()
   )
 
   target_link_libraries(vix_sync INTERFACE
-    ${VIX_NET_TARGET}
     ${VIX_JSON_TARGET}
   )
 
@@ -201,7 +171,6 @@ if (SYNC_SOURCES)
 else()
   message(STATUS "Mode: HEADER-ONLY / no sources")
 endif()
-message(STATUS "Net target:      ${VIX_NET_TARGET}")
 message(STATUS "Include dir: ${CMAKE_CURRENT_SOURCE_DIR}/include (for <vix/...>)")
 message(STATUS "Sanitizers (inherited): ${VIX_ENABLE_SANITIZERS}")
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")

include/vix/sync/engine/SyncEngine.hpp

@@ -18,11 +18,11 @@
 
 #include <atomic>
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <thread>
 #include <vector>
 
-#include <vix/net/NetworkProbe.hpp>
 #include <vix/sync/engine/SyncWorker.hpp>
 #include <vix/sync/outbox/Outbox.hpp>
 
@@ -34,7 +34,7 @@ namespace vix::sync::engine
    * SyncEngine is responsible for running the main synchronization control loop:
    * - Spawns and owns a set of SyncWorker instances
    * - Periodically ticks workers to pull operations from the Outbox
-   * - Uses NetworkProbe to adapt behavior when offline/online
+   * - Applies configured send permission before delivery attempts
    * - Delegates actual I/O to an ISyncTransport implementation
    *
    * The engine can be driven manually via tick() (single-threaded integration),
@@ -65,10 +65,22 @@ namespace vix::sync::engine
       std::int64_t idle_sleep_ms{250};
 
       /**
-       * @brief Sleep duration when network is considered offline.
+       * @brief Sleep duration when delivery permission is denied.
        */
       std::int64_t offline_sleep_ms{500};
 
+      /**
+       * @brief Optional policy deciding whether remote delivery may proceed.
+       *
+       * When unset, Sync permits delivery. Exceptions propagate from tick().
+       */
+      std::function<bool()> send_permission{};
+
+      /**
+       * @brief Minimum delay between shared permission evaluations.
+       */
+      std::int64_t send_permission_min_interval_ms{1000};
+
       /**
        * @brief Maximum number of operations to pull per batch.
        */
@@ -88,13 +100,11 @@ namespace vix::sync::engine
      *
      * @param cfg Engine configuration.
      * @param outbox Shared Outbox containing pending operations to sync.
-     * @param probe Network probe used to detect offline/online state.
      * @param transport Transport used to send/receive sync payloads.
      */
     SyncEngine(
         Config cfg,
         std::shared_ptr<vix::sync::outbox::Outbox> outbox,
-        std::shared_ptr<vix::net::NetworkProbe> probe,
         std::shared_ptr<ISyncTransport> transport);
 
     /**
@@ -160,9 +170,9 @@ namespace vix::sync::engine
     std::shared_ptr<vix::sync::outbox::Outbox> outbox_;
 
     /**
-     * @brief Network probe used to detect connectivity changes.
+     * @brief Shared, rate-limited delivery permission used by every worker.
      */
-    std::shared_ptr<vix::net::NetworkProbe> probe_;
+    std::function<bool(std::int64_t)> send_permission_;
 
     /**
      * @brief Transport used by workers to communicate with remote peers/edge.

include/vix/sync/engine/SyncWorker.hpp

@@ -21,7 +21,6 @@
 #include <memory>
 #include <string>
 
-#include <vix/net/NetworkProbe.hpp>
 #include <vix/sync/Operation.hpp>
 #include <vix/sync/outbox/Outbox.hpp>
 
@@ -84,7 +83,7 @@ namespace vix::sync::engine
    * @brief Single-worker unit that processes ready operations from the Outbox.
    *
    * SyncWorker:
-   * - Consults NetworkProbe to decide if sending should proceed
+   * - Consults configured send permission before delivery attempts
    * - Pulls a batch of ready operations from the Outbox
    * - Sends operations through ISyncTransport
    * - Applies retry/backoff decisions by updating Outbox state (implementation-defined)
@@ -117,7 +116,7 @@ namespace vix::sync::engine
       std::int64_t idle_sleep_ms{250};
 
       /**
-       * @brief Sleep duration when network is considered offline.
+       * @brief Sleep duration when delivery permission is denied.
        *
        * This is mainly used by higher-level orchestrators (SyncEngine).
        */
@@ -137,13 +136,13 @@ namespace vix::sync::engine
      *
      * @param cfg Worker configuration.
      * @param outbox Shared outbox used to fetch and update operations.
-     * @param probe Network probe used to detect offline/online state.
+     * @param send_permission Optional policy deciding whether sending proceeds.
      * @param transport Transport used to deliver operations.
      */
     SyncWorker(
         Config cfg,
         std::shared_ptr<vix::sync::outbox::Outbox> outbox,
-        std::shared_ptr<vix::net::NetworkProbe> probe,
+        std::function<bool(std::int64_t)> send_permission,
         std::shared_ptr<ISyncTransport> transport);
 
     /**
@@ -161,7 +160,7 @@ namespace vix::sync::engine
     /**
      * @brief Decide whether the worker should attempt sending right now.
      *
-     * Typically checks connectivity (NetworkProbe) and possibly Outbox state.
+     * Applies the configured delivery permission policy.
      *
      * @param now_ms Current monotonic time in milliseconds.
      * @return true if sending should proceed, false otherwise.
@@ -191,9 +190,9 @@ namespace vix::sync::engine
     std::shared_ptr<vix::sync::outbox::Outbox> outbox_;
 
     /**
-     * @brief Network probe used to detect connectivity.
+     * @brief Optional policy deciding whether sending proceeds at a given time.
      */
-    std::shared_ptr<vix::net::NetworkProbe> probe_;
+    std::function<bool(std::int64_t)> send_permission_;
 
     /**
      * @brief Transport used to send operations.

src/engine/SyncEngine.cpp

@@ -14,10 +14,55 @@
 #include <vix/sync/engine/SyncEngine.hpp>
 
 #include <chrono>
+#include <functional>
+#include <memory>
+#include <utility>
 
 namespace vix::sync::engine
 {
 
+  namespace
+  {
+    class SendGate
+    {
+    public:
+      SendGate(
+          std::function<bool()> permission,
+          std::int64_t minimum_interval_ms)
+          : permission_(std::move(permission)),
+            minimum_interval_ms_(minimum_interval_ms >= 0
+                                     ? minimum_interval_ms
+                                     : 1000)
+      {
+      }
+
+      [[nodiscard]] bool allows_send(std::int64_t now_ms)
+      {
+        if (!permission_)
+        {
+          return true;
+        }
+
+        if (!initialized_ || now_ms - last_evaluation_ms_ < 0 ||
+            now_ms - last_evaluation_ms_ >= minimum_interval_ms_)
+        {
+          last_allowed_ = permission_();
+          last_evaluation_ms_ = now_ms;
+          initialized_ = true;
+        }
+
+        return last_allowed_;
+      }
+
+    private:
+      std::function<bool()> permission_;
+      std::int64_t minimum_interval_ms_{1000};
+      bool last_allowed_{true};
+      std::int64_t last_evaluation_ms_{0};
+      bool initialized_{false};
+    };
+  } // namespace
+
   static std::int64_t now_ms()
   {
     using namespace std::chrono;
@@ -27,13 +72,19 @@ namespace vix::sync::engine
   SyncEngine::SyncEngine(
       Config cfg,
       std::shared_ptr<vix::sync::outbox::Outbox> outbox,
-      std::shared_ptr<vix::net::NetworkProbe> probe,
       std::shared_ptr<ISyncTransport> transport)
-      : cfg_(cfg),
+      : cfg_(std::move(cfg)),
         outbox_(std::move(outbox)),
-        probe_(std::move(probe)),
         transport_(std::move(transport))
   {
+    auto send_gate = std::make_shared<SendGate>(
+        cfg_.send_permission,
+        cfg_.send_permission_min_interval_ms);
+    send_permission_ = [send_gate](std::int64_t now_ms)
+    {
+      return send_gate->allows_send(now_ms);
+    };
+
     workers_.reserve(cfg_.worker_count);
     for (std::size_t i = 0; i < cfg_.worker_count; ++i)
     {
@@ -43,7 +94,11 @@ namespace vix::sync::engine
       wc.offline_sleep_ms = cfg_.offline_sleep_ms;
       wc.inflight_timeout_ms = cfg_.inflight_timeout_ms;
 
-      workers_.push_back(std::make_unique<SyncWorker>(wc, outbox_, probe_, transport_));
+      workers_.push_back(std::make_unique<SyncWorker>(
+          wc,
+          outbox_,
+          send_permission_,
+          transport_));
     }
   }
 

src/engine/SyncWorker.cpp

@@ -19,19 +19,18 @@ namespace vix::sync::engine
   SyncWorker::SyncWorker(
       Config cfg,
       std::shared_ptr<vix::sync::outbox::Outbox> outbox,
-      std::shared_ptr<vix::net::NetworkProbe> probe,
+      std::function<bool(std::int64_t)> send_permission,
       std::shared_ptr<ISyncTransport> transport)
       : cfg_(cfg),
         outbox_(std::move(outbox)),
-        probe_(std::move(probe)),
+        send_permission_(std::move(send_permission)),
         transport_(std::move(transport))
   {
   }
 
   bool SyncWorker::should_send_(std::int64_t now_ms)
   {
-    const bool online = probe_ ? probe_->refresh(now_ms) : true;
-    return online;
+    return send_permission_ ? send_permission_(now_ms) : true;
   }
 
   std::size_t SyncWorker::process_ready_(std::int64_t now_ms)

tests/sync_engine_inflight_timeout_test.cpp

@@ -17,7 +17,6 @@
 #include <iostream>
 #include <memory>
 
-#include <vix/net/NetworkProbe.hpp>
 #include <vix/sync/outbox/Outbox.hpp>
 #include <vix/sync/outbox/FileOutboxStore.hpp>
 #include <vix/sync/engine/SyncEngine.hpp>
@@ -58,13 +57,7 @@ int main()
       },
       store);
 
-  // 2) Probe: always online
-  auto probe = std::make_shared<vix::net::NetworkProbe>(
-      vix::net::NetworkProbe::Config{},
-      []
-      { return true; });
-
-  // 3) Transport: success
+  // 2) Transport: success
   auto transport = std::make_shared<FakeHttpTransport>();
   transport->setDefault({.ok = true});
 
@@ -75,8 +68,9 @@ int main()
   ecfg.idle_sleep_ms = 0;
   ecfg.offline_sleep_ms = 0;
   ecfg.inflight_timeout_ms = 50; // 50ms for test
+  ecfg.send_permission = [] { return true; };
 
-  SyncEngine engine(ecfg, outbox, probe, transport);
+  SyncEngine engine(ecfg, outbox, transport);
 
   // 5) Enqueue op
   Operation op;

tests/sync_engine_outbox_permanent_fail_test.cpp

@@ -17,7 +17,6 @@
 #include <iostream>
 #include <memory>
 
-#include <vix/net/NetworkProbe.hpp>
 #include <vix/sync/outbox/Outbox.hpp>
 #include <vix/sync/outbox/FileOutboxStore.hpp>
 #include <vix/sync/engine/SyncEngine.hpp>
@@ -58,13 +57,7 @@ int main()
       },
       store);
 
-  // 2) Network probe: always online
-  auto probe = std::make_shared<vix::net::NetworkProbe>(
-      vix::net::NetworkProbe::Config{},
-      []
-      { return true; });
-
-  // 3) Fake transport: permanent failure on this target
+  // 2) Fake transport: permanent failure on this target
   auto transport = std::make_shared<FakeHttpTransport>();
   transport->setRuleForTarget(
       "/api/messages",
@@ -79,8 +72,9 @@ int main()
   ecfg.batch_limit = 10;
   ecfg.idle_sleep_ms = 0;
   ecfg.offline_sleep_ms = 0;
+  ecfg.send_permission = [] { return true; };
 
-  SyncEngine engine(ecfg, outbox, probe, transport);
+  SyncEngine engine(ecfg, outbox, transport);
 
   // 5) Enqueue operation
   Operation op;