punchblock 0.4.3 → 0.5.0

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # develop
 
+# v0.5.0
+  * Refactoring/API change: Client and connection level concerns are now separated, and one must create a Connection to be passed to a Client on creation. Client now has the choice between an event queue and guarded event handlers.
+
 # v0.4.3
   * Feature: Support for meta-data on recordings (size & duration)
   * Feature: Allow specifying all of Blather's setup options (required to use PB as an XMPP component)

data/bin/punchblock-console

@@ -54,18 +54,19 @@ options[:transport_logger] = Logger.new options.delete(:transport_log_file)
 options[:transport_logger].level = Logger::DEBUG
 options[:transport_logger].debug "Starting up..."
 
-connection = Connection.new options
+connection = Connection::XMPP.new options
+client = Client.new :connection => connection
 
 [:INT, :TERM].each do |signal|
   trap signal do
     puts "Shutting down!"
-    connection.stop
+    client.stop
   end
 end
 
-connection_thread = Thread.new do
+client_thread = Thread.new do
   begin
-    connection.run
+    client.run
   rescue => e
     puts "Exception in XMPP thread! #{e.message}"
     puts e.backtrace.join("\t\n")
@@ -80,8 +81,8 @@ CALL_QUEUES = {}
 # the queue.
 Thread.new do
   loop do
-    event = connection.event_queue.pop
-    if event == connection.connected
+    event = client.event_queue.pop
+    if event == Connection::Connected
       puts event
       puts "Waiting for a call..."
       next
@@ -92,7 +93,7 @@ Thread.new do
       raise "Duplicate call ID for #{event.call_id}" if CALL_QUEUES.has_key?(event.call_id)
       CALL_QUEUES[event.call_id] = Queue.new
       CALL_QUEUES[event.call_id].push event
-      run_call connection, event
+      run_call client, event
     when Event
       CALL_QUEUES[event.call_id].push event
     else
@@ -101,14 +102,14 @@ Thread.new do
   end
 end
 
-def run_call(connection, offer)
+def run_call(client, offer)
   ### CALL THREAD
   # One thread is spun up to handle each call.
   Thread.new do
     raise "Unknown call #{offer.call_id}" unless CALL_QUEUES.has_key?(offer.call_id)
     queue = CALL_QUEUES[offer.call_id]
     call = queue.pop
-    dsl = DSL.new connection, offer.call_id, queue
+    dsl = DSL.new client, offer.call_id, queue
 
     puts "Incoming offer to #{offer.to} from #{offer.headers_hash[:from]} #{offer}"
     dsl.pry
@@ -118,4 +119,4 @@ def run_call(connection, offer)
   end
 end
 
-connection_thread.join
+client_thread.join

data/lib/punchblock.rb

@@ -1,6 +1,7 @@
 %w{
   active_support/dependencies/autoload
   active_support/core_ext/object/blank
+  active_support/core_ext/module/delegation
   future-resource
   has_guarded_handlers
 }.each { |l| require l }
@@ -21,12 +22,12 @@ end
 module Punchblock
   extend ActiveSupport::Autoload
 
+  autoload :Client
   autoload :Command
   autoload :CommandNode
   autoload :Component
   autoload :Connection
   autoload :DSL
-  autoload :GenericConnection
   autoload :HasHeaders
   autoload :Header
   autoload :MediaContainer

data/lib/punchblock/client.rb

@@ -0,0 +1,64 @@
+module Punchblock
+  class Client
+    extend ActiveSupport::Autoload
+
+    autoload :ComponentRegistry
+
+    include HasGuardedHandlers
+
+    attr_reader :connection, :event_queue, :component_registry
+
+    delegate :run, :stop, :to => :connection
+
+    # @param [Hash] options
+    # @option options [Connection::XMPP] :connection The Punchblock connection to use for this session
+    #
+    def initialize(options = {})
+      @event_queue = Queue.new
+      @connection = options[:connection]
+      @connection.event_handler = lambda { |event| self.handle_event event } if @connection
+      register_initial_handlers
+      @component_registry = ComponentRegistry.new
+      @write_timeout = options[:write_timeout] || 3
+    end
+
+    def handle_event(event)
+      event.client = self
+      if event.source
+        event.source.add_event event
+      else
+        trigger_handler :event, event
+      end
+    end
+
+    def register_event_handler(*guards, &block)
+      register_handler :event, *guards, &block
+    end
+
+    def register_initial_handlers
+      register_handler_with_priority :event, -10 do |event|
+        event_queue.push event
+      end
+    end
+
+    def register_component(component)
+      component_registry << component
+    end
+
+    def find_component_by_id(component_id)
+      component_registry.find_by_id component_id
+    end
+
+    def execute_command(command, options = {})
+      async = options.has_key?(:async) ? options.delete(:async) : true
+      command.client = self
+      if command.respond_to?(:register_event_handler)
+        command.register_event_handler do |event|
+          trigger_handler :event, event
+        end
+      end
+      connection.write command, options
+      command.response(@write_timeout).tap { |result| raise result if result.is_a? Exception } unless async
+    end
+  end
+end

data/lib/punchblock/client/component_registry.rb

@@ -0,0 +1,22 @@
+module Punchblock
+  class Client
+    class ComponentRegistry
+      def initialize
+        @mutex = Mutex.new
+        @components = Hash.new
+      end
+      
+      def <<(component)
+        @mutex.synchronize do
+          @components[component.component_id] = component
+        end
+      end
+
+      def find_by_id(component_id)
+        @mutex.synchronize do
+          @components[component_id]
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/command/dial.rb

@@ -73,11 +73,8 @@ module Punchblock
       end
 
       def response=(other)
+        @call_id = other.id if other.is_a?(Ref)
         super
-        if other.is_a?(Blather::Stanza::Iq)
-          ref = other.rayo_node
-          @call_id = ref.id if ref.is_a?(Ref)
-        end
       end
 
       def inspect_attributes # :nodoc:

data/lib/punchblock/component.rb

@@ -38,18 +38,16 @@ module Punchblock
       end
 
       def write_action(action)
-        connection.write call_id, action, component_id
+        client.execute_command action, :call_id => call_id, :component_id => component_id
+        action
       end
 
       def response=(other)
-        super
-        if other.is_a?(Blather::Stanza::Iq)
-          ref = other.rayo_node
-          if ref.is_a?(Ref)
-            @component_id = ref.id
-            @connection.record_command_id_for_iq_id @component_id, other.id
-          end
+        if other.is_a?(Ref)
+          @component_id = other.id
+          client.register_component self
         end
+        super
       end
 
       ##

data/lib/punchblock/connection.rb

@@ -1,210 +1,8 @@
-%w{
-  timeout
-  blather/client/dsl
-  punchblock/core_ext/blather/stanza
-  punchblock/core_ext/blather/stanza/presence
-}.each { |f| require f }
-
 module Punchblock
-  class Connection < GenericConnection
-    include Blather::DSL
-
-    ##
-    # Initialize the required connection attributes
-    #
-    # @param [Hash] options
-    # @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
-    #
-    def initialize(options = {})
-      super
-
-      raise ArgumentError unless (@username = options[:username]) && options[:password]
-
-      setup *[:username, :password, :host, :port, :certs].map { |key| options.delete key }
-
-      @rayo_domain = options[:rayo_domain] || Blather::JID.new(@username).domain
-
-      @callmap = {} # This hash maps call IDs to their XMPP domain.
-
-      @component_id_to_iq_id = {}
-      @iq_id_to_command = {}
-
-      @auto_reconnect = !!options[:auto_reconnect]
-      @reconnect_attempts = 0
-
-      @write_timeout = options[:write_timeout] || 3
-
-      @ping_period = options.has_key?(:ping_period) ? options[:ping_period] : 60
-
-      Blather.logger = options.delete(:wire_logger) if options.has_key?(:wire_logger)
-    end
-
-    ##
-    # Write a command to the Rayo server for a particular call
-    #
-    # @param [String] call the call ID on which to act
-    # @param [CommandNode] cmd the command to execute on the call
-    # @param [String, Optional] component_id the component_id on which to execute
-    #
-    # @raise Exception if there is a server-side error
-    #
-    # @return true
-    #
-    def write(call_id, cmd, component_id = nil)
-      async_write call_id, cmd, component_id
-      cmd.response(@write_timeout).tap { |result| raise result if result.is_a? Exception }
-    end
-
-    ##
-    # @return [Queue] Pop this queue to determine result of command execution. Will be true or an exception
-    def async_write(call_id, cmd, component_id = nil)
-      iq = prep_command_for_execution call_id, cmd, component_id
-      write_to_stream iq
-      cmd.request!
-    end
-
-    def prep_command_for_execution(call_id, cmd, component_id = nil)
-      cmd.connection = self
-      cmd.call_id = call_id
-      jid = cmd.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} #{cmd.inspect} to #{jid}" if @logger
-        iq << cmd
-        @iq_id_to_command[iq.id] = cmd
-      end
-    end
-
-    ##
-    # Fire up the connection
-    #
-    def run
-      register_handlers
-      connect
-    end
-
-    def connect
-      begin
-        EM.run { client.run }
-      rescue Blather::SASLError, Blather::StreamError => e
-        raise ProtocolError.new(e.class.to_s, e.message)
-      end
-    end
-
-    def stop
-      @reconnect_attempts = nil
-      client.close
-    end
-
-    def connected?
-      client.connected?
-    end
-
-    ##
-    #
-    # Get the original command issued by command ID
-    #
-    # @param [String] component_id
-    #
-    # @return [RayoNode]
-    #
-    def original_component_from_id(component_id)
-      @iq_id_to_command[@component_id_to_iq_id[component_id]]
-    end
-
-    def record_command_id_for_iq_id(command_id, iq_id)
-      @component_id_to_iq_id[command_id] = iq_id
-    end
-
-    private
-
-    def handle_presence(p)
-      throw :pass unless p.rayo_event? && p.from.domain == @rayo_domain
-      @logger.info "Receiving event for call ID #{p.call_id}" if @logger
-      @callmap[p.call_id] = p.from.domain
-      @logger.debug p.inspect if @logger
-      event = p.event
-      event.connection = self
-      if event.source
-        event.source.add_event event
-      else
-        @event_queue.push event
-      end
-    end
-
-    def handle_iq_result(iq)
-      # FIXME: Do we need to raise a warning if the domain changes?
-      throw :pass unless command = @iq_id_to_command[iq.id]
-      @callmap[iq.from.node] = iq.from.domain
-      @logger.debug "Command #{iq.id} completed successfully" if @logger
-      command.response = iq
-    end
-
-    def handle_error(iq)
-      e = Blather::StanzaError.import iq
-
-      protocol_error = ProtocolError.new e.name, e.text, iq.call_id, iq.component_id
-
-      throw :pass unless command = @iq_id_to_command[iq.id]
-
-      command.response = protocol_error
-    end
-
-    def register_handlers
-      # Push a message to the queue and the log that we connected
-      when_ready do
-        @event_queue.push connected
-        @logger.info "Connected to XMPP as #{@username}" if @logger
-        @reconnect_attempts = 0
-        @rayo_ping = EM::PeriodicTimer.new(@ping_period) { ping_rayo } if @ping_period
-      end
-
-      disconnected do
-        @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
-          sleep timer
-          @logger.info "Trying to reconnect..." if @logger
-          @reconnect_attempts += 1
-          connect
-        end
-      end
-
-      # Read/handle call control messages. These are mostly just acknowledgement of commands
-      iq :result? do |msg|
-        handle_iq_result msg
-      end
-
-      # Read/handle error IQs
-      iq :error? do |e|
-        handle_error e
-      end
-
-      # Read/handle presence requests. This is how we get events.
-      presence do |msg|
-        handle_presence msg
-      end
-    end
-
-    def ping_rayo
-      client.write_with_handler Blather::Stanza::Iq::Ping.new(:set, @rayo_domain) do |response|
-        begin
-          handle_error response if response.is_a? Blather::BlatherError
-        rescue ProtocolError => e
-          raise e unless e.name == :feature_not_implemented
-        end
-      end
-    end
+  module Connection
+    extend ActiveSupport::Autoload
 
-    def create_iq(jid = nil)
-      Blather::Stanza::Iq.new :set, jid || @call_id
-    end
+    autoload :Connected
+    autoload :XMPP
   end
 end

data/lib/punchblock/connection/connected.rb

@@ -0,0 +1,15 @@
+module Punchblock
+  module Connection
+    Connected = Class.new do
+      class << self
+        def source
+          nil
+        end
+
+        def client=(other)
+          nil
+        end
+      end
+    end
+  end
+end