sant0sk1-adhearsion 0.7.999

data/lib/adhearsion/voip/asterisk/config_generators/voicemail.conf.rb

@@ -0,0 +1,240 @@
+require File.join(File.dirname(__FILE__), 'config_generator')
+
+module Adhearsion
+  module VoIP
+    module Asterisk
+      module ConfigFileGenerators
+        class Voicemail < AsteriskConfigGenerator
+          
+          DEFAULT_GENERAL_SECTION = {
+            :format => :wav
+          }
+          
+          # Don't worry. These will be overridable soon.
+          STATIC_ZONEMESSAGES_CONTEXT = %{
+            [zonemessages]
+            eastern=America/New_York|'vm-received' Q 'digits/at' IMp
+            central=America/Chicago|'vm-received' Q 'digits/at' IMp
+            central24=America/Chicago|'vm-received' q 'digits/at' H N 'hours'
+            military=Zulu|'vm-received' q 'digits/at' H N 'hours' 'phonetic/z_p'
+            european=Europe/Copenhagen|'vm-received' a d b 'digits/at' HM
+          }.unindent
+          
+          attr_reader :properties, :context_definitions
+          def initialize
+            @properties = DEFAULT_GENERAL_SECTION.clone
+            @mailboxes  = {}
+            @context_definitions = []
+            super
+          end
+          
+          def context(name)
+            raise ArgumentError, "Name cannot be 'general'!" if name.to_s.downcase == 'general'
+            raise ArgumentError, "A name can only be characters, numbers, and underscores!" if name.to_s !~ /^[\w_]+$/            
+            
+            returning ContextDefinition.new(name) do |context_definition|
+              yield context_definition
+              context_definitions << context_definition
+            end
+          end
+          
+          def greeting_maximum(seconds)
+            int "maxgreet" => seconds
+          end
+          
+          def execute_on_pin_change(command)
+            string "externpass" => command 
+          end
+          
+          def recordings
+            @recordings ||= RecordingDefinition.new
+            yield @recordings if block_given?
+            @recordings
+          end
+          
+          def emails
+            @emails ||= EmailDefinition.new
+            if block_given?
+              yield @emails
+            else
+              @emails
+            end
+          end
+          
+          def to_s
+            email_properties = @emails ? @emails.properties : {}
+            AsteriskConfigGenerator.warning_message +
+            "[general]\n" +
+            properties.merge(email_properties).map { |(key,value)| "#{key}=#{value}" }.sort.join("\n") + "\n\n" +
+            STATIC_ZONEMESSAGES_CONTEXT +
+            context_definitions.map(&:to_s).join("\n\n")
+          end
+          
+          private
+          
+          class ContextDefinition < AsteriskConfigGenerator
+            
+            attr_reader :mailboxes
+            def initialize(name)
+              @name      = name
+              @mailboxes = []
+              super()
+            end
+            
+            # TODO: This will hold a lot of the methods from the [general] section!
+            
+            def to_s
+              (%W[[#@name]] + mailboxes.map(&:to_s)).join "\n"
+            end
+            
+            def mailbox(mailbox_number)
+              box = MailboxDefinition.new(mailbox_number)
+              yield box
+              mailboxes << box
+            end
+            
+            private
+            
+            def mailbox_entry(options)
+              returning MailboxDefinition.new do |mailbox|
+                yield mailbox if block_given?
+                mailboxes << definition
+              end
+            end
+            
+            class MailboxDefinition
+
+              attr_reader :mailbox_number
+              def initialize(mailbox_number)
+                check_numeric mailbox_number
+                @mailbox_number = mailbox_number
+                @definition = {}
+                super()
+              end
+
+              def pin_number(number)
+                check_numeric number
+                @definition[:pin_number] = number
+              end
+
+              def name(str)
+                @definition[:name] = str
+              end
+
+              def email(str)
+                @definition[:email] = str
+              end
+
+              def to_hash
+                @definition
+              end
+              
+              def to_s
+                %(#{mailbox_number} => #{@definition[:pin_number]},#{@definition[:name]},#{@definition[:email]})[/^(.+?),*$/,1]
+              end
+
+              private
+              
+              def check_numeric(number)
+                raise ArgumentError, number.inspect + " is not numeric!" unless number.to_s =~ /^\d+$/
+              end
+
+            end
+          end
+          
+          class EmailDefinition < AsteriskConfigGenerator
+            EMAIL_VARIABLE_CONVENIENCES = {
+              :name             => '${VM_NAME}',
+              :duration         => '${VM_DUR}',
+              :message_number   => '${VM_MSGNUM}',
+              :mailbox          => '${VM_MAILBOX}',
+              :caller_id        => '${VM_CALLERID}',
+              :date             => '${VM_DATE}',
+              :caller_id_number => '${VM_CIDNUM}',
+              :caller_id_name   => '${VM_CIDNAME}'
+            }
+            
+            attr_reader :properties
+            def initialize
+              @properties = {}
+              super
+            end
+            
+            def [](email_variable)
+              if EMAIL_VARIABLE_CONVENIENCES.has_key? email_variable
+                EMAIL_VARIABLE_CONVENIENCES[email_variable]
+              else
+                raise ArgumentError, "Unrecognized variable #{email_variable.inspect}"
+              end
+            end
+            
+            def disable!
+              raise NotImpementedError
+            end
+            
+            def from(options)
+              name, email = options.values_at :name, :email
+              string :serveremail => email
+              string :fromstring  => name
+            end
+            
+            def attach_recordings(true_or_false)
+              boolean :attach => true_or_false
+            end
+            
+            def attach_recordings?
+              properties[:attach] == 'yes'
+            end
+            
+            def body(str)
+              str = str.gsub("\r", '').gsub("\n", '\n')
+              if str.length > 512
+                raise ArgumentError, "Asterisk has an email body limit of 512 characters! Your body is too long!\n" +
+                ("-" * 10) + "\n" + str
+              end
+              string :emailbody => str
+            end
+            
+            def subject(str)
+              string :emailsubject => str
+            end
+            
+            def command(cmd)
+              string :mailcmd => cmd
+            end
+            
+          end
+          
+          class RecordingDefinition < AsteriskConfigGenerator
+            
+            attr_reader :properties
+            def initialize
+              @properties = {}
+              super
+            end
+            
+            def format(symbol)
+              one_of [:gsm, :wav49, :wav], :format => symbol
+            end
+            
+            def allowed_length(seconds)
+              case seconds
+                when Fixnum
+                  int :maxmessage => "value"
+                when Range
+                  int :minmessage => seconds.first
+                  int :maxmessage => seconds.last
+                else
+                  raise ArgumentError, "Argument must be a Fixnum or Range!"
+              end
+            end
+            
+            def maximum_silence(seconds)
+              int :maxsilence => seconds
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/asterisk/config_manager.rb

@@ -0,0 +1,71 @@
+require 'enumerator'
+module Adhearsion
+  module VoIP
+    module Asterisk
+      class ConfigurationManager
+        
+        class << self
+          def normalize_configuration(file_contents)
+            # cat sip.conf | sed -e 's/\s*;.*$//g' | sed -e '/^;.*$/d' | sed -e '/^\s*$/d'
+            file_contents.split(/\n+/).map do |line|
+              line.sub(/;.+$/, '').strip
+            end.join("\n").squeeze("\n")
+          end
+        end
+        
+        attr_reader :filename
+        
+        def initialize(filename)
+          @filename = filename
+        end
+        
+        def sections
+          @sections ||= read_configuration
+        end
+        
+        def [](section_name)
+          result = sections.find { |(name, *rest)| section_name == name }
+          result.last if result
+        end
+        
+        def delete_section(section_name)
+          sections.reject! { |(name, *rest)| section_name == name }
+        end
+        
+        def new_section(name, properties={})
+          sections << [name, properties]
+        end
+        
+        private
+        
+        def read_configuration
+          normalized_file = self.class.normalize_configuration execute(read_command)
+          normalized_file.split(/^\[([-_\w]+)\]$/)[1..-1].enum_slice(2).map do |(name,properties)|
+            [name, hash_from_properties(properties)]
+          end
+        end
+        
+        def hash_from_properties(properties)
+          properties.split(/\n+/).inject({}) do |property_hash,property|
+            all, name, value = *property.match(/^\s*([^=]+?)\s*=\s*(.+)\s*$/)
+            next property_hash unless name && value
+            property_hash[name] = value
+            property_hash
+          end
+        end
+        
+        def execute(command)
+          %x[command]
+        end
+        
+        def read_command
+          "cat #{filename}"
+        end
+        
+      end
+    end
+  end
+end
+
+# Read a file: cat a file
+# Parse a file: separate into a two dimensional hash

data/lib/adhearsion/voip/asterisk/special_dial_plan_managers.rb

@@ -0,0 +1,80 @@
+module Adhearsion
+  class DialPlan
+    class ConfirmationManager
+      
+      class << self
+          
+        def encode_hash_for_dial_macro_argument(options)
+          options    = options.clone
+          macro_name = options.delete :macro
+          options[:play] &&= options[:play].kind_of?(Array) ? options[:play].join('++') : options[:play]
+          encoded_options = URI.escape options.map { |key,value| "#{key}:#{value}" }.join('!')
+          returning "M(#{macro_name}^#{encoded_options})" do |str|
+            if str.rindex('^') != str.index('^')
+              raise ArgumentError, "You seem to have supplied a :confirm option with a caret (^) in it!" + 
+                                   " Please remove it. This will blow Asterisk up."
+            end
+          end
+        end
+        
+        def handle(call)
+          new(call).handle
+        end
+        
+        def confirmation_call?(call)
+          call.variables.has_key?(:network_script) && call.variables[:network_script].starts_with?('confirm!')
+        end
+                
+        def decode_hash(encoded_hash)
+          encoded_hash = encoded_hash =~ /^M\((.+)\)$/ ? $1 : encoded_hash
+          encoded_hash = encoded_hash =~ /^([^:]+\^)?(.+)$/ ? $2 : encoded_hash # Remove the macro name if it's there
+          unencoded = URI.unescape(encoded_hash).split('!')
+          unencoded.shift unless unencoded.first.include?(':')
+          unencoded = unencoded.map { |pair| key, value = pair.split(':'); [key.to_sym ,value] }.flatten
+          returning Hash[*unencoded] do |hash|
+            hash[:timeout]    &&= hash[:timeout].to_i
+            hash[:play]       &&= hash[:play].split('++')
+          end
+        end
+
+      end
+      
+      attr_reader :call
+      def initialize(call)
+        @call = call
+        extend Adhearsion::VoIP::Commands.for(call.originating_voip_platform)
+      end
+      
+      def handle
+        variables = self.class.decode_hash call.variables[:network_script]
+        
+        answer
+        loop do
+          response = interruptable_play(*variables[:play])
+          if response && response.to_s == variables[:key].to_s
+            # Don't set a variable to pass through to dial()
+            break
+          elsif response && response.to_s != variables[:key].to_s
+            next
+          else
+            response = wait_for_digit variables[:timeout]
+            if response 
+              if response.to_s == variables[:key].to_s
+                # Don't set a variable to pass through to dial()
+                break
+              else
+                next
+              end
+            else
+              # By setting MACRO_RESULT to CONTINUE, we cancel the dial.
+              variable 'MACRO_RESULT' => "CONTINUE"
+              break
+            end
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/adhearsion/voip/call.rb

@@ -0,0 +1,436 @@
+require 'uri'
+#TODO Some of this is asterisk-specific
+module Adhearsion
+  class << self
+    def active_calls
+      @calls ||= Calls.new
+    end
+  
+    def receive_call_from(io, &block)
+      active_calls << (call = Call.receive_from(io, &block))
+      call
+    end
+    
+    def remove_inactive_call(call)
+      active_calls.remove_inactive_call(call)
+    end
+  end
+  
+  ##
+  # This manages the list of calls the Adhearsion service receives
+  class Calls
+    def initialize
+      @semaphore = Monitor.new
+      @calls     = {}
+    end
+    
+    def <<(call)
+      atomically do
+        calls[call.unique_identifier] = call
+      end
+    end
+    
+    def any?
+      atomically do
+        !calls.empty?
+      end
+    end
+    
+    def size
+      atomically do
+        calls.size
+      end
+    end
+    
+    def remove_inactive_call(call)
+      atomically do
+        calls.delete call.unique_identifier
+      end
+    end
+    
+    # Searches all active calls by their unique_identifier. See Call#unique_identifier.
+    def find(id)
+      atomically do
+        return calls[id]
+      end
+    end
+    
+    def clear!
+      atomically do
+        calls.clear
+      end
+    end
+    
+    def with_tag(tag)
+      atomically do
+        calls.inject(Array.new) do |calls_with_tag,(key,call)|
+          call.tagged_with?(tag) ? calls_with_tag << call : calls_with_tag
+        end
+      end
+    end
+    
+    private
+      attr_reader :semaphore, :calls
+      
+      def atomically(&block)
+        semaphore.synchronize(&block)
+      end
+      
+  end
+  
+  class UselessCallException < Exception; end
+  
+  class MetaAgiCallException < Exception
+    attr_reader :call
+    def initialize(call)
+      super()
+      @call = call
+    end
+  end
+  
+  class FailedExtensionCallException < MetaAgiCallException; end
+  
+  class HungupExtensionCallException < MetaAgiCallException; end
+  
+  ##
+  # Encapsulates call-related data and behavior.
+  # For example, variables passed in on call initiation are
+  # accessible here as attributes    
+  class Call
+    
+    # This is basically a translation of ast_channel_reason2str() from main/channel.c and
+    # ast_control_frame_type in include/asterisk/frame.h in the Asterisk source code. When
+    # Asterisk jumps to the 'failed' extension, it sets a REASON channel variable to a number.
+    # The indexes of these symbols represent the possible numbers REASON could be.
+    ASTERISK_FRAME_STATES = [
+      :failure,     # "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)"
+      :hangup,      # Other end has hungup
+      :ring,        # Local ring
+      :ringing,     # Remote end is ringing
+      :answer,      # Remote end has answered
+      :busy,        # Remote end is busy
+      :takeoffhook, # Make it go off hook
+      :offhook,     # Line is off hook
+      :congestion,  # Congestion (circuits busy)
+      :flash,       # Flash hook
+      :wink,        # Wink
+      :option,      # Set a low-level option
+      :radio_key,   # Key Radio
+      :radio_unkey, # Un-Key Radio
+      :progress,    # Indicate PROGRESS
+      :proceeding,  # Indicate CALL PROCEEDING
+      :hold,        # Indicate call is placed on hold
+      :unhold,      # Indicate call is left from hold
+      :vidupdate    # Indicate video frame update
+    ]
+    
+    
+    class << self
+      ##
+      # The primary public interface for creating a Call instance.
+      # Given an IO (probably a socket accepted from an Asterisk service),
+      # creates a Call instance which encapsulates everything we know about that call.
+      def receive_from(io, &block)
+        returning new(io, variable_parser_for(io).variables) do |call|
+          block.call(call) if block
+        end
+      end
+    
+      private
+      def variable_parser_for(io)
+        Variables::Parser.parse(io)
+      end
+      
+    end
+    
+    attr_accessor :io, :type, :variables, :originating_voip_platform, :inbox
+    def initialize(io, variables)
+      @io, @variables = io, variables.symbolize_keys
+      check_if_valid_call
+      define_variable_accessors
+      set_originating_voip_platform!
+      @tag_mutex = Mutex.new
+      @tags = []
+    end
+
+    def tags
+      @tag_mutex.synchronize do
+        return @tags.clone
+      end
+    end
+
+    def tag(symbol)
+      raise ArgumentError, "tag must be a Symbol" unless symbol.is_a? Symbol
+      @tag_mutex.synchronize do
+        @tags << symbol
+      end
+    end
+    
+    def remove_tag(symbol)
+      @tag_mutex.synchronize do
+        @tags.reject! { |tag| tag == symbol }
+      end
+    end
+    
+    def tagged_with?(symbol)
+      @tag_mutex.synchronize do
+        @tags.include? symbol
+      end
+    end
+
+    def deliver_message(message)
+      inbox << message
+    end
+    alias << deliver_message
+
+    def inbox
+      @inbox ||= Queue.new
+    end
+
+    def hangup!
+      io.close
+      Adhearsion.remove_inactive_call self
+    end
+
+    def closed?
+      io.closed?
+    end
+    
+    # Asterisk sometimes uses the "failed" extension to indicate a failed dial attempt.
+    # Since it may be important to handle these, this flag helps the dialplan Manager
+    # figure that out.
+    def failed_call?
+      @failed_call
+    end
+    
+    def hungup_call?
+      @hungup_call
+    end
+    
+    # Adhearsion indexes calls by this identifier so they may later be found and manipulated. For calls from Asterisk, this
+    # method uses the following properties for uniqueness, falling back to the next if one is for some reason unavailable:
+    #
+    #     Asterisk channel ID     ->        unique ID        -> Call#object_id
+    # (e.g. SIP/mytrunk-jb12c88a) -> (e.g. 1215039989.47033) -> (e.g. 2792080)
+    #
+    # Note: channel is used over unique ID because channel may be used to bridge two channels together.
+    def unique_identifier
+      case originating_voip_platform
+        when :asterisk
+          variables[:channel] || variables[:uniqueid] || object_id
+        else
+          raise NotImplementedError
+      end
+    end
+    
+    def define_variable_accessors(recipient=self)
+      variables.each do |key, value| 
+        define_singleton_accessor_with_pair(key, value, recipient)
+      end
+    end
+    
+    def extract_failed_reason_from(environment)
+      if originating_voip_platform == :asterisk
+        failed_reason = environment.variable 'REASON'
+        failed_reason &&= ASTERISK_FRAME_STATES[failed_reason.to_i]
+        define_singleton_accessor_with_pair(:failed_reason, failed_reason, environment)
+      end
+    end
+    
+    private
+      
+      def define_singleton_accessor_with_pair(key, value, recipient=self)
+        recipient.metaclass.send :attr_accessor, key unless recipient.class.respond_to?("#{key}=")
+        recipient.send "#{key}=", value
+      end
+      
+      def check_if_valid_call
+        extension = variables[:extension]
+        @failed_call = true if extension == 'failed'
+        @hungup_call = true if extension == 'h'
+        raise UselessCallException if extension == 't' # TODO: Move this whole method to Manager
+      end
+    
+      def set_originating_voip_platform!
+        # TODO: we can make this determination programatically at some point,
+        # but it will probably involve a bit more engineering than just a case statement (like
+        # subclasses of Call for the various platforms), so we'll be totally cheap for now.
+        self.originating_voip_platform = :asterisk
+      end
+    
+    module Variables
+      
+      module Coercions
+
+        COERCION_ORDER = %w{
+          remove_agi_prefixes_from_keys_and_strip_whitespace
+          coerce_keys_into_symbols
+          coerce_extension_into_phone_number_object
+          coerce_numerical_values_to_numerics
+          replace_unknown_values_with_nil
+          replace_yes_no_answers_with_booleans
+          coerce_request_into_uri_object
+          decompose_uri_query_into_hash
+          override_variables_with_query_params
+          remove_dashes_from_context_name
+          coerce_type_of_number_into_symbol
+        }
+
+        class << self
+          
+          def remove_agi_prefixes_from_keys_and_strip_whitespace(variables)
+            variables.inject({}) do |new_variables,(key,value)|
+              returning new_variables do
+                stripped_name = key.kind_of?(String) ? key[/^(agi_)?(.+)$/,2] : key
+                new_variables[stripped_name] = value.kind_of?(String) ? value.strip : value
+              end
+            end
+          end
+          
+          def coerce_keys_into_symbols(variables)
+            variables.inject({}) do |new_variables,(key,value)|
+              returning new_variables do
+                new_variables[key.to_sym] = value
+              end
+            end
+          end
+          
+          def coerce_extension_into_phone_number_object(variables)
+            returning variables do
+              variables[:extension] = Adhearsion::VoIP::DSL::PhoneNumber.new(variables[:extension])
+            end
+          end
+          
+          def coerce_numerical_values_to_numerics(variables)
+            variables.inject({}) do |vars,(key,value)|
+              returning vars do
+                is_numeric = value =~ /^-?\d+(?:(\.)\d+)?$/
+                is_float   = $1
+                vars[key] = if is_numeric
+                  if Adhearsion::VoIP::DSL::NumericalString.starts_with_leading_zero?(value)
+                    Adhearsion::VoIP::DSL::NumericalString.new(value)
+                  else
+                    is_float ? value.to_f : value.to_i
+                  end
+                else
+                  value
+                end
+              end
+            end
+          end
+
+          def replace_unknown_values_with_nil(variables)
+            variables.each do |key,value|
+              variables[key] = nil if value == 'unknown'
+            end
+          end
+
+          def replace_yes_no_answers_with_booleans(variables)
+            variables.each do |key,value|
+              case value
+                when 'yes' : variables[key] = true
+                when 'no'  : variables[key] = false
+              end
+            end
+          end
+          
+          def coerce_request_into_uri_object(variables)
+            returning variables do
+              variables[:request] = URI.parse(variables[:request]) unless variables[:request].kind_of? URI
+            end
+          end
+          
+          def coerce_type_of_number_into_symbol(variables)
+            returning variables do
+              variables[:type_of_calling_number] = Adhearsion::VoIP::Constants::Q931_TYPE_OF_NUMBER[variables.delete(:callington).to_i]
+            end
+          end
+
+          def decompose_uri_query_into_hash(variables)
+            returning variables do
+              if variables[:request].query
+                variables[:query] = variables[:request].query.split('&').inject({}) do |query_string_parameters, key_value_pair|
+                  parameter_name, parameter_value = *key_value_pair.match(/(.+)=(.+)/).captures
+                  query_string_parameters[parameter_name] = parameter_value
+                  query_string_parameters
+                end
+              else
+                variables[:query] = {}
+              end
+            end
+          end
+          
+          def override_variables_with_query_params(variables)
+            returning variables do
+              if variables[:query]
+                variables[:query].each do |key, value|
+                  variables[key.to_sym] = value
+                end
+              end
+            end
+          end
+          
+          def remove_dashes_from_context_name(variables)
+            returning variables do
+              variables[:context].gsub!('-', '_')
+            end
+          end
+          
+        end
+      end
+
+      class Parser
+        
+        class << self
+          def parse(*args, &block)
+            returning new(*args, &block) do |parser|
+              parser.parse
+            end
+          end
+          
+          def coerce_variables(variables)
+            Coercions::COERCION_ORDER.inject(variables) do |tmp_variables, coercing_method_name|
+              Coercions.send(coercing_method_name, tmp_variables)
+            end
+          end
+          
+          def separate_line_into_key_value_pair(line)
+            line.match(/^([^:]+):\s?(.+)/).captures
+          end
+        end
+      
+        attr_reader :io, :variables, :lines
+        def initialize(io)
+          @io = io
+          @lines = []
+        end
+      
+        def parse
+          extract_variable_lines_from_io
+          initialize_variables_as_hash_from_lines
+          @variables = self.class.coerce_variables(variables)
+        end
+        
+        private
+          
+          def initialize_variables_as_hash_from_lines
+            @variables = lines.inject({}) do |new_variables,line|
+              returning new_variables do
+                key, value = self.class.separate_line_into_key_value_pair line
+                new_variables[key] = value
+              end
+            end
+          end
+          
+          def extract_variable_lines_from_io
+            while line = io.readline.chomp
+              break if line.empty?
+              @lines << line
+            end
+          end
+        
+      end
+    
+    end
+  end  
+end