signalwire 1.4.0 → 2.0.0

data/lib/signalwire/relay/calling/result/record_result.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Signalwire::Relay::Calling
+  class RecordResult < Result
+    def_delegators :@component, :url, :duration, :size
+  end
+end

data/lib/signalwire/relay/client.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Signalwire::Relay
+  class Client
+    include Signalwire::Logger
+    include Signalwire::Common
+    include Signalwire::Blade::EventHandler
+
+    attr_accessor :project, :host, :url, :protocol, :connected, :session
+
+    # Creates a Relay client
+    #
+    # @param project [String] Your SignalWire project identifier
+    # @param token [String] Your SignalWire secret token
+    # @param SIGNALWIRE_HOST [String] Your SignalWire space URL (not needed for production usage)
+
+    def initialize(project:, token:, host: nil)
+      @project = project
+      @token = token
+      @host = host || ENV.fetch('SIGNALWIRE_HOST', Signalwire::Relay::DEFAULT_URL)
+      @url = clean_up_space_url(@host)
+      @protocol = nil
+
+      @connected = false
+
+      setup_session
+      setup_handlers
+      setup_events
+    end
+
+    # Starts the client connection
+    #
+    def connect!
+      logger.debug "Connecting to #{@space_url}"
+      session.connect!
+    end
+
+    # Terminates the session
+    #
+    def disconnect!
+      session.disconnect!
+    end
+
+    def clean_up_space_url(space_url)
+      uri = URI.parse(space_url)
+      # oddly, URI.parse interprets a simple hostname as a path
+      if uri.scheme.nil? && uri.host.nil?
+        unless uri.path.nil?
+          uri.scheme = 'wss'
+          uri.host = uri.path
+          uri.path = ''
+        end
+      end
+
+      uri.to_s
+    end
+
+    def execute(command, &block)
+      @session.execute(command, &block)
+    end
+
+    # TODO: refactor this for style
+    def relay_execute(command, timeout = Signalwire::Relay::COMMAND_TIMEOUT, &block)
+      promise = Concurrent::Promises.resolvable_future
+
+      execute(command) do |event|
+        promise.fulfill event
+      end
+
+      promise.wait timeout
+
+      if promise.fulfilled?
+        event = promise.value
+        code = event.dig(:result, :result, :code)
+        message = event.dig(:result, :result, :message)
+        success = code == '200' ? :success : :failure
+
+        if code
+          block.call(event, success) if block_given?
+          logger.error "Relay command failed with code #{code} and message: #{message}" unless success
+        else
+          logger.error 'Unknown Relay command failure, result code not found'
+        end
+      else
+        logger.error 'Unknown Relay command failure, command timed out'
+      end
+    end
+
+    def calling
+      @calling ||= Signalwire::Relay::Calling::Instance.new(self)
+    end
+
+  private
+
+    def setup_handlers
+      @session.on :connected do |event|
+        logger.debug 'Relay client connected'
+        broadcast :connecting, event
+        protocol_setup
+      end
+    end
+
+    def protocol_setup
+      setup = {
+        protocol: 'signalwire',
+        method: 'setup',
+        params: {
+        }
+      }
+
+      # hijack our protocol
+      setup[:params][:protocol] = @protocol if @protocol
+
+      @session.execute(setup) do |event|
+        @protocol = event.dig(:result, :result, :protocol)
+        logger.debug "Protocol set up as #{protocol}"
+
+        notification_request = {
+          "protocol": @protocol,
+          "command": 'add',
+          "channels": ['notifications']
+        }
+
+        @session.subscribe(notification_request) do
+          logger.debug "Subscribed to notifications for #{protocol}"
+          @connected = true
+          broadcast :ready, self
+        end
+      end
+    end
+
+    def setup_session
+      auth = {
+        project: @project,
+        token: @token
+      }
+      @session = Signalwire::Blade::Connection.new(url: url, authentication: auth)
+    end
+
+    def setup_events
+      @session.on :message, %i[\[\] method] => 'blade.broadcast' do |event|
+        relay = Signalwire::Relay::Event.from_blade(event)
+        broadcast :event, relay
+      end
+    end
+  end
+end

data/lib/signalwire/relay/constants.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Signalwire::Relay
+  DEFAULT_URL = 'relay.signalwire.com'
+  COMMAND_TIMEOUT = 30
+  DEFAULT_CALL_TIMEOUT = 30
+  PING_TIMEOUT = 5
+
+  module CallState
+    NONE = 'none'
+    CREATED = 'created'
+    RINGING = 'ringing'
+    ANSWERED = 'answered'
+    ENDING = 'ending'
+    ENDED = 'ended'
+  end
+
+  CALL_STATES = [
+    CallState::NONE,
+    CallState::CREATED,
+    CallState::RINGING,
+    CallState::ANSWERED,
+    CallState::ENDING,
+    CallState::ENDED
+  ].freeze
+
+  module DisconnectReason
+    HANGUP = 'hangup'
+    CANCEL = 'cancel'
+    BUSY = 'busy'
+    NO_ANSWER = 'noAnswer'
+    DECLINE = 'decline'
+    ERROR = 'error'
+  end
+
+  module DisconnectSource
+    NONE = 'none'
+    CLIENT = 'client'
+    SERVER = 'server'
+    ENDPOINT = 'endpoint'
+  end
+
+  module CallType
+    PHONE = 'phone'
+    SIP = 'sip'
+    WEBRTC = 'webrtc'
+  end
+
+  module CallConnectState
+    DISCONNECTED = 'disconnected'
+    CONNECTING = 'connecting'
+    CONNECTED = 'connected'
+    FAILED = 'failed'
+  end
+
+  module CallNotification
+    STATE = 'calling.call.state'
+    RECEIVE = 'calling.call.receive'
+    CONNECT = 'calling.call.connect'
+    RECORD = 'calling.call.record'
+    PLAY = 'calling.call.play'
+    COLLECT = 'calling.call.collect'
+  end
+
+  CALL_EVENT_STATE_FIELDS = {
+    CallNotification::STATE => 'state',
+    CallNotification::RECEIVE => 'call_state',
+    CallNotification::CONNECT => 'connect_state',
+    CallNotification::RECORD => 'state',
+    CallNotification::PLAY => 'state',
+    CallNotification::COLLECT => 'result' # this actually need to be parsed separately
+  }.freeze
+
+  module CallPlayState
+    PLAYING = 'playing'
+    ERROR = 'error'
+    FINISHED = 'finished'
+  end
+
+  module CallPromptState
+    ERROR = 'error'
+    NO_INPUT = 'no_input'
+    NO_MATCH = 'no_match'
+    DIGIT = 'digit'
+    SPEECH = 'speech'
+  end
+
+  module CallRecordState
+    RECORDING = 'recording'
+    NO_INPUT = 'no_input'
+    FINISHED = 'finished'
+  end
+
+  module ComponentMethod
+    ANSWER = 'call.answer'
+    CONNECT = 'call.connect'
+    DIAL = 'call.begin' # BEGIN is a reserved word
+    HANGUP = 'call.end' # END is a reserved word
+    PLAY = 'call.play'
+    PROMPT = 'call.play_and_collect'
+    RECORD = 'call.record'
+  end
+
+  module CommonState
+    SUCCESSFUL = 'successful'
+  end
+end
+
+Relay = Signalwire::Relay

data/lib/signalwire/relay/consumer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Signalwire::Relay
+  class Consumer
+    include Signalwire::Logger
+    attr_reader :client, :project, :token
+
+    class << self
+      def contexts(val = nil)
+        if val.nil?
+          @contexts || []
+        else
+          @contexts = val
+        end
+      end
+    end
+
+    # Creates a Consumer instance ready to be run
+    #
+    # The initialization parameters can also be supplied via ENV variables
+    # (SIGNALWIRE_ACCOUNT, SIGNALWIRE_TOKEN and SIGNALWIRE_HOST)
+    # Passed-in values override the environment ones.
+    #
+    # @param project [String] Your SignalWire project identifier
+    # @param token [String] Your SignalWire secret token
+    # @param SIGNALWIRE_HOST [String] Your SignalWire space URL (not needed for production usage)
+
+    def initialize(project: nil, token: nil, host: nil)
+      @project = project   || ENV['SIGNALWIRE_ACCOUNT']
+      @token =   token     || ENV['SIGNALWIRE_TOKEN']
+      @url =     host  || ENV['SIGNALWIRE_HOST'] || Signalwire::Relay::DEFAULT_URL
+      @client = Signalwire::Relay::Client.new(project: @project,
+        token: @token, host: @url)
+    end
+
+    def setup
+      # do stuff here.
+    end
+
+    def ready
+      # do stuff here.
+    end
+
+    def teardown
+      # do stuff here.
+    end
+
+    def on_task(task); end
+
+    def on_event(event)
+      # all-events firespout
+    end
+
+    def on_incoming_call(call); end
+
+    def run
+      setup
+      client.once :ready do
+        ready
+        setup_receive_listeners
+        setup_all_events_listener
+        # not sure if ordering matters
+      end
+      client.connect!
+    end
+
+    def stop
+      teardown
+      client.disconnect!
+    end
+
+  private
+
+    def setup_receive_listeners
+      self.class.contexts.each do |cxt|
+        client.calling.receive context: cxt do |call|
+          on_incoming_call(call)
+        end
+      end
+    end
+
+    def setup_all_events_listener
+      client.on :event do |evt|
+        on_event(evt)
+      end
+    end
+  end
+end

data/lib/signalwire/relay/event.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Signalwire::Relay
+  class Event < Signalwire::Blade::Message
+    def event_type
+      dig(:params, :params, :event_type)
+    end
+
+    def name
+      event_type
+    end
+
+    def call_id
+      dig(:params, :params, :params, :call_id)
+    rescue StandardError
+      nil
+    end
+
+    def control_id
+      dig(:params, :params, :params, :control_id)
+    rescue StandardError
+      nil
+    end
+
+    def event_params
+      dig(:params, :params)
+    rescue StandardError
+      {}
+    end
+
+    def call_params
+      dig(:params, :params, :params)
+    rescue StandardError
+      {}
+    end
+
+    def self.from_blade(blade_event)
+      new(blade_event.payload)
+    end
+  end
+end

data/lib/signalwire/relay/request.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Signalwire::Relay
+  class Request < Signalwire::Blade::Execute
+  end
+end

data/lib/signalwire/rest/client.rb

@@ -2,12 +2,12 @@
 
 module Signalwire::REST
   class Client < Twilio::REST::Client
-    def initialize(username=nil, password=nil, account_sid=nil, region=nil, http_client=Twilio::HTTP::Client.new, **args)
-      signalwire_space_url = args.delete(:signalwire_space_url)
-      
-      unless signalwire_space_url.nil?
+    def initialize(username = nil, password = nil, account_sid = nil, region = nil, http_client = Twilio::HTTP::Client.new, **args)
+      host = args.delete(:SIGNALWIRE_HOST)
+
+      unless host.nil?
         Signalwire::Sdk.configure do |config|
-          config.hostname = signalwire_space_url
+          config.hostname = host
         end
       end
 

data/lib/signalwire/sdk/fax_response.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
+
 require 'twilio-ruby/twiml/fax_response'
 
 module Signalwire::Sdk
   class FaxResponse < Twilio::TwiML::FaxResponse
     # Create a new <Reject> element
     # keyword_args:: additional attributes
-    def reject(reason: nil, **keyword_args)
+    def reject(**keyword_args)
       append(Reject.new(**keyword_args))
     end
-    
+
     # <Leave> TwiML Verb
     class Reject < ::Twilio::TwiML::TwiML
       def initialize(**keyword_args)
@@ -20,4 +21,3 @@ module Signalwire::Sdk
     end
   end
 end
-

data/lib/signalwire/sdk/messaging_response.rb

@@ -4,5 +4,3 @@ module Signalwire::Sdk
   class MessagingResponse < Twilio::TwiML::MessagingResponse
   end
 end
-
-