xmpp4r 0.3.1 → 0.3.2

data/lib/xmpp4r/feature_negotiation/iq/feature.rb

@@ -11,24 +11,8 @@ module Jabber
     # Feature negotiation,
     # can appear as direct child to Iq
     # or as child of IqSi
-    class IqFeature < REXML::Element
-      def initialize
-        super('feature')
-
-        add_namespace 'http://jabber.org/protocol/feature-neg'
-      end
-
-      def IqFeature.import(element)
-        IqFeature::new.import(element)
-      end
-
-      def typed_add(element)
-        if element.name == 'x' and element.namespace == 'jabber:x:data'
-          super Dataforms::XData.new.import(element)
-        else
-          super element
-        end
-      end
+    class IqFeature < XMPPElement
+      name_xmlns 'feature', 'http://jabber.org/protocol/feature-neg'
 
       ##
       # First <x/> child with xmlns='jabber:x:data'
@@ -40,7 +24,5 @@ module Jabber
         res
       end
     end
-
-    Iq.add_elementclass('feature', IqFeature)
   end
 end

data/lib/xmpp4r/httpbinding.rb

@@ -0,0 +1,5 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r/httpbinding/client'

data/lib/xmpp4r/httpbinding/client.rb

@@ -0,0 +1,285 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+
+require 'xmpp4r/client'
+require 'net/http'
+
+module Jabber
+  module HTTPBinding
+    ##
+    # This class implements an alternative Client
+    # using HTTP Binding (JEP0124).
+    #
+    # This class is designed to be a drop-in replacement
+    # for Jabber::Client, except for the
+    # Jabber::HTTP::Client#connect method which takes an URI
+    # as argument.
+    #
+    # HTTP requests are buffered to not exceed the negotiated
+    # 'polling' and 'requests' parameters.
+    #
+    # Stanzas in HTTP resonses may be delayed to arrive in the
+    # order defined by 'rid' parameters.
+    #
+    # =Debugging
+    # Turning Jabber::debug to true will make debug output
+    # not only spit out stanzas but HTTP request/response
+    # bodies, too.
+    class Client < Jabber::Client
+
+      # Content-Type to be used for communication
+      # (you can set this to "text/html")
+      attr_accessor :http_content_type
+      # The server should wait this value seconds if
+      # there is no stanza to be received
+      attr_accessor :http_wait
+      # The server may hold this amount of stanzas
+      # to reduce number of HTTP requests
+      attr_accessor :http_hold
+
+      ##
+      # Initialize
+      # jid:: [JID or String]
+      def initialize(jid)
+        super
+
+        @lock = Mutex.new
+        @pending_requests = 0
+        @last_send = Time.at(0)
+        @send_buffer = ''
+
+        @http_wait = 20
+        @http_hold = 1
+        @http_content_type = 'text/xml; charset=utf-8'
+      end
+
+      ##
+      # Set up the stream using uri as the HTTP Binding URI
+      #
+      # You may optionally pass host and port parameters
+      # to make use of the JEP0124 'route' feature.
+      #
+      # uri:: [URI::Generic or String]
+      # host:: [String] Optional host to route to
+      # port:: [Fixnum] Port for route feature
+      def connect(uri, host=nil, port=5222)
+        uri = URI::parse(uri) unless uri.kind_of? URI::Generic
+        @uri = uri
+
+        @allow_tls = false  # Shall be done at HTTP level
+        @stream_mechanisms = []
+        @stream_features = {}
+        @http_rid = IdGenerator.generate_id.to_i
+        @pending_rid = @http_rid
+        @pending_rid_lock = Mutex.new
+
+        req_body = REXML::Element.new('body')
+        req_body.attributes['rid'] = @http_rid
+        req_body.attributes['content'] = @http_content_type
+        req_body.attributes['hold'] = @http_hold.to_s
+        req_body.attributes['wait'] = @http_wait.to_s
+        req_body.attributes['to'] = @jid.domain
+        if host
+          req_body.attributes['route'] = 'xmpp:#{host}:#{port}'
+        end
+        req_body.attributes['secure'] = 'true'
+        req_body.attributes['xmlns'] = 'http://jabber.org/protocol/httpbind'
+        res_body = post(req_body)
+        unless res_body.name == 'body'
+          raise 'Response body is no <body/> element'
+        end
+
+        @streamid = res_body.attributes['authid']
+        @status = CONNECTED
+        @http_sid = res_body.attributes['sid']
+        @http_wait = res_body.attributes['wait'].to_i if res_body.attributes['wait']
+        @http_hold = res_body.attributes['hold'].to_i if res_body.attributes['hold']
+        @http_inactivity = res_body.attributes['inactivity'].to_i
+        @http_polling = res_body.attributes['polling'].to_i
+        @http_polling = 5 if @http_polling == 0
+        @http_requests = res_body.attributes['requests'].to_i
+        @http_requests = 1 if @http_requests == 0
+
+        receive_elements_with_rid(@http_rid, res_body.children)
+
+        @features_sem.run
+      end
+
+      ##
+      # Send a stanza, additionally with block
+      #
+      # This method ensures a 'jabber:client' namespace for
+      # the stanza
+      def send(xml, &block)
+        if xml.kind_of? REXML::Element
+          xml.add_namespace('jabber:client')
+        end
+
+        super
+      end
+
+      ##
+      # Ensure that there is one pending request
+      #
+      # Will be automatically called if you've sent
+      # a stanza.
+      def ensure_one_pending_request
+        return if is_disconnected?
+
+        if @lock.synchronize { @pending_requests } < 1
+          send_data('')
+        end
+      end
+
+      ##
+      # Close the session by sending
+      # <presence type='unavailable'/>
+      def close
+        @status = DISCONNECTED
+        send(Jabber::Presence.new.set_type(:unavailable))
+      end
+
+      private
+
+      ##
+      # Receive stanzas ensuring that the 'rid' order is kept
+      # result:: [REXML::Element]
+      def receive_elements_with_rid(rid, elements)
+        while rid > @pending_rid
+          @pending_rid_lock.lock
+        end
+        @pending_rid = rid + 1
+
+        elements.each { |e|
+          receive(e)
+        }
+
+        @pending_rid_lock.unlock
+      end
+
+      ##
+      # Do a POST request
+      def post(body)
+        body = body.to_s
+        request = Net::HTTP::Post.new(@uri.path)
+        request.content_length = body.size
+        request.body = body
+        request['Content-Type'] = @http_content_type
+        Jabber::debuglog("HTTP REQUEST (#{@pending_requests}/#{@http_requests}):\n#{request.body}")
+        response = Net::HTTP.start(@uri.host, @uri.port) { |http|
+          http.use_ssl = true if @uri.kind_of? URI::HTTPS
+          http.request(request)
+        }
+        Jabber::debuglog("HTTP RESPONSE (#{@pending_requests}/#{@http_requests}):\n#{response.body}")
+
+        unless response.kind_of? Net::HTTPSuccess
+          # Unfortunately, HTTPResponses aren't exceptions
+          # TODO: rescue'ing code should be able to distinguish
+          raise Net::HTTPBadResponse, "#{response.class}"
+        end
+
+        body = REXML::Document.new(response.body).root
+        if body.name != 'body' and body.namespace != 'http://jabber.org/protocol/httpbind'
+          raise REXML::ParseException.new('Malformed body')
+        end
+        body
+      end
+
+      ##
+      # Prepare data to POST and
+      # handle the result
+      def post_data(data)
+        req_body = nil
+        current_rid = nil
+
+        begin
+          begin
+            @lock.synchronize {
+              # Do not send unneeded requests
+              if data.size < 1 and @pending_requests > 0
+                return
+              end
+
+              req_body = "<body"
+              req_body += " rid='#{@http_rid += 1}'"
+              req_body += " sid='#{@http_sid}'"
+              req_body += " xmlns='http://jabber.org/protocol/httpbind'"
+              req_body += ">"
+              req_body += data
+              req_body += "</body>"
+              current_rid = @http_rid
+
+              @pending_requests += 1
+              @last_send = Time.now
+            }
+
+            res_body = post(req_body)
+
+          ensure
+            @lock.synchronize { @pending_requests -= 1 }
+          end
+
+          receive_elements_with_rid(current_rid, res_body.children)
+          ensure_one_pending_request
+
+        rescue REXML::ParseException
+          if @exception_block
+            Thread.new do
+              Thread.current.abort_on_exception = true
+              close; @exception_block.call(e, self, :parser)
+            end
+          else
+            puts "Exception caught when parsing HTTP response!"
+            close
+            raise
+          end
+
+        rescue StandardError => e
+          Jabber::debuglog("POST error (will retry): #{e.class}: #{e}")
+          receive_elements_with_rid(current_rid, [])
+          # It's not good to resend on *any* exception,
+          # but there are too many cases (Timeout, 404, 502)
+          # where resending is appropriate
+          # TODO: recognize these conditions and act appropriate
+          send_data(data)
+        end
+      end
+
+      ##
+      # Send data,
+      # buffered and obeying 'polling' and 'requests' limits
+      def send_data(data)
+        @lock.synchronize do
+
+          @send_buffer += data
+          limited_by_polling = (@last_send + @http_polling >= Time.now)
+          limited_by_requests = (@pending_requests + 1 > @http_requests)
+
+          # Can we send?
+          if !limited_by_polling and !limited_by_requests
+            data = @send_buffer
+            @send_buffer = ''
+
+            Thread.new do
+              Thread.current.abort_on_exception = true
+              post_data(data)
+            end
+
+          elsif !limited_by_requests
+            Thread.new do
+              Thread.current.abort_on_exception = true
+              # Defer until @http_polling has expired
+              wait = @last_send + @http_polling - Time.now
+              sleep(wait) if wait > 0
+              # Ignore locking, it's already threaded ;-)
+              send_data('')
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/xmpp4r/iq.rb

@@ -2,17 +2,23 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 
-require 'xmpp4r/xmlstanza'
+require 'xmpp4r/xmppstanza'
 require 'xmpp4r/jid'
 require 'digest/sha1'
 
+require 'xmpp4r/query'
+require 'xmpp4r/vcard/iq/vcard'
+
 module Jabber
   ##
   # IQ: Information/Query
   # (see RFC3920 - 9.2.3
   #
   # A class used to build/parse IQ requests/responses
-  class Iq < XMLStanza
+  class Iq < XMPPStanza
+    name_xmlns 'iq', 'jabber:client'
+    force_xmlns true
+
     @@element_classes = {}
 
     ##
@@ -20,13 +26,14 @@ module Jabber
     # type:: [Symbol] or nil, see Iq#type
     # to:: [JID] Recipient
     def initialize(type = nil, to = nil)
-      super("iq")
+      super()
+
       if not to.nil?
         set_to(to)
-      end 
+      end
       if not type.nil?
         set_type(type)
-      end 
+      end
     end
 
     ##
@@ -88,7 +95,7 @@ module Jabber
     ##
     # Returns the iq's query's namespace, or nil
     # result:: [String]
-    def queryns 
+    def queryns
       e = first_element('query')
       if e
         return e.namespace
@@ -100,30 +107,22 @@ module Jabber
     ##
     # Returns the iq's <vCard/> child, or nil
     # result:: [IqVcard]
-    def vcard 
+    def vcard
       first_element('vCard')
     end
 
     ##
-    # Create a new iq from a stanza,
-    # copies all attributes and children from xmlstanza
-    # xmlstanza:: [REXML::Element] Source stanza
-    # return:: [Iq] New stanza
-    def Iq.import(xmlstanza)
-      Iq::new.import(xmlstanza)
+    # Returns the iq's <pubsub/> child, or nil
+    # result:: [IqVcard]
+    def pubsub
+      first_element('pubsub')
     end
 
     ##
-    # Add an element to the Iq stanza
-    # element:: [REXML::Element] Element to add.
-    # Will be automatically converted (imported) to
-    # a class registered with add_elementclass
-    def typed_add(element)
-      if element.kind_of?(REXML::Element) && @@element_classes.has_key?(element.name)
-        super(@@element_classes[element.name]::import(element))
-      else
-        super(element)
-      end
+    # Returns the iq's <command/> child, or nil
+    # resulte:: [IqCommand]
+    def command
+      first_element("command")
     end
 
     ##
@@ -207,23 +206,5 @@ module Jabber
       iq.add(query)
       iq
     end
-
-    ##
-    # Add a class by name.
-    # Elements with this name will be automatically converted
-    # to the specific class.
-    # Used for <query/>, <vCard>, <pubsub> etc.
-    # name:: [String] Element name
-    # elementclass:: [Class] Target class
-    def Iq.add_elementclass(name, elementclass)
-      @@element_classes[name] = elementclass
-    end
   end
 end
-
-# Actually these should be included at the top,
-# but then they would be unable to call Iq.add_elementclass
-# because it hasn't just been defined.
-
-require 'xmpp4r/query'
-require 'xmpp4r/vcard/iq/vcard'

data/lib/xmpp4r/message.rb

@@ -2,21 +2,26 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 
-require 'xmpp4r/xmlstanza'
+require 'xmpp4r/xmppstanza'
 require 'xmpp4r/x'
 
 module Jabber
   ##
   # The Message class manages the <message/> stanzas,
   # which is used for all messaging communication.
-  class Message < XMLStanza
+  class Message < XMPPStanza
+
+    name_xmlns 'message', 'jabber:client'
+    force_xmlns true
+
+    include XParent
 
     ##
     # Create a new message
     # >to:: a JID or a String object to send the message to.
     # >body:: the message's body
     def initialize(to = nil, body = nil)
-      super("message")
+      super()
       if not to.nil?
         set_to(to)
       end
@@ -25,19 +30,6 @@ module Jabber
       end
     end
 
-    ##
-    # Add a sub-element
-    #
-    # Will be converted to [X] if named "x"
-    # element:: [REXML::Element] to add
-    def typed_add(element)
-      if element.kind_of?(REXML::Element) && (element.name == 'x')
-        super(X::import(element))
-      else
-        super(element)
-      end
-    end
-
     ##
     # Get the type of the Message stanza
     #
@@ -81,19 +73,6 @@ module Jabber
       self
     end
 
-    ##
-    # Get the first <x/> element in this stanza, or nil if none found.
-    # namespace:: [String] Optional, find the first <x/> element having this xmlns
-    # result:: [REXML::Element] or nil
-    def x(namespace=nil)
-      each_element('x') { |x|
-        if namespace.nil? or namespace == x.namespace
-          return x
-        end
-      }
-      nil
-    end
-
     ##
     # Returns the message's body, or nil.
     # This is the message's plain-text content.
@@ -101,15 +80,6 @@ module Jabber
       first_element_text('body')
     end
 
-    ##
-    # Create a new message from a stanza,
-    # by copying all attributes and children from it.
-    # xmlstanza:: [REXML::Element] Source
-    # return:: [Message] Result
-    def Message.import(xmlstanza)
-      Message::new.import(xmlstanza)
-    end
-
     ##
     # Sets the message's body
     #