adhearsion 2.6.4 → 3.0.0.beta1

data/lib/adhearsion/rayo/ref.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'ruby_jid'
+
+module Adhearsion
+  module Rayo
+    ##
+    # A rayo Ref message. This provides the command ID in response to execution of a command.
+    #
+    class Ref < RayoNode
+      register :ref, :core
+
+      # @return [String] the command URI
+      attribute :uri
+      def uri=(other)
+        super URI(other)
+      end
+
+      def scheme
+        uri.scheme
+      end
+
+      def call_id
+        case scheme
+        when 'xmpp'
+          RubyJID.new(uri.opaque).node
+        when nil
+          uri.path
+        else
+          uri.opaque
+        end
+      end
+
+      def domain
+        case scheme
+        when 'xmpp'
+          RubyJID.new(uri.opaque).domain
+        end
+      end
+
+      def component_id
+        case scheme
+        when 'xmpp'
+          RubyJID.new(uri.opaque).resource
+        else
+          call_id
+        end
+      end
+
+      def rayo_attributes
+        {}.tap do |atts|
+          atts[:uri] = uri if uri
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/statistics.rb

@@ -8,7 +8,7 @@ module Adhearsion
 
     # @private
     def self.setup_event_handlers
-      Events.punchblock(Punchblock::Event::Offer) do
+      Events.rayo(Adhearsion::Event::Offer) do
         begin
           Celluloid::Actor[:statistics].register_call_offered
         ensure

data/lib/adhearsion/tasks.rb

@@ -12,13 +12,12 @@ initializer.load_lib_folder
 initializer.load_config_file
 initializer.load_events_file
 initializer.load_routes_file
-initializer.initialize_log_paths
 initializer.start_logging
 initializer.init_plugins
 
 Adhearsion::Plugin.load_tasks
 
-puts "\nAdhearsion configured environment: #{Adhearsion.config.platform.environment}\n" unless ARGV.empty?
+puts "\nAdhearsion configured environment: #{Adhearsion.environment}\n" unless ARGV.empty?
 
 desc "Dump useful information about this application's Adhearsion environment"
 task :about do

data/lib/adhearsion/tasks/configuration.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 namespace :config do
-  desc "Show configuration values; accepts a parameter: [nil|platform|<plugin-name>|all]"
+  desc "Show configuration values; accepts a parameter: [nil|core|<plugin-name>|all]"
   task :show, [:name] => [:environment] do |t, args|
     name = args.name.nil? ? :all : args.name.to_sym
     puts "\nAdhearsion.config do |config|\n\n"

data/lib/adhearsion/tasks/environment.rb

@@ -1,8 +1,6 @@
 # encoding: utf-8
 
 task :environment do
-  require 'adhearsion/punchblock_plugin'
-
   begin
     Adhearsion.config # load default config vlaues
     initializer = Adhearsion::Initializer.new

data/lib/adhearsion/tasks/i18n.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+namespace :i18n do
+  desc "Validate configured audio prompt files exist"
+  task :validate_files => :environment do
+    Adhearsion::Initializer.new.setup_i18n_load_path
+
+    config = Adhearsion.config.core.i18n
+    locale_files = Dir.glob(I18n.load_path)
+
+    locale_errors = {}
+    checked_prompts = 0
+    locale_files.each do |locale_file|
+      # We only support YAML for now
+      next unless locale_file =~ /\.ya?ml$/
+      prompts = YAML.load File.read(locale_file)
+
+      locale = prompts.keys.first
+      prompts = prompts[locale]
+
+      prompts.each_pair do |key, mapping|
+        logger.trace "Checking i18n key #{key}"
+        # Not all prompts will have audio files
+        next unless mapping['audio']
+
+        file = File.absolute_path "#{config['audio_path']}/#{locale}/#{mapping['audio']}"
+        unless File.exist?(file)
+          logger.warn "[#{locale}] Missing audio file: #{file}"
+          locale_errors[locale] ||= 0
+          locale_errors[locale] += 1
+        end
+        checked_prompts += 1
+      end
+    end
+
+    if checked_prompts == 0
+      logger.warn "No Adhearsion i18n prompts found. No files checked."
+    else
+      if locale_errors.keys.count > 0
+        logger.error "Errors detected! Number of errors by locale:"
+        locale_errors.each_pair do |locale, err_count|
+          logger.error "[#{locale}]: #{err_count} missing prompts"
+        end
+      else
+        logger.info "All configured prompt files successfully validated."
+      end
+    end
+  end
+end

data/lib/adhearsion/translator.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'adhearsion/error'
+
+module Adhearsion
+  module Translator
+    OptionError = Class.new Adhearsion::Error
+  end
+end
+
+require 'adhearsion/translator/asterisk'

data/lib/adhearsion/translator/asterisk.rb

@@ -0,0 +1,234 @@
+# encoding: utf-8
+
+require 'celluloid'
+require 'ruby_ami'
+
+require 'adhearsion/translator/asterisk/agi_command'
+require 'adhearsion/translator/asterisk/call'
+require 'adhearsion/translator/asterisk/channel'
+require 'adhearsion/translator/asterisk/component'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      include Celluloid
+
+      # Indicates that a command was executed against a channel which no longer exists
+      ChannelGoneError = Class.new Error
+
+      attr_reader :ami_client, :connection, :calls, :bridges
+
+      REDIRECT_CONTEXT = 'adhearsion-redirect'
+      REDIRECT_EXTENSION = '1'
+      REDIRECT_PRIORITY = '1'
+
+      EVENTS_ALLOWED_BRIDGED = %w{AGIExec AsyncAGI}
+
+      trap_exit :actor_died
+
+      # Set the AMI event filter to be applied to incoming AMI events. A truthy return value will send the event via Rayo to the client (Adhearsion).
+      #
+      # @param [#[<RubyAMI::Event>]] filter
+      #
+      # @example A lambda
+      #   Translator::Asterisk.event_filter = ->(event) { event.name == 'AsyncAGI' }
+      #
+      def self.event_filter=(filter)
+        @event_filter = filter
+      end
+
+      def self.event_passes_filter?(event)
+        @event_filter ? !!@event_filter[event] : true
+      end
+
+      event_filter = nil
+
+      def initialize(ami_client, connection)
+        @ami_client, @connection = ami_client, connection
+        @calls, @components, @channel_to_call_id, @bridges = {}, {}, {}, {}
+      end
+
+      def register_call(call)
+        @channel_to_call_id[call.channel] = call.id
+        @calls[call.id] ||= call
+      end
+
+      def deregister_call(id, channel)
+        @channel_to_call_id.delete channel
+        @calls.delete id
+      end
+
+      def call_with_id(call_id)
+        @calls[call_id]
+      end
+
+      def call_for_channel(channel)
+        call_with_id @channel_to_call_id[Channel.new(channel).name]
+      end
+
+      def register_component(component)
+        @components[component.id] ||= component
+      end
+
+      def component_with_id(component_id)
+        @components[component_id]
+      end
+
+      def handle_ami_event(event)
+        return unless event.is_a? RubyAMI::Event
+
+        if event.name == 'FullyBooted'
+          handle_pb_event Adhearsion::Rayo::Connection::Connected.new
+          run_at_fully_booted
+          return
+        end
+
+        handle_varset_ami_event event
+
+        ami_dispatch_to_or_create_call event
+        if !ami_event_known_call?(event) && self.class.event_passes_filter?(event)
+          handle_pb_event Adhearsion::Event::Asterisk::AMI.new(name: event.name, headers: event.headers)
+        end
+      end
+
+      def handle_pb_event(event)
+        connection.handle_event event
+      end
+
+      def send_message(call_id, domain, body, options = {})
+        call = call_with_id call_id
+        call.send_message body if call
+      end
+
+      def execute_command(command, options = {})
+        command.request!
+
+        command.target_call_id ||= options[:call_id]
+        command.component_id ||= options[:component_id]
+
+        if command.target_call_id
+          execute_call_command command
+        elsif command.component_id
+          execute_component_command command
+        else
+          execute_global_command command
+        end
+      end
+
+      def execute_call_command(command)
+        if call = call_with_id(command.target_call_id)
+          begin
+            call.execute_command command
+          rescue => e
+            deregister_call call.id, call.channel
+          end
+        else
+          command.response = Adhearsion::ProtocolError.new.setup :item_not_found, "Could not find a call with ID #{command.target_call_id}", command.target_call_id
+        end
+      end
+
+      def execute_component_command(command)
+        if (component = component_with_id(command.component_id))
+          component.execute_command command
+        else
+          command.response = Adhearsion::ProtocolError.new.setup :item_not_found, "Could not find a component with ID #{command.component_id}", command.target_call_id, command.component_id
+        end
+      end
+
+      def execute_global_command(command)
+        case command
+        when Adhearsion::Rayo::Component::Asterisk::AMI::Action
+          component = Component::Asterisk::AMIAction.new command, current_actor, ami_client
+          register_component component
+          component.execute
+        when Adhearsion::Rayo::Command::Dial
+          if call = call_with_id(command.uri)
+            command.response = Adhearsion::ProtocolError.new.setup(:conflict, 'Call ID already in use')
+          else
+            call = Call.new command.to, current_actor, ami_client, connection, nil, command.uri
+            register_call call
+            call.dial command
+          end
+        else
+          command.response = Adhearsion::ProtocolError.new.setup 'command-not-acceptable', "Did not understand command"
+        end
+      end
+
+      def run_at_fully_booted
+        send_ami_action 'Command', 'Command' => "dialplan add extension #{REDIRECT_EXTENSION},#{REDIRECT_PRIORITY},AGI,agi:async into #{REDIRECT_CONTEXT}"
+
+        result = send_ami_action 'Command', 'Command' => "dialplan show #{REDIRECT_CONTEXT}"
+        if result.text_body =~ /failed/
+          logger.error "Adhearsion failed to add the #{REDIRECT_EXTENSION} extension to the #{REDIRECT_CONTEXT} context. Please add a [#{REDIRECT_CONTEXT}] entry to your dialplan."
+        end
+
+        check_recording_directory
+      end
+
+      def check_recording_directory
+        logger.warn "Recordings directory #{Component::Record::RECORDING_BASE_PATH} does not exist. Recording might not work. This warning can be ignored if Adhearsion is running on a separate machine than Asterisk. See http://adhearsion.com/docs/call-controllers#recording" unless File.exists?(Component::Record::RECORDING_BASE_PATH)
+      end
+
+      def actor_died(actor, reason)
+        return unless reason
+        if id = @calls.key(actor)
+          @calls.delete id
+          end_event = Adhearsion::Event::End.new :target_call_id  => id,
+                                                 :reason          => :error
+          handle_pb_event end_event
+        end
+      end
+
+      private
+
+      def send_ami_action(name, headers = {})
+        ami_client.send_action name, headers
+      end
+
+      def handle_varset_ami_event(event)
+        return unless event.name == 'VarSet' && event['Variable'] == 'adhearsion_call_id' && (call = call_with_id event['Value'])
+
+        @channel_to_call_id.delete call.channel
+        call.channel = event['Channel']
+        register_call call
+      end
+
+      def ami_dispatch_to_or_create_call(event)
+        calls_for_event = channels_for_ami_event(event).inject({}) do |h, channel|
+          call = call_for_channel channel
+          h[channel] = call if call
+          h
+        end
+
+        if !calls_for_event.empty?
+          calls_for_event.each_pair do |channel, call|
+            next if channel.bridged? && !EVENTS_ALLOWED_BRIDGED.include?(event.name)
+            call.process_ami_event event
+          end
+        elsif event.name == "AsyncAGIStart" || (event.name == "AsyncAGI" && event['SubEvent'] == "Start")
+          handle_async_agi_start_event event
+        end
+      end
+
+      def channels_for_ami_event(event)
+        [event['Channel'], event['Channel1'], event['Channel2']].compact.map { |channel| Channel.new(channel) }
+      end
+
+      def ami_event_known_call?(event)
+        (event['Channel'] && call_for_channel(event['Channel'])) ||
+          (event['Channel1'] && call_for_channel(event['Channel1'])) ||
+          (event['Channel2'] && call_for_channel(event['Channel2']))
+      end
+
+      def handle_async_agi_start_event(event)
+        env = RubyAMI::AsyncAGIEnvironmentParser.new(event['Env']).to_hash
+
+        return if env[:agi_extension] == 'h' || env[:agi_type] == 'Kill'
+
+        call = Call.new event['Channel'], current_actor, ami_client, connection, env
+        register_call call
+        call.send_offer
+      end
+    end
+  end
+end

data/lib/adhearsion/translator/asterisk/agi_app.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      class AGIApp
+        def initialize(app, *args)
+          @app, @args = app, args
+        end
+
+        def execute(call)
+          call.execute_agi_command "EXEC #{@app}", @args.join(',')
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/translator/asterisk/agi_command.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'active_support/core_ext/string/filters'
+require 'adhearsion/translator/asterisk/ami_error_converter'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      class AGICommand
+        ARG_QUOTER = /["\\]/.freeze
+
+        attr_reader :id
+
+        def initialize(id, channel, command, *params)
+          @id, @channel, @command, @params = id, channel, command, params
+        end
+
+        # @raises RubyAMI::Error, ChannelGoneError
+        def execute(ami_client)
+          AMIErrorConverter.convert { ami_client.send_action 'AGI', 'Channel' => @channel, 'Command' => agi_command, 'CommandID' => id }
+        end
+
+        def parse_result(event)
+          parser = RubyAMI::AGIResultParser.new event['Result']
+          {code: parser.code, result: parser.result, data: parser.data}
+        rescue ArgumentError => e
+          logger.warn "Illegal message received from Asterisk: #{e.message}"
+          {code: -1, result: nil, data: nil}
+        end
+
+        private
+
+        def agi_command
+          "#{@command} #{@params.map { |arg| quote_arg(arg) }.join(' ')}".squish
+        end
+
+        # Arguments surrounded by quotes; quotes backslash-escaped.
+        # See parse_args in asterisk/res/res_agi.c (Asterisk 1.4.21.1)
+        def quote_arg(arg)
+          '"' + arg.to_s.gsub(ARG_QUOTER) { |m| "\\#{m}" } + '"'
+        end
+      end
+    end
+  end
+end