xmpp4em 0.2.0

data/History.txt

@@ -0,0 +1,6 @@
+== 0.2.0 / 2010-04-19
+
+	Added new Component connection.
+	Made base classes for Client, Component and connections.
+	Added class Lazy Loading. 
+	Add Credits.	

data/README.md

@@ -0,0 +1,10 @@
+# XMPP4EM
+
+Simple XMPP client built on EventMachine.
+
+Requires eventmachine-xmlpushparser (in vendor/) and eventmachine 0.12.1
+
+# CREDIT
+
+ * by Aman Gupta
+ * by Kokorin Denis (http://blog.mccoder.name)

data/Rakefile

@@ -0,0 +1,5 @@
+task :default do
+  Dir.chdir('spec'){
+    sh 'bacon spec_runner.rb'
+  }
+end

data/examples/component_test.rb

@@ -0,0 +1,39 @@
+#encoding: utf-8
+require 'xmpp4em'
+
+started = Time.now
+users = {}
+connected = 0
+
+EM.epoll
+
+EM.run{  
+  user = XMPP4EM::Component.new("test.localhost", 'secret')
+  user.on(:login) do
+    connected += 1
+    p ['connected', "#{connected}"]  
+    
+    p ['done', Time.now - started]
+    #EM.stop_event_loop      
+  end
+  user.on(:iq) do |stanza|
+	p ["IQ",stanza]
+	stanza.to,stanza.from=stanza.from,stanza.to
+	user.send stanza
+  end
+  user.on(:message) do |stanza|
+	p ["message", stanza]
+	stanza.to,stanza.from=stanza.from,stanza.to
+	user.send stanza
+  end
+  user.on(:presence) do |stanza|
+	p ["presence", stanza]
+	stanza.to,stanza.from=stanza.from,stanza.to
+	user.send stanza
+  end
+  user.on(:disconnect) do
+    p ['disconnected']
+  end
+  
+  user.connect('127.0.0.1', 5555)  
+}

data/examples/stress_test.rb

@@ -0,0 +1,40 @@
+require 'xmpp4em'
+
+started = Time.now
+users = {}
+connected = 0
+num = Integer(ARGV[0])
+num = 1000 if num < 1
+EM.epoll
+
+EM.run{
+  num.times do |i|
+    users[i] = XMPP4EM::Client.new("test_#{i}@localhost", 'test', :auto_register => true)
+    users[i].on(:login) do
+      connected += 1
+      p ['connected', i, "#{connected} of #{num}"]
+  
+      if connected == num
+        p ['done', Time.now - started]
+        EM.stop_event_loop
+      end
+    end
+users[i].on(:iq) do |stanza|
+	p "IQ"
+	p stanza
+  end
+users[i].on(:message) do |stanza|
+	p "IQ"
+	p stanza
+  end
+users[i].on(:presence) do |stanza|
+	p "IQ"
+	p stanza
+  end
+    users[i].on(:disconnect) do
+      p ['disconnected', i]
+    end
+  
+    users[i].connect('localhost', 5222)
+  end
+}

data/lib/xmpp4em/base_client.rb

@@ -0,0 +1,122 @@
+#encoding: utf-8
+require 'rubygems'
+
+require 'stringio'
+require 'rexml/parsers/sax2parser'
+
+require 'xmpp4r/idgenerator'
+require 'xmpp4r/xmppstanza'
+require 'xmpp4r/iq'
+require 'xmpp4r/message'
+require 'xmpp4r/presence'
+require 'resolv'
+
+require 'eventmachine'
+require 'evma_xmlpushparser'
+EM.epoll
+
+module XMPP4EM
+  
+  class BaseClient
+    include EM::Deferrable
+    
+    def initialize user, pass, logger=nil,opts = {}
+      @user = user
+      @pass = pass
+      @logger=logger
+      @deferred_status =:succeeded
+      @connection = nil
+      @authenticated = false
+      @opts = opts
+      @auth_callback = nil
+      @id_callbacks  = {}
+      @on_stanza=nil
+      @events_callbacks = {
+        :message    => [],
+        :presence   => [],
+        :iq         => [],
+        :exception  => [],
+        :login      => [],
+        :disconnect => [],
+        :connected  => []
+      }     
+      
+      on(:disconnect) do
+        @deferred_status = nil
+        @authenticated=false
+      end         
+      on(:login) do
+        succeed
+      end    
+    end
+    attr_reader :connection, :user
+    
+    def reconnect
+      @connection.close_connection_after_writing
+      @deferred_status = nil
+      connect
+    end
+    
+    def connected?
+      @connection and !@connection.error?
+    end
+        
+    def register_stanza &blk          
+      @on_stanza = blk if block_given?
+    end       
+    
+    def send data, safe=false,  &blk
+      
+      if block_given? and data.is_a? Jabber::XMPPStanza
+        if data.id.nil?
+          data.id = Jabber::IdGenerator.instance.generate_id
+        end
+        @id_callbacks[ data.id ] = blk
+      end
+      if safe
+        callback {   @connection.send(data) }
+      else
+        @connection.send(data)
+      end
+    end
+    
+    def close
+      @connection.close_connection_after_writing
+      @deferred_status = nil
+      @connection = nil
+    end
+    alias :disconnect :close
+        
+    def receive stanza
+      if stanza.kind_of?(Jabber::XMPPStanza) and stanza.id and blk = @id_callbacks[ stanza.id ]
+        @id_callbacks.delete stanza.id
+        blk.call(stanza)
+        return
+      end
+      
+      return if receive_stanza(stanza)      
+      return if @on_stanza && @on_stanza.call(stanza)  
+      
+      case stanza
+        when Jabber::Message then  on(:message, stanza)
+        when Jabber::Iq then  on(:iq, stanza)
+        when Jabber::Presence then on(:presence, stanza)
+      end
+    end
+    
+    def on type, *args, &blk
+      if blk
+        @events_callbacks[type] << blk
+      else
+        @events_callbacks[type].each do |blk|
+          blk.call(*args)
+        end
+      end
+    end
+    
+    def add_message_callback  (&blk) on :message,   &blk end
+    def add_presence_callback (&blk) on :presence,  &blk end
+    def add_iq_callback       (&blk) on :iq,        &blk end
+    def on_exception          (&blk) on :exception, &blk end
+  end
+end

data/lib/xmpp4em/base_connection.rb

@@ -0,0 +1,129 @@
+#encoding: utf-8
+require 'stringio'
+require 'rexml/parsers/sax2parser'
+
+require 'xmpp4r/idgenerator'
+require 'xmpp4r/xmppstanza'
+require 'xmpp4r/iq'
+require 'xmpp4r/message'
+require 'xmpp4r/presence'
+
+module XMPP4EM
+  
+  class BaseConnection < EventMachine::Connection
+    
+    def initialize host, port=5222
+      @host, @port = host, port
+      @client = nil
+    end
+    attr_accessor :client, :host, :port, :logger
+    
+    def connection_completed
+      @logger.debug{'connected'} if @logger
+      @stream_features, @stream_mechanisms = {}, []
+      @keepalive = EM::Timer.new(60){ send_data("\n") }
+      @client.on(:connected)
+      init
+    end
+    attr_reader :stream_features
+    
+    include EventMachine::XmlPushParser
+    
+    def encode2utf8(text)
+      text.respond_to?(:force_encoding) ? text.force_encoding("utf-8") : text
+    end
+    
+    def start_element name, attrs
+      e = REXML::Element.new(name)
+      attrs.each { |name, value|
+        e.add_attribute(name, encode2utf8(value))
+      }
+      
+      @current = @current.nil? ? e : @current.add_element(e)
+      
+      if @current.name == 'stream' and not @started
+        @started = true
+        process
+        @current = nil
+      end
+    end
+    
+    def end_element name
+      if name == 'stream:stream' and @current.nil?
+        @started = false
+      else
+        if @current.parent
+          @current = @current.parent
+        else
+          process
+          @current = nil
+        end
+      end
+    end
+    
+    def characters text
+      @current.text = @current.text.to_s + encode2utf8(text) if @current
+    end
+    
+    def error *args
+      p ['error', *args]
+    end
+    
+    def receive_data data
+      @logger.debug{"<< #{data}"} if @logger
+      super
+    end
+    
+    def send data, &blk
+      @logger.debug{ ">> #{data}"} if @logger
+      send_data data.to_s     
+    end
+    
+    def unbind
+      if @keepalive
+        @keepalive.cancel
+        @keepalive = nil
+      end
+      @client.on(:disconnect)
+      @logger.debug{'disconnected'} if @logger
+    end
+    
+    def reconnect host = @host, port = @port
+      super
+    end
+    
+    def init
+      send "<?xml version='1.0' ?>" unless @started
+      @started = false
+      send "<stream:stream xmlns:stream='http://etherx.jabber.org/streams' xmlns='#{namespace;}' xml:lang='en' version='1.0' to='#{@host}'>"
+    end
+    
+    private
+    
+    def  pre_process_stanza(stanza)
+    end    
+    
+    def process
+      if @current.namespace('').to_s == '' # REXML namespaces are always strings
+        @current.add_namespace(@streamns)
+      end
+      stanza = @current
+      if  'stream'==stanza.prefix
+        if 'stream'==stanza.name
+          @streamid = stanza.attributes['id']      
+          #All connections has the same namespace
+          @streamns = 'jabber:client'    
+        end
+        pre_process_stanza(stanza)	 
+      end
+      # Any stanza, classes are registered by XMPPElement::name_xmlns
+      begin
+        stanza = Jabber::XMPPStanza::import(@current)
+      rescue Jabber::NoNameXmlnsRegistered
+        stanza = @current
+      end
+      @client.receive(stanza)
+    end
+  end
+  
+end

data/lib/xmpp4em/client.rb

@@ -0,0 +1,138 @@
+#encoding: utf-8
+require 'xmpp4r/sasl'
+require 'resolv'
+
+module XMPP4EM
+  
+  class Client < BaseClient
+    
+    def initialize user, pass, logger=nil, opts = {}
+      super      
+      @opts = { :auto_register => false }.merge(opts)        
+    end
+    
+    def jid
+      @jid ||= if @user.kind_of?(Jabber::JID)
+        @user
+      else
+        @user =~ /@/ ? Jabber::JID.new(@user) : Jabber::JID.new(@user, 'localhost')
+      end
+    end
+    
+    def connect host = jid.domain, port = 5222
+      if host=='localhost' || host=='127.0.0.1' || %r{^([0-9]{1,3}.){3}[0-9]{1,3}$}.match(host)
+        target_host, target_port= host, port
+      else
+        target_host, target_port = resolve_host(host)
+      end
+      EM.connect target_host, target_port, ClientConnection, jid.domain, port do |conn|
+        @connection = conn
+        conn.client = self
+        conn.logger=@logger
+      end
+    end   
+    
+    def resolve_host(domain)
+      srv = []
+      begin        
+        Resolv::DNS.open { |dns|
+          # If ruby version is too old and SRV is unknown, this will raise a NameError
+          # which is catched below
+          #debug("RESOLVING:\n_xmpp-client._tcp.#{domain} (SRV)")
+          srv = dns.getresources("_xmpp-client._tcp.#{domain}", Resolv::DNS::Resource::IN::SRV)
+        }
+      rescue NameError
+        
+      end
+      
+      unless srv.blank?
+        # Sort SRV records: lowest priority first, highest weight first
+        srv.sort! { |a,b| (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight) }        
+        #debug "USING #{srv.first.target.to_s}"
+        return srv.first.target.to_s, srv.first.port
+      else
+        #debug "USING #{domain}:5222"          
+        return domain, 5222
+      end
+      
+    end
+    
+    def login &blk
+      Jabber::SASL::new(self, 'PLAIN').auth(@pass)
+      @auth_callback = blk if block_given?
+    end
+    
+    def register &blk
+      reg = Jabber::Iq.new_register(jid.node, @pass)
+      reg.to = jid.domain
+      
+      send(reg){ |reply|
+        blk.call( reply.type == :result ? :success : reply.type )
+      }
+    end 
+    
+    def send_msg to, msg
+      send_safe Jabber::Message::new(to, msg).set_type(:chat)
+    end
+    
+    def receive_stanza(stanza)
+      
+      case stanza.name
+        when 'features'
+        unless @authenticated
+          login do |res|
+            # log ['login response', res].inspect
+            if res == :failure and @opts[:auto_register]
+              register do |res|
+                #p ['register response', res]
+                login unless res == :error
+              end
+            end
+          end
+          
+        else
+          if @connection.stream_features.has_key? 'bind'
+            iq = Jabber::Iq.new(:set)
+            bind = iq.add REXML::Element.new('bind')
+            bind.add_namespace @connection.stream_features['bind']            
+            resource = bind.add REXML::Element.new('resource')
+            resource.text=jid.resource
+            
+            send(iq){ |reply|
+              if reply.type == :result and jid = reply.first_element('//jid') and jid.text
+                # log ['new jid is', jid.text].inspect
+                @jid = Jabber::JID.new(jid.text)
+              end
+            }
+          end
+          
+          if @connection.stream_features.has_key? 'session'
+            iq = Jabber::Iq.new(:set)
+            session = iq.add REXML::Element.new('session')
+            session.add_namespace @connection.stream_features['session']
+            
+            send(iq){ |reply|
+              if reply.type == :result
+                on(:login, stanza)
+              end
+            }
+          end
+        end
+        
+        return true
+        
+        when 'success', 'failure'
+        if stanza.name == 'success'
+          @authenticated = true
+          @connection.reset_parser
+          @connection.init
+        end
+        
+        @auth_callback.call(stanza.name.to_sym) if @auth_callback
+        return true
+      end
+      false
+    end    
+    
+  end
+end

data/lib/xmpp4em/client_connection.rb

@@ -0,0 +1,24 @@
+#encoding: utf-8
+
+module XMPP4EM
+  
+  class ClientConnection < BaseConnection     
+    def namespace; 'jabber:client'; end;
+    
+    private
+    def pre_process_stanza(stanza)   
+      return if 'stream'!=stanza.prefix && 'features'!=stanza.name
+      @stream_features, @stream_mechanisms = {}, []
+      stanza.each do |e|
+        if e.name == 'mechanisms' and e.namespace == 'urn:ietf:params:xml:ns:xmpp-sasl'
+          e.each_element('mechanism') do |mech|
+            @stream_mechanisms.push(mech.text)
+          end
+        else
+          @stream_features[e.name] = e.namespace
+        end
+      end
+    end
+  end
+  
+end

data/lib/xmpp4em/component.rb

@@ -0,0 +1,45 @@
+#encoding: utf-8
+
+module XMPP4EM
+  
+  class Component < BaseClient    
+    def initialize user, pass, opts = {}
+      super
+    end
+   
+    def jid
+      @jid ||= @user.kind_of?(Jabber::JID) ? @user :  Jabber::JID.new(@user)               
+    end
+    
+    def connect host = jid.domain, port = 5222
+      EM.connect host, port, ComponentConnection, jid.domain, port do |conn|
+        @connection = conn
+        conn.client = self
+      end
+    end
+    
+    def receive_stanza(stanza)
+      
+      case stanza.name
+        when 'stream'
+        if !@authenticated && jid.domain == stanza.attributes['from']
+          streamid = stanza.attributes['id']
+          hash = Digest::SHA1::hexdigest(streamid.to_s + @pass)      
+          send("<handshake>#{hash}</handshake>")          
+        end
+        return true
+        when 'not-authorized'  
+        on(:error, 'not-authorized')
+        return true
+        when 'handshake'        
+        @authenticated = true
+        on(:login, stanza)
+        return true
+      end  
+      
+      false
+      
+    end
+    
+  end
+end

data/lib/xmpp4em/component_connection.rb

@@ -0,0 +1,9 @@
+#encoding: utf-8
+
+module XMPP4EM
+  
+  class ComponentConnection < BaseConnection
+    def namespace; 'jabber:component:accept'; end;
+  end
+  
+end

data/lib/xmpp4em.rb

@@ -0,0 +1,10 @@
+module XMPP4EM
+  class NotConnected < Exception; end
+  VERSION='0.2.0'
+  autoload :ClientConnection, 'xmpp4em/client_connection'
+  autoload :Client, 'xmpp4em/client'
+  autoload :BaseClient, 'xmpp4em/base_client'  
+  autoload :ComponentConnection, 'xmpp4em/component_connection'
+  autoload :BaseConnection, 'xmpp4em/base_connection'
+  autoload :Component, 'xmpp4em/component'
+end

data/spec/spec_runner.rb

@@ -0,0 +1,26 @@
+require 'bacon'
+$:.unshift File.dirname(__FILE__) + '/..'
+require 'xmpp4em'
+
+shared 'eventmachine' do
+  $bacon_thread = Thread.current
+  def wait
+    Thread.stop
+    @timer = EM::Timer.new(10) do
+      wake
+      should.flunk('waited too long')
+    end
+  end
+  def wake
+    $bacon_thread.wakeup
+    @timer.cancel if @timer
+  end
+end
+
+EM.run{
+  Thread.new{
+    Thread.abort_on_exception = true
+    require 'xmpp4em_spec'
+    EM.stop_event_loop
+  }
+}

data/spec/xmpp4em_spec.rb

@@ -0,0 +1,57 @@
+describe 'XMPP4EM' do
+  behaves_like 'eventmachine'
+
+  @foo = XMPP4EM::Client.new('foo@localhost', 'test', :auto_register => true)
+  @bar = XMPP4EM::Client.new('bar@localhost', 'test', :auto_register => true)
+
+  should 'login to an xmpp server' do
+    @foo.on(:login) do
+      @foo.send Jabber::Presence.new
+      wake
+    end
+
+    @foo.connect
+    wait
+
+    @foo.should.be.connected?
+  end
+
+  should 'send messages to others' do
+    @bar.on(:login) do
+      @bar.send Jabber::Presence.new do
+        wake
+      end
+    end
+
+    received = nil
+    @bar.on(:message) do |msg|
+      received = msg.first_element_text('//body')
+      wake
+    end
+
+    @bar.connect
+    wait
+
+    @foo.send_msg 'bar@localhost', 'hello'
+    wait
+
+    received.should == 'hello'
+  end
+
+  should 'fire disconnect callback and reconnect' do
+    user = XMPP4EM::Client.new('user@localhost', 'user', :auto_register => true)
+    user.on(:disconnect){ wake }
+    user.connect 'localhost', 5333 # invalid port
+    wait
+
+    user.should.not.be.connected?
+
+    user.instance_variable_get('@callbacks')[:disconnect] = []
+    user.connection.port = 5222
+    user.on(:login){ wake }
+    user.reconnect
+    wait
+
+    user.should.be.connected?
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: xmpp4em
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Aman Gupta
+- Kokorin Denis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-21 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 12
+        - 10
+        version: 0.12.10
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: xmpp4r
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        version: "0.5"
+  type: :runtime
+  version_requirements: *id002
+description: Simple XMPP client and component built on EventMachine.
+email: mccoder-nospam@ya.ru
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- Rakefile
+- History.txt
+- lib/xmpp4em/base_client.rb
+- lib/xmpp4em/base_connection.rb
+- lib/xmpp4em/client.rb
+- lib/xmpp4em/client_connection.rb
+- lib/xmpp4em/component.rb
+- lib/xmpp4em/component_connection.rb
+- lib/xmpp4em.rb
+- examples/component_test.rb
+- examples/stress_test.rb
+- spec/spec_runner.rb
+- spec/xmpp4em_spec.rb
+has_rdoc: true
+homepage: http://github.com/mccoder/xmpp4em
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      version: "1.9"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: EventMachine based XMPP client and component
+test_files: []
+