kenwiesner-adhearsioncw 0.8.3

data/lib/adhearsion/voip/dial_plan.rb

@@ -0,0 +1,218 @@
+# Hardcoding require for now since for some reason it's not being loaded
+require 'adhearsion/voip/dsl/dialplan/control_passing_exception'
+
+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)
+          returning(new(*args)) { |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 < Exception; 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)
+        if entry_point = dial_plan.lookup(call.context.to_sym)
+          entry_point
+        elsif call.respond_to?(:request) && m = call.request.path.match(%r{/([^/]+)})
+          dial_plan.lookup(m[1].to_sym)
+        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
+          returning new 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
+                  returning other 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
+            returning @table.clone 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: merge! other
+              when ProviderDefinition: providers << other
+              else raise RouteException, "Unrecognized object in route definition: #{other.inspect}"
+            end
+            self
+          end
+
+          def |(other)
+            case other
+              when RouteRule: 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 < Exception; 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 < Exception
+          
+          attr_reader :target
+          
+          def initialize(target)
+            super()
+            @target = target
+          end
+          
+        end
+      
+        class ContextNotFoundException < Exception; 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 < Exception
+          attr_reader :obj
+          def initialize(obj)
+            @obj = obj
+            super
+          end
+        end
+        
+        class Hangup < Exception; 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
+            returning super 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,71 @@
+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?
+            
+            returning({}) 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] = returning OpenStruct.new do |metadata|
+                      metadata.file  = file
+                      metadata.name  = name
+                      metadata.block = block
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        
+        class ContextsEnvelope
+
+          keep = %w"__send__ __id__ define_method instance_eval meta_def meta_eval metaclass"
+          (instance_methods - keep).each do |m|
+            undef_method m
+          end
+
+          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