rene-adhearsion 0.8.6

data/lib/adhearsion/voip/dsl/dialing_dsl/dialing_dsl_monkey_patches.rb

@@ -0,0 +1,37 @@
+module Adhearsion
+  module VoIP
+    module DSL
+      class DialingDSL
+        module MonkeyPatches
+          module RegexpMonkeyPatch
+
+            def |(other)
+              case other
+                when RouteRule
+                  other.unshift_pattern self
+                  other
+                when Regexp
+                  RouteRule.new :patterns => [self, other]
+                else
+                  raise ArgumentError, "Unsupported pattern type #{other.inspect}"
+              end
+            end
+
+            def >>(other)
+              case other
+                when ProviderDefinition
+                  RouteRule.new :patterns => self, :providers => other
+                when RouteRule
+                  other.tap do |route|
+                    route.unshift_pattern self
+                  end
+                else raise ArgumentError, "Unsupported route definition #{other.inspect}"
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Adhearsion
+  module VoIP
+    module DSL
+      module Dialplan
+        # A ControlPassingException is used internally to stop execution of one
+        # dialplan context and begin execution of another proc instead. It is
+        # most notably used by the ~@ unary operator that can be called on a
+        # context name within a dialplan to transfer control entirely to that
+        # particular context. The serve() method in the servlet_container actually
+        # rescues these exceptions specifically and then does +e.target to execute
+        # that code.
+        class ControlPassingException < StandardError
+
+          attr_reader :target
+
+          def initialize(target)
+            super()
+            @target = target
+          end
+
+        end
+
+        class ContextNotFoundException < StandardError; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+module Adhearsion
+  module VoIP
+    module DSL
+      module Dialplan
+
+        class ReturnValue < StandardError
+          attr_reader :obj
+          def initialize(obj)
+            @obj = obj
+            super
+          end
+        end
+
+        class Hangup < StandardError; end
+
+        # Instantiated and returned in every dialplan command
+        class EventCommand
+
+          attr_accessor :app, :args, :response_block, :returns, :on_keypress
+
+          def initialize(app, *args, &block)
+            @hash = args.pop if args.last.kind_of?(Hash)
+            @app, @args = app, args
+
+            if @hash
+              @returns = @hash[:returns] || :raw
+              @on_keypress = @hash[:on_keypress]
+            end
+
+            @response_block = block if block_given?
+          end
+
+          def on_keypress(&block)
+            block_given? ? @on_keypress = block : @on_keypress
+          end
+
+          def on_break(&block)
+            block_given? ? @on_break = block : @on_break
+          end
+
+        end
+
+        class NoOpEventCommand < EventCommand
+          attr_reader :timeout, :on_keypress
+          def initialize(timeout=nil, hash={})
+            @timeout = timeout
+            @on_keypress = hash[:on_keypress]
+          end
+        end
+
+        class ExitingEventCommand < EventCommand; end
+
+        # Serves as a EventCommand proxy for handling EventCommands. Useful
+        # if doing any pre-processing.
+        #
+        # For example, when sending commands over the event socket to FreeSwitch,
+        # every command must start with "api", but, when doing an originate, it
+        # must begin with an ampersand. These two pre-processors would be developed
+        # as separate CommandDispatchers.
+        class CommandDispatcher
+
+          attr_reader :factory, :context
+
+          def initialize(factory, context=nil)
+            @context = context
+            @factory = factory.new context
+          end
+
+          def dispatch!(event_command)
+            raise NotImplementedError, "Must subclass #{self.class} and override this!"
+          end
+
+          def method_missing(name, *args, &block)
+            *commands = *@factory.send(name, *args, &block)
+            commands.map do |command|
+              if command.kind_of? Proc
+                instance_eval(&command)
+              elsif command.kind_of? EventCommand
+                dispatched_command = dispatch! command
+                if command.response_block
+                  while (new_cmd = command.response_block.call(dispatched_command)).kind_of? EventCommand
+                    dispatched_command = dispatch! new_cmd
+                  end
+                end
+                dispatched_command
+              else
+                command
+              end
+            end.last
+          rescue ReturnValue => r
+            return r.obj
+          end
+
+          def return!(obj)
+            raise DSL::Dialplan::ReturnValue.new(obj)
+          end
+
+          def break!(uuid=@context)
+            raise NotImplementedError, "Must subclass #{self.class} and override this!"
+          end
+
+          # Takes a Hash and meta_def()'s a method for each key that returns
+          # the key's value in the Hash.
+          def def_keys!(hash)
+            hash.each_pair do |k,v|
+              meta_def(k) { v } rescue nil
+            end
+          end
+
+          def clone
+            super.tap do |nemesis|
+              instance_variables.each do |iv|
+                value = instance_variable_get(iv)
+                nemesis.instance_variable_set iv, value.clone if value
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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 = %w"define_method instance_eval meta_def meta_eval metaclass"
+          (instance_methods - keep).each { |m| undef_method m unless m =~ /^__/ }
+
+          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,115 @@
+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 - %w{instance_eval object_id}).each { |m| undef_method m unless m =~ /^__/ }
+
+        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
+
+      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.include?(new_name.to_s)
+      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.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