blather 0.2.1 → 0.2.2

data/lib/blather/stream.rb

@@ -1,8 +1,13 @@
 module Blather
 
-  module Stream
-
-    # Connect to the server
+  class Stream < EventMachine::Connection
+    ##
+    # Start the stream between client and server
+    #   [client] must be an object that will respond to #call and #jid=
+    #   [jid] must be a valid argument for JID.new (see JID)
+    #   [pass] must be the password
+    #   [host] (optional) must be the hostname or IP to connect to. defaults to the domain of [jid]
+    #   [port] (optional) must be the port to connect to. defaults to 5222
     def self.start(client, jid, pass, host = nil, port = 5222)
       jid = JID.new jid
       host ||= jid.domain
@@ -10,43 +15,85 @@ module Blather
       EM.connect host, port, self, client, jid, pass
     end
 
+    ##
+    # Send data over the wire
+    #   The argument for this can be anything that
+    #   responds to #to_s
+    def send(stanza)
+      #TODO Queue if not ready
+      LOG.debug "SENDING: (#{caller[1]}) #{stanza}"
+      send_data stanza.respond_to?(:to_xml) ? stanza.to_xml : stanza.to_s
+    end
+
+    ##
+    # True if the stream is in the stopped state
+    def stopped?
+      @state == :stopped
+    end
+
+    ##
+    # True when the stream is in the negotiation phase.
+    def negotiating?
+      ![:stopped, :ready].include? @state
+    end
+
+    ##
+    # True when the stream is ready
+    #   The stream is ready immediately after receiving <stream:stream>
+    #   and before any feature negotion. Once feature negoation starts
+    #   the stream will not be ready until all negotations have completed
+    #   successfully.
+    def ready?
+      @state == :ready
+    end
+
+    ##
+    # Called by EM.connect to initialize stream variables
     def initialize(client, jid, pass) # :nodoc:
       super()
 
+      @error = nil
       @client = client
 
       self.jid = jid
       @pass = pass
 
       @to = @jid.domain
-      @id = nil
-      @lang = 'en'
-      @version = '1.0'
-      @namespace = 'jabber:client'
-
-      @parser = Parser.new self
     end
 
+    ##
+    # Called when EM completes the connection to the server
+    # this kicks off the starttls/authorize/bind process
     def connection_completed # :nodoc:
 #      @keepalive = EM::Timer.new(60) { send_data ' ' }
       @state = :stopped
       dispatch
     end
 
+    ##
+    # Called by EM with data from the wire
     def receive_data(data) # :nodoc:
-      @parser.parse data
+      LOG.debug "\n#{'-'*30}\n"
+      LOG.debug "<< #{data}"
+      @parser.receive_data data
 
-    rescue => e
-      @client.respond_to?(:rescue) ? @client.rescue(e) : raise(e)
+    rescue ParseError => e
+      @error = e
+      stop
     end
 
+    ##
+    # Called by EM when the connection is closed
     def unbind # :nodoc:
 #      @keepalive.cancel
       @state = :stopped
+      @client.call @error if @error
+      @client.stopped
     end
 
+    ##
+    # Called by the parser with parsed nodes
     def receive(node) # :nodoc:
-      LOG.debug "\n"+('-'*30)+"\n"
       LOG.debug "RECEIVING (#{node.element_name}) #{node}"
       @node = node
 
@@ -55,7 +102,7 @@ module Blather
         @state = :ready if @state == :stopped
 
       when 'stream:end'
-        @state = :stopped
+        stop
 
       when 'stream:features'
         @features = @node.children
@@ -63,7 +110,9 @@ module Blather
         dispatch
 
       when 'stream:error'
-        raise StreamError.new(@node)
+        @error = StreamError.import @node
+        stop
+        @state = :error
 
       else
         dispatch
@@ -72,61 +121,57 @@ module Blather
     end
 
     ##
-    # Send data over the wire
-    def send(stanza)
-      #TODO Queue if not ready
-      LOG.debug "SENDING: (#{caller[1]}) #{stanza}"
-      send_data stanza.to_s
-    end
-
-    def stopped?
-      @state == :stopped
-    end
-
-    def ready?
-      @state == :ready
-    end
-
+    # Ensure the JID gets attached to the client
     def jid=(new_jid) # :nodoc:
       LOG.debug "NEW JID: #{new_jid}"
-      new_jid = JID.new new_jid
-      @client.jid = new_jid
-      @jid = new_jid
+      @jid = JID.new new_jid
+      @client.jid = @jid
     end
 
-  private
+  protected
+    ##
+    # Dispatch based on current state
     def dispatch
       __send__ @state
     end
 
+    ##
+    # Start the stream
+    #   Each time the stream is started or re-started we need to kill off the old
+    #   parser so as not to confuse it
     def start
-      send <<-STREAM
-        <stream:stream
-          to='#{@to}'
-          xmlns='#{@namespace}'
-          xmlns:stream='http://etherx.jabber.org/streams'
-          version='#{@version}'
-          xml:lang='#{@lang}'
-        >
-      STREAM
     end
 
+    ##
+    # Stop the stream
     def stop
-      send '</stream:stream>'
+      unless @state == :stopped
+        @state = :stopped
+        send '</stream:stream>'
+      end
     end
 
+    ##
+    # Called when @state == :stopped to start the stream
+    #   Counter intuitive, I know
     def stopped
       start
     end
 
+    ##
+    # Called when @state == :ready
+    #   Simply passes the stanza to the client
     def ready
       @client.call @node.to_stanza
     end
 
+    ##
+    # Called when @state == :features
+    #   Runs through the list of features starting each one in turn
     def features
       feature = @features.first
       LOG.debug "FEATURE: #{feature}"
-      @state = case feature ? feature['xmlns'] : nil
+      @state = case feature ? feature.namespaces.default.href : nil
       when 'urn:ietf:params:xml:ns:xmpp-tls'      then :establish_tls
       when 'urn:ietf:params:xml:ns:xmpp-sasl'     then :authenticate_sasl
       when 'urn:ietf:params:xml:ns:xmpp-bind'     then :bind_resource
@@ -134,47 +179,70 @@ module Blather
       else :ready
       end
 
+      # Dispatch to the individual feature methods unless
+      # feature negotiation is complete
       dispatch unless ready?
     end
 
+    ##
+    # Start TLS
     def establish_tls
       unless @tls
         @tls = TLS.new self
-        @tls.success { LOG.debug "TLS: SUCCESS"; @tls = nil; start }
-        @tls.failure { LOG.debug "TLS: FAILURE"; stop }
+        # on success destroy the TLS object and restart the stream
+        @tls.on_success { LOG.debug "TLS: SUCCESS"; @tls = nil; start }
+        # on failure stop the stream
+        @tls.on_failure { |err| LOG.debug "TLS: FAILURE"; @error = err; stop }
+
         @node = @features.shift
       end
-      @tls.receive @node
+      @tls.handle @node
     end
 
+    ##
+    # Authenticate via SASL
     def authenticate_sasl
       unless @sasl
         @sasl = SASL.new(self, @jid, @pass)
-        @sasl.success { LOG.debug "SASL SUCCESS"; @sasl = nil; start }
-        @sasl.failure { LOG.debug "SASL FAIL"; stop }
+        # on success destroy the SASL object and restart the stream
+        @sasl.on_success { LOG.debug "SASL SUCCESS"; @sasl = nil; start }
+        # on failure set the error and stop the stream
+        @sasl.on_failure { |err| LOG.debug "SASL FAIL"; @error = err; stop }
+
         @node = @features.shift
       end
-      @sasl.receive @node
+      @sasl.handle @node
     end
 
+    ##
+    # Bind to the resource provided by either the client or the server
     def bind_resource
       unless @resource
         @resource = Resource.new self, @jid
-        @resource.success { |jid| LOG.debug "RESOURCE: SUCCESS"; @resource = nil; self.jid = jid; @state = :features; dispatch }
-        @resource.failure { LOG.debug "RESOURCE: FAILURE"; stop }
+        # on success destroy the Resource object, set the jid, continue along the features dispatch process
+        @resource.on_success { |jid| LOG.debug "RESOURCE: SUCCESS"; @resource = nil; self.jid = jid; @state = :features; dispatch }
+        # on failure end the stream
+        @resource.on_failure { |err| LOG.debug "RESOURCE: FAILURE"; @error = err; stop }
+
         @node = @features.shift
       end
-      @resource.receive @node
+      @resource.handle @node
     end
 
+    ##
+    # Establish the session between client and server
     def establish_session
       unless @session
         @session = Session.new self, @to
-        @session.success { LOG.debug "SESSION: SUCCESS"; @session = nil; @client.stream_started(self); @state = :features; dispatch }
-        @session.failure { LOG.debug "SESSION: FAILURE"; stop }
+        # on success destroy the session object, let the client know the stream has been started
+        # then continue the features dispatch process
+        @session.on_success { LOG.debug "SESSION: SUCCESS"; @session = nil; @client.stream_started(self); @state = :features; dispatch }
+        # on failure end the stream
+        @session.on_failure { |err| LOG.debug "SESSION: FAILURE"; @error = err; stop }
+
         @node = @features.shift
       end
-      @session.receive @node
+      @session.handle @node
     end
   end
 

data/lib/blather/stream/client.rb

@@ -0,0 +1,26 @@
+module Blather
+class Stream
+
+  class Client < Stream
+    LANG = 'en'
+    VERSION = '1.0'
+    NAMESPACE = 'jabber:client'
+
+  protected
+    def start
+      @parser = Parser.new self
+      start_stream = <<-STREAM
+        <stream:stream
+          to='#{@to}'
+          xmlns='#{NAMESPACE}'
+          xmlns:stream='http://etherx.jabber.org/streams'
+          version='#{VERSION}'
+          xml:lang='#{LANG}'
+        >
+      STREAM
+      send start_stream.gsub(/\s+/, ' ')
+    end
+  end #Client
+
+end #Stream
+end #Blather

data/lib/blather/stream/component.rb

@@ -0,0 +1,34 @@
+module Blather
+class Stream
+
+  class Component < Stream
+    NAMESPACE = 'jabber:component:accept'
+
+    def receive(node) # :nodoc:
+      if node.element_name == 'handshake'
+        @client.stream_started(self)
+      else
+        super
+      end
+
+      if node.element_name == 'stream:stream'
+        send("<handshake>#{Digest::SHA1.hexdigest(@node['id']+@pass)}</handshake>")
+      end
+    end
+
+  protected
+    def start
+      @parser = Parser.new self
+      start_stream = <<-STREAM
+        <stream:stream
+          to='#{@jid}'
+          xmlns='#{NAMESPACE}'
+          xmlns:stream='http://etherx.jabber.org/streams'
+        >
+      STREAM
+      send start_stream.gsub(/\s+/, ' ')
+    end
+  end #Client
+
+end #Stream
+end #Blather

data/lib/blather/stream/parser.rb

@@ -1,11 +1,11 @@
 module Blather # :nodoc:
-module Stream # :nodoc:
+class Stream # :nodoc:
 
   class Parser # :nodoc:
     STREAM_REGEX = %r{(/)?stream:stream}.freeze
     ERROR_REGEX = /^<(stream:[a-z]+)/.freeze
 
-    @@debug = false
+    @@debug = !false
     def self.debug; @@debug; end
     def self.debug=(debug); @@debug = debug; end
 
@@ -14,31 +14,20 @@ module Stream # :nodoc:
     def initialize(receiver)
       @receiver = receiver
       @current = nil
-
-      @parser = XML::SaxParser.new
-      @parser.io = StringIO.new
-      @parser.callbacks = self
+      @parser = XML::SaxPushParser.new self
     end
 
-    def parse(string)
-      LOG.debug "PARSING: #{string}" if @@debug
-      if string =~ STREAM_REGEX && $1
-        @receiver.receive XMPPNode.new('stream:end')
-      else
-        string << "</stream:stream>" if string =~ STREAM_REGEX && !$1
-        string.gsub!(ERROR_REGEX, "<\\1 xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'")
-
-        @parser.string = string
-        @parser.parse
-      end
+    def receive_data(string)
+      LOG.debug "PARSING: (#{string})" if @@debug
+      @parser.receive string
     end
 
-    NON_ATTRS = [nil, 'stream'].freeze
     def on_start_element_ns(elem, attrs, prefix, uri, namespaces)
-      LOG.debug "START ELEM: (#{{:elem => elem, :attrs => attrs, :prefix => prefix, :ns => namespaces}.inspect})" if @@debug
+      LOG.debug "START ELEM: (#{{:elem => elem, :attrs => attrs, :prefix => prefix, :uri => uri, :ns => namespaces}.inspect})" if @@debug
       elem = "#{"#{prefix}:" if prefix}#{elem}"
       e = XMPPNode.new elem
-      attrs.each { |n,v| n = "xmlns#{":#{n}" if n}" if NON_ATTRS.include?(n); e.attributes[n] = v }
+      XML::Namespace.new(e, prefix, uri)
+      attrs.each { |k,v| e.attributes[k] = v if k }
 
       if elem == 'stream:stream'
         @receiver.receive e
@@ -56,23 +45,24 @@ module Stream # :nodoc:
     end
 
     def on_end_element_ns(elem, prefix, uri)
-      LOG.debug "END ELEM: #{{:elem => elem, :prefix => prefix, :uri => uri, :current => @current}.inspect}" if @@debug
+      LOG.debug "END ELEM: #{{:elem => elem, :prefix => prefix, :uri => uri}.inspect}" if @@debug
 
-      elem = "#{"#{prefix}:" if prefix}#{elem}"
-      return if elem =~ STREAM_REGEX
+      if !@current && "#{prefix}:#{elem}" =~ STREAM_REGEX
+        @receiver.receive XMPPNode.new('stream:end')
 
-      if @current.parent?
+      elsif @current.parent?
         @current = @current.parent
 
       else
         c, @current = @current, nil
+        XML::Document.new.root = c
         @receiver.receive c
 
       end
+    end
 
-      def on_error(msg)
-        raise Blather::ParseError, msg.to_s
-      end
+    def on_error(msg)
+      raise ParseError.new(msg.to_s)
     end
   end #Parser
 

data/lib/blather/stream/resource.rb

@@ -1,49 +1,46 @@
 module Blather # :nodoc:
-module Stream # :nodoc:
+class Stream # :nodoc:
 
-  class Resource # :nodoc:
+  class Resource < StreamHandler # :nodoc:
     def initialize(stream, jid)
-      @stream = stream
+      super stream
       @jid = jid
-      @callbacks = {}
-    end
-
-    def success(&callback)
-      @callbacks[:success] = callback
-    end
-
-    def failure(&callback)
-      @callbacks[:failure] = callback
-    end
-
-    def receive(node)
-      @node = node
-      __send__(@node.element_name == 'iq' ? @node['type'] : @node.element_name)
     end
 
+  private
+    ##
+    # Respond to the bind request
+    # If @jid has a resource set already request it from the server
     def bind
+      response = Stanza::Iq.new :set
+      @id = response.id
+
       binder = XMPPNode.new('bind')
-      binder.xmlns = 'urn:ietf:params:xml:ns:xmpp-bind'
+      binder.namespace = 'urn:ietf:params:xml:ns:xmpp-bind'
 
       binder << XMPPNode.new('resource', @jid.resource) if @jid.resource
 
-      response = Stanza::Iq.new :set
-      @id = response.id
       response << binder
-
       @stream.send response
     end
 
+    ##
+    # Process the result from the server
+    # Sets the sends the JID (now bound to a resource)
+    # back to the stream
     def result
       LOG.debug "RESOURE NODE #{@node}"
+      # ensure this is a response to our original request
       if @id == @node['id']
-        @jid = JID.new @node.find_first('bind').content_from(:jid)
-        @callbacks[:success].call(@jid) if @callbacks[:success]
+        @jid = JID.new @node.find_first('bind/jid').content
+        success @jid
       end
     end
 
+    ##
+    # Server returned an error
     def error
-      @callbacks[:failure].call if @callbacks[:failure]
+      failure StanzaError.import(@node)
     end
   end #Resource