troystribling-agent_xmpp 0.0.0

data/lib/agent_xmpp/app/routes.rb

@@ -0,0 +1,77 @@
+##############################################################################################################
+module AgentXmpp
+
+  #####-------------------------------------------------------------------------------------------------------
+  module Routing
+  
+    #####-------------------------------------------------------------------------------------------------------
+    class Routes
+
+      #.........................................................................................................
+      @map = Map.new
+      #.........................................................................................................
+
+      ####......................................................................................................
+      class << self
+      
+        #.........................................................................................................
+        attr_reader :map
+        #.........................................................................................................
+
+        #.......................................................................................................
+        def draw
+          yield map
+        end
+
+        #.......................................................................................................
+        def invoke_command_response(connection, params)
+          route_path = "#{params[:node]}/#{params[:action]}"
+          field_path = fields(params)
+          route_path += "/#{field_path}" unless field_path.nil? 
+          route = map[route_path]
+          unless route.nil?
+            begin
+              controller_class = eval("#{route[:controller].classify}Controller")
+            rescue NameError
+              AgentXmpp.logger.error "ROUTING ERROR: #{route[:controller].classify}Controller does not exist for route {:controller => '#{route[:controller]}', :node => '#{params[:node]}', :action => '#{params[:action]}'}."
+            else   
+              controler_instance = controller_class.new       
+              if controler_instance.respond_to?(route[:action])
+                controler_instance.handle_request(connection, route[:action], params)
+              else
+                AgentXmpp.logger.error "ROUTING ERROR: no action on #{controller_class.to_s} for route {:controller => '#{route[:controller]}', :node => '#{params[:node]}', :action => '#{params[:action]}'}."
+              end
+            end
+          else
+            AgentXmpp.logger.error "ROUTING ERROR: no route for {:node => '#{params[:node]}', :action => '#{params[:action]}'}."
+          end
+        end
+
+        #.......................................................................................................
+        def invoke_chat_message_body_response(connection, params)
+          route = map.chat_message_body_route
+          begin
+            controller_class = eval("#{route[:controller].classify}Controller")
+          rescue ArgumentError
+            AgentXmpp.logger.error "ROUTING ERROR: #{params[:node].classify}Controller inavlid for node:#{params[:node]} action:#{params[:action]}."
+          else          
+            controller_class.new.handle_request(connection, route[:action], params)
+          end
+        end
+        
+        #.......................................................................................................
+        def fields(params)
+          nil
+        end
+        
+      end
+      ####......................................................................................................
+      
+      #### Routes
+      end
+
+  #### Routing
+  end
+  
+#### AgentXmpp
+end

data/lib/agent_xmpp/app/view.rb

@@ -0,0 +1,49 @@
+##############################################################################################################
+module AgentXmpp
+  
+  #####-------------------------------------------------------------------------------------------------------
+  class View
+
+    #---------------------------------------------------------------------------------------------------------
+    attr_reader :connection, :format, :params
+    #---------------------------------------------------------------------------------------------------------
+
+    #.........................................................................................................
+    def initialize(connection, format, params)
+      @connection = connection
+      @format = format
+      @params = params
+    end
+           
+    #.........................................................................................................
+    def add_payload_to_container(payload)
+      container_type = case format.xmlns
+        when 'jabber:x:data' then :add_x_data_to_container
+        when 'message:chat'  then :add_chat_message_body_container
+      end
+      container_type.nil? ? nil : send(container_type, payload)
+    end
+
+  private
+ 
+    #.........................................................................................................
+    def add_x_data_to_container(payload)
+      iq = Jabber::Iq.new(:result, params[:from])
+      iq.id = params[:id] unless params[:id].nil?
+      iq.command = Jabber::Command::IqCommand.new(params[:node], 'completed')
+      iq.command << payload
+      iq      
+    end
+
+    #.........................................................................................................
+    def add_chat_message_body_container(payload)
+      message = Jabber::Message.new(params[:from], payload)
+      message.type = :chat
+      message      
+    end
+      
+  #### View
+  end
+
+#### AgentXmpp
+end

data/lib/agent_xmpp/app.rb

@@ -0,0 +1,7 @@
+require 'agent_xmpp/app/boot'
+require 'agent_xmpp/app/controller'
+require 'agent_xmpp/app/format'
+require 'agent_xmpp/app/map'
+require 'agent_xmpp/app/routes'
+require 'agent_xmpp/app/view'
+require 'agent_xmpp/app/chat_message_body_controller'

data/lib/agent_xmpp/client/client.rb

@@ -0,0 +1,197 @@
+##############################################################################################################
+module AgentXmpp
+  
+  #####-------------------------------------------------------------------------------------------------------
+  class Client
+
+    #---------------------------------------------------------------------------------------------------------
+    attr_reader :jid, :port, :password, :roster, :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'])
+    end
+
+    #.........................................................................................................
+    def connect
+      while (true)
+        EventMachine.run do
+          @connection = EventMachine.connect(jid.domain, port, Connection, self, jid, password, port)
+        end
+        sleep(10.0)
+        AgentXmpp.logger.warn "RESTARTING SERVER"
+      end
+    end
+
+    #.........................................................................................................
+    def reconnect
+      AgentXmpp.logger.info "RECONNECTING"
+      connection.reconnect(jid.domain, port)
+    end
+
+    #.........................................................................................................
+    def connected?
+      connection and !connection.error?
+    end
+
+    #.........................................................................................................
+    def add_delegate(delegate)
+      connection.add_delegate(delegate)
+    end
+
+    #.........................................................................................................
+    def remove_delegate(delegate)
+      connection.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
+
+#### AgentXmpp
+end

data/lib/agent_xmpp/client/connection.rb

@@ -0,0 +1,314 @@
+##############################################################################################################
+module AgentXmpp
+  
+  #####-------------------------------------------------------------------------------------------------------
+  class NotConnected < Exception; end
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Connection < EventMachine::Connection
+
+    #---------------------------------------------------------------------------------------------------------
+    include Parser
+    #---------------------------------------------------------------------------------------------------------
+
+    #---------------------------------------------------------------------------------------------------------
+    attr_reader :client, :jid, :port, :password, :connection_status, :delegates, :keepalive
+    #---------------------------------------------------------------------------------------------------------
+
+    #.........................................................................................................
+    def initialize(client, jid, password, port=5222)
+      @client, @jid, @password, @port = client, jid, password, port
+      @connection_status = :offline;
+      @id_callbacks = {}
+      @delegates = []
+    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)
+    end
+
+    #.........................................................................................................
+    def receive_data(data)
+      AgentXmpp.logger.info "RECV: #{data.to_s}"
+      super(data)
+    end
+
+    #.........................................................................................................
+    def unbind
+      if @keepalive
+        @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
+    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
+
+    #.........................................................................................................
+    def reject_contact_request(contact_jid)
+      presence = Jabber::Presence.new.set_type(:unsubscribed)
+      presence.to = contact_jid      
+      send(presence)
+    end
+
+    #---------------------------------------------------------------------------------------------------------
+    # process commands
+    #.........................................................................................................
+    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}"
+      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
+      else
+        demux_channel(stanza)
+      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                
+    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
+    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)
+      end
+    end
+  
+    #.........................................................................................................
+    def broadcast_to_delegates(method, *args)
+      delegates.each{|d| d.send(method, *args) if d.respond_to?(method)}
+    end
+
+  #### Connection
+  end
+
+#### AgentXmpp
+end