punchblock 0.6.1 → 0.6.2

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # develop
 
+# v0.6.2
+  # Feature: Added basic support for running Punchblock apps on Asterisk. Calls coming in to AsyncAGI result in the client receiving an Offer, hangup events are sent, and accept/answer/hangup commands work.
+  # API change: The logger is now set using Punchblock.logger= rather than as a hash key to Connection.new
+
 # v0.6.1
   * Feature: Allow instructing the connection we are ready. An XMPP connection will send initial presence with a status of 'chat' to the rayo domain
   * Bugfix: When running on Asterisk, two FullyBooted events will now trigger a connected event

data/lib/punchblock.rb

@@ -4,21 +4,9 @@
   active_support/core_ext/module/delegation
   future-resource
   has_guarded_handlers
+  punchblock/core_ext/ruby
 }.each { |l| require l }
 
-class Hash
-  def select(&block)
-    val = super(&block)
-    if val.is_a?(Array)
-      val = val.inject({}) do |accumulator, element|
-        accumulator[element[0]] = element[1]
-        accumulator
-      end
-    end
-    val
-  end
-end
-
 module Punchblock
   extend ActiveSupport::Autoload
 
@@ -36,6 +24,20 @@ module Punchblock
   autoload :RayoNode
   autoload :Translator
 
+  class << self
+    def logger
+      @logger || reset_logger
+    end
+
+    def logger=(other)
+      @logger = other
+    end
+
+    def reset_logger
+      @logger = NullObject.new
+    end
+  end
+
   ##
   # This exception may be raised if a transport error is detected.
   TransportError = Class.new StandardError

data/lib/punchblock/client.rb

@@ -50,6 +50,7 @@ module Punchblock
     end
 
     def execute_command(command, options = {})
+      pb_logger.debug "Executing command: #{command.inspect} with options #{options.inspect}"
       async = options.has_key?(:async) ? options.delete(:async) : true
       command.client = self
       if command.respond_to?(:register_event_handler)

data/lib/punchblock/component.rb

@@ -46,7 +46,7 @@ module Punchblock
       def response=(other)
         if other.is_a?(Ref)
           @component_id = other.id
-          client.register_component self
+          client.register_component self if client
         end
         super
       end

data/lib/punchblock/connection/asterisk.rb

@@ -7,13 +7,13 @@ module Punchblock
       attr_accessor :event_handler
 
       def initialize(options = {})
-        options[:logger] = options[:wire_logger]
-        @ami_client = RubyAMI::Client.new options.merge(:event_handler => lambda { |event| translator.handle_ami_event! event })
+        @ami_client = RubyAMI::Client.new options.merge(:event_handler => lambda { |event| translator.handle_ami_event! event }, :logger => pb_logger)
         @translator = Translator::Asterisk.new @ami_client, self
         super()
       end
 
       def run
+        logger.debug "Starting the RubyAMI client"
         ami_client.start
       end
 

data/lib/punchblock/connection/xmpp.rb

@@ -18,7 +18,6 @@ module Punchblock
       # @option options [String] :username client JID
       # @option options [String] :password XMPP password
       # @option options [String] :rayo_domain the domain on which Rayo is running
-      # @option options [Logger] :wire_logger to which all XMPP transactions will be logged
       # @option options [Boolean, Optional] :auto_reconnect whether or not to auto reconnect
       # @option options [Numeric, Optional] :write_timeout for which to wait on a command response
       # @option options [Numeric, nil, Optional] :ping_period interval in seconds on which to ping the server. Nil or false to disable
@@ -37,7 +36,7 @@ module Punchblock
 
         @ping_period = options.has_key?(:ping_period) ? options[:ping_period] : 60
 
-        Blather.logger = options.delete(:wire_logger) if options.has_key?(:wire_logger)
+        Blather.logger = pb_logger
 
         super()
       end
@@ -61,7 +60,7 @@ module Punchblock
         jid = command.is_a?(Command::Dial) ? @rayo_domain : "#{call_id}@#{@callmap[call_id]}"
         jid << "/#{component_id}" if component_id
         create_iq(jid).tap do |iq|
-          @logger.debug "Sending IQ ID #{iq.id} #{command.inspect} to #{jid}" if @logger
+          pb_logger.debug "Sending IQ ID #{iq.id} #{command.inspect} to #{jid}"
           iq << command
         end
       end
@@ -102,9 +101,9 @@ module Punchblock
 
       def handle_presence(p)
         throw :pass unless p.rayo_event?
-        @logger.info "Receiving event for call ID #{p.call_id}" if @logger
+        pb_logger.info "Receiving event for call ID #{p.call_id}"
         @callmap[p.call_id] = p.from.domain
-        @logger.debug p.inspect if @logger
+        pb_logger.debug p.inspect
         event = p.event
         event.connection = self
         event.domain = p.from.domain
@@ -114,7 +113,7 @@ module Punchblock
       def handle_iq_result(iq, command)
         # FIXME: Do we need to raise a warning if the domain changes?
         @callmap[iq.from.node] = iq.from.domain
-        @logger.debug "Command #{iq.id} completed successfully" if @logger
+        pb_logger.debug "Command #{iq.id} completed successfully"
         command.response = iq.rayo_node.is_a?(Ref) ? iq.rayo_node : true
       end
 
@@ -128,7 +127,7 @@ module Punchblock
         # Push a message to the queue and the log that we connected
         when_ready do
           event_handler.call Connected.new
-          @logger.info "Connected to XMPP as #{@username}" if @logger
+          pb_logger.info "Connected to XMPP as #{@username}"
           @reconnect_attempts = 0
           @rayo_ping = EM::PeriodicTimer.new(@ping_period) { ping_rayo } if @ping_period
         end
@@ -137,9 +136,9 @@ module Punchblock
           @rayo_ping.cancel if @rayo_ping
           if @auto_reconnect && @reconnect_attempts
             timer = 30 * 2 ** @reconnect_attempts
-            @logger.warn "XMPP disconnected. Tried to reconnect #{@reconnect_attempts} times. Reconnecting in #{timer}s." if @logger
+            pb_logger.warn "XMPP disconnected. Tried to reconnect #{@reconnect_attempts} times. Reconnecting in #{timer}s."
             sleep timer
-            @logger.info "Trying to reconnect..." if @logger
+            pb_logger.info "Trying to reconnect..."
             @reconnect_attempts += 1
             connect
           end

data/lib/punchblock/core_ext/ruby.rb

@@ -0,0 +1,24 @@
+class Hash
+  def select(&block)
+    val = super(&block)
+    if val.is_a?(Array)
+      val = val.inject({}) do |accumulator, element|
+        accumulator[element[0]] = element[1]
+        accumulator
+      end
+    end
+    val
+  end
+end
+
+class NullObject
+  def method_missing(*args)
+    self
+  end
+end
+
+class Object
+  def pb_logger
+    Punchblock.logger
+  end
+end

data/lib/punchblock/has_headers.rb

@@ -30,5 +30,9 @@ module Punchblock
         [headers].flatten.each { |i| self << Header.new(i) }
       end
     end
+
+    def inspect_attributes # :nodoc:
+      [:headers_hash] + super
+    end
   end
 end

data/lib/punchblock/translator/asterisk.rb

@@ -9,19 +9,20 @@ module Punchblock
 
       extend ActiveSupport::Autoload
 
-      autoload :AMIAction
       autoload :Call
       autoload :Component
 
-      attr_reader :ami_client, :connection
+      attr_reader :ami_client, :connection, :calls
 
       def initialize(ami_client, connection)
+        pb_logger.debug "Starting up..."
         @ami_client, @connection = ami_client, connection
-        @calls, @components = {}, {}
+        @calls, @components, @channel_to_call_id = {}, {}, {}
         @fully_booted_count = 0
       end
 
       def register_call(call)
+        @channel_to_call_id[call.channel] = call.id
         @calls[call.id] ||= call
       end
 
@@ -29,6 +30,10 @@ module Punchblock
         @calls[call_id]
       end
 
+      def call_for_channel(channel)
+        call_with_id @channel_to_call_id[channel]
+      end
+
       def register_component(component)
         @components[component.id] ||= component
       end
@@ -39,18 +44,32 @@ module Punchblock
 
       def handle_ami_event(event)
         return unless event.is_a? RubyAMI::Event
+        pb_logger.trace "Handling AMI event #{event.inspect}"
         if event.name.downcase == "fullybooted"
+          pb_logger.trace "Counting FullyBooted event"
           @fully_booted_count += 1
           if @fully_booted_count >= 2
-            connection.handle_event Connection::Connected.new
+            handle_pb_event Connection::Connected.new
             @fully_booted_count = 0
           end
-        else
-          connection.handle_event Event::Asterisk::AMI::Event.new(:name => event.name, :attributes => event.headers)
+          return
         end
+        if event.name.downcase == "asyncagi" && event['SubEvent'] == "Start"
+          handle_async_agi_start_event event
+        end
+        if call = call_for_channel(event['Channel'])
+          pb_logger.trace "Found call by channel matching this event. Sending to call #{call.id}"
+          call.process_ami_event! event
+        end
+        handle_pb_event Event::Asterisk::AMI::Event.new(:name => event.name, :attributes => event.headers)
+      end
+
+      def handle_pb_event(event)
+        connection.handle_event event
       end
 
       def execute_command(command, options = {})
+        pb_logger.debug "Executing command #{command.inspect}"
         command.request!
         if command.call_id || options[:call_id]
           command.call_id ||= options[:call_id]
@@ -66,18 +85,30 @@ module Punchblock
       end
 
       def execute_call_command(command)
-        call_with_id(command.call_id).execute_command command
+        call_with_id(command.call_id).execute_command! command
       end
 
       def execute_component_command(command)
-        call_with_id(command.call_id).execute_component_command command
+        call_with_id(command.call_id).execute_component_command! command
       end
 
       def execute_global_command(command)
-        component = AMIAction.new command, ami_client
+        component = Component::Asterisk::AMIAction.new command, current_actor
         # register_component component
         component.execute!
       end
+
+      def send_ami_action(name, headers = {}, &block)
+        ami_client.send_action name, headers, &block
+      end
+
+      private
+
+      def handle_async_agi_start_event(event)
+        call = Call.new event['Channel'], current_actor, event['Env']
+        register_call call
+        call.send_offer!
+      end
     end
   end
 end

data/lib/punchblock/translator/asterisk/call.rb

@@ -1,11 +1,18 @@
+require 'uri'
+
 module Punchblock
   module Translator
     class Asterisk
       class Call
         include Celluloid
 
-        def initialize
-          @components = {}
+        attr_reader :id, :channel, :translator, :agi_env
+
+        def initialize(channel, translator, agi_env = '')
+          @channel, @translator = channel, translator
+          @agi_env = parse_environment agi_env
+          @id, @components = UUIDTools::UUID.random_create.to_s, {}
+          pb_logger.debug "Starting up call with channel #{channel}, id #{@id}"
         end
 
         def register_component(component)
@@ -17,7 +24,104 @@ module Punchblock
         end
 
         def execute_component_command(command)
-          component_with_id(command.component_id).execute_command command
+          component_with_id(command.component_id).execute_command! command
+        end
+
+        def send_offer
+          send_pb_event offer_event
+        end
+
+        def process_ami_event(ami_event)
+          pb_logger.trace "Processing AMI event #{ami_event.inspect}"
+          case ami_event.name
+          when 'Hangup'
+            pb_logger.debug "Received a Hangup AMI event. Sending End event."
+            send_pb_event Event::End.new(:reason => :hangup)
+          when 'AsyncAGI'
+            pb_logger.debug "Received an AsyncAGI event. Looking for matching AGICommand component."
+            if component = component_with_id(ami_event['CommandID'])
+              pb_logger.debug "Found component #{component.id} for event. Forwarding event..."
+              component.handle_ami_event! ami_event
+            end
+          end
+        end
+
+        def execute_command(command)
+          pb_logger.debug "Executing command: #{command.inspect}"
+          case command
+          when Command::Accept
+            send_agi_action 'EXEC RINGING' do |response|
+              command.response = true
+            end
+          when Command::Answer
+            send_agi_action 'EXEC ANSWER' do |response|
+              command.response = true
+            end
+          when Command::Hangup
+            send_ami_action 'Hangup', 'Channel' => channel do |response|
+              command.response = true
+            end
+          when Punchblock::Component::Asterisk::AGI::Command
+            execute_agi_command command
+          end
+        end
+
+        def send_agi_action(command, &block)
+          pb_logger.debug "Sending AGI action #{command}"
+          @current_agi_command = Punchblock::Component::Asterisk::AGI::Command.new :name => command, :call_id => id
+          @current_agi_command.request!
+          @current_agi_command.register_event_handler Punchblock::Event::Complete do |e|
+            pb_logger.debug "AGI action received complete event #{e.inspect}"
+            block.call e
+          end
+          execute_agi_command @current_agi_command
+        end
+
+        def send_ami_action(name, headers = {}, &block)
+          (name.is_a?(RubyAMI::Action) ? name : RubyAMI::Action.new(name, headers, &block)).tap do |action|
+            @current_ami_action = action
+            pb_logger.debug "Sending AMI action #{action.inspect}"
+            translator.send_ami_action! action
+          end
+        end
+
+        private
+
+        def execute_agi_command(command)
+          Component::Asterisk::AGICommand.new(command, current_actor).tap do |component|
+            register_component component
+            component.execute!
+          end
+        end
+
+        def send_pb_event(event)
+          event.call_id = id
+          pb_logger.debug "Sending Punchblock event: #{event.inspect}"
+          translator.handle_pb_event! event
+        end
+
+        def offer_event
+          Event::Offer.new :to      => agi_env[:agi_dnid],
+                           :from    => [agi_env[:agi_type].downcase, agi_env[:agi_callerid]].join(':'),
+                           :headers => sip_headers
+        end
+
+        def sip_headers
+          agi_env.to_a.inject({}) do |accumulator, element|
+            accumulator[('x_' + element[0].to_s).to_sym] = element[1] || ''
+            accumulator
+          end
+        end
+
+        def parse_environment(agi_env)
+          agi_env_as_array(agi_env).inject({}) do |accumulator, element|
+            accumulator[element[0].to_sym] = element[1] || ''
+            accumulator
+          end
+        end
+
+        def agi_env_as_array(agi_env)
+          URI.unescape(agi_env).encode.split("\n").map { |p| p.split ': ' }
         end
       end
     end

data/lib/punchblock/translator/asterisk/component.rb

@@ -1,10 +1,16 @@
 module Punchblock
   module Translator
     class Asterisk
-      class Component
-        include Celluloid
+      module Component
+        extend ActiveSupport::Autoload
 
-        attr_reader :id
+        autoload :Asterisk
+
+        class Component
+          include Celluloid
+
+          attr_reader :id
+        end
       end
     end
   end

data/lib/punchblock/translator/asterisk/component/asterisk.rb

@@ -0,0 +1,14 @@
+module Punchblock
+  module Translator
+    class Asterisk
+      module Component
+        module Asterisk
+          extend ActiveSupport::Autoload
+
+          autoload :AGICommand
+          autoload :AMIAction
+        end
+      end
+    end
+  end
+end