troystribling-agent_xmpp 0.0.0 → 0.0.1

data/lib/agent_xmpp/client.rb

@@ -1,3 +1,8 @@
-require 'agent_xmpp/client/parser'
+require 'agent_xmpp/client/response'
+require 'agent_xmpp/client/message_pipe'
+require 'agent_xmpp/client/message_delegate'
 require 'agent_xmpp/client/connection'
 require 'agent_xmpp/client/client'
+require 'agent_xmpp/client/roster_model'
+require 'agent_xmpp/client/services_model'
+require 'agent_xmpp/client/publish_model'

data/lib/agent_xmpp/client/client.rb

@@ -4,192 +4,59 @@ module AgentXmpp
   #####-------------------------------------------------------------------------------------------------------
   class Client
 
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+
+    #### self
+    end
+    
     #---------------------------------------------------------------------------------------------------------
-    attr_reader :jid, :port, :password, :roster, :connection
+    attr_reader :connection
     #---------------------------------------------------------------------------------------------------------
 
     #.........................................................................................................
-    def initialize(config)
-      @password = config['password']
-      @port = config['port'] || 5222
-      resource = config['resource'] || Socket.gethostname
-      @jid = Jabber::JID.new("#{config['jid']}/#{resource}")
-      @roster = Roster.new(@jid, config['contacts'])
+    def initialize
     end
 
     #.........................................................................................................
     def connect
       while (true)
         EventMachine.run do
-          @connection = EventMachine.connect(jid.domain, port, Connection, self, jid, password, port)
+          @connection = EventMachine.connect(AgentXmpp.jid.domain, AgentXmpp.port, Connection, self)
         end
+        Boot.call_if_implemented(:call_restarting_client, pipe)     
         sleep(10.0)
-        AgentXmpp.logger.warn "RESTARTING SERVER"
+        AgentXmpp.logger.warn "RESTARTING CLIENT"
       end
     end
 
+    #.........................................................................................................
+    def close_connection
+      AgentXmpp.logger.info "CLOSE CONNECTION"
+      connection.close_connection_after_writing unless connection.nil?
+    end
+
     #.........................................................................................................
     def reconnect
       AgentXmpp.logger.info "RECONNECTING"
-      connection.reconnect(jid.domain, port)
+      connection.reconnect(jid.domain, port) unless connection.nil?
     end
 
     #.........................................................................................................
-    def connected?
-      connection and !connection.error?
+    def pipe
+      connection.pipe
     end
 
     #.........................................................................................................
     def add_delegate(delegate)
-      connection.add_delegate(delegate)
+      connection.pipe.add_delegate(delegate)
     end
 
     #.........................................................................................................
     def remove_delegate(delegate)
-      connection.remove_delegate(delegate)
+      connection.pipe.remove_delegate(delegate)
     end
     
-    #---------------------------------------------------------------------------------------------------------
-    # AgentXmpp::Connection delegate
-    #.........................................................................................................
-    # connection
-    #.........................................................................................................
-    def did_connect(client_connection)
-      AgentXmpp.logger.info "CONNECTED"
-    end
-
-    #.........................................................................................................
-    def did_disconnect(client_connection)
-      AgentXmpp.logger.warn "DISCONNECTED"
-      EventMachine::stop_event_loop
-    end
-
-    #.........................................................................................................
-    def did_not_connect(client_connection)
-      AgentXmpp.logger.warn "CONNECTION FAILED"
-    end
-
-    #.........................................................................................................
-    # authentication
-    #.........................................................................................................
-    def did_authenticate(client_connection, stanza)
-      AgentXmpp.logger.info "AUTHENTICATED"
-    end
- 
-    #.........................................................................................................
-    def did_not_authenticate(client_connection, stanza)
-      AgentXmpp.logger.info "AUTHENTICATION FAILED"
-    end
-
-    #.........................................................................................................
-    def did_bind(client_connection, stanza)
-      AgentXmpp.logger.info "BIND ACKNOWLEDGED"
-    end
-
-    #.........................................................................................................
-    # presence
-    #.........................................................................................................
-    def did_receive_presence(client_connection, presence)
-      from_jid = presence.from.to_s     
-      from_bare_jid = presence.from.bare.to_s     
-      if roster.has_key?(from_bare_jid) 
-        roster[from_bare_jid.to_s][:resources][from_jid] = {} if roster[from_bare_jid.to_s][:resources][from_jid].nil?
-        roster[from_bare_jid.to_s][:resources][from_jid][:presence] = presence
-        client_connection.get_client_version(from_jid) if not from_jid.eql?(client_connection.jid.to_s) and presence.type.nil?
-        AgentXmpp.logger.info "RECEIVED PRESENCE FROM: #{from_jid}"
-      else
-        AgentXmpp.logger.info "RECEIVED PRESENCE FROM JID NOT IN CONTACT LIST: #{from_jid}"        
-      end
-    end
-
-    #.........................................................................................................
-    def did_receive_subscribe_request(client_connection, presence)
-      from_jid = presence.from.to_s     
-      if roster.has_key?(presence.from.bare.to_s ) 
-        client_connection.accept_contact_request(from_jid)  
-        AgentXmpp.logger.info "RECEIVED SUBSCRIBE REQUEST: #{from_jid}"
-      else
-        client_connection.reject_contact_request(from_jid)  
-        AgentXmpp.logger.info "RECEIVED SUBSCRIBE REQUEST FROM JID NOT IN CONTACT LIST: #{from_jid}"        
-      end
-    end
-
-    #.........................................................................................................
-    def did_receive_unsubscribed_request(client_connection, presence)
-      from_jid = presence.from.to_s     
-      if roster.delete(presence.from.bare.to_s )           
-        client_connection.remove_contact(presence.from)  
-        AgentXmpp.logger.info "RECEIVED UNSUBSCRIBED REQUEST: #{from_jid}"
-      else
-        AgentXmpp.logger.warn "RECEIVED UNSUBSCRIBED REQUEST FROM JID NOT IN CONTACT LIST: #{from_jid}"        
-      end
-    end
-
-    #.........................................................................................................
-    # roster management
-    #.........................................................................................................
-    def did_receive_roster_item(client_connection, roster_item)
-      AgentXmpp.logger.info "RECEIVED ROSTER ITEM"   
-      roster_item_jid = roster_item.jid.to_s
-      if roster.has_key?(roster_item_jid) 
-        roster[roster_item_jid][:activated] = true 
-        roster[roster_item_jid][:roster_item] = roster_item 
-        AgentXmpp.logger.info "ACTIVATING CONTACT: #{roster_item_jid}"   
-      else
-        client_connection.remove_contact(roster_item.jid)  
-        AgentXmpp.logger.info "REMOVING CONTACT: #{roster_item_jid}"   
-      end
-    end
-
-    #.........................................................................................................
-    def did_remove_roster_item(client_connection, roster_item)
-      AgentXmpp.logger.info "REMOVE ROSTER ITEM"   
-      roster_item_jid = roster_item.jid.to_s
-      if roster.has_key?(roster_item_jid) 
-        roster.delete(roster_item_jid) 
-        AgentXmpp.logger.info "REMOVED CONTACT: #{roster_item_jid}"   
-      end
-    end
-
-    #.........................................................................................................
-    def did_receive_all_roster_items(client_connection)
-      AgentXmpp.logger.info "RECEIVED ALL ROSTER ITEMS"   
-      roster.select{|j,r| not r[:activated]}.each do |j,r|
-        AgentXmpp.logger.info "ADDING CONTACT: #{j}" 
-        client_connection.add_contact(Jabber::JID.new(j))  
-      end
-    end
-
-    #.........................................................................................................
-    def did_acknowledge_add_contact(client_connection, response, contact_jid)
-      AgentXmpp.logger.info "CONTACT ADD ACKNOWLEDGED: #{contact_jid.to_s}"
-    end
-
-    #.........................................................................................................
-    def did_remove_contact(client_connection, response, contact_jid)
-      AgentXmpp.logger.info "CONTACT REMOVED: #{contact_jid.to_s}"
-    end
-
-    #.........................................................................................................
-    def did_add_contact(client_connection, roster_item)
-      AgentXmpp.logger.info "CONTACT ADDED: #{roster_item.jid.to_s}"
-    end
-
-    #.........................................................................................................
-    # service discovery management
-    #.........................................................................................................
-    def did_receive_client_version_result(client_connection, from, version)
-      roster[from.bare.to_s][:resources][from.to_s][:version] = version \
-        unless roster[from.bare.to_s][:resources][from.to_s].nil?
-      AgentXmpp.logger.info "RECEIVED CLIENT VERSION RESULT: #{from.to_s}, #{version.iname}, #{version.version}"
-    end
-
-    #.........................................................................................................
-    def did_receive_client_version_request(client_connection, request)
-      client_connection.send_client_version(request)
-      AgentXmpp.logger.info "RECEIVED CLIENT VERSION REQUEST: #{request.from.to_s}"
-    end
-
   #### Client
   end
 

data/lib/agent_xmpp/client/connection.rb

@@ -1,67 +1,35 @@
 ##############################################################################################################
 module AgentXmpp
   
-  #####-------------------------------------------------------------------------------------------------------
-  class NotConnected < Exception; end
-
   #####-------------------------------------------------------------------------------------------------------
   class Connection < EventMachine::Connection
 
     #---------------------------------------------------------------------------------------------------------
-    include Parser
+    include EventMachine::XmlPushParser
     #---------------------------------------------------------------------------------------------------------
 
     #---------------------------------------------------------------------------------------------------------
-    attr_reader :client, :jid, :port, :password, :connection_status, :delegates, :keepalive
+    attr_reader :client, :delegates, :keepalive, :pipe
     #---------------------------------------------------------------------------------------------------------
 
     #.........................................................................................................
-    def initialize(client, jid, password, port=5222)
-      @client, @jid, @password, @port = client, jid, password, port
-      @connection_status = :offline;
-      @id_callbacks = {}
-      @delegates = []
+    def initialize(client)
+      @client = client
+      @pipe = MessagePipe.new(self)
     end
     
-    #.........................................................................................................
-    def add_delegate(delegate)
-      @delegates << delegate
-    end
-
-    #.........................................................................................................
-    def remove_delegate(delegate)
-      @delegates.delete(delegate)
-    end
-    
-    #.........................................................................................................
-    def send(data, &blk)
-      raise NotConnected if error?
-      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
-      send_data(data.to_s)
-      AgentXmpp.logger.info "SEND: #{data.to_s}"
-    end
-
     #---------------------------------------------------------------------------------------------------------
     # EventMachine::Connection callbacks
     #.........................................................................................................
     def connection_completed
-      init_connection
       @keepalive = EventMachine::PeriodicTimer.new(60) do 
         send_data("\n")
       end
-      add_delegate(client)      
-      AgentXmpp::Boot.call_after_connection_completed(self) if AgentXmpp::Boot.respond_to?(:call_after_connection_completed)
-      broadcast_to_delegates(:did_connect, self)
+      pipe.connection_completed
     end
 
     #.........................................................................................................
     def receive_data(data)
-      AgentXmpp.logger.info "RECV: #{data.to_s}"
       super(data)
     end
 
@@ -71,242 +39,65 @@ module AgentXmpp
         @keepalive.cancel
         @keepalive = nil
       end
-      @connection_status = :off_line
-      broadcast_to_delegates(:did_disconnect, self)
-    end
-
-    #---------------------------------------------------------------------------------------------------------
-    # service discovery
-    #.........................................................................................................
-    def get_client_version(contact_jid)
-      iq = Jabber::Iq.new(:get, contact_jid)
-      iq.query = Jabber::Version::IqQueryVersion.new
-      send(iq) do |r|
-        if (r.type == :result) && r.query.kind_of?(Jabber::Version::IqQueryVersion)
-          broadcast_to_delegates(:did_receive_client_version_result, self, r.from, r.query)
-        end
-      end
+      pipe.unbind
     end
 
-    #.........................................................................................................
-    def send_client_version(request)
-      iq = Jabber::Iq.new(:result, request.from.to_s)
-      iq.id = request.id unless request.id.nil?
-      iq.query = Jabber::Version::IqQueryVersion.new
-      iq.query.set_iname(AgentXmpp::AGENT_XMPP_NAME).set_version(AgentXmpp::VERSION).set_os(AgentXmpp::OS_VERSION)
-      send(iq)
-    end
-    
     #---------------------------------------------------------------------------------------------------------
-    # roster management
-    #.........................................................................................................
-    def get_roster
-      send(Jabber::Iq.new_rosterget) do |r|
-        if r.type == :result and r.query.kind_of?(Jabber::Roster::IqQueryRoster)
-          r.query.each_element {|i|  broadcast_to_delegates(:did_receive_roster_item, self, i)}
-          broadcast_to_delegates(:did_receive_all_roster_items, self)
-        end
-      end
-    end
-
-    #.........................................................................................................
-    def add_contact(contact_jid)
-      request = Jabber::Iq.new_rosterset
-      request.query.add(Jabber::Roster::RosterItem.new(contact_jid))
-      send(request) do |r|
-        send(Jabber::Presence.new.set_type(:subscribe).set_to(contact_jid))
-        broadcast_to_delegates(:did_acknowledge_add_contact, self, r, contact_jid)
-      end
-    end
-
-    #.........................................................................................................
-    def remove_contact(contact_jid)
-      request = Jabber::Iq.new_rosterset
-      request.query.add(Jabber::Roster::RosterItem.new(contact_jid, nil, :remove))
-      send(request) do |r|
-        broadcast_to_delegates(:did_remove_contact, self, r, contact_jid)
-      end
-    end
-
-    #.........................................................................................................
-    def accept_contact_request(contact_jid)
-      presence = Jabber::Presence.new.set_type(:subscribed)
-      presence.to = contact_jid      
-      send(presence)
-    end
-
+    # EventMachine::XmlPushParser callbacks
     #.........................................................................................................
-    def reject_contact_request(contact_jid)
-      presence = Jabber::Presence.new.set_type(:unsubscribed)
-      presence.to = contact_jid      
-      send(presence)
-    end
-
-    #---------------------------------------------------------------------------------------------------------
-    # process commands
+  	def start_document
+  	end
+  
     #.........................................................................................................
-    def process_command(stanza)
-      command = stanza.command
-      unless command.x.nil? 
-        params = {:xmlns => command.x.namespace, :action => command.action, :to => stanza.from.to_s, 
-          :from => stanza.from.to_s, :node => command.node, :id => stanza.id, :fields => {}}
-        Routing::Routes.invoke_command_response(self, params)
-        AgentXmpp.logger.info "RECEIVED COMMAND: #{command.node}, FROM: #{stanza.from.to_s}"
+    def start_element(name, attrs)
+      e = REXML::Element.new(name)
+      e.add_attributes(attrs)      
+      @current = @current.nil? ? e : @current.add_element(e)  
+      if @current.xpath == 'stream:stream'
+        process
+        @current = nil
       end
     end
-
-    #---------------------------------------------------------------------------------------------------------
-    # process messages
-    #.........................................................................................................
-    def process_chat_message_body(stanza)
-      params = {:xmlns => 'message:chat', :to => stanza.from.to_s, :from => stanza.from.to_s, :id => stanza.id, 
-        :body => stanza.body}
-      Routing::Routes.invoke_chat_message_body_response(self, params)
-      AgentXmpp.logger.info "RECEIVED MESSAGE BODY: #{stanza.body}"
-    end
-
-    #---------------------------------------------------------------------------------------------------------
-    # AgentXmpp::Parser callbacks
+  
     #.........................................................................................................
-    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
-
-      case stanza.xpath
-      when 'stream:features'
-        @stream_features, @stream_mechanisms = {}, []
-        @current.each do |e|
-          if e.name == 'mechanisms' and e.namespace == 'urn:ietf:params:xml:ns:xmpp-sasl'
-            e.each_element('mechanism') {|mech| @stream_mechanisms.push(mech.text)}
-          else
-            @stream_features[e.name] = e.namespace
-          end
-        end
-        if @connection_status.eql?(:offline)
-          authenticate
-        elsif @connection_status.eql?(:authenticated)
-          bind(stanza)
-        end
-      when 'stream:stream'
-      when 'success'
-        case connection_status
-        when :offline
-          reset_parser
-          init_connection(false)
-          @connection_status = :authenticated
-        end
-        return
-      when 'failure'
-        case connection_status
-        when :offline
-          reset_parser
-          broadcast_to_delegates(:did_not_authenticate, self, stanza)
-        end
+    def end_element(name)
+      if @current.parent
+        @current = @current.parent
       else
-        demux_channel(stanza)
+        process
+        @current = nil
       end
-            
     end
 
-    #---------------------------------------------------------------------------------------------------------
-    protected
-    #---------------------------------------------------------------------------------------------------------
-  
-    #---------------------------------------------------------------------------------------------------------
-    # Process XMPP messages
     #.........................................................................................................
-    def authenticate
-      begin
-          Jabber::SASL.new(self, 'PLAIN').auth(password)
-      rescue
-        raise ClientAuthenticationFailure.new, $!.to_s
-      end
-    end
-  
-    #.........................................................................................................
-    def bind(stanza)
-      if stream_features.has_key?('bind')
-        iq = Jabber::Iq.new(:set)
-        bind = iq.add(REXML::Element.new('bind'))
-        bind.add_namespace(stream_features['bind'])                
-        resource = bind.add REXML::Element.new('resource')
-        resource.text = jid.resource
-        send(iq) do |r|
-          if r.type == :result and full_jid = r.first_element('//jid') and full_jid.text
-            @connection_status = :bind
-            jid = Jabber::JID.new(full_jid.text) unless jid.to_s.eql?(full_jid.text)      
-            broadcast_to_delegates(:did_bind, self, stanza)
-            session(stanza)
-          end
-        end
-      end                
+    def characters(text)
+      @current.text = @current.text.to_s + text if @current
     end
     
     #.........................................................................................................
-    def session(stanza)
-      if stream_features.has_key?('session')
-        iq = Jabber::Iq.new(:set)
-        session = iq.add REXML::Element.new('session')
-        session.add_namespace stream_features['session']                
-        send(iq) do |r|
-          if r.type == :result                
-            @connection_status = :active
-            broadcast_to_delegates(:did_authenticate, self, stanza)
-            send(Jabber::Presence.new(nil, nil, 1))
-            get_roster
-          end
-        end
-      end
+    def error(*args)
+      AgentXmpp.logger.error *args
     end
 
     #.........................................................................................................
-    def init_connection(starting=true)
-      send("<?xml version='1.0' ?>") if starting
-      send("<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0' to='#{jid.domain}'>" )
-    end
-
-    #.........................................................................................................
-    def demux_channel(stanza)
-      stanza_class = stanza.class.to_s
-      #### roster update
-      if stanza.type == :set and stanza.query.kind_of?(Jabber::Roster::IqQueryRoster)
-        stanza.query.each_element do |i|  
-          method =  case i.subscription
-                    when :remove then :did_remove_roster_item
-                    when :none   then :did_receive_roster_item
-                    when :to     then :did_add_contact
-                    end         
-          broadcast_to_delegates(method, self, i) unless method.nil?
-        end
-      #### presence subscription request  
-      elsif stanza.type.eql?(:subscribe) and stanza_class.eql?('Jabber::Presence')
-        broadcast_to_delegates(:did_receive_subscribe_request, self, stanza)
-      #### presence unsubscribe 
-      elsif stanza.type.eql?(:unsubscribed) and stanza_class.eql?('Jabber::Presence')
-        broadcast_to_delegates(:did_receive_unsubscribed_request, self, stanza)
-      #### client version request
-      elsif stanza.type.eql?(:get) and stanza.query.kind_of?(Jabber::Version::IqQueryVersion)
-        broadcast_to_delegates(:did_receive_client_version_request, self, stanza)
-      #### received command
-      elsif stanza.type.eql?(:set) and stanza.command.kind_of?(Jabber::Command::IqCommand)
-        process_command(stanza)
-      #### chat message received
-      elsif stanza_class.eql?('Jabber::Message') and stanza.type.eql?(:chat) and stanza.respond_to?(:body)
-        process_chat_message_body(stanza)
-      else
-        method = ('did_receive_' + /.*::(.*)/.match(stanza_class).to_a.last.downcase).to_sym
-        broadcast_to_delegates(method, self, stanza)
+    def process
+      @current.add_namespace(@streamns) if @current.namespace('').to_s.eql?('')
+      begin
+        stanza = Xmpp::Stanza::import(@current)
+      rescue Xmpp::NoNameXmlnsRegistered
+        stanza = @current
       end
+      if @current.xpath.eql?('stream:stream')
+        @streamns = @current.namespace('') if @current.namespace('')
+      end
+      receive(stanza) if respond_to?(:receive)
     end
   
     #.........................................................................................................
-    def broadcast_to_delegates(method, *args)
-      delegates.each{|d| d.send(method, *args) if d.respond_to?(method)}
+    def receive(stanza)
+      pipe.receive(stanza)
     end
-
+  
   #### Connection
   end