adhearsion-cw 1.0.2.1

data/lib/adhearsion/voip/constants.rb

@@ -0,0 +1,39 @@
+# Adhearsion, open source collaboration framework
+# Copyright (C) 2006,2007,2008 Jay Phillips
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Adhearsion
+  module VoIP
+
+    # Please help adjust these if they may be inaccurate!
+    module Constants
+      US_LOCAL_NUMBER = /^[1-9]\d{6}$/
+      US_NATIONAL_NUMBER = /^1?[1-9]\d{2}[1-9]\d{6}$/
+      ISN = /^\d+\*\d+$/ # See http://freenum.org
+      SIP_URI = /^sip:[\w\._%+-]+@[\w\.-]+\.[a-zA-Z]{2,4}$/
+
+      # Type of Number definitions given over PRI. Taken from the Q.931-ITU spec, page 68.
+      Q931_TYPE_OF_NUMBER = Hash.new(:unknown).merge 0b001 => :international,
+                                                     0b010 => :national,
+                                                     0b011 => :network_specific,
+                                                     0b100 => :subscriber,
+                                                     0b110 => :abbreviated_number
+    end
+
+    include Constants
+
+  end
+end

data/lib/adhearsion/voip/conveniences.rb

@@ -0,0 +1,18 @@
+module Adhearsion
+  module VoIP
+    module Conveniences
+
+      # Compiles the provided Asterisk dialplan pattern into a Ruby regular
+      # expression. For more usage of Asterisk's pattern syntax, see
+      # http://www.voip-info.org/wiki/view/Asterisk+Dialplan+Patterns
+      def _(pattern)
+        # Uncomment the following code fragment for complete compatibility.
+        # The fragment handles the seldom-used hyphen number spacer with no
+        # meaning.
+      	Regexp.new '^' << pattern.# gsub(/(?!\[[\w+-]+)-(?![\w-]+\])/,'').
+      	  gsub('X', '[0-9]').gsub('Z', '[1-9]').gsub('N','[2-9]').
+      	  gsub('.','.+').gsub('!','.*') << '$'
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/dial_plan.rb

@@ -0,0 +1,250 @@
+# Hardcoding require for now since for some reason it's not being loaded
+require 'adhearsion/voip/dsl/dialplan/control_passing_exception'
+
+require 'adhearsion/version'
+# JRuby contains a bug that breaks some of the menu functionality
+# See: https://adhearsion.lighthouseapp.com/projects/5871/tickets/92-menu-method-under-jruby-does-not-appear-to-work
+begin
+  curver = Adhearsion::PkgVersion.new(JRUBY_VERSION)
+  minver = Adhearsion::PkgVersion.new("1.6.0")
+  if curver < minver
+    puts "****************************************************************************"
+    puts "Versions of JRuby prior to 1.6.0 contain a bug that impacts"
+    puts "using the \"+\" operator to jump from one context to another."
+    puts "Adhearsion has detected JRuby version #{JRUBY_VERSION}. For more information see:"
+    puts "https://adhearsion.lighthouseapp.com/projects/5871/tickets/92-menu-method-under-jruby-does-not-appear-to-work"
+    puts "****************************************************************************"
+  end
+rescue NameError
+  # In case JRUBY_VERSION is not defined.
+rescue ArgumentError
+  # Needed to handle ActiveSupport's handling of missing constants
+  # with anonymous modules under Ruby 1.9
+end
+
+module Adhearsion
+  class DialPlan
+    attr_accessor :loader, :entry_points
+    def initialize(loader = Loader)
+      @loader       = loader
+      @entry_points = @loader.load_dialplans.contexts
+    end
+
+    ##
+    # Lookup and return an entry point by context name
+    #
+    def lookup(context_name)
+      entry_points[context_name]
+    end
+
+    ##
+    # Executable environment for a dial plan in the scope of a call. This class has all the dialplan methods mixed into it.
+    #
+    class ExecutionEnvironment
+
+      class << self
+        def create(*args)
+          new(*args).tap { |instance| instance.stage! }
+        end
+      end
+
+      attr_reader :call
+      def initialize(call, entry_point)
+        @call, @entry_point = call, entry_point
+      end
+
+      ##
+      # Adds the methods to this ExecutionEnvironment which make it useful. e.g. dialplan-related methods, call variables,
+      # and component methods.
+      #
+      def stage!
+        extend_with_voip_commands!
+        extend_with_call_variables!
+        extend_with_dialplan_component_methods!
+      end
+
+      def run
+        raise "Cannot run ExecutionEnvironment without an entry point!" unless entry_point
+        current_context = entry_point
+        answer if AHN_CONFIG.automatically_answer_incoming_calls
+        begin
+          instance_eval(&current_context)
+        rescue Adhearsion::VoIP::DSL::Dialplan::ControlPassingException => exception
+          current_context = exception.target
+          retry
+        end
+      end
+
+      protected
+
+      attr_reader :entry_point
+
+
+      def extend_with_voip_commands!
+        extend Adhearsion::VoIP::Conveniences
+        extend Adhearsion::VoIP::Commands.for(call.originating_voip_platform)
+      end
+
+      def extend_with_call_variables!
+        call.define_variable_accessors self
+      end
+
+      def extend_with_dialplan_component_methods!
+        Components.component_manager.extend_object_with(self, :dialplan) if Components.component_manager
+      end
+
+    end
+
+    class Manager
+
+      class NoContextError < StandardError; end
+
+      class << self
+        def handle(call)
+          new.handle(call)
+        end
+      end
+
+      attr_accessor :dial_plan, :context
+      def initialize
+        @dial_plan = DialPlan.new
+      end
+
+      def handle(call)
+        if call.failed_call?
+          environment = ExecutionEnvironment.create(call, nil)
+          call.extract_failed_reason_from environment
+          raise FailedExtensionCallException.new(environment)
+        end
+
+        if call.hungup_call?
+          raise HungupExtensionCallException.new(ExecutionEnvironment.new(call, nil))
+        end
+
+        starting_entry_point = entry_point_for call
+        raise NoContextError, "No dialplan entry point for call context '#{call.context}' -- Ignoring call!" unless starting_entry_point
+        @context = ExecutionEnvironment.create(call, starting_entry_point)
+        inject_context_names_into_environment @context
+        @context.run
+      end
+
+      # Find the dialplan by the context name from the call or from the
+      # first path entry in the AGI URL
+      def entry_point_for(call)
+
+        # Try the request URI for an entry point first
+        if call.respond_to?(:request) && m = call.request.path.match(%r{/([^/]+)})
+          if entry_point = dial_plan.lookup(m[1].to_sym)
+            return entry_point
+          else
+            ahn_log.warn "AGI URI requested context \"#{m[1]}\" but matching Adhearsion context not found!  Falling back to Asterisk context."
+          end
+        end
+
+        # Fall back to the matching Asterisk context name
+        if entry_point = dial_plan.lookup(call.context.to_sym)
+          return entry_point
+        end
+      end
+
+      protected
+
+      def inject_context_names_into_environment(environment)
+        return unless dial_plan.entry_points
+        dial_plan.entry_points.each do |name, context|
+          environment.meta_def(name) { context }
+        end
+      end
+
+    end
+
+    class Loader
+      class << self
+        attr_accessor :default_dial_plan_file_name
+
+        def load(dial_plan_as_string)
+          string_io = StringIO.new dial_plan_as_string
+          def string_io.path
+            "(eval)"
+          end
+          load_dialplans string_io
+        end
+
+        def load_dialplans(*files)
+          files = Adhearsion::AHN_CONFIG.files_from_setting("paths", "dialplan") if files.empty?
+          files = Array files
+          files.map! do |file|
+            case file
+              when File, StringIO
+                file
+              when String
+                File.new file
+              else
+                raise ArgumentError, "Unrecognized type of file #{file.inspect}"
+            end
+          end
+          new.tap do |loader|
+            files.each do |file|
+              loader.load file
+            end
+          end
+        end
+
+      end
+
+      self.default_dial_plan_file_name ||= 'dialplan.rb'
+
+      def initialize
+        @context_collector = ContextNameCollector.new
+      end
+
+      def contexts
+        @context_collector.contexts
+      end
+
+      def load(dialplan_file)
+        dialplan_code = dialplan_file.read
+        @context_collector.instance_eval(dialplan_code, dialplan_file.path)
+        nil
+      end
+
+      class ContextNameCollector# < ::BlankSlate
+
+        class << self
+
+          def const_missing(name)
+            super
+          rescue ArgumentError
+            raise NameError, %(undefined constant "#{name}")
+          end
+
+        end
+
+        attr_reader :contexts
+        def initialize
+          @contexts = {}
+        end
+
+        def method_missing(name, *args, &block)
+          super if !block_given? || args.any?
+          contexts[name] = DialplanContextProc.new(name, &block)
+        end
+
+      end
+    end
+    class DialplanContextProc < Proc
+
+      attr_reader :name
+
+      def initialize(name, &block)
+        super(&block)
+        @name = name
+      end
+
+      def +@
+        raise Adhearsion::VoIP::DSL::Dialplan::ControlPassingException.new(self)
+      end
+
+    end
+  end
+end

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/dialing_dsl.rb

@@ -0,0 +1,151 @@
+# Adhearsion, open source collaboration framework
+# Copyright (C) 2006,2007,2008 Jay Phillips
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'adhearsion/foundation/metaprogramming'
+require 'adhearsion/voip/conveniences'
+require 'adhearsion/voip/constants'
+require 'adhearsion/voip/dsl/dialing_dsl/dialing_dsl_monkey_patches'
+
+module Adhearsion
+  module VoIP
+    module DSL
+      class DialingDSL
+
+        extend  Conveniences
+        include Constants
+
+        Regexp.class_eval do
+          include Adhearsion::VoIP::DSL::DialingDSL::MonkeyPatches::RegexpMonkeyPatch
+        end
+
+        def self.inherited(klass)
+          klass.class_eval do
+            [:@@providers, :@@routes].each do |var|
+              class_variable_set(var, [])
+              cattr_reader var.to_s.gsub('@@', '')
+            end
+          end
+        end
+
+        def self.calculate_routes_for(destination)
+          destination = destination.to_s
+          routes.select { |defined_route| defined_route === destination }.map &:providers
+        end
+
+        class ProviderDefinition < OpenStruct
+
+          def initialize(name)
+            super()
+            self.name = name.to_s.to_sym
+          end
+
+          def >>(other)
+            RouteRule.new :providers => [self, other]
+          end
+
+          def format_number_for_platform(number, platform=:asterisk)
+            case platform
+              when :asterisk
+                [protocol || "SIP", name || "default", number].join '/'
+              else
+                raise "Unsupported platform #{platform}!"
+            end
+          end
+
+          def format_number_for_platform(number, platform=:asterisk)
+            case platform
+              when :asterisk
+                [protocol || "SIP", name || "default", number].join '/'
+              else
+                raise "Unsupported platform #{platform}!"
+            end
+          end
+
+          def defined_properties_without_name
+            @table.clone.tap do |copy|
+              copy.delete :name
+            end
+          end
+
+        end
+
+        protected
+
+        def self.provider(name, &block)
+          raise ArgumentError, "no block given" unless block_given?
+
+          options = ProviderDefinition.new name
+          yield options
+
+          providers << options
+          meta_def(name) { options }
+        end
+
+        def self.route(route)
+          routes << route
+        end
+
+        class RouteRule
+
+          attr_reader :patterns, :providers
+
+          def initialize(hash={})
+            @patterns  = Array hash[:patterns]
+            @providers = Array hash[:providers]
+          end
+
+          def merge!(other)
+            providers.concat other.providers
+            patterns.concat  other.patterns
+            self
+          end
+
+          def >>(other)
+            case other
+              when RouteRule then merge! other
+              when ProviderDefinition then providers << other
+              else raise RouteException, "Unrecognized object in route definition: #{other.inspect}"
+            end
+            self
+          end
+
+          def |(other)
+            case other
+              when RouteRule then merge! other
+              when Regexp
+                patterns << other
+                self
+              else raise other.inspect
+            end
+          end
+
+          def ===(other)
+            patterns.each { |pattern| return true if pattern === other }
+            false
+          end
+
+          def unshift_pattern(pattern)
+            patterns.unshift pattern
+          end
+
+          class RouteException < StandardError; 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