punchblock 1.3.0 → 1.4.0

data/lib/punchblock/translator/freeswitch/component.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+module Punchblock
+  module Translator
+    class Freeswitch
+      module Component
+        extend ActiveSupport::Autoload
+
+        autoload :AbstractOutput
+        autoload :FliteOutput
+        autoload :Input
+        autoload :Output
+        autoload :Record
+        autoload :TTSOutput
+
+        class Component
+          include Celluloid
+          include DeadActorSafety
+          include HasGuardedHandlers
+
+          attr_reader :id, :call, :call_id
+
+          def initialize(component_node, call = nil)
+            @component_node, @call = component_node, call
+            @call_id = safe_from_dead_actors { call.id } if call
+            @id = Punchblock.new_uuid
+            @complete = false
+            setup
+          end
+
+          def setup
+          end
+
+          def execute_command(command)
+            command.response = ProtocolError.new.setup 'command-not-acceptable', "Did not understand command for component #{id}", call_id, id
+          end
+
+          def handle_es_event(event)
+            trigger_handler :es, event
+          end
+
+          def send_complete_event(reason, recording = nil)
+            return if @complete
+            @complete = true
+            event = Punchblock::Event::Complete.new.tap do |c|
+              c.reason = reason
+              c << recording if recording
+            end
+            send_event event
+            current_actor.terminate!
+          end
+
+          def send_event(event)
+            event.component_id    = id
+            event.target_call_id  = call_id
+            safe_from_dead_actors { 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 Punchblock::Event::Complete::Hangup.new
+          end
+
+          def application(appname, options = nil)
+            call.application appname, "%[punchblock_component_id=#{id}]#{options}"
+          end
+
+          private
+
+          def translator
+            call.translator
+          end
+
+          def set_node_response(value)
+            @component_node.response = value
+          end
+
+          def send_ref
+            set_node_response Ref.new :id => id
+          end
+
+          def with_error(name, text)
+            set_node_response ProtocolError.new.setup(name, text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/translator/freeswitch/component/abstract_output.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module Punchblock
+  module Translator
+    class Freeswitch
+      module Component
+        class AbstractOutput < Component
+          UnrenderableDocError = Class.new OptionError
+
+          def execute(*args)
+            validate
+            send_ref
+            do_output(*args)
+          rescue UnrenderableDocError => e
+            with_error 'unrenderable document error', e.message
+          rescue OptionError => e
+            with_error 'option error', e.message
+          end
+
+          def execute_command(command)
+            case command
+            when Punchblock::Component::Stop
+              command.response = true
+              application 'break'
+              send_complete_event Punchblock::Event::Complete::Stop.new
+            else
+              super
+            end
+          end
+
+          private
+
+          def do_output
+            raise 'Not Implemented'
+          end
+
+          def validate
+            raise OptionError, 'An SSML document is required.' unless @component_node.ssml
+
+            [:start_offset, :start_paused, :repeat_interval, :repeat_times, :max_time].each do |opt|
+              raise OptionError, "A #{opt} value is unsupported." if @component_node.send opt
+            end
+
+            case @component_node.interrupt_on
+            when :speech, :dtmf, :any
+              raise OptionError, "An interrupt-on value of #{@component_node.interrupt_on} is unsupported."
+            end
+          end
+
+          def success_reason
+            Punchblock::Component::Output::Complete::Success.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/translator/freeswitch/component/flite_output.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Punchblock
+  module Translator
+    class Freeswitch
+      module Component
+        class FliteOutput < TTSOutput
+          private
+
+          def document
+            @component_node.ssml.inner_text.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/translator/freeswitch/component/input.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Punchblock
+  module Translator
+    class Freeswitch
+      module Component
+        class Input < Component
+
+          include InputComponent
+
+          private
+
+          def register_dtmf_event_handler
+            component = current_actor
+            call.register_handler :es, :event_name => 'DTMF' do |event|
+              safe_from_dead_actors do
+                component.process_dtmf! event[:dtmf_digit]
+              end
+            end
+          end
+
+          def unregister_dtmf_event_handler
+            call.unregister_handler :es, @dtmf_handler_id if instance_variable_defined?(:@dtmf_handler_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/translator/freeswitch/component/output.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+module Punchblock
+  module Translator
+    class Freeswitch
+      module Component
+        class Output < AbstractOutput
+          private
+
+          def validate
+            super
+            raise OptionError, "A voice value is unsupported." if @component_node.voice
+            filenames
+          end
+
+          def do_output
+            playback "file_string://#{filenames.join('!')}"
+          end
+
+          def filenames
+            @filenames ||= @component_node.ssml.children.map do |node|
+              case node
+              when RubySpeech::SSML::Audio
+                node.src
+              when String
+                raise if node.include?(' ')
+                node
+              else
+                raise
+              end
+            end.compact
+          rescue
+            raise UnrenderableDocError, 'The provided document could not be rendered.'
+          end
+
+          def playback(path)
+            op = current_actor
+            register_handler :es, :event_name => 'CHANNEL_EXECUTE_COMPLETE' do |event|
+              op.send_complete_event! complete_reason_for_event(event)
+            end
+            application 'playback', path
+          end
+
+          def complete_reason_for_event(event)
+            case event[:application_response]
+            when 'FILE PLAYED'
+              success_reason
+            else
+              Punchblock::Event::Complete::Error.new(:details => "Engine error: #{event[:application_response]}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/translator/freeswitch/component/record.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+module Punchblock
+  module Translator
+    class Freeswitch
+      module Component
+        class Record < Component
+          RECORDING_BASE_PATH = '/var/punchblock/record'
+
+          def setup
+            @complete_reason = nil
+          end
+
+          def execute
+            max_duration = @component_node.max_duration || -1
+
+            raise OptionError, 'A start-beep value of true is unsupported.' if @component_node.start_beep
+            raise OptionError, 'A start-paused value of true is unsupported.' if @component_node.start_paused
+            raise OptionError, 'An initial-timeout value is unsupported.' if @component_node.initial_timeout && @component_node.initial_timeout != -1
+            raise OptionError, 'A final-timeout value is unsupported.' if @component_node.final_timeout && @component_node.final_timeout != -1
+            raise OptionError, 'A max-duration value that is negative (and not -1) is invalid.' unless max_duration >= -1
+
+            @format = @component_node.format || 'wav'
+
+            component = current_actor
+            call.register_handler :es, :event_name => 'RECORD_STOP', [:[], :record_file_path] => filename do |event|
+              component.finished
+            end
+
+            record_args = ['start', filename]
+            record_args << max_duration/1000 unless max_duration == -1
+            call.uuid_foo :record, record_args.join(' ')
+
+            send_ref
+          rescue OptionError => e
+            with_error 'option error', e.message
+          end
+
+          def execute_command(command)
+            case command
+            when Punchblock::Component::Stop
+              call.uuid_foo :record, "stop #{filename}"
+              @complete_reason = stop_reason
+              command.response = true
+            else
+              super
+            end
+          end
+
+          def finished
+            send_complete_event(@complete_reason || success_reason)
+          end
+
+          private
+
+          def filename
+            File.join RECORDING_BASE_PATH, [id, @format].join('.')
+          end
+
+          def recording
+            Punchblock::Component::Record::Recording.new :uri => "file://#{filename}"
+          end
+
+          def stop_reason
+            Punchblock::Event::Complete::Stop.new
+          end
+
+          def success_reason
+            Punchblock::Component::Record::Complete::Success.new
+          end
+
+          def send_complete_event(reason)
+            super reason, recording
+          end
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/translator/freeswitch/component/tts_output.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Punchblock
+  module Translator
+    class Freeswitch
+      module Component
+        class TTSOutput < AbstractOutput
+          private
+
+          def do_output(engine, default_voice = nil)
+            op = current_actor
+            register_handler :es, :event_name => 'CHANNEL_EXECUTE_COMPLETE' do |event|
+              op.send_complete_event! success_reason
+            end
+            voice = @component_node.voice || default_voice || 'kal'
+            application :speak, [engine, voice, document].join('|')
+          end
+
+          def document
+            @component_node.ssml.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/translator/input_component.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+
+module Punchblock
+  module Translator
+    module InputComponent
+      def setup
+        @buffer = ""
+        @initial_timeout = @component_node.initial_timeout || -1
+        @inter_digit_timeout = @component_node.inter_digit_timeout || -1
+      end
+
+      def execute
+        validate
+        send_ref
+
+        @grammar = prepare_grammar
+
+        begin_initial_timer @initial_timeout/1000 unless @initial_timeout == -1
+
+        @dtmf_handler_id = register_dtmf_event_handler
+      rescue OptionError => e
+        with_error 'option error', e.message
+      end
+
+      def process_dtmf(digit)
+        @buffer << digit
+        cancel_initial_timer
+        case (match = @grammar.match @buffer.dup)
+        when RubySpeech::GRXML::Match
+          complete success_reason(match)
+        when RubySpeech::GRXML::NoMatch
+          complete Punchblock::Component::Input::Complete::NoMatch.new
+        when RubySpeech::GRXML::PotentialMatch
+          reset_inter_digit_timer
+        end
+      end
+
+      def execute_command(command)
+        case command
+        when Punchblock::Component::Stop
+          command.response = true
+          complete Punchblock::Event::Complete::Stop.new
+        else
+          super
+        end
+      end
+
+      private
+
+      def validate
+        raise OptionError, 'A grammar document is required.' unless @component_node.grammar
+        raise OptionError, 'A mode value other than DTMF is unsupported.' unless @component_node.mode == :dtmf
+        raise OptionError, 'An initial timeout value that is negative (and not -1) is invalid.' unless @initial_timeout >= -1
+        raise OptionError, 'An inter-digit timeout value that is negative (and not -1) is invalid.' unless @inter_digit_timeout >= -1
+      end
+
+      def prepare_grammar
+        @component_node.grammar.value.clone.tap do |grammar|
+          grammar.inline!
+          grammar.tokenize!
+          grammar.normalize_whitespace
+        end
+      end
+
+      def begin_initial_timer(timeout)
+        @initial_timer = after timeout do
+          complete Punchblock::Component::Input::Complete::NoInput.new
+        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
+            complete Punchblock::Component::Input::Complete::NoMatch.new
+          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 success_reason(match)
+        Punchblock::Component::Input::Complete::Success.new :mode           => match.mode,
+                                                            :confidence     => match.confidence,
+                                                            :utterance      => match.utterance,
+                                                            :interpretation => match.interpretation
+      end
+
+      def complete(reason)
+        unregister_dtmf_event_handler
+        cancel_initial_timer
+        cancel_inter_digit_timer
+        send_complete_event reason
+      end
+    end
+  end
+end