daytona 0.197.0 → 0.198.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e838c81b167b038d7935b94479648df5ebecb486e34465986baaeed2da7a0a5c
-  data.tar.gz: 1dce18d22149936bf16af4beda9dcf52bb1de63a0b358c7e965f2dc663bd5933
+  metadata.gz: e2003b4293b8ee69d171ad86402151e2924b814022649097deb51da19da6ff58
+  data.tar.gz: 30884a506c2dd332c804f995dd2d3afc654cf75b0fa66e4bf54cdd4a38909c12
 SHA512:
-  metadata.gz: e55a677df194a0dd60144888407f1186a03b26de14d9c3b4faf6d8611859c5d7ad059b73a1a3ce9cb41f22300c69b029139659817a27a7622e351073e00cb432
-  data.tar.gz: e62f6b6366d05fa9bd5343752064c1e50cdd4e0a93e101d7ec09791773e81feda4df1a856646c9961b09bdef2d96b2b7c7320afdca1e1f5189434f83556036a4
+  metadata.gz: f4627f864da4ae028a19d856a014da0f3513e30a5a8c7299148d89d815a82b13a2c0de3bc8fc3dc4e96ca7a455ee9ef9e291fe71dd58f57e12af8e85ebcbd3d1
+  data.tar.gz: c8b07b46dfb64043794af1d4d33db1ca3ac49c1271ebde8eae3b2c9e05ca66030e780d2fbb5cede035c564c03a69f0abba68d87ff098bac36d198fe3ab1d2636

data/lib/daytona/common/event_dispatcher.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+require_relative 'socketio_client'
+
+module Daytona
+  # Manages a Socket.IO connection and dispatches events to per-resource handlers.
+  # Generic — works for sandboxes, volumes, snapshots, runners, etc.
+  class EventDispatcher
+    DISCONNECT_DELAY = 30
+
+    # @param api_url [String]
+    # @param token [String]
+    # @param organization_id [String, nil]
+    def initialize(api_url:, token:, organization_id: nil, source: nil, sdk_version: nil)
+      @api_url = api_url
+      @token = token
+      @organization_id = organization_id
+      @source = source
+      @sdk_version = sdk_version
+      @client = nil
+      @connected = false
+      @failed = false
+      @fail_error = nil
+      @listeners = {}
+      @registered_events = Set.new
+      @mutex = Mutex.new
+      @disconnect_timer = nil
+      @disconnect_generation = 0
+      @reconnect_thread = nil
+      @connect_thread = nil
+      @reconnecting = false
+      @connecting = false
+      @close_requested = false
+      @closed = false
+      @max_reconnects = 100
+    end
+
+    # Idempotent: ensure a connection attempt is in progress or already established.
+    # Non-blocking. Starts a background Thread to connect if not already connected
+    # and no attempt is currently running.
+    # @return [void]
+    def ensure_connected
+      @mutex.synchronize do
+        return if @closed || @connected || @connecting || @connect_thread&.alive?
+
+        @connect_thread = Thread.new do
+          connect
+        rescue StandardError
+          # Callers check connected? when they need it
+        ensure
+          @mutex.synchronize do
+            @connect_thread = nil if @connect_thread == Thread.current
+          end
+        end
+      end
+    end
+
+    # Establish the Socket.IO connection.
+    # @return [void]
+    # @raise [StandardError] on connection failure
+    def connect
+      @mutex.synchronize do
+        return if @closed || @connected || @connecting
+
+        @connecting = true
+      end
+
+      # Close any existing stale connection before creating a fresh one
+      @client&.close rescue nil # rubocop:disable Style/RescueModifier
+
+      client = SocketIOClient.new(
+        api_url: @api_url,
+        token: @token,
+        organization_id: @organization_id,
+        source: @source,
+        sdk_version: @sdk_version,
+        on_event: method(:handle_event),
+        on_disconnect: method(:handle_disconnect)
+      )
+
+      @mutex.synchronize do
+        @client = client
+        @close_requested = false
+      end
+
+      client.connect
+
+      @mutex.synchronize do
+        @connected = true
+        @failed = false
+        @fail_error = nil
+        schedule_delayed_disconnect_locked if @listeners.empty?
+      end
+    rescue StandardError => e
+      @mutex.synchronize do
+        @failed = true
+        @fail_error = "WebSocket connection failed: #{e.message}"
+      end
+    ensure
+      @mutex.synchronize { @connecting = false }
+    end
+
+    # Subscribe to specific events for a resource.
+    # @param resource_id [String] The ID of the resource (e.g. sandbox ID, volume ID).
+    # @param events [Array<String>] List of Socket.IO event names to listen for.
+    # @yield [event_name, data] Called with raw event name and data hash.
+    # @return [Proc] Unsubscribe function.
+    def subscribe(resource_id, events:, &handler)
+      @mutex.synchronize do
+        # No-op after disconnect
+        return -> {} if @closed
+
+        @disconnect_timer&.kill
+        @disconnect_timer = nil
+        @disconnect_generation += 1
+
+        @listeners[resource_id] ||= []
+        @listeners[resource_id] << handler
+        # Mark events in filter under lock to avoid dropping first event
+        events.each { |evt| @registered_events.add(evt) }
+      end
+
+      ensure_connected
+
+      lambda {
+        return if @close_requested || @closed
+
+        should_schedule = false
+        @mutex.synchronize do
+          @listeners[resource_id]&.delete(handler)
+          unsubscribe_resource_locked(resource_id) if @listeners[resource_id] && @listeners[resource_id].empty?
+          should_schedule = @listeners.empty?
+
+          schedule_delayed_disconnect_locked if should_schedule
+        end
+      }
+    end
+
+    # @return [Boolean]
+    def connected?
+      @connected
+    end
+
+    # @return [Boolean]
+    def failed?
+      @failed
+    end
+
+    # @return [String, nil]
+    attr_reader :fail_error
+
+    # Disconnect and clean up.
+    def disconnect
+      thread_state = @mutex.synchronize do
+        begin_disconnect_locked(permanent: true, skip_thread: Thread.current)
+      end
+
+      finalize_disconnect(thread_state)
+    end
+
+    private
+
+    def unsubscribe_resource_locked(resource_id)
+      @listeners.delete(resource_id)
+    end
+
+    def schedule_delayed_disconnect_locked
+      @disconnect_timer&.kill
+      generation = @disconnect_generation
+      @disconnect_timer = Thread.new do
+        sleep(DISCONNECT_DELAY)
+        thread_state = @mutex.synchronize do
+          next unless generation == @disconnect_generation
+          next unless @listeners.empty?
+
+          begin_disconnect_locked(permanent: false, skip_thread: Thread.current)
+        end
+
+        finalize_disconnect(thread_state) if thread_state
+      end
+      @disconnect_timer.abort_on_exception = false
+    end
+
+    def handle_event(event_name, data)
+      # Read registered_events under lock for thread safety
+      registered = @mutex.synchronize { @registered_events.include?(event_name) }
+      return unless registered
+
+      resource_id = extract_id_from_event(data)
+      return unless resource_id
+
+      dispatch(resource_id, event_name, data)
+    end
+
+    # Extract resource ID from an event payload.
+    # Handles two payload shapes:
+    #   - Wrapper: {sandbox: {id: ...}, ...} -> nested resource ID
+    #   - Direct: {id: ...} -> top-level ID
+    def extract_id_from_event(data)
+      return nil unless data.is_a?(Hash)
+
+      %w[sandbox volume snapshot runner].each do |key|
+        nested = data[key]
+        next unless nested.is_a?(Hash)
+
+        sid = nested['id']
+        return sid if sid.is_a?(String)
+      end
+
+      top_id = data['id']
+      return top_id if top_id.is_a?(String)
+
+      nil
+    end
+
+    def dispatch(resource_id, event_name, data)
+      handlers = @mutex.synchronize { @listeners[resource_id]&.dup || [] }
+      handlers.each do |handler|
+        handler.call(event_name, data)
+      rescue StandardError
+        # Don't let handler errors break other handlers
+      end
+    end
+
+    def handle_disconnect
+      @connected = false
+      return if @close_requested
+
+      @reconnect_thread = Thread.new { reconnect_loop }
+    end
+
+    def reconnect_loop
+      @mutex.synchronize do
+        return if @reconnecting
+
+        @reconnecting = true
+      end
+
+      attempt = 0
+      while attempt < @max_reconnects
+        if @close_requested
+          @mutex.synchronize { @reconnecting = false }
+          return
+        end
+
+        delay = [2**attempt, 30].min
+        sleep(delay)
+        if @close_requested
+          @mutex.synchronize { @reconnecting = false }
+          return
+        end
+
+        begin
+          connect
+          if @connected
+            @mutex.synchronize { @reconnecting = false }
+            return
+          end
+        rescue StandardError
+          # Continue retrying
+        end
+
+        attempt += 1
+      end
+
+      # All attempts failed
+      @mutex.synchronize do
+        @failed = true
+        @fail_error = "WebSocket reconnection failed after #{@max_reconnects} attempts"
+        @reconnecting = false
+      end
+    end
+
+    def begin_disconnect_locked(permanent:, skip_thread:)
+      @closed = true if permanent
+      @close_requested = true
+
+      thread_state = {
+        client: @client,
+        reconnect_thread: @reconnect_thread,
+        connect_thread: @connect_thread,
+        disconnect_timer: @disconnect_timer,
+        skip_thread:
+      }
+
+      @client = nil
+      @reconnect_thread = nil
+      @connect_thread = nil
+      @disconnect_timer = nil
+      @connected = false
+      @connecting = false
+      @listeners.clear
+      @registered_events.clear
+
+      thread_state
+    end
+
+    def finalize_disconnect(thread_state)
+      return unless thread_state
+
+      [thread_state[:reconnect_thread], thread_state[:connect_thread], thread_state[:disconnect_timer]].each do |thread|
+        next unless thread
+        next if thread == thread_state[:skip_thread]
+
+        stop_thread(thread)
+      end
+
+      thread_state[:client]&.close
+    rescue StandardError
+      nil
+    end
+
+    def stop_thread(thread)
+      return unless thread
+      return if thread == Thread.current
+
+      thread.kill
+      thread.join
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/daytona/common/event_subscription_manager.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+require 'securerandom'
+
+module Daytona
+  class EventSubscriptionManager
+    SUBSCRIPTION_TTL = 300
+    private_constant :SUBSCRIPTION_TTL
+
+    def initialize(dispatcher = nil)
+      @dispatcher = dispatcher
+      @subscriptions = {}
+      @mutex = Mutex.new
+      @closed = false
+    end
+
+    def subscribe(resource_id:, handler:, events:)
+      @mutex.synchronize do
+        return nil if @closed || @dispatcher.nil?
+      end
+
+      unsubscribe = @dispatcher.subscribe(resource_id, events:, &handler)
+      sub_id = SecureRandom.hex(16)
+      timer_to_stop = nil
+      rollback_unsubscribe = nil
+
+      @mutex.synchronize do
+        if @closed
+          # Rollback dispatcher subscription on failure
+          rollback_unsubscribe = unsubscribe
+          next
+        end
+
+        @subscriptions[sub_id] = { unsubscribe:, timer: nil }
+        timer_to_stop = start_timer_locked(sub_id)
+      end
+
+      if rollback_unsubscribe
+        rollback_unsubscribe.call
+        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)
+
+        timer_to_stop = start_timer_locked(sub_id)
+      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
+        end
+      end
+
+      return unless subscription
+
+      stop_thread(timer)
+      subscription[:unsubscribe].call
+    end
+
+    def shutdown
+      subscriptions = nil
+
+      @mutex.synchronize do
+        @closed = true
+        subscriptions = @subscriptions.values
+        @subscriptions = {}
+      end
+
+      subscriptions.each do |subscription|
+        stop_thread(subscription[:timer])
+        subscription[:unsubscribe].call
+      end
+    end
+
+    private
+
+    def start_timer_locked(sub_id)
+      subscription = @subscriptions[sub_id]
+      return unless subscription
+
+      previous_timer = cancel_timer_locked(sub_id)
+      timer = Thread.new do
+        sleep(SUBSCRIPTION_TTL)
+
+        unsubscribe = @mutex.synchronize do
+          current_subscription = @subscriptions[sub_id]
+          next unless current_subscription && current_subscription[:timer] == Thread.current
+
+          @subscriptions.delete(sub_id)&.dig(:unsubscribe)
+        end
+
+        unsubscribe&.call
+      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
+
+      timer = subscription[:timer]
+      subscription[:timer] = nil
+      timer
+    end
+
+    def stop_thread(thread)
+      return unless thread
+      return if thread == Thread.current
+
+      thread.kill
+      thread.join
+    rescue StandardError
+      nil
+    end
+  end
+end