adhearsion-cw 1.0.2.1

data/lib/adhearsion/voip/dsl/dialplan/parser.rb

@@ -0,0 +1,69 @@
+require 'ostruct'
+
+module Adhearsion
+  module VoIP
+    module DSL
+      module Dialplan
+        #TODO: This is obsolete, but we still need it for Freeswitch until we port that to the new 0.8.0 APIs
+        module DialplanParser
+
+          # Create a container and then clone that. when the container is created
+          # it should have all the contexts meta_def'd into it. for each call coming
+          # in, the cloned copy has the variables meta_def'd and set as instance
+          # variables
+
+          #TODO: separate into smaller pieces
+          def self.get_contexts
+            envelope = ContextsEnvelope.new
+
+            dialplans = AHN_CONFIG.files_from_setting "paths", "dialplan"
+            ahn_log.dialplan.warn "No dialplan files were found!" if dialplans.empty?
+
+            {}.tap do |contexts|
+              dialplans.each do |file|
+                raise "Dialplan file #{file} does not exist!" unless File.exists? file
+                envelope.instance_eval do
+                  eval File.read(file)
+                end
+                current_contexts = envelope.parsed_contexts
+                current_contexts.each_pair do |name, block|
+                  if contexts.has_key? name
+                    warn %'Dialplan context "#{name}" exists in both #{contexts[name].file} and #{file}.' +
+                         %' Using the "#{name}" context from #{contexts[name].file}.'
+                  else
+                    contexts[name] = OpenStruct.new.tap do |metadata|
+                      metadata.file  = file
+                      metadata.name  = name
+                      metadata.block = block
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        class ContextsEnvelope
+
+          keep = [:define_method, :instance_eval, :meta_def, :meta_eval, :metaclass, :methods, :object_id]
+          (instance_methods.map{|m| m.to_sym} - keep).each { |m| undef_method m unless m.to_s =~ /^__/ }
+
+          def initialize
+            @parsed_contexts = {}
+          end
+
+          attr_reader :parsed_contexts
+
+          def method_missing(name, *args, &block)
+            super unless block_given?
+            @parsed_contexts[name] = block
+            meta_def(name) { block }
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/adhearsion/voip/dsl/dialplan/thread_mixin.rb

@@ -0,0 +1,16 @@
+require 'ostruct'
+module Adhearsion
+  module VoIP
+    module DSL
+      module Dialplan
+        module ThreadMixin
+
+          def call
+            @thread_call_struct ||= OpenStruct.new
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/dsl/numerical_string.rb

@@ -0,0 +1,128 @@
+module Adhearsion
+  module VoIP
+    module DSL
+      # In Ruby, a number with a leading zero such as 023.45 or 023 does not evaluate as expected.
+      # In the case of the float 023.45, you get a syntax error. In the case of 023 the number is
+      # parsed as being in octal form and the number 19 is returned.
+      #
+      # In Adhearsion, various strings that are entirely numeric might start with zero and that zero
+      # should be preserved when converting that string of numbers into a number. The numerical string
+      # retains the zero while still allowing it to be compared to other numbers.
+      #
+      # [[I think this leading zero thing is only part of the reason that NumericalString exists. I'm
+      # currently writing tests for this leading zero stuff so I thought I'd dump some of my assumptions
+      # about it here in the documentation.]]
+      class NumericalString
+        class << self
+          def starts_with_leading_zero?(string)
+            string.to_s[/^0\d+/]
+          end
+        end
+
+        (instance_methods.map{|m| m.to_sym} - [:instance_eval, :object_id, :class]).each { |m| undef_method m unless m.to_s =~ /^__/ }
+
+        attr_reader :__real_num, :__real_string
+
+        def initialize(str)
+          @__real_string = str.to_s
+          @__real_num = str.to_i if @__real_string =~ /^\d+$/
+        end
+
+        def method_missing(name, *args, &block)
+          @__real_string.__send__ name, *args, &block
+        end
+
+        def respond_to?(m)
+          @__real_string.respond_to?(m) || m == :__real_num || m == :__real_string
+        end
+
+        def ==(x)
+          return x.is_a?(Fixnum) ? x == @__real_num : x == @__real_string
+        end
+        alias :=== :==
+
+        def is_a?(obj)
+          case obj.to_s
+          when "Fixnum" then true
+          when "String" then true
+          end
+        end
+        alias :kind_of? :is_a?
+
+      end
+
+      # The PhoneNumber class is used by one object throughout Adhearsion: the AGI
+      # "extension" variable. Using some clevery Ruby hackery, the Extension class allows
+      # dialplan writers to use the best of Fixnum and String usage such as
+      #
+      # - Dialing international numbers
+      # - Using a regexp in a case statement for "extension"
+      # - Using a numerical range against extension -- e.g. (100...200)
+      # - Using the thousands separator
+      class PhoneNumber < NumericalString
+
+        # Checks against a pattern identifying US local numbers (i.e numbers
+        # without an area code seven digits long)
+        def us_local_number?() to_s =~ Adhearsion::VoIP::Constants::US_LOCAL_NUMBER end
+
+        # Checks against a pattern identifying US domestic numbers.
+        def us_national_number?() to_s =~ Adhearsion::VoIP::Constants::US_NATIONAL_NUMBER end
+
+        # Checks against a pattern identifying an ISN number. See http://freenum.org
+        # for more info.
+        def isn?() to_s =~ Adhearsion::VoIP::Constants::ISN end
+
+        # Useful for dialing those 1-800-FUDGEME type numbers with letters in them. Letters
+        # in the argument will be converted to their appropriate keypad key.
+        def self.from_vanity str
+          str.gsub(/\W/, '').upcase.tr('A-Z', '22233344455566677778889999')
+        end
+
+      end
+
+    end
+  end
+end
+
+# These monkey patches are necessary for the NumericalString to work, unfortunately.
+class Class
+  def alias_method_once(new_name, old_name)
+    unless instance_methods.map{|m| m.to_sym}.include?(new_name.to_sym)
+      alias_method(new_name, old_name)
+    end
+  end
+end
+
+[Object, Range, class << String; self; end].each do |klass|
+  klass.alias_method_once(:pre_modified_threequal, :===)
+end
+
+class Object
+  def ===(arg)
+    if arg.respond_to? :__real_string
+      arg = arg.__real_num if kind_of?(Numeric) || kind_of?(Range)
+      pre_modified_threequal arg
+    else
+      pre_modified_threequal arg
+    end
+  end
+end
+
+class Range
+  alias_method_once(:original_threequal, :===)
+  def ===(arg)
+    if (arg.respond_to? :__real_string) &&  !arg.__real_num.nil?
+      arg = arg.__real_num
+      original_threequal arg
+    else
+      original_threequal arg
+    end
+  end
+end
+
+class << String
+  alias_method_once(:original_threequal, :===)
+  def ===(arg)
+    arg.respond_to?(:__real_string) || original_threequal(arg)
+  end
+end

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

@@ -0,0 +1,48 @@
+module Adhearsion
+  module VoIP
+    module FreeSwitch
+
+      class BasicConnectionManager
+
+        def initialize(io)
+          @io = io
+        end
+
+        # The send-command operator
+        def <<(str)
+          @io.write str + "\n\n"
+        end
+
+        def get_header
+          separate_pairs get_raw_header
+        end
+
+        def get_raw_header
+          ([].tap do |lines|
+            until line = @io.gets and line.chomp.empty?
+              lines << line.chomp
+            end
+          end) * "\n"
+        end
+
+        def next_event
+          header = get_raw_header
+          length = header.first[/\d+$/].to_i
+          # puts "Reading an event of #{length} bytes"
+          separate_pairs @io.read(length)
+        end
+
+        def separate_pairs(lines)
+          lines.split("\n").inject({}) do |h,line|
+            h.tap do |hash|
+              k,v = line.split(/\s*:\s*/)
+              hash[k] = URI.unescape(v).strip if k && v
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

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
+            [].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

@@ -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)
+          {}.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