adhearsion 2.6.4 → 3.0.0.beta1

data/lib/adhearsion/translator/asterisk/component.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        class Component
+          attr_reader :id, :call, :call_id
+
+          def initialize(component_node, call = nil)
+            @component_node, @call = component_node, call
+            @call_id = call.id if call
+            @id = Adhearsion.new_uuid
+            @complete = false
+            setup
+          end
+
+          def setup
+          end
+
+          def execute_command(command)
+            command.response = Adhearsion::ProtocolError.new.setup 'command-not-acceptable', "Did not understand command for component #{id}", call_id, id
+          end
+
+          def send_complete_event(reason, recording = nil)
+            return if @complete
+            @complete = true
+            event = Adhearsion::Event::Complete.new reason: reason, recording: recording
+            send_event event
+            call.deregister_component id if call
+          end
+
+          def send_event(event)
+            event.component_id    = id
+            event.target_call_id  = call_id
+            event.source_uri      = id
+            translator.handle_pb_event event
+          end
+
+          def logger_id
+            "#{self.class}: #{call_id ? "Call ID: #{call_id}, Component ID: #{id}" : id}"
+          end
+
+          def call_ended
+            send_complete_event Adhearsion::Event::Complete::Hangup.new
+          end
+
+          private
+
+          def translator
+            @translator ||= call.translator
+          end
+
+          def ami_client
+            translator.ami_client
+          end
+
+          def set_node_response(value)
+            @component_node.response = value
+          end
+
+          def send_ref
+            set_node_response Adhearsion::Rayo::Ref.new uri: id
+          end
+
+          def with_error(name, text)
+            set_node_response Adhearsion::ProtocolError.new.setup(name, text)
+          end
+
+          def complete_with_error(error)
+            send_complete_event Adhearsion::Event::Complete::Error.new(details: error)
+          end
+        end
+      end
+    end
+  end
+end
+
+%w{
+  asterisk
+  composed_prompt
+  input
+  output
+  mrcp_prompt
+  mrcp_native_prompt
+  record
+  stop_by_redirect
+}.each { |component| require "adhearsion/translator/asterisk/component/#{component}" }

data/lib/adhearsion/translator/asterisk/component/asterisk.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        module Asterisk
+        end
+      end
+    end
+  end
+end
+
+require 'adhearsion/translator/asterisk/component/asterisk/agi_command'
+require 'adhearsion/translator/asterisk/component/asterisk/ami_action'

data/lib/adhearsion/translator/asterisk/component/asterisk/agi_command.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        module Asterisk
+          class AGICommand < Component
+            def setup
+              @agi = Translator::Asterisk::AGICommand.new id, @call.channel, @component_node.name, *@component_node.params
+            end
+
+            def execute
+              @agi.execute ami_client
+              send_ref
+            rescue RubyAMI::Error
+              set_node_response false
+            rescue ChannelGoneError
+              set_node_response Adhearsion::ProtocolError.new.setup(:item_not_found, "Could not find a call with ID #{call_id}", call_id)
+            end
+
+            def handle_ami_event(event)
+              if (event.name == 'AsyncAGI' && event['SubEvent'] == 'Exec') || event.name == 'AsyncAGIExec'
+                send_complete_event success_reason(event)
+                if @component_node.name == 'ASYNCAGI BREAK' && @call.channel_var('ADHEARSION_END_ON_ASYNCAGI_BREAK')
+                  @call.handle_hangup_event nil, event.best_time
+                end
+              end
+            end
+
+            private
+
+            def success_reason(event)
+              result = @agi.parse_result event
+              Adhearsion::Rayo::Component::Asterisk::AGI::Command::Complete::Success.new result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/translator/asterisk/component/asterisk/ami_action.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        module Asterisk
+          class AMIAction < Component
+            attr_reader :translator
+
+            def initialize(component_node, translator, ami_client)
+              super component_node, nil
+              @translator, @ami_client = translator, ami_client
+            end
+
+            def execute
+              send_ref
+              response = send_action
+              final_event = send_events response
+              send_complete_event success_reason(response, final_event)
+            rescue RubyAMI::Error => e
+              send_complete_event error_reason(e)
+            end
+
+            private
+
+            def send_action
+              @ami_client.send_action @component_node.name, action_headers
+            end
+
+            def error_reason(response)
+              Adhearsion::Event::Complete::Error.new details: response.message
+            end
+
+            def success_reason(response, final_event = nil)
+              headers = response.headers
+              headers.merge! final_event.headers if final_event
+              headers.delete 'ActionID'
+              Adhearsion::Rayo::Component::Asterisk::AMI::Action::Complete::Success.new message: headers.delete('Message'), text_body: response.text_body, headers: headers
+            end
+
+            def send_events(response)
+              final_event = response.events.pop
+              response.events.each do |e|
+                send_event pb_event_from_ami_event(e)
+              end
+              final_event
+            end
+
+            def pb_event_from_ami_event(ami_event)
+              headers = ami_event.headers
+              headers.delete 'ActionID'
+              Adhearsion::Event::Asterisk::AMI.new name: ami_event.name, headers: headers
+            end
+
+            def action_headers
+              headers = {}
+              @component_node.params.each_pair do |key, value|
+                headers[key.to_s.capitalize] = value
+              end
+              headers
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/translator/asterisk/component/composed_prompt.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+require 'adhearsion/translator/asterisk/component/input_component'
+require 'adhearsion/translator/asterisk/component/stop_by_redirect'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        class ComposedPrompt < Component
+          include InputComponent
+          include StopByRedirect
+
+          def execute
+            validate
+            output_command.request!
+            setup_dtmf_recognizer
+
+            @output_incomplete = true
+
+            @output_component = Output.new(output_command, @call)
+            call.register_component @output_component
+            fut = Celluloid::Future.new { @output_component.execute }
+
+            case @output_command.response
+            when Adhearsion::Rayo::Ref
+              send_ref
+            else
+              set_node_response @output_command.response
+            end
+
+            if @component_node.barge_in
+              @barged = false
+              register_dtmf_event_handler
+              fut.value # Block until output is complete before starting timers
+              @output_incomplete = false
+              start_timers unless @barged
+            else
+              fut.value # Block until output is complete before allowing input
+              register_dtmf_event_handler
+              start_timers
+            end
+          end
+
+          def process_dtmf(digit)
+            if @component_node.barge_in && @output_incomplete
+              @output_component.stop_by_redirect Adhearsion::Event::Complete::Stop.new
+              @barged = true
+            end
+            super
+          end
+
+          def output_command
+            @output_command ||= @component_node.output
+          end
+
+          private
+
+          def input_node
+            @input_node ||= @component_node.input
+          end
+
+          def register_dtmf_event_handler
+            @dtmf_handler_id = call.register_handler :ami, [{:name => 'DTMF', [:[], 'End'] => 'Yes'}, {:name => 'DTMFEnd'}] do |event|
+              process_dtmf event['Digit']
+            end
+          end
+
+          def unregister_dtmf_event_handler
+            call.unregister_handler :ami, @dtmf_handler_id if instance_variable_defined?(:@dtmf_handler_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/translator/asterisk/component/dtmf_recognizer.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+
+require 'ruby_speech'
+require 'singleton'
+require 'adhearsion/translator/asterisk/component'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        class DTMFRecognizer
+          class BuiltinMatcherCache
+            include Singleton
+            include MonitorMixin
+
+            def get(uri)
+              cache[uri] ||= fetch(uri)
+            end
+
+            private
+
+            def fetch(uri)
+              grammar = RubySpeech::GRXML.from_uri(uri)
+              RubySpeech::GRXML::Matcher.new(grammar)
+            end
+
+            def cache
+              @cache ||= {}
+            end
+          end
+
+          include Celluloid
+
+          def initialize(responder, grammar, initial_timeout = nil, inter_digit_timeout = nil, terminator = nil)
+            @responder = responder
+            self.initial_timeout = initial_timeout || -1
+            self.inter_digit_timeout = inter_digit_timeout || -1
+            @terminator = terminator
+            @finished = false
+
+            @matcher = if grammar.url
+              BuiltinMatcherCache.instance.get(grammar.url)
+            else
+              RubySpeech::GRXML::Matcher.new RubySpeech::GRXML.import(grammar.value.to_s)
+            end
+            @buffer = ""
+          end
+
+          def <<(digit)
+            cancel_initial_timer
+            @buffer << digit unless terminating?(digit)
+            case (match = get_match)
+            when RubySpeech::GRXML::NoMatch
+              finalize :nomatch
+            when RubySpeech::GRXML::MaxMatch
+              finalize :match, match
+            when RubySpeech::GRXML::Match
+              finalize :match, match if terminating?(digit)
+            when RubySpeech::GRXML::PotentialMatch
+              finalize :nomatch if terminating?(digit)
+            end
+            reset_inter_digit_timer unless @finished
+          end
+
+          def start_timers
+            begin_initial_timer @initial_timeout/1000 unless @initial_timeout == -1
+          end
+
+          private
+
+          def terminating?(digit)
+            digit == @terminator
+          end
+
+          def get_match
+            @matcher.match @buffer.dup
+          end
+
+          def initial_timeout=(other)
+            raise OptionError, 'An initial timeout value that is negative (and not -1) is invalid.' if other < -1
+            @initial_timeout = other
+          end
+
+          def inter_digit_timeout=(other)
+            raise OptionError, 'An inter-digit timeout value that is negative (and not -1) is invalid.' if other < -1
+            @inter_digit_timeout = other
+          end
+
+          def begin_initial_timer(timeout)
+            @initial_timer = after timeout do
+              finalize :noinput
+            end
+          end
+
+          def cancel_initial_timer
+            return unless instance_variable_defined?(:@initial_timer) && @initial_timer
+            @initial_timer.cancel
+            @initial_timer = nil
+          end
+
+          def reset_inter_digit_timer
+            return if @inter_digit_timeout == -1
+            @inter_digit_timer ||= begin
+              after @inter_digit_timeout/1000 do
+                case (match = get_match)
+                when RubySpeech::GRXML::Match
+                  finalize :match, match
+                else
+                  finalize :nomatch
+                end
+              end
+            end
+            @inter_digit_timer.reset
+          end
+
+          def cancel_inter_digit_timer
+            return unless instance_variable_defined?(:@inter_digit_timer) && @inter_digit_timer
+            @inter_digit_timer.cancel
+            @inter_digit_timer = nil
+          end
+
+          def finalize(match_type, match = nil)
+            cancel_initial_timer
+            cancel_inter_digit_timer
+            if match
+              @responder.send match_type, match
+            else
+              @responder.send match_type
+            end
+            @finished = true
+            terminate
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/translator/asterisk/component/input.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'adhearsion/translator/asterisk/component/input_component'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        class Input < Component
+
+          include InputComponent
+
+          def execute
+            @call.send_progress
+            super
+            @dtmf_handler_id = register_dtmf_event_handler
+          end
+
+          private
+
+          def register_dtmf_event_handler
+            call.register_handler :ami, [{:name => 'DTMF', [:[], 'End'] => 'Yes'}, {:name => 'DTMFEnd'}] do |event|
+              process_dtmf event['Digit']
+            end
+          end
+
+          def unregister_dtmf_event_handler
+            call.unregister_handler :ami, @dtmf_handler_id if instance_variable_defined?(:@dtmf_handler_id)
+          end
+        end
+      end
+    end
+  end
+end