switest 0.5.1 → 0.7.0

data/lib/switest/esl/client.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-require_relative "from_parser"
-
-module Switest
-  module ESL
-    class Client
-      attr_reader :connection, :calls
-
-      def initialize(connection = nil)
-        @connection = connection
-        @calls = Concurrent::Map.new
-        @offer_handlers = []
-        @mutex = Mutex.new
-      end
-
-      def start
-        @connection ||= Connection.new(
-          host: Switest.configuration.host,
-          port: Switest.configuration.port,
-          password: Switest.configuration.password
-        )
-        @connection.connect
-
-        # Register event handler with connection
-        @connection.on_event { |response| handle_response(response) }
-
-        self
-      end
-
-      def stop
-        hangup_all
-        @connection&.disconnect
-
-        # Any remaining calls are orphaned - just clear them
-        @calls.clear
-      end
-
-      # Hangup all active calls individually and wait for them to end.
-      # This ensures proper hangup_cause is set for each call (important for CDRs).
-      # Sends all hangups first, then waits with a shared deadline to avoid
-      # O(n * timeout) delays with many calls.
-      def hangup_all(cause: "NORMAL_CLEARING", timeout: 5)
-        return unless @connection&.connected?
-
-        active = @calls.values.reject(&:ended?)
-
-        # Send all hangups without waiting
-        active.each do |call|
-          call.hangup(cause, wait: false) rescue nil
-        end
-
-        # Wait for all to end with a single shared deadline
-        deadline = Time.now + timeout
-        active.each do |call|
-          remaining = deadline - Time.now
-          break if remaining <= 0
-          call.wait_for_end(timeout: remaining) unless call.ended?
-        end
-      end
-
-      def dial(to:, from: nil, timeout: nil, headers: {})
-        uuid = SecureRandom.uuid
-
-        # Build channel variables
-        vars = {
-          origination_uuid: uuid,
-          return_ring_ready: true
-        }
-        vars.merge!(FromParser.parse(from)) if from
-        vars[:originate_timeout] = timeout if timeout
-
-        var_string = Escaper.build_var_string(vars, headers)
-
-        # Create call object before originate
-        call = Call.new(
-          id: uuid,
-          connection: @connection,
-          direction: :outbound,
-          to: to,
-          from: from,
-          headers: headers
-        )
-        @calls[uuid] = call
-
-        # Originate call (park it so we control it)
-        begin
-          @connection.bgapi("originate #{var_string}#{to} &park")
-        rescue
-          @calls.delete(uuid)
-          raise
-        end
-
-        call
-      end
-
-      def on_offer(&block)
-        @mutex.synchronize { @offer_handlers << block }
-      end
-
-      def active_calls
-        result = {}
-        @calls.each_pair { |k, v| result[k] = v if v.alive? }
-        result
-      end
-
-      private
-
-      def handle_response(response)
-        return unless response && response[:body]
-
-        event = Event.parse(response[:body])
-        return unless event
-
-        handle_event(event)
-      end
-
-      def handle_event(event)
-        case event.name
-        when "CHANNEL_CREATE"
-          handle_channel_create(event)
-        when "CHANNEL_ANSWER"
-          handle_channel_answer(event)
-        when "CHANNEL_BRIDGE"
-          handle_channel_bridge(event)
-        when "CHANNEL_HANGUP_COMPLETE"
-          handle_channel_hangup(event)
-        when "DTMF"
-          handle_dtmf(event)
-        end
-      end
-
-      def handle_channel_create(event)
-        uuid = event.uuid
-        return unless uuid
-
-        # Skip if we already have this call (outbound call we created)
-        return if @calls[uuid]
-
-        # Only handle inbound calls
-        direction = event.call_direction
-        return unless direction == "inbound"
-
-        call = Call.new(
-          id: uuid,
-          connection: @connection,
-          direction: :inbound,
-          to: event.destination,
-          from: event.caller_id,
-          headers: event.headers.dup
-        )
-        @calls[uuid] = call
-
-        # Notify offer handlers
-        fire_offer(call)
-      end
-
-      def handle_channel_answer(event)
-        uuid = event.uuid
-        return unless uuid
-
-        call = @calls[uuid]
-        other_uuid = event["Other-Leg-Unique-ID"]
-        # For loopback calls, also check the other leg's UUID
-        call ||= @calls[other_uuid] if other_uuid
-        call&.handle_answer
-      end
-
-      def handle_channel_bridge(event)
-        uuid = event.uuid
-        return unless uuid
-
-        call = @calls[uuid]
-        other_uuid = event["Other-Leg-Unique-ID"]
-        call ||= @calls[other_uuid] if other_uuid
-        call&.handle_bridge
-      end
-
-      def handle_channel_hangup(event)
-        uuid = event.uuid
-        return unless uuid
-
-        call = @calls[uuid]
-        other_uuid = event["Other-Leg-Unique-ID"]
-        # For loopback calls, also check the other leg's UUID
-        call ||= @calls[other_uuid] if other_uuid
-        return unless call
-
-        call.handle_hangup(event.hangup_cause, event.headers)
-      end
-
-      def handle_dtmf(event)
-        uuid = event.uuid
-        return unless uuid
-
-        call = @calls[uuid]
-        other_uuid = event["Other-Leg-Unique-ID"]
-        # For loopback calls, also check the other leg's UUID
-        call ||= @calls[other_uuid] if other_uuid
-        return unless call
-
-        digit = event["DTMF-Digit"]
-        call.handle_dtmf(digit) if digit
-      end
-
-      def fire_offer(call)
-        handlers = @mutex.synchronize { @offer_handlers.dup }
-        handlers.each { |h| h.call(call) }
-      end
-    end
-  end
-end

data/lib/switest/esl/connection.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-require "socket"
-require "concurrent"
-
-module Switest
-  module ESL
-    # Thread-safe ESL connection.
-    #
-    # All socket I/O is handled by a single reader thread to avoid race conditions.
-    # Commands are sent via a queue and responses are returned via promises.
-    class Connection
-      attr_reader :host, :port
-
-      def initialize(host:, port:, password:)
-        @host = host
-        @port = port
-        @password = password
-        @socket = nil
-        @running = false
-        @reader_thread = nil
-        @command_queue = Queue.new
-        @event_handlers = []
-        @mutex = Mutex.new
-      end
-
-      def connect
-        @socket = TCPSocket.new(@host, @port)
-        authenticate
-        subscribe_events
-        @running = true
-        @reader_thread = Thread.new { reader_loop }
-        self
-      end
-
-      def disconnect
-        @running = false
-        # Close socket to unblock any pending reads
-        @mutex.synchronize do
-          if @socket
-            @socket.close rescue nil
-            @socket = nil
-          end
-        end
-        # Fail any pending commands
-        until @command_queue.empty?
-          item = @command_queue.pop(true) rescue nil
-          item[:promise].fail(ConnectionError.new("Disconnected")) if item&.dig(:promise)
-        end
-        @reader_thread&.join(2)
-        @reader_thread = nil
-      end
-
-      def connected?
-        @running && @socket && !@socket.closed?
-      end
-
-      # Send a command and wait for response (thread-safe)
-      def send_command(cmd, timeout: 5)
-        raise ConnectionError, "Not connected" unless connected?
-
-        promise = Concurrent::IVar.new
-        @command_queue.push({ cmd: cmd, promise: promise })
-
-        # Wait for response with timeout
-        result = promise.value(timeout)
-        if promise.pending?
-          raise Switest::Error, "Command timed out: #{cmd}"
-        elsif promise.rejected?
-          raise promise.reason
-        end
-        result
-      end
-
-      # Register a handler for incoming events
-      def on_event(&block)
-        @mutex.synchronize { @event_handlers << block }
-      end
-
-      def api(cmd)
-        response = send_command("api #{cmd}")
-        body = response[:body] || ""
-        raise Switest::Error, body if body.start_with?("-ERR")
-        body
-      end
-
-      def bgapi(cmd)
-        send_command("bgapi #{cmd}")
-      end
-
-      private
-
-      def authenticate
-        # Read auth request (before reader thread starts)
-        response = read_response
-        unless response[:headers]["Content-Type"] == "auth/request"
-          raise AuthenticationError, "Expected auth/request, got: #{response[:headers]["Content-Type"]}"
-        end
-
-        # Send password
-        @socket.write("auth #{@password}\n\n")
-
-        # Read reply
-        response = read_response
-        reply = response[:headers]["Reply-Text"] || ""
-        unless reply.start_with?("+OK")
-          raise AuthenticationError, "Authentication failed: #{reply}"
-        end
-      end
-
-      def subscribe_events
-        events = %w[
-          CHANNEL_CREATE           # Detect new inbound calls
-          CHANNEL_ANSWER           # Track when calls are answered
-          CHANNEL_BRIDGE           # Track when calls are bridged
-          CHANNEL_HANGUP_COMPLETE  # Track call end with final headers
-          DTMF                     # Receive DTMF digits per call
-        ].join(" ")
-
-        @socket.write("event plain #{events}\n\n")
-        response = read_response
-        reply = response[:headers]["Reply-Text"] || ""
-        unless reply.start_with?("+OK")
-          raise Switest::Error, "Failed to subscribe to events: #{reply}"
-        end
-      end
-
-      # Main reader loop - handles both commands and events
-      def reader_loop
-        while @running
-          begin
-            # Process any pending commands first
-            process_pending_commands
-
-            # Check for incoming data with short timeout (allows checking queue regularly)
-            ready = IO.select([@socket], nil, nil, 0.1) rescue nil
-            break unless @running && @socket && !@socket.closed?
-            next unless ready
-
-            # Read and dispatch event (skip orphaned command replies)
-            response = read_response
-            content_type = response[:headers]["Content-Type"]
-            next if content_type == "command/reply" || content_type == "api/response"
-
-            if content_type == "text/disconnect-notice"
-              break
-            end
-
-            dispatch_event(response)
-          rescue IOError, Errno::EBADF, Errno::ECONNRESET
-            # Socket closed
-            break
-          rescue
-            # Log but continue on other errors
-            break unless @running
-          end
-        end
-      end
-
-      def process_pending_commands
-        while @running && !@command_queue.empty?
-          item = @command_queue.pop(true) rescue nil
-          break unless item
-
-          begin
-            @socket.write("#{item[:cmd]}\n\n")
-            response = read_command_response
-            item[:promise].set(response)
-          rescue => e
-            item[:promise].fail(e)
-          end
-        end
-      end
-
-      def dispatch_event(response)
-        handlers = @mutex.synchronize { @event_handlers.dup }
-        handlers.each { |h| h.call(response) }
-      end
-
-      # Read responses until we get a command reply, dispatching any
-      # interleaved events that arrive before the reply.
-      def read_command_response
-        loop do
-          response = read_response
-          content_type = response[:headers]["Content-Type"]
-
-          case content_type
-          when "command/reply", "api/response"
-            return response
-          when "text/event-plain"
-            dispatch_event(response)
-          when "text/disconnect-notice"
-            raise ConnectionError, "Disconnected"
-          else
-            return response
-          end
-        end
-      end
-
-      def read_response
-        headers = read_headers
-        body = nil
-
-        if (content_length = headers["Content-Length"]&.to_i) && content_length > 0
-          body = @socket.read(content_length)
-        end
-
-        { headers: headers, body: body }
-      end
-
-      def read_headers
-        headers = {}
-        loop do
-          line = @socket.gets
-          raise ConnectionError, "Connection closed" if line.nil?
-          line = line.chomp
-          break if line.empty?
-
-          key, value = line.split(": ", 2)
-          headers[key] = value if key && value
-        end
-        headers
-      end
-    end
-  end
-end

data/lib/switest/esl/event.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-module Switest
-  module ESL
-    class Event
-      attr_reader :headers
-
-      def self.parse(raw_data)
-        return nil if raw_data.nil? || raw_data.empty?
-        new(raw_data)
-      end
-
-      def initialize(raw_data)
-        @headers = Switest::CaseInsensitiveHash.new
-        parse_headers(raw_data)
-      end
-
-      # Common accessors
-      def name
-        @headers["Event-Name"]
-      end
-
-      def uuid
-        @headers["Unique-ID"] || @headers["Channel-Call-UUID"]
-      end
-
-      def caller_id
-        @headers["Caller-Caller-ID-Number"]
-      end
-
-      def destination
-        @headers["Caller-Destination-Number"]
-      end
-
-      def call_direction
-        @headers["Call-Direction"]
-      end
-
-      def hangup_cause
-        @headers["Hangup-Cause"]
-      end
-
-      def [](key)
-        @headers[key]
-      end
-
-      def variable(name)
-        @headers["variable_#{name}"]
-      end
-
-      private
-
-      def parse_headers(raw_data)
-        raw_data.each_line do |line|
-          line = line.strip
-          next if line.empty?
-
-          key, value = line.split(": ", 2)
-          next unless key && value
-
-          # ESL uses percent-encoding (%XX) but NOT + for spaces
-          @headers[key] = value.gsub(/%([0-9A-Fa-f]{2})/) { [$1.to_i(16)].pack("C") }
-        end
-      end
-    end
-  end
-end