adhearsion 0.7.7 → 0.8.0

data/lib/adhearsion/voip/freeswitch/event_handler.rb

@@ -0,0 +1,58 @@
+module Adhearsion
+  module VoIP
+    module FreeSwitch
+
+      # Subclass this to register a new event handler
+      class EventHandler
+
+        @@events = {}
+        @@compound_events = {}
+
+        @@connection = nil
+
+        def self.start!(hash=nil)
+          login hash if hash
+          raise "You must login to the FreeSWITCH EventSocket!" unless @@connection
+          loop do
+            # debug "Waiting for an event"
+            dispatch_event! @@connection.get_header
+          end
+        end
+
+        def self.dispatch_event!(data)
+          #puts "\nHandling an event! #{data.inspect}"
+          name = data['Event-Name']
+          normal_event = name && @@events[name.underscore.to_sym]
+          # puts "THIS IS WHAT I THINK IT MIGHT BE : #{normal_event.inspect} (with #{name.underscore.to_sym.inspect})"
+          if normal_event then normal_event.call(data)
+          else
+            #debug "Trying compound events"
+            @@compound_events.each do |(event, block)|
+              mini_event = {}
+              event.keys.each { |k| mini_event[k] = data[k] }
+              block.call(data) if event == mini_event
+            end
+          end
+        rescue => e
+          p e
+          puts e.backtrace.map { |x| " " * 4 + x }
+        end
+
+        protected
+
+        # Can be specified in the subclass
+        def self.login(hash)
+          debug "Creating a new event connection manager"
+          @@connection = InboundConnectionManager.new hash
+          debug "Enabling events"
+          @@connection.enable_events!
+        end
+
+        def self.on(event, &block)
+          event = event.underscore.to_sym if event.is_a? String
+          (event.kind_of?(Hash) ? @@compound_events : @@events)[event] = block
+        end    
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/freeswitch/freeswitch_dialplan_command_factory.rb

@@ -0,0 +1,129 @@
+require 'adhearsion/voip/dsl/dialplan/dispatcher'
+
+module Adhearsion
+  module VoIP
+    module FreeSwitch
+      class FreeSwitchDialplanCommandFactory
+        
+        def initialize(context=nil)
+          @context = context
+        end
+        
+        # These should all return those objects...
+        def speak(text, hash={})
+          voice, engine = hash[:voice] || "Dianne", hash[:engine] || "cepstral"
+          
+          dtmf = hash[:on_keypress]
+          speak_cmd = cmd 'speak', "#{engine}|#{voice}|%p" % text, :on_keypress => dtmf
+          
+          if hash[:timeout] == 0
+            [speak_cmd, DSL::Dialplan::NoOpEventCommand.new(hash[:timeout], :on_keypress => dtmf)]
+          else
+            puts "Returning the normal speak command"
+            speak_cmd 
+          end
+        end
+        
+        def set(key, value)
+          cmd 'set', "#{key}=#{value}"
+        end
+        
+        def play(*files)
+          hash = files.last.kind_of?(Hash) ? files.pop : {}
+          conference, to = hash[:conference], hash[:to]
+          puts "conference: #{conference.inspect}, to: #{to.inspect}, hash: #{hash.inspect}, files: #{files.inspect}"
+          if conference
+            # Normal (inbound) event socket playing to a conference
+            files.map do |file|
+              cmd "conference", "#{conference} play #{file} #{to}"
+            end
+          elsif to
+            # Normal event socket syntax
+            files.map do |file|
+              # TODO: Support playing to an individual leg of the call.
+              cmd "broadcast", "#{to} #{file} both"
+            end
+          else
+            # Outbound event sockets
+            files.map { |file| cmd('playback', file) }
+          end
+        end
+        
+        def join(id)
+          DSL::Dialplan::ExitingEventCommand.new "conference", id.to_s
+        end
+        
+        def hangup!
+          cmd "exit"
+        end
+        
+        def return!(obj)
+          raise DSL::Dialplan::ReturnValue.new(obj)
+        end
+        
+        def hangup!
+          raise DSL::Dialplan::Hangup
+        end
+        
+        def wait(seconds=nil, &block)
+          DSL::Dialplan::NoOpEventCommand.new(seconds)
+        end
+        
+        def record(hash={}, &block)
+          # TODO: Could want to record a conference or a UUID
+          p hash
+          if hash[:stop]
+            cmd 'stop_record_session', hash[:stop]
+          else
+            file = hash[:file] || File.join(Dir::tmpdir, String.random(32), '.wav')
+            
+            raise "Cannot supply both a timeout and a block!" if hash[:timeout] && block_given?
+            
+            dtmf_breaker = lambda do |digit|
+              return! file if digit == hash[:break_on]
+            end
+            
+            rec_cmd = cmd "record", file, :on_keypress => dtmf_breaker
+            returning [] do |cmds|
+              cmds << play('beep') if hash[:beep]
+              cmds << rec_cmd
+              if hash[:timeout]
+                cmds << DSL::Dialplan::NoOpEventCommand.new(hash[:timeout])
+              elsif block_given?
+                cmds << block
+                cmds << record(:stop => file)
+              end
+              cmds << file
+              p cmds
+              cmds
+            end
+          end
+        end
+        
+        def input(number=nil, hash={})
+          timeout, file = hash[:timeout], hash[:play] || hash[:file]
+          break_on = hash[:break_on] || '#'
+
+          # TODO: compile play() and set its DTMF callback to this one
+          digits = []
+          dtmf_hook = lambda do |digit|
+            puts "RECEIVED #{digit} WITH #{digits}"
+            return! digits.to_s if digit.to_s == break_on.to_s
+            digits << digit
+            return! digits.to_s if number && digits.size >= number
+          end
+          returning DSL::Dialplan::NoOpEventCommand.new do |command|
+            command.on_keypress &dtmf_hook
+          end
+        end
+        
+        private
+        
+        def cmd(*args, &block)
+          DSL::Dialplan::EventCommand.new(*args, &block)
+        end
+        
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/freeswitch/inbound_connection_manager.rb

@@ -0,0 +1,38 @@
+require 'adhearsion/voip/freeswitch/basic_connection_manager'
+module Adhearsion
+  module VoIP
+    module FreeSwitch
+      class InboundConnectionManager < BasicConnectionManager
+    
+        DEFAULTS = { :pass => "ClueCon", :host => '127.0.0.1', :port => 8021 }
+    
+        def initialize(arg)
+          if arg.kind_of? Hash
+            @opts = DEFAULTS.merge arg
+            @io = TCPSocket.new(@opts[:host], @opts[:port])
+            super @io
+            unless login(@opts[:pass])
+              raise "Your FreeSwitch Event Socket password for #{@opts[:host]} was invalid!"
+            end
+          else arg.kind_of? IO
+            @io = arg
+            super @io
+          end
+        end
+    
+        def enable_events!(which='ALL')
+          self << "event plain #{which}"
+          get_raw_header
+        end
+    
+        # Only called when nothing has been sent over the socket.
+        def login(pass)
+          get_raw_header
+          self << "auth #{pass}"
+          get_raw_header.include? "+OK"
+        end
+    
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/freeswitch/oes_server.rb

@@ -0,0 +1,195 @@
+require 'gserver'
+
+require 'adhearsion/voip/dsl/dialplan/thread_mixin'
+require 'adhearsion/voip/dsl/dialplan/parser'
+require 'adhearsion/voip/dsl/dialplan/dispatcher'
+require 'adhearsion/voip/freeswitch/basic_connection_manager'
+require 'adhearsion/voip/freeswitch/freeswitch_dialplan_command_factory'
+
+module Adhearsion
+  module VoIP
+    module FreeSwitch
+      class OesServer < GServer
+        
+        def initialize(port, host=nil)
+          @port, @host = port || 4572, host || "0.0.0.0"
+          @cache_lock = Mutex.new
+          super @port, @host, (1.0/0.0)
+          log "Starting FreeSwitch OES Server"
+        end
+        
+        def serve(io)
+          
+          log "Incoming call on the FreeSwitch outbound event socket..."
+          Thread.me.extend DSL::Dialplan::ThreadMixin
+          Thread.me.call.io = io
+          conn = BasicConnectionManager.new io
+          
+          Thread.my.call.mgr = conn
+          conn << "connect"
+          @vars = conn.get_header
+          answered = @vars['variable_endpoint_disposition'] == "ANSWER"
+          
+          conn << "myevents"
+          myevents_response = conn.get_header
+          answered ||= myevents_response['Event-Name'] == 'CHANNEL_ANSWER'
+          
+          log "Connected to Freeswitch. Waiting for answer state."
+          
+          until answered
+            answered ||= conn.get_header['Event-Name'] == 'CHANNEL_ANSWER'
+          end
+          
+          log "Loading cached dialplan"
+          contexts, dispatcher = cached_dialplan_data
+          log "Finished loading cached dialplans"
+          
+          first_context_name  = @vars['variable_context'] || @vars["Channel-Context"]
+          first_context       = contexts[first_context_name.to_sym]
+          
+          log "Found context #{first_context_name} from call variables."
+          
+          # If the target context does not exist, warn and don't handle the call
+          unless first_context
+            log "No context '#{first_context_name}' found in " +
+                "#{AHN_CONFIG.files_from_setting("paths", "").to_sentence(:connector => "or")}. Ignoring request!"
+            return
+          end
+          
+          # Enable events
+          
+          # Now that we have the code, let's dispatch it back.
+          
+          pretty_vars = rubyize_keys_for @vars
+          dispatcher.def_keys! pretty_vars
+          dispatcher.instance_eval(&first_context.block)
+          
+        rescue => e
+          p e
+          puts e.backtrace.map {|x| " " * 4 + x }
+        end
+        
+        def cached_dialplan_data
+          @cache_lock.synchronize do
+            log "Checking whether the contexts should be reloaded"
+            if should_reload_contexts?
+              log "Getting the contexts"
+              @abstract_contexts = DSL::Dialplan::DialplanParser.get_contexts
+              log "Creating a new OesDispatcher"
+              @abstract_dispatcher = OesDispatcher.new @vars['Channel-Unique-ID']
+              log "Done creating it"
+              @abstract_dispatcher.def_keys! @abstract_contexts
+            else  
+              log "Should not reload context."
+              @abstract_dispatcher.instance_variable_set :@uuid, @vars['Channel-Unique-ID']
+            end
+            return [@abstract_contexts.clone, @abstract_dispatcher.clone]
+          end
+        end
+        
+        # TODO. This is broken. Always returns true. Should cache the last reload
+        # time.
+        def should_reload_contexts?
+          !@abstract_contexts || !@abstract_dispatcher ||
+            AHN_CONFIG.files_from_setting("paths", "dialplan").map { |x| File.mtime(x) }.max < Time.now
+        end
+        
+        def rubyize_keys_for(hash)
+          returning({}) do |pretty|
+            hash.each { |k,v| pretty[k.to_s.underscore] = v }
+          end
+        end
+        
+        class OesDispatcher < DSL::Dialplan::CommandDispatcher
+          
+          def initialize(uuid=nil)
+            super FreeSwitchDialplanCommandFactory, uuid
+          end
+          
+          def dispatch!(event)
+            if event.kind_of?(DSL::Dialplan::NoOpEventCommand) && event.on_keypress
+              return_value = nil
+              dispatch = lambda do
+                loop do
+                  Thread.my.call.mgr.get_raw_header
+                  async_event = Thread.my.call.mgr.get_header
+                  if async_event['Event-Name'] == 'DTMF'
+                    key = async_event['DTMF-String']
+                    return_value = event.on_keypress.call(('0'..'9').include?(key) ? key.to_i : key)
+                  end
+                end
+              end
+              if event.timeout
+                begin
+                  Timeout.timeout event.timeout, &dispatch
+                rescue Timeout::Error
+                  break!
+                  return_value
+                end
+              else dispatch.call
+              end
+              
+            else
+              log "Not a noop. Sending #{event.app}(#{event.args.to_a * " "})"
+              Thread.my.call.mgr << "SendMsg\ncall-command: execute\nexecute-app-name: " +  
+                "#{event.app}\nexecute-app-arg: #{event.args.to_a * " "}"
+              
+              if event.kind_of? DSL::Dialplan::ExitingEventCommand
+                Thread.my.call.io.close
+                Thread.me.exit
+              end
+              
+              # Useless "command/reply" +OK and content-length headers
+              lambda do
+                Thread.my.call.mgr.get_raw_header
+                redo if Thread.my.call.mgr.get_header['Event-Name'] == "CHANNEL_EXECUTE_COMPLETE"
+              end.call
+              
+              # Main event information. Keep track of the Core-UUID and wait for
+              # it to come back to us as a CHANNEL_EXECUTE_COMPLETE event.
+              execution_header = Thread.my.call.mgr.get_header
+              execution_uuid = execution_header['Core-UUID']
+              
+              loop do
+                log "Waiting for either a DTMF or the app to finish"
+                hdr = Thread.my.call.mgr.get_raw_header
+                log "Got head #{hdr}"
+                
+                if hdr == "Content-Type: api/response\nContent-Length: 0"
+                  break
+                end
+                
+                async_event = Thread.my.call.mgr.get_header
+                event_name = async_event['Event-Name']
+                if event_name == 'DTMF' && event.on_keypress
+                  key = async_event['DTMF-String']
+                  event.on_keypress.call(('0'..'9') === key ? key.to_i : key)
+                elsif event_name == 'CHANNEL_EXECUTE_COMPLETE' && async_event['Core-UUID'] == execution_uuid
+                  break async_event
+                else
+                  
+                end
+              end
+            end
+          rescue DSL::Dialplan::ReturnValue => r
+            log "Dispatch!: Got a return value with #{r.obj}"
+            break!
+            raise r
+          rescue DSL::Dialplan::Hangup
+            Thread.my.call.mgr << "SendMsg\ncall-command: hangup"
+            Thread.my.call.mgr.io.close rescue nil
+          end
+          
+          def break!(uuid=@context)
+            log "Breaking with #{uuid}"
+            Thread.my.call.mgr << "api break #{uuid}"
+            Thread.my.call.mgr.get_raw_header
+            # Thread.my.call.mgr.get_raw_header
+            # Thread.my.call.mgr.get_raw_header
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/menu_state_machine/calculated_match.rb

@@ -0,0 +1,80 @@
+module Adhearsion
+  module VoIP
+    class CalculatedMatch
+
+      # Convenience method for instantiating failed matches
+      def self.failed_match!(pattern, query, match_payload)
+        new :pattern => pattern, :query => query, :match_payload => match_payload
+      end
+
+      attr_reader :match_payload, :potential_matches, :exact_matches, :pattern, :query
+
+      def initialize(options={})
+        @pattern, @query, @match_payload = options.values_at :pattern, :query, :match_payload
+        @potential_matches = options[:potential_matches] ? Array(options[:potential_matches]) : []
+        @exact_matches     = options[:exact_matches] ? Array(options[:exact_matches])     : []
+      end
+
+      def exact_match?
+        exact_matches.any?
+      end
+
+      def potential_match?
+        potential_matches.any?
+      end
+
+      def failed_match?
+        !potential_match? && !exact_match?
+      end
+
+      def type_of_match
+        if exact_match?
+          :exact
+        elsif potential_match?
+          :potential
+        end
+      end
+
+    end
+
+    class CalculatedMatchCollection
+
+      attr_reader :calculated_matches, :potential_matches, :exact_matches,
+                  :actual_potential_matches, :actual_exact_matches
+
+      def initialize
+        @calculated_matches       = []
+        @potential_matches        = []
+        @exact_matches            = []
+        @actual_potential_matches = []
+        @actual_exact_matches     = []
+      end
+
+      def <<(calculated_match)
+        calculated_matches << calculated_match
+        actual_potential_matches.concat calculated_match.potential_matches
+        actual_exact_matches.concat calculated_match.exact_matches
+  
+        potential_matches << calculated_match if calculated_match.potential_match?
+        exact_matches << calculated_match if calculated_match.exact_match?
+      end
+
+      def potential_match_count
+        actual_potential_matches.size
+      end
+
+      def exact_match_count
+        actual_exact_matches.size
+      end
+
+      def potential_match?
+        potential_match_count > 0
+      end
+
+      def exact_match?
+        exact_match_count > 0
+      end
+
+    end
+  end
+end