daytona 0.200.0 → 0.200.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de70d9e56ce97468d9ef3bcf8c7dbe0b70f74ee7e64a7ac1d0e8642857a3c257
-  data.tar.gz: 3cec447b03a65f42bcd84c49e719cd8771a1404f496384afd5e797b429e47fb1
+  metadata.gz: 714770a5cd03bbfb27825fd9c018333d0377db70c0ce32b7ed484ff62946b2da
+  data.tar.gz: 1ea5e87028fffadb41659ceb7d76e6ec635ce2801e27f53bf1319d02b66ea6a7
 SHA512:
-  metadata.gz: 91c94980be6003996bbbf4b447b170e9165cbc3a47e78c47f91886f28accd5f7b083b04903fc59dede9bbe56ccdcaf9957da73e07202e762ca928203274b2c8b
-  data.tar.gz: db39e610c03a011d4c2468475393ca7b7bd17cc1087dbb0edd46c9fc6959da18e0ca61d861485ca0b27faa8ccb4061f631ec44c97d90d8e6bea7db75317db4e3
+  metadata.gz: 9f8bec4d5a367c8c1f2cc48bab297903dd2b75f03460c0c72728842a639da4dd00c781ec5668f64aef5375af1955f3e1cb6221577dfa4d3fd237c97fbb6056e2
+  data.tar.gz: 19a3b2b8bafb2c5a9fc14777411de38abe6a6ac17b1c0d132af9334142ab915ef3aa325aa8184e1ac999df7e0c867a47e8d3691975b09be3ca6a98a80584b8b8

data/lib/daytona/common/event_subscription_manager.rb

@@ -6,14 +6,29 @@
 require 'securerandom'
 
 module Daytona
+  # Tracks dispatcher subscriptions with TTL auto-expiry.
+  #
+  # All subscriptions share ONE lazily started expiry worker thread instead of a
+  # dedicated sleeping thread per subscription, so listing many sandboxes costs
+  # one thread total, not one thread each
+  # (https://github.com/daytona/clients/issues/108). #refresh only bumps the
+  # subscription deadline — it never creates or kills threads.
   class EventSubscriptionManager
     SUBSCRIPTION_TTL = 300
     private_constant :SUBSCRIPTION_TTL
 
-    def initialize(dispatcher = nil)
+    def initialize(dispatcher = nil, ttl_seconds: SUBSCRIPTION_TTL)
       @dispatcher = dispatcher
+      @ttl = ttl_seconds
       @subscriptions = {}
+      # Deadline-ordered [expires_at, sub_id] entries. Entries are lazily
+      # invalidated: a popped entry is discarded when its subscription is gone,
+      # or re-queued at the current deadline when it was refreshed meanwhile.
+      # Invariant: every live subscription has at least one queue entry.
+      @expiry_queue = []
       @mutex = Mutex.new
+      @cond = ConditionVariable.new
+      @worker = nil
       @closed = false
     end
 
@@ -24,7 +39,6 @@ module Daytona
 
       unsubscribe = @dispatcher.subscribe(resource_id, events:, &handler)
       sub_id = SecureRandom.hex(16)
-      timer_to_stop = nil
       rollback_unsubscribe = nil
 
       @mutex.synchronize do
@@ -34,8 +48,11 @@ module Daytona
           next
         end
 
-        @subscriptions[sub_id] = { unsubscribe:, timer: nil }
-        timer_to_stop = start_timer_locked(sub_id)
+        expires_at = monotonic_now + @ttl
+        @subscriptions[sub_id] = { unsubscribe:, expires_at: }
+        push_entry_locked(expires_at, sub_id)
+        ensure_worker_locked
+        @cond.signal
       end
 
       if rollback_unsubscribe
@@ -43,44 +60,36 @@ module Daytona
         return nil
       end
 
-      stop_thread(timer_to_stop)
       sub_id
     end
 
     def refresh(sub_id)
       @mutex.synchronize do
-        # Reject after shutdown to prevent use-after-close
         return false if @closed
-      end
-
-      timer_to_stop = nil
 
-      @mutex.synchronize do
-        return false unless @subscriptions.key?(sub_id)
+        subscription = @subscriptions[sub_id]
+        return false unless subscription
 
-        timer_to_stop = start_timer_locked(sub_id)
+        # No queue entry or worker wake-up needed: when the old deadline pops,
+        # the worker sees the newer expires_at and re-queues the subscription.
+        subscription[:expires_at] = monotonic_now + @ttl
+        true
       end
-
-      stop_thread(timer_to_stop)
-      true
     end
 
     def unsubscribe(sub_id)
-      subscription = nil
-      timer = nil
-
-      @mutex.synchronize do
-        subscription = @subscriptions.delete(sub_id)
-        if subscription
-          timer = subscription[:timer]
-          subscription[:timer] = nil
+      subscription = @mutex.synchronize do
+        removed = @subscriptions.delete(sub_id)
+        # The stale queue entry is discarded when the worker pops it — except
+        # when it was the last subscription: drop the leftovers and wake the
+        # worker so it exits now instead of idling until the old deadline.
+        if removed && @subscriptions.empty?
+          @expiry_queue.clear
+          @cond.signal
         end
+        removed
       end
-
-      return unless subscription
-
-      stop_thread(timer)
-      subscription[:unsubscribe].call
+      subscription&.dig(:unsubscribe)&.call
     end
 
     def shutdown
@@ -90,55 +99,96 @@ module Daytona
         @closed = true
         subscriptions = @subscriptions.values
         @subscriptions = {}
+        @expiry_queue.clear
+        @cond.broadcast
       end
 
-      subscriptions.each do |subscription|
-        stop_thread(subscription[:timer])
-        subscription[:unsubscribe].call
-      end
+      subscriptions.each { |subscription| subscription[:unsubscribe].call }
     end
 
     private
 
-    def start_timer_locked(sub_id)
-      subscription = @subscriptions[sub_id]
-      return unless subscription
+    def monotonic_now
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
 
-      previous_timer = cancel_timer_locked(sub_id)
-      timer = Thread.new do
-        sleep(SUBSCRIPTION_TTL)
+    # Caller must hold @mutex.
+    def push_entry_locked(expires_at, sub_id)
+      index = @expiry_queue.bsearch_index { |entry| entry[0] > expires_at } || @expiry_queue.length
+      @expiry_queue.insert(index, [expires_at, sub_id])
+    end
 
-        unsubscribe = @mutex.synchronize do
-          current_subscription = @subscriptions[sub_id]
-          next unless current_subscription && current_subscription[:timer] == Thread.current
+    # Caller must hold @mutex. The alive? check is a safety net: a worker that
+    # crashed for any reason leaves a dead-but-truthy reference, and a plain nil
+    # check would then block replacements forever, silently disabling expiry.
+    def ensure_worker_locked
+      return if @worker&.alive?
 
-          @subscriptions.delete(sub_id)&.dig(:unsubscribe)
-        end
+      @worker = Thread.new { expiry_loop }
+      @worker.name = 'daytona-subscription-expiry'
+      @worker.abort_on_exception = false
+    end
 
-        unsubscribe&.call
+    def expiry_loop
+      loop do
+        expired = collect_expired
+        return if expired.nil?
+
+        expired.each do |subscription|
+          subscription[:unsubscribe].call
+        rescue StandardError
+          # One failing dispatcher unsubscribe must not kill the shared worker
+          # and silently stop expiry for every other subscription.
+          nil
+        end
       end
-      timer.abort_on_exception = false
-      subscription[:timer] = timer
-      previous_timer
     end
 
-    def cancel_timer_locked(sub_id)
-      subscription = @subscriptions[sub_id]
-      return unless subscription
+    # Blocks until at least one subscription expires. Returns nil when the
+    # worker should exit (shutdown, or no live subscriptions remain).
+    def collect_expired
+      @mutex.synchronize do
+        expired = []
+
+        while expired.empty?
+          return nil if @closed
+
+          if @expiry_queue.empty?
+            # No live subscriptions remain (see queue invariant above):
+            # exit and let the next subscribe start a fresh worker.
+            @worker = nil
+            return nil
+          end
+
+          now = monotonic_now
+          deadline = @expiry_queue.first[0]
+          if deadline > now
+            @cond.wait(@mutex, deadline - now)
+            next
+          end
+
+          drain_due_entries_locked(now, expired)
+        end
 
-      timer = subscription[:timer]
-      subscription[:timer] = nil
-      timer
+        expired
+      end
     end
 
-    def stop_thread(thread)
-      return unless thread
-      return if thread == Thread.current
+    # Caller must hold @mutex.
+    def drain_due_entries_locked(now, expired)
+      while !@expiry_queue.empty? && @expiry_queue.first[0] <= now
+        _, sub_id = @expiry_queue.shift
+        subscription = @subscriptions[sub_id]
+        next unless subscription
 
-      thread.kill
-      thread.join
-    rescue StandardError
-      nil
+        if subscription[:expires_at] > now
+          push_entry_locked(subscription[:expires_at], sub_id)
+          next
+        end
+
+        @subscriptions.delete(sub_id)
+        expired << subscription
+      end
     end
   end
 end

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.200.0'
+    VERSION = '0.200.1'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daytona
 version: !ruby/object:Gem::Version
-  version: 0.200.0
+  version: 0.200.1
 platform: ruby
 authors:
 - Daytona Platforms Inc.
@@ -85,42 +85,42 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.0
+        version: 0.200.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.0
+        version: 0.200.1
 - !ruby/object:Gem::Dependency
   name: daytona_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.0
+        version: 0.200.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.0
+        version: 0.200.1
 - !ruby/object:Gem::Dependency
   name: daytona_toolbox_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.0
+        version: 0.200.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.0
+        version: 0.200.1
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement