adhearsion 1.2.6 → 2.0.0.alpha1

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

@@ -1,58 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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
-            [].tap 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
-          DSL::Dialplan::NoOpEventCommand.new.tap 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

@@ -1,38 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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)
-          {}.tap 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

@@ -1,80 +0,0 @@
-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