adhearsion 2.6.4 → 3.0.0.beta1

data/lib/adhearsion/rayo/connection/xmpp.rb

@@ -0,0 +1,198 @@
+# encoding: utf-8
+
+%w{
+  timeout
+  blather/client/dsl
+  adhearsion/core_ext/blather/stanza
+  adhearsion/core_ext/blather/stanza/presence
+  adhearsion/rayo/connection/generic_connection
+}.each { |f| require f }
+
+module Adhearsion
+  module Rayo
+    module Connection
+      class XMPP < GenericConnection
+        include Blather::DSL
+        attr_accessor :event_handler, :root_domain
+
+        ##
+        # 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 [Numeric, Optional] :write_timeout for which to wait on a command response
+        # @option options [Numeric, Optional] :connection_timeout for which to wait on a connection being established
+        # @option options [Numeric, nil, Optional] :ping_period interval in seconds on which to ping the server. Nil or false to disable
+        #
+        def initialize(options = {})
+          raise ArgumentError unless (@username = options[:username]) && options[:password]
+
+          setup(*[:username, :password, :host, :port, :certs, :connection_timeout].map { |key| options.delete key })
+
+          @root_domain = Blather::JID.new(options[:root_domain] || options[:rayo_domain] || @username).domain
+
+          @joined_mixers = []
+
+          @ping_period = options.has_key?(:ping_period) ? options[:ping_period] : 60
+
+          Blather.logger = logger
+          Blather.default_log_level = :trace if Blather.respond_to? :default_log_level
+
+          register_handlers
+
+          super()
+        end
+
+        def write(command, options = {})
+          iq = prep_command_for_execution command, options
+          command.request!
+          client.write_with_handler iq do |response|
+            if response.result?
+              handle_iq_result response, command
+            elsif response.error?
+              handle_error response, command
+            end
+          end
+        end
+
+        def prep_command_for_execution(command, options = {})
+          command.connection    = self
+          command.target_call_id    ||= options[:call_id]
+          command.target_mixer_name ||= options[:mixer_name]
+          command.domain            ||= options[:domain]
+          command.component_id      ||= options[:component_id]
+          if command.is_a?(Command::Join) && command.mixer_name
+            @joined_mixers << command.mixer_name
+          end
+          create_iq(jid_for_command(command), command.request_id).tap do |iq|
+            command.to_rayo(iq)
+          end
+        end
+
+        def send_message(call_id, domain, body, options = {})
+          jid = Blather::JID.new(call_id, domain || root_domain).to_s
+          message = Blather::Stanza::Message.new(jid, body, :normal)
+          message.subject = options[:subject]
+          client.write message
+        end
+
+        ##
+        # Fire up the connection
+        #
+        def run
+          connect
+        end
+
+        def connect
+          begin
+            EM.run { client.run }
+          rescue Blather::Stream::ConnectionFailed, Blather::Stream::ConnectionTimeout, Blather::StreamError => e
+            raise DisconnectedError.new(e.class.to_s, e.message)
+          end
+        end
+
+        def stop
+          client.close if client.connected?
+        end
+
+        def connected?
+          client.connected?
+        end
+
+        def ready!
+          send_presence :chat
+          super
+        end
+
+        def not_ready!
+          send_presence :dnd
+          super
+        end
+
+        def new_call_uri
+          "xmpp:#{Adhearsion.new_uuid}@#{root_domain}"
+        end
+
+        private
+
+        def jid_for_command(command)
+          return root_domain if command.is_a?(Command::Dial)
+
+          if command.target_call_id
+            node = command.target_call_id
+          elsif command.target_mixer_name
+            node = command.target_mixer_name
+          end
+
+          Blather::JID.new(node, command.domain || root_domain, command.component_id).to_s
+        end
+
+        def send_presence(presence)
+          status = Blather::Stanza::Presence::Status.new presence
+          status.to = root_domain
+          client.write status
+        end
+
+        def handle_presence(p)
+          throw :pass unless p.rayo_event?
+          event = p.event
+          event.connection = self
+          event.domain = p.from.domain
+          event.transport = "xmpp"
+          if @joined_mixers.include?(p.call_id)
+            event.target_mixer_name = p.call_id
+          else
+            event.target_call_id = p.call_id
+          end
+          event_handler.call event
+        end
+
+        def handle_iq_result(iq, command)
+          command.response = iq.rayo_node.is_a?(Ref) ? iq.rayo_node : true
+        end
+
+        def handle_error(iq, command = nil)
+          e = Blather::StanzaError.import iq
+          protocol_error = ProtocolError.new.setup e.name, e.text, iq.call_id, iq.component_id
+          command.response = protocol_error if command
+        end
+
+        def register_handlers
+          # 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}"
+            @rayo_ping = EM::PeriodicTimer.new(@ping_period) { ping_rayo } if @ping_period
+            throw :pass
+          end
+
+          disconnected do
+            @rayo_ping.cancel if @rayo_ping
+            raise DisconnectedError
+          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(:get, root_domain) do |response|
+            begin
+              handle_error response if response.is_a? Blather::BlatherError
+            rescue ProtocolError => e
+              raise unless e.name == :feature_not_implemented
+            end
+          end
+        end
+
+        def create_iq(jid, id)
+          Blather::Stanza::Iq.new :set, jid, id
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/disconnected_error.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'adhearsion/error'
+
+module Adhearsion
+  module Rayo
+    ##
+    # This exception may be raised if the connection to the server is interrupted.
+    class DisconnectedError < Error
+      attr_accessor :cause, :message
+
+      def initialize(cause = nil, message = nil)
+        @cause, @message = cause, message
+      end
+
+      def to_s
+        "#<#{self.class}: cause=#{cause.inspect} message=#{message.inspect}"
+      end
+      alias :inspect :to_s
+    end
+  end
+end

data/lib/adhearsion/{punchblock_plugin → rayo}/initializer.rb

@@ -4,7 +4,7 @@ require 'blather'
 require 'active_support/core_ext/class/attribute_accessors'
 
 module Adhearsion
-  class PunchblockPlugin < Plugin
+  module Rayo
     class Initializer
       cattr_accessor :config, :client, :dispatcher, :attempts
 
@@ -12,10 +12,10 @@ module Adhearsion
 
       class << self
         def init
-          self.config = Adhearsion.config[:punchblock]
+          self.config = Adhearsion.config.core
 
           username = self.config.username
-          if (self.config.platform || :xmpp) == :xmpp
+          if (self.config.type || :xmpp) == :xmpp
             username = Blather::JID.new username
             username = Blather::JID.new username.node, username.domain, resource unless username.resource
             username = username.to_s
@@ -31,9 +31,9 @@ module Adhearsion
             :root_domain        => self.config.root_domain
           }
 
-          self.client = Punchblock.client_with_connection self.config.platform, connection_options
+          self.client = Adhearsion.client_with_connection self.config.type, connection_options
 
-          # Tell the Punchblock connection that we are ready to process calls.
+          # Tell the connection that we are ready to process calls.
           Events.register_callback :after_initialized do
             connection.ready!
           end
@@ -49,25 +49,25 @@ module Adhearsion
             client.stop
           end
 
-          # Handle events from Punchblock via events system
+          # Handle events from connection via events system
           self.client.register_event_handler do |event|
             handle_event event
           end
 
-          Events.punchblock Punchblock::Connection::Connected do |event|
-            logger.info "Connected to Punchblock server"
+          Events.rayo Adhearsion::Rayo::Connection::Connected do |event|
+            logger.info "Connected to Rayo server"
             self.attempts = 0
           end
 
-          Events.punchblock Punchblock::Event::Offer do |offer|
+          Events.rayo Adhearsion::Event::Offer do |offer|
             dispatch_offer offer
           end
 
-          Events.punchblock proc { |e| e.respond_to?(:source) }, :source do |event|
+          Events.rayo proc { |e| e.respond_to?(:source) }, :source do |event|
             event.source.trigger_event_handler event
           end
 
-          Events.punchblock proc { |e| e.respond_to?(:target_call_id) }, :target_call_id do |event|
+          Events.rayo proc { |e| e.respond_to?(:target_call_id) }, :target_call_id do |event|
             dispatch_call_event event
           end
         end
@@ -81,7 +81,7 @@ module Adhearsion
           m = Mutex.new
           blocker = ConditionVariable.new
 
-          Events.punchblock Punchblock::Connection::Connected do
+          Events.rayo Adhearsion::Rayo::Connection::Connected do
             Adhearsion::Process.booted
             m.synchronize { blocker.broadcast }
           end
@@ -104,7 +104,7 @@ module Adhearsion
         def connect_to_server
           logger.info "Starting connection to server"
           client.run
-        rescue Punchblock::DisconnectedError => e
+        rescue Adhearsion::Rayo::DisconnectedError => e
           # We only care about disconnects if the process is up or booting
           return unless [:booting, :running].include? Adhearsion::Process.state_name
 
@@ -121,7 +121,7 @@ module Adhearsion
           logger.error "Connection lost. Attempting reconnect #{self.attempts} of #{self.config.reconnect_attempts}"
           sleep self.config.reconnect_timer
           retry
-        rescue Punchblock::ProtocolError => e
+        rescue Adhearsion::ProtocolError => e
           logger.fatal "The connection failed due to a protocol error: #{e.name}."
           raise e
         end
@@ -152,9 +152,9 @@ module Adhearsion
         end
 
         def handle_event(event)
-          Events.trigger :punchblock, event
+          Events.trigger :rayo, event
           case event
-          when Punchblock::Event::Asterisk::AMI::Event
+          when Adhearsion::Event::Asterisk::AMI
             Events.trigger :ami, event
           end
         end
@@ -173,6 +173,6 @@ module Adhearsion
           client.connection
         end
       end
-    end # Punchblock
-  end # Plugin
-end # Adhearsion
+    end
+  end
+end

data/lib/adhearsion/rayo/rayo_node.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+
+require 'active_support/core_ext/class/attribute'
+require 'virtus'
+
+require 'adhearsion/rayo'
+
+module Adhearsion
+  module Rayo
+    class RayoNode
+      include Virtus.model
+
+      @@registrations = {}
+
+      class_attribute :registered_ns, :registered_name
+
+      attribute :target_call_id
+      attribute :target_mixer_name
+      attribute :component_id
+      attribute :source_uri
+      attribute :domain
+      attribute :transport
+      attribute :timestamp, DateTime, default: ->(*) { DateTime.now }
+
+      attr_accessor :connection, :client, :original_component
+
+      # Register a new stanza class to a name and/or namespace
+      #
+      # This registers a namespace that is used when looking
+      # up the class name of the object to instantiate when a new
+      # stanza is received
+      #
+      # @param [#to_s] name the name of the node
+      # @param [String, nil] ns the namespace the node belongs to
+      def self.register(name, ns = nil)
+        self.registered_name = name.to_s
+        self.registered_ns = ns.is_a?(Symbol) ? RAYO_NAMESPACES[ns] : ns
+        @@registrations[[self.registered_name, self.registered_ns]] = self
+      end
+
+      # Find the class to use given the name and namespace of a stanza
+      #
+      # @param [#to_s] name the name to lookup
+      # @param [String, nil] xmlns the namespace the node belongs to
+      # @return [Class, nil] the class appropriate for the name/ns combination
+      def self.class_from_registration(name, ns = nil)
+        @@registrations[[name.to_s, ns]]
+      end
+
+      # Import an XML::Node to the appropriate class
+      #
+      # Looks up the class the node should be then creates it based on the
+      # elements of the XML::Node
+      # @param [XML::Node] node the node to import
+      # @return the appropriate object based on the node name and namespace
+      def self.from_xml(node, call_id = nil, component_id = nil, uri = nil, timestamp = nil)
+        ns = (node.namespace.href if node.namespace)
+        klass = class_from_registration(node.name, ns)
+        if klass && klass != self
+          klass.from_xml node, call_id, component_id
+        else
+          new.inherit node
+        end.tap do |event|
+          event.target_call_id = call_id
+          event.component_id = component_id
+          event.source_uri = uri
+          event.timestamp = timestamp if timestamp
+        end
+      end
+
+      def inherit(xml_node)
+        xml_node.attributes.each do |key, attr_node|
+          setter_method = "#{key.gsub('-', '_')}="
+          send setter_method, xml_node[key] if respond_to?(setter_method)
+        end
+        self
+      end
+
+      def inspect
+        "#<#{self.class} #{to_hash.map { |k, v| "#{k}=#{v.inspect}" }.compact * ', '}>"
+      end
+
+      def ==(o)
+        o.is_a?(self.class) && self.comparable_attributes == o.comparable_attributes
+      end
+
+      ##
+      # @return [RayoNode] the original command issued that lead to this event
+      #
+      def source
+        @source ||= client.find_component_by_uri source_uri if client && source_uri
+        @source ||= original_component
+      end
+
+      def rayo_attributes
+        {}
+      end
+
+      def rayo_children(root)
+      end
+
+      def to_rayo(parent = nil)
+        parent = parent.parent if parent.is_a?(Nokogiri::XML::Builder)
+        Nokogiri::XML::Builder.with(parent) do |xml|
+          xml.send(registered_name,
+            {xmlns: registered_ns}.merge(rayo_attributes.delete_if { |k,v| v.nil? })) do |root|
+            rayo_children root
+          end
+        end.doc.root
+      end
+
+      def to_xml
+        to_rayo.to_xml
+      end
+
+      alias :to_s :inspect
+
+    protected
+
+      def comparable_attributes
+        to_hash.tap do |hash|
+          hash.delete :timestamp
+        end
+      end
+    end
+  end
+end