xmpp4r 0.4 → 0.5

data/lib/xmpp4r/reliable.rb

@@ -0,0 +1,168 @@
+require 'xmpp4r/stream'
+
+module Jabber
+  module Reliable
+    
+    class Connection < Jabber::Client
+      def initialize(full_jid, config)
+        super(full_jid)
+        @servers = config[:servers]
+        @port = config[:port] || 5222
+        @max_retry = config[:max_retry] || 30
+        @retry_sleep = config[:retry_sleep] || 2
+        if(@servers.nil? or @servers.empty?)
+          @servers = [@jid.domain]
+        end
+      end
+      
+      def connect
+        retry_count = 0
+        server_to_use = nil
+        server_pool = @servers.dup.sort{ rand <=> rand }
+        begin
+          server_to_use = server_pool.shift
+          server_pool.push(server_to_use)
+
+          Jabber::debuglog "timeout will be: #{@retry_sleep.to_f}"
+          Timeout.timeout(@retry_sleep.to_f){
+            Jabber::debuglog "trying to connect to #{server_to_use}"
+            super(server_to_use, @port)
+          }
+
+          Jabber::debuglog self.jid.to_s + " connected to " + server_to_use.to_s
+          Jabber::debuglog "out of possible servers " + @servers.inspect
+        rescue Exception, Timeout::Error => e
+          Jabber::warnlog "#{server_to_use} error: #{e.inspect}. Will attempt to reconnect in #{@retry_sleep}"
+          sleep(@retry_sleep.to_f)
+          if(retry_count >= @max_retry.to_i)
+            Jabber::warnlog "reached max retry count on exception, failing"
+            raise e
+          end
+          retry_count += 1
+          retry
+        end
+      end
+            
+    end
+    
+    class Listener
+      def initialize(full_jid, password, config, &block)
+        @on_message_block = block
+        @full_jid = full_jid
+        @config = config
+        @password = password
+        @max_retry = config[:max_retry] || 30
+      end
+      
+      def setup_connection
+        @connection = Connection.new(@full_jid, @config)
+        if @on_message_block
+          @connection.add_message_callback(&@on_message_block)
+        else
+          @connection.add_message_callback do |msg|
+            self.on_message(msg)
+          end
+        end
+        
+        #We could just reconnect in @connection.on_exception, 
+        #but by raising into this seperate thread, we avoid growing our stack trace
+        @reconnection_thread = Thread.new do
+          first_run = true
+          begin
+            self.start unless first_run
+            loop do 
+              sleep(1)
+              Thread.pass
+            end
+          rescue => e
+            first_run = false
+            retry
+          end
+        end
+        @exception_handlers = []
+        @connection.on_exception do |e, connection, where_failed|
+          self.run_exception_handlers(e, connection, where_failed)
+        end
+      end
+      
+      def run_exception_handlers(e, connection, where_failed)
+        @exception_handlers.each do |ex_handler|
+          ex_handler.call(e, connection, where_failed)
+        end
+        if where_failed == :sending
+          @message_to_send_on_reconnect = @message_now_sending
+        end
+        if where_failed != :close && !@connection.is_connected?
+          @reconnection_thread.raise(e)
+        end
+      end
+      
+      def add_exception_handler(&block)
+        @exception_handlers << block
+      end
+      
+      def start
+        setup_connection unless @connection
+        connect
+        auth
+        send_presence
+        if @message_to_send_on_reconnect
+          send_message(@message_to_send_on_reconnect)
+        end
+        @message_to_send_on_reconnect = nil
+      end
+      
+      #Stop the listener. (close the connection)
+      def stop
+        @connection.close if @connection and @connection.is_connected?
+        @connection = nil
+      end
+      
+      def connect
+        @connection.connect        
+      end
+      
+      def auth
+        @connection.auth(@password)
+      end
+      
+      def send_presence
+        presence_message = @config[:presence_message]
+        if presence_message && !presence_message.empty?
+          @connection.send(Jabber::Presence.new.set_show(:chat).set_status(presence_message))
+        end
+      end
+      
+      #TODO: test and fix situation where we get disconnected while sending but then successfully reconnect 
+      # (and make sure in such cases we resent)      
+      def send_message(message)
+        unless @connection
+          raise ::ArgumentError, "Can't send messages while listener is stopped.  Plase 'start' the listener first."
+        end
+        retry_count = 0
+        begin
+          while(not @connection.is_connected?)
+            #wait
+            Thread.pass
+          end
+          @message_now_sending = message
+          @connection.send(message)
+          return true #true, message was sent
+        rescue => e
+          if e.is_a?(Interrupt)
+            raise e
+          end
+          if(retry_count > @max_retry.to_i)
+            Jabber::debuglog "reached max retry count on message re-send, failing"
+            raise e
+          end
+          retry_count += 1
+          Jabber::debuglog "retrying message send.." + e.inspect
+          retry
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/xmpp4r/rexmladdons.rb

@@ -17,6 +17,12 @@ module REXML
   # this class adds a few helper methods to REXML::Element
   class Element
 
+    def each_elements(*els, &block)
+      els.inject([ ]) do |res, e|
+        res + each_element(e, &block)
+      end
+    end
+
     ##
     # Replaces or adds a child element of name <tt>e</tt> with text <tt>t</tt>.
     def replace_element_text(e, t)

data/lib/xmpp4r/roster/helper/roster.rb

@@ -36,7 +36,7 @@ module Jabber
       # <b>Attention:</b> If you send presence and receive presences
       # before the roster has arrived, the Roster helper will let them
       # pass through and does *not* keep them!
-      def initialize(stream)
+      def initialize(stream, startnow = true)
         @stream = stream
         @items = {}
         @items_lock = Mutex.new
@@ -66,10 +66,13 @@ module Jabber
             handle_presence(pres)
           end
         }
+        get_roster if startnow
+      end
 
+      def get_roster
         # Request the roster
         rosterget = Iq.new_rosterget
-        stream.send(rosterget)
+        @stream.send(rosterget)
       end
 
       ##

data/lib/xmpp4r/sasl.rb

@@ -122,7 +122,6 @@ module Jabber
         state = :key
         key = ''
         value = ''
-
         text.scan(/./) do |ch|
           if state == :key
             if ch == '='
@@ -133,6 +132,9 @@ module Jabber
 
           elsif state == :value
             if ch == ','
+              # due to our home-made parsing of the challenge, the key could have
+              # leading whitespace. strip it, or that would break jabberd2 support.
+              key = key.strip
               res[key] = value
               key = ''
               value = ''
@@ -151,9 +153,12 @@ module Jabber
             end
           end
         end
+        # due to our home-made parsing of the challenge, the key could have
+        # leading whitespace. strip it, or that would break jabberd2 support.
+        key = key.strip
         res[key] = value unless key == ''
 
-        Jabber::debuglog("SASL DIGEST-MD5 challenge:\n#{text.inspect}\n#{res.inspect}")
+        Jabber::debuglog("SASL DIGEST-MD5 challenge:\n#{text}\n#{res.inspect}")
 
         res
       end
@@ -172,7 +177,7 @@ module Jabber
         response['nc'] = '00000001'
         response['qop'] = 'auth'
         response['digest-uri'] = "xmpp/#{@stream.jid.domain}"
-        response['response'] = response_value(@stream.jid.node, @stream.jid.domain, response['digest-uri'], password, @nonce, response['cnonce'], response['qop'])
+        response['response'] = response_value(@stream.jid.node, @stream.jid.domain, response['digest-uri'], password, @nonce, response['cnonce'], response['qop'], response['authzid'])
         response.each { |key,value|
           unless %w(nc qop response charset).include? key
             response[key] = "\"#{value}\""
@@ -180,7 +185,7 @@ module Jabber
         }
 
         response_text = response.collect { |k,v| "#{k}=#{v}" }.join(',')
-        Jabber::debuglog("SASL DIGEST-MD5 response:\n#{response_text}")
+        Jabber::debuglog("SASL DIGEST-MD5 response:\n#{response_text}\n#{response.inspect}")
 
         r = REXML::Element.new('response')
         r.add_namespace NS_SASL
@@ -224,14 +229,20 @@ module Jabber
 
       ##
       # Calculate the value for the response field
-      def response_value(username, realm, digest_uri, passwd, nonce, cnonce, qop)
+      def response_value(username, realm, digest_uri, passwd, nonce, cnonce, qop, authzid)
         a1_h = h("#{username}:#{realm}:#{passwd}")
         a1 = "#{a1_h}:#{nonce}:#{cnonce}"
-        #a2 = "AUTHENTICATE:#{digest_uri}#{(qop == 'auth') ? '' : ':00000000000000000000000000000000'}"
-        a2 = "AUTHENTICATE:#{digest_uri}"
-
+        if authzid
+          a1 += ":#{authzid}"
+        end
+        if qop == 'auth-int' || qop == 'auth-conf'
+          a2 = "AUTHENTICATE:#{digest_uri}:00000000000000000000000000000000"
+        else
+          a2 = "AUTHENTICATE:#{digest_uri}"
+        end
         hh("#{hh(a1)}:#{nonce}:00000001:#{cnonce}:#{qop}:#{hh(a2)}")
       end
     end
   end
 end
+

data/lib/xmpp4r/stream.rb

@@ -35,6 +35,9 @@ module Jabber
     # connection status
     attr_reader :status
 
+    # number of stanzas currently being processed
+    attr_reader :processing
+
     ##
     # Initialize a new stream
     def initialize
@@ -48,12 +51,14 @@ module Jabber
       @send_lock = Mutex.new
       @last_send = Time.now
       @exception_block = nil
+      @tbcbmutex = Mutex.new
       @threadblocks = []
       @wakeup_thread = nil
       @streamid = nil
       @streamns = 'jabber:client'
       @features_sem = Semaphore.new
       @parser_thread = nil
+      @processing = 0
     end
 
     ##
@@ -76,7 +81,7 @@ module Jabber
             close!
           end
         rescue Exception => e
-          Jabber::debuglog("EXCEPTION:\n#{e.class}\n#{e.message}\n#{e.backtrace.join("\n")}")
+          Jabber::warnlog("EXCEPTION:\n#{e.class}\n#{e.message}\n#{e.backtrace.join("\n")}")
 
           if @exception_block
             Thread.new do
@@ -85,7 +90,7 @@ module Jabber
               @exception_block.call(e, self, :start)
             end
           else
-            Jabber::debuglog "Exception caught in Parser thread! (#{e.class})\n#{e.backtrace.join("\n")}"
+            Jabber::warnlog "Exception caught in Parser thread! (#{e.class})\n#{e.backtrace.join("\n")}"
             close!
             raise
           end
@@ -116,7 +121,7 @@ module Jabber
     ##
     # This method is called by the parser when a failure occurs
     def parse_failure(e)
-      Jabber::debuglog("EXCEPTION:\n#{e.class}\n#{e.message}\n#{e.backtrace.join("\n")}")
+      Jabber::warnlog("EXCEPTION:\n#{e.class}\n#{e.message}\n#{e.backtrace.join("\n")}")
 
       # A new thread has to be created because close will cause the thread
       # to commit suicide(???)
@@ -128,7 +133,7 @@ module Jabber
           @exception_block.call(e, self, :parser)
         end
       else
-        Jabber::debuglog "Stream#parse_failure was called by XML parser. Dumping " +
+        Jabber::warnlog "Stream#parse_failure was called by XML parser. Dumping " +
           "backtrace...\n" + e.exception + "\n#{e.backtrace.join("\n")}"
         close
         raise
@@ -170,6 +175,7 @@ module Jabber
     #
     # element:: [REXML::Element] The received element
     def receive(element)
+      @tbcbmutex.synchronize { @processing += 1 }
       Jabber::debuglog("RECEIVED:\n#{element.to_s}")
 
       if element.namespace('').to_s == '' # REXML namespaces are always strings
@@ -219,13 +225,21 @@ module Jabber
         end
       end
 
+      if @xmlcbs.process(stanza)
+        @tbcbmutex.synchronize { @processing -= 1 }
+        return true
+      end
+
       # Iterate through blocked threads (= waiting for an answer)
       #
       # We're dup'ping the @threadblocks here, so that we won't end up in an
       # endless loop if Stream#send is being nested. That means, the nested
       # threadblock won't receive the stanza currently processed, but the next
       # one.
-      threadblocks = @threadblocks.dup
+      threadblocks = nil
+      @tbcbmutex.synchronize do
+        threadblocks = @threadblocks.dup
+      end
       threadblocks.each { |threadblock|
         exception = nil
         r = false
@@ -236,26 +250,68 @@ module Jabber
         end
 
         if r == true
-          @threadblocks.delete(threadblock)
+          @tbcbmutex.synchronize do
+            @threadblocks.delete(threadblock)
+          end
           threadblock.wakeup
-          return
+          @tbcbmutex.synchronize { @processing -= 1 }
+          return true
         elsif exception
-          @threadblocks.delete(threadblock)
+          @tbcbmutex.synchronize do
+            @threadblocks.delete(threadblock)
+          end
           threadblock.raise(exception)
         end
       }
 
       Jabber::debuglog("PROCESSING:\n#{stanza.to_s} (#{stanza.class})")
-      return true if @xmlcbs.process(stanza)
-      return true if @stanzacbs.process(stanza)
+      Jabber::debuglog("TRYING stanzacbs...")
+      if @stanzacbs.process(stanza)
+          @tbcbmutex.synchronize { @processing -= 1 }
+          return true
+      end
+      r = false
+      Jabber::debuglog("TRYING message/iq/presence/cbs...")
       case stanza
       when Message
-        return true if @messagecbs.process(stanza)
+        r = @messagecbs.process(stanza)
       when Iq
-        return true if @iqcbs.process(stanza)
+        r = @iqcbs.process(stanza)
       when Presence
-        return true if @presencecbs.process(stanza)
+        r = @presencecbs.process(stanza)
       end
+      @tbcbmutex.synchronize { @processing -= 1 }
+      return r
+    end
+
+    ##
+    # Get the list of iq callbacks.
+    def iq_callbacks
+      @iqcbs
+    end
+
+    ##
+    # Get the list of message callbacks.
+    def message_callbacks
+      @messagecbs
+    end
+
+    ##
+    # Get the list of presence callbacks.
+    def presence_callbacks
+      @presencecbs
+    end
+
+    ##
+    # Get the list of stanza callbacks.
+    def stanza_callbacks
+      @stanzacbs
+    end
+
+    ##
+    # Get the list of xml callbacks.
+    def xml_callbacks
+      @xmlcbs
     end
 
     ##
@@ -276,7 +332,6 @@ module Jabber
         raise @exception if @exception
       end
       def wakeup
-        # TODO: Handle threadblock removal if !alive?
         @waiter.run
       end
       def raise(exception)
@@ -305,11 +360,17 @@ module Jabber
     # &block:: [Block] The optional block
     def send(xml, &block)
       Jabber::debuglog("SENDING:\n#{xml}")
-      @threadblocks.unshift(threadblock = ThreadBlock.new(block)) if block
+      if block
+        threadblock = ThreadBlock.new(block)
+        @tbcbmutex.synchronize do
+          @threadblocks.unshift(threadblock)
+        end
+      end
       begin
         # Temporarily remove stanza's namespace to
         # reduce bandwidth consumption
-        if xml.kind_of? XMPPStanza and xml.namespace == 'jabber:client'
+        if xml.kind_of? XMPPStanza and xml.namespace == 'jabber:client' and
+            xml.prefix != 'stream' and xml.name != 'stream'
           xml.delete_namespace
           send_data(xml.to_s)
           xml.add_namespace(@streamns)
@@ -317,7 +378,7 @@ module Jabber
           send_data(xml.to_s)
         end
       rescue Exception => e
-        Jabber::debuglog("EXCEPTION:\n#{e.class}\n#{e.message}\n#{e.backtrace.join("\n")}")
+        Jabber::warnlog("EXCEPTION:\n#{e.class}\n#{e.message}\n#{e.backtrace.join("\n")}")
 
         if @exception_block
           Thread.new do
@@ -326,7 +387,7 @@ module Jabber
             @exception_block.call(e, self, :sending)
           end
         else
-          Jabber::debuglog "Exception caught while sending! (#{e.class})\n#{e.backtrace.join("\n")}"
+          Jabber::warnlog "Exception caught while sending! (#{e.class})\n#{e.backtrace.join("\n")}"
           close!
           raise
         end
@@ -336,7 +397,7 @@ module Jabber
       if block and Thread.current != @parser_thread
         threadblock.wait
       elsif block
-        Jabber::debuglog("WARNING:\nCannot stop current thread in Jabber::Stream#send because it is the parser thread!")
+        Jabber::warnlog("WARNING:\nCannot stop current thread in Jabber::Stream#send because it is the parser thread!")
       end
     end
 
@@ -393,13 +454,17 @@ module Jabber
     end
 
     ##
-    # Adds a callback block to process received XML messages
+    # Adds a callback block to process received XML messages, these
+    # will be handled before any blocks given to Stream#send or other
+    # callbacks.
     #
     # priority:: [Integer] The callback's priority, the higher, the sooner
     # ref:: [String] The callback's reference
     # &block:: [Block] The optional block
     def add_xml_callback(priority = 0, ref = nil, &block)
-      @xmlcbs.add(priority, ref, block)
+      @tbcbmutex.synchronize do
+        @xmlcbs.add(priority, ref, block)
+      end
     end
 
     ##
@@ -407,7 +472,9 @@ module Jabber
     #
     # ref:: [String] The reference of the callback to delete
     def delete_xml_callback(ref)
-      @xmlcbs.delete(ref)
+      @tbcbmutex.synchronize do
+        @xmlcbs.delete(ref)
+      end
     end
 
     ##
@@ -417,7 +484,9 @@ module Jabber
     # ref:: [String] The callback's reference
     # &block:: [Block] The optional block
     def add_message_callback(priority = 0, ref = nil, &block)
-      @messagecbs.add(priority, ref, block)
+      @tbcbmutex.synchronize do
+        @messagecbs.add(priority, ref, block)
+      end
     end
 
     ##
@@ -425,7 +494,9 @@ module Jabber
     #
     # ref:: [String] The reference of the callback to delete
     def delete_message_callback(ref)
-      @messagecbs.delete(ref)
+      @tbcbmutex.synchronize do
+        @messagecbs.delete(ref)
+      end
     end
 
     ##
@@ -435,7 +506,9 @@ module Jabber
     # ref:: [String] The callback's reference
     # &block:: [Block] The optional block
     def add_stanza_callback(priority = 0, ref = nil, &block)
-      @stanzacbs.add(priority, ref, block)
+      @tbcbmutex.synchronize do
+        @stanzacbs.add(priority, ref, block)
+      end
     end
 
     ##
@@ -443,7 +516,9 @@ module Jabber
     #
     # ref:: [String] The reference of the callback to delete
     def delete_stanza_callback(ref)
-      @stanzacbs.delete(ref)
+      @tbcbmutex.synchronize do
+        @stanzacbs.delete(ref)
+      end
     end
 
     ##
@@ -453,7 +528,9 @@ module Jabber
     # ref:: [String] The callback's reference
     # &block:: [Block] The optional block
     def add_presence_callback(priority = 0, ref = nil, &block)
-      @presencecbs.add(priority, ref, block)
+      @tbcbmutex.synchronize do
+        @presencecbs.add(priority, ref, block)
+      end
     end
 
     ##
@@ -461,7 +538,9 @@ module Jabber
     #
     # ref:: [String] The reference of the callback to delete
     def delete_presence_callback(ref)
-      @presencecbs.delete(ref)
+      @tbcbmutex.synchronize do
+        @presencecbs.delete(ref)
+      end
     end
 
     ##
@@ -471,7 +550,9 @@ module Jabber
     # ref:: [String] The callback's reference
     # &block:: [Block] The optional block
     def add_iq_callback(priority = 0, ref = nil, &block)
-      @iqcbs.add(priority, ref, block)
+      @tbcbmutex.synchronize do
+        @iqcbs.add(priority, ref, block)
+      end
     end
 
     ##
@@ -480,7 +561,9 @@ module Jabber
     # ref:: [String] The reference of the callback to delete
     #
     def delete_iq_callback(ref)
-      @iqcbs.delete(ref)
+      @tbcbmutex.synchronize do
+        @iqcbs.delete(ref)
+      end
     end
     ##
     # Closes the connection to the Jabber service
@@ -489,9 +572,28 @@ module Jabber
     end
 
     def close!
-      @parser_thread.kill if @parser_thread
+      pr = 1
+      n = 0
+      # In some cases, we might lost count of some stanzas
+      # (for example, if the handler raises an exception)
+      # so we can't block forever.
+      while pr > 0 and n <= 1000
+        @tbcbmutex.synchronize { pr = @processing }
+        if pr > 0
+          n += 1
+          Jabber::debuglog("TRYING TO CLOSE, STILL PROCESSING #{pr} STANZAS")
+          #puts("TRYING TO CLOSE, STILL PROCESSING #{pr} STANZAS")
+          Thread::pass
+        end
+      end
+
+      # Order Matters here! If this method is called from within 
+      # @parser_thread then killing @parser_thread first would 
+      # mean the other parts of the method fail to execute. 
+      # That would be bad. So kill parser_thread last
       @fd.close if @fd and !@fd.closed?
       @status = DISCONNECTED
+      @parser_thread.kill if @parser_thread
     end
   end
 end