signalwire 1.4.0 → 2.0.0

data/examples/relay/outbound_record.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+%w[
+  bundler/setup
+  signalwire
+].each { |f| require f }
+
+# Set logging to debug for testing
+Signalwire::Logger.logger.level = ::Logger::DEBUG
+
+class OutboundConsumer < Signalwire::Relay::Consumer
+  def ready
+    logger.info 'Dialing out'
+    call = client.calling.new_call(from: ENV['FROM_NUMBER'], to: ENV['TO_NUMBER'])
+    call.dial
+    call.play_tts 'please leave your message after the beep. Press pound when done.'
+    result = call.record({"audio": { "beep": "true", "terminators": "#"}})
+    call.play_tts 'you said:'
+    call.play_audio result.url
+    call.hangup
+  end
+end
+
+OutboundConsumer.new.run

data/lib/signalwire.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Signalwire
+end
+
+require 'signalwire/sdk'
+require 'signalwire/logger'
+require 'signalwire/common'
+
+require 'signalwire/blade'
+require 'signalwire/relay'
+
+

data/lib/signalwire/blade.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Signalwire::Blade
+  RECONNECT_PERIOD = 5
+end
+
+require 'signalwire/blade/event_handler'
+require 'signalwire/blade/connection'
+require 'signalwire/blade/message'
+require 'signalwire/blade/message/connect'
+require 'signalwire/blade/message/execute'
+require 'signalwire/blade/message/subscribe'

data/lib/signalwire/blade/connection.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require 'has_guarded_handlers'
+require 'eventmachine'
+require 'faye/websocket'
+require 'json'
+
+module Signalwire::Blade
+  class Connection
+    include Signalwire::Logger
+    include Signalwire::Blade::EventHandler
+    include Signalwire::Common
+
+    attr_reader :session_id, :connected, :node_id, :connection
+
+    def initialize(**options)
+      @options = options
+      @session_id = nil
+      @node_id = nil
+      @connected = false
+      @url = @options.fetch(:url, 'wss://relay.signalwire.com')
+      @log_traffic = options.fetch(:log_traffic, true)
+      @authentication = options.fetch(:authentication, nil)
+
+      @inbound_queue = EM::Queue.new
+      @outbound_queue = EM::Queue.new
+
+      @counter = 1
+    end
+
+    def connect!
+      setup_started_event
+      enable_epoll
+      handle_signals
+
+      main_loop!
+    end
+
+    def reconnect!
+      return if @shutdown
+      sleep Signalwire::Blade::RECONNECT_PERIOD
+      @connected = false
+      logger.info "Attempting reconnection"
+      main_loop!
+    end
+
+    def main_loop!
+      EM.run do
+        @ws = Faye::WebSocket::Client.new(@url)
+
+        @ws.on(:open) { |event| broadcast :started, event }
+        @ws.on(:message) { |event| enqueue_inbound event }
+        @ws.on(:close) { handle_close }
+
+        @ws.on :error do |error|
+          logger.error "Error occurred: #{error.message}"
+        end
+
+        EM.next_tick { flush_queues }
+      end
+    end
+
+    def setup_started_event
+      on :started do |_event|
+        @connected = true
+        myreq = connect_request
+        start_periodic_timer
+
+        write_command(myreq) do |event|
+          @session_id = event.dig(:result, :sessionid) unless @session_id
+          @node_id = event.dig(:result, :nodeid) unless @node_d
+          logger.info "Blade Session connected with id: #{@session_id}"
+          broadcast :connected, event
+        end
+
+      rescue StandardError => e
+        logger.error e.inspect
+        logger.error e.backtrace
+      end
+    end
+
+    def enable_epoll
+      # This is only enabled on Linux
+      EM.epoll
+      logger.debug "Running with epoll #{EM.epoll?}"
+    end
+
+    def transmit(message)
+      enqueue_outbound message
+    end
+
+    def write(message)
+      log_traffic :send, message
+      @ws.send(message)
+    end
+
+    def receive(message)
+      event = Message.from_json(message.data)
+      log_traffic :recv, event.payload
+      EM.defer do
+        broadcast :message, event
+      end
+    end
+
+    def write_command(command, &block)
+      once(:message, id: command.id, &block) if block_given?
+      transmit(command.build_request.to_json)
+    end
+
+    def execute(params, &block)
+      block_given? ? write_command(Execute.new(params), &block) : write_command(Execute.new(params))
+    end
+
+    def subscribe(params, &block)
+      block_given? ? write_command(Subscribe.new(params), &block) : write_command(Subscribe.new(params))
+    end
+
+    def handle_close
+      reconnect!
+    end
+
+    def disconnect!
+      # logger.info 'Stopping Blade event loop'
+      @ws = nil
+      @connected = false
+      EM.stop
+    end
+
+    def flush_queues
+      @inbound_queue.pop { |inbound| receive(inbound) } until @inbound_queue.empty?
+      if connected?
+        @outbound_queue.pop { |outbound| write(outbound) } until @outbound_queue.empty?
+      end
+
+      EM.next_tick { flush_queues }
+    end
+
+    def enqueue_inbound(message)
+      @inbound_queue.push message
+    end
+
+    def enqueue_outbound(message)
+      @outbound_queue.push message
+    end
+
+    def connect_request
+      req = Connect.new
+      req[:params][:authentication] = @authentication if @authentication
+      req
+    end
+
+    def connected?
+      @connected == true
+    end
+
+    def start_periodic_timer
+      pinger = EventMachine::PeriodicTimer.new(Signalwire::Relay::PING_TIMEOUT) do
+        timeouter = EventMachine::Timer.new(2) do
+          # reconnect logic goes here
+          logger.error "We got disconnected!"
+          pinger.cancel
+          reconnect!
+        end
+    
+        @ws.ping 'detecting presence' do
+          timeouter.cancel
+        end
+      end
+    end
+
+    def log_traffic(direction, message)
+      if @log_traffic
+        pretty = case direction
+                 when :send
+                   JSON.pretty_generate(JSON.parse(message))
+                 when :recv
+                   JSON.pretty_generate(message)
+                 end
+      end
+      logger.debug "#{direction.to_s.upcase}: #{pretty}"
+    end
+
+    def handle_signals
+      Signal.trap('INT') do
+        shutdown_from_signal
+      end
+      
+      Signal.trap('TERM') do
+        shutdown_from_signal
+      end
+    end
+
+
+    def shutdown_from_signal
+      @shutdown = true
+      disconnect!
+      exit
+    end
+  end
+end

data/lib/signalwire/blade/event_handler.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'has_guarded_handlers'
+
+module Signalwire::Blade
+  module EventHandler
+    include HasGuardedHandlers
+    alias on register_handler
+    alias once register_tmp_handler
+
+    def broadcast(event_type, event)
+      trigger_handler event_type, event, broadcast: true
+    end
+  end
+end

data/lib/signalwire/blade/message.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Signalwire::Blade
+  class Message
+    extend Forwardable
+    def_delegators :@payload, :[], :[]=, :dig
+
+    def initialize(params = {})
+      @payload = params
+      @id = params[:id]
+    end
+
+    def id
+      @id ||= SecureRandom.uuid
+    end
+
+    def payload
+      @payload ||= {}
+    end
+
+    def build_request
+      payload.merge(
+        jsonrpc: '2.0',
+        id: id
+      )
+    end
+
+    def self.from_json(json_hash)
+      new JSON.parse(json_hash, symbolize_names: true)
+    end
+
+    def to_s
+      inspect
+    end
+  end
+end

data/lib/signalwire/blade/message/connect.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Signalwire::Blade
+  class Connect < Message
+    def initialize
+      @payload = {
+        method: 'blade.connect',
+        params: {
+          version: {
+            major: 2,
+            minor: 1,
+            revision: 0
+          }
+        }
+      }
+    end
+  end
+end

data/lib/signalwire/blade/message/execute.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Signalwire::Blade
+  class Execute < Message
+    # Creates an Execute message
+    #
+    # @param params [Hash] The "params" portion of the execute
+    def initialize(params = {})
+      @payload =
+        {
+          method: 'blade.execute',
+          params: params
+        }
+    end
+  end
+end

data/lib/signalwire/blade/message/subscribe.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Signalwire::Blade
+  class Subscribe < Message
+    # Creates a Subscribe message
+    #
+    # @param params   [Hash] The "params" portion of the message
+    def initialize(params = {})
+      @payload = {
+        method: 'blade.subscription',
+        params: params
+      }
+    end
+  end
+end

data/lib/signalwire/common.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Signalwire
+  module Common
+  end
+end

data/lib/signalwire/logger.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Signalwire
+  module Logger
+    class << self
+      # A global logger object
+      # @return [Logger] a Logger instance
+      def logger
+        @logger ||= begin
+          logger = ::Logger.new(STDERR, progname: 'SignalWire', level: ::Logger::DEBUG)
+          logger.level = ENV.fetch('SIGNALWIRE_LOG_LEVEL', ::Logger::WARN)
+          logger
+        end
+      end
+    end
+
+    def logger
+      Signalwire::Logger.logger
+    end
+
+    def level=(level)
+      Signalwire::Logger.logger.level = level
+    end
+  end
+end

data/lib/signalwire/relay.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Signalwire::Relay
+end
+
+require 'signalwire/relay/constants'
+require 'signalwire/relay/client'
+require 'signalwire/relay/request'
+require 'signalwire/relay/event'
+require 'signalwire/relay/consumer'
+
+require 'signalwire/relay/calling'
+require 'signalwire/relay/calling/call_convenience_methods'
+require 'signalwire/relay/calling/call'
+
+require 'signalwire/relay/calling/action'
+require 'signalwire/relay/calling/action/connect_action'
+require 'signalwire/relay/calling/action/play_action'
+require 'signalwire/relay/calling/action/prompt_action'
+require 'signalwire/relay/calling/action/record_action'
+
+require 'signalwire/relay/calling/result'
+require 'signalwire/relay/calling/result/answer_result'
+require 'signalwire/relay/calling/result/connect_result'
+require 'signalwire/relay/calling/result/dial_result'
+require 'signalwire/relay/calling/result/hangup_result'
+require 'signalwire/relay/calling/result/play_result'
+require 'signalwire/relay/calling/result/prompt_result'
+require 'signalwire/relay/calling/result/record_result'
+
+require 'signalwire/relay/calling/component'
+require 'signalwire/relay/calling/control_component'
+require 'signalwire/relay/calling/component/answer'
+require 'signalwire/relay/calling/component/connect'
+require 'signalwire/relay/calling/component/dial'
+require 'signalwire/relay/calling/component/hangup'
+require 'signalwire/relay/calling/component/play'
+require 'signalwire/relay/calling/component/prompt'
+require 'signalwire/relay/calling/component/record'
+require 'signalwire/relay/calling/component/await'

data/lib/signalwire/relay/calling.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'concurrent-ruby'
+
+module Signalwire::Relay
+  module Calling
+    class Instance
+      extend Forwardable
+      include Signalwire::Logger
+      include Signalwire::Common
+
+      def_delegators :@client, :relay_execute, :protocol, :on, :once, :broadcast
+
+      def initialize(client)
+        @client = client
+      end
+
+      def calls
+        @calls ||= Concurrent::Array.new
+      end
+
+      def contexts
+        @contexts ||= Concurrent::Array.new
+      end
+
+      def receive(context:, &block)
+        @client.on :event, event_type: 'calling.call.receive' do |event|
+          logger.info "Starting up call for #{event.call_params}"
+          call_obj = Signalwire::Relay::Calling::Call.from_event(self, event)
+          calls << call_obj
+          block.call(call_obj) if block_given?
+        end
+
+        receive_command = {
+          protocol: protocol,
+          method: 'call.receive',
+          params: {
+            context: context
+          }
+        }
+
+        relay_execute receive_command do
+          contexts << context
+        end
+      end
+
+      def find_call_by_id(call_id)
+        calls.find { |call| call.id == call_id }
+      end
+
+      def find_call_by_tag(tag)
+        calls.find { |call| call.tag == tag }
+      end
+
+      def end_call(call_id)
+        calls.delete find_call_by_id(call_id)
+      end
+
+      def new_call(from:, to:, device_type: 'phone', timeout: 30)
+        params = {
+          device: {
+            type: device_type,
+            params: {
+              from_number: from,
+              to_number: to,
+              timeout: timeout
+            }
+          }
+        }
+        call = Call.new(self, params)
+        calls << call
+        call
+      end
+
+      def dial(from:, to:, device_type: 'phone', timeout: 30)
+        handle = new_call(from: from, to: to, device_type: device_type, timeout: timeout)
+        handle.dial
+      end
+    end
+  end
+end