agent_xmpp 0.1.0

data/lib/agent_xmpp/client/client.rb

@@ -0,0 +1,64 @@
+##############################################################################################################
+module AgentXmpp
+  
+  #####-------------------------------------------------------------------------------------------------------
+  class Client
+
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+
+    #### self
+    end
+    
+    #---------------------------------------------------------------------------------------------------------
+    attr_reader :connection
+    #---------------------------------------------------------------------------------------------------------
+
+    #.........................................................................................................
+    def initialize
+    end
+
+    #.........................................................................................................
+    def connect
+      while (true)
+        EventMachine.run do
+          @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 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) unless connection.nil?
+    end
+
+    #.........................................................................................................
+    def pipe
+      connection.pipe
+    end
+
+    #.........................................................................................................
+    def add_delegate(delegate)
+      connection.pipe.add_delegate(delegate)
+    end
+
+    #.........................................................................................................
+    def remove_delegate(delegate)
+      connection.pipe.remove_delegate(delegate)
+    end
+    
+  #### Client
+  end
+
+#### AgentXmpp
+end

data/lib/agent_xmpp/client/connection.rb

@@ -0,0 +1,108 @@
+##############################################################################################################
+module AgentXmpp
+  
+  #####-------------------------------------------------------------------------------------------------------
+  class Connection < EventMachine::Connection
+
+    #---------------------------------------------------------------------------------------------------------
+    include EventMachine::XmlPushParser
+    #---------------------------------------------------------------------------------------------------------
+
+    #---------------------------------------------------------------------------------------------------------
+    attr_reader :client, :delegates, :keepalive, :pipe
+    #---------------------------------------------------------------------------------------------------------
+
+    #.........................................................................................................
+    def initialize(client)
+      @client = client
+      @pipe = MessagePipe.new(self)
+    end
+    
+    #---------------------------------------------------------------------------------------------------------
+    # EventMachine::Connection callbacks
+    #.........................................................................................................
+    def connection_completed
+      @keepalive = EventMachine::PeriodicTimer.new(60) do 
+        send_data("\n")
+      end
+      AgentXmpp.start_garbage_collection(pipe)
+      pipe.connection_completed
+    end
+
+    #.........................................................................................................
+    def receive_data(data)
+      super(data)
+    end
+
+    #.........................................................................................................
+    def unbind
+      if @keepalive
+        @keepalive.cancel
+        @keepalive = nil
+      end
+      pipe.unbind
+    end
+
+    #---------------------------------------------------------------------------------------------------------
+    # EventMachine::XmlPushParser callbacks
+    #.........................................................................................................
+  	def start_document
+  	end
+  
+    #.........................................................................................................
+    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
+  
+    #.........................................................................................................
+    def end_element(name)
+      if @current and @current.parent
+        @current = @current.parent
+      else
+        process
+        @current = nil
+      end
+    end
+
+    #.........................................................................................................
+    def characters(text)
+      @current.text = @current.text.to_s + text if @current
+    end
+    
+    #.........................................................................................................
+    def error(*args)
+      AgentXmpp.logger.error *args
+    end
+
+    #.........................................................................................................
+    def process
+      if @current
+        @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
+    end
+  
+    #.........................................................................................................
+    def receive(stanza)
+      pipe.receive(stanza)
+    end
+  
+  #### Connection
+  end
+
+#### AgentXmpp
+end

data/lib/agent_xmpp/client/controller.rb

@@ -0,0 +1,394 @@
+##############################################################################################################
+module AgentXmpp
+  
+  #####-------------------------------------------------------------------------------------------------------
+  class BaseController
+
+    #---------------------------------------------------------------------------------------------------------
+    @routes = {}
+    @before_filters = {}
+    @commands_list = {}    
+    @commands_list_mutex = Mutex.new
+    
+    #---------------------------------------------------------------------------------------------------------
+    class << self
+      
+      #.........................................................................................................
+      attr_reader :routes, :before_filters, :commands_list, :commands_list_mutex
+
+      #.........................................................................................................
+      # application interface
+      #.........................................................................................................
+      def command(node, opts = {}, &blk) 
+        route(:command, {:node => node, :opts => opts, :blk => blk}) 
+      end
+
+      #.........................................................................................................
+      def event(jid, node, opts = {}, &blk) 
+        j = Xmpp::Jid.new(jid)
+        route(:event, {:node => "/home/#{j.domain}/#{j.node}/#{node}", :domain => j.domain, :opts => opts, :blk => blk}) 
+      end
+
+      #.........................................................................................................
+      def chat(opts = {}, &blk) 
+        route(:chat, {:opts => opts, :blk => blk})
+      end
+
+      #.........................................................................................................
+      def before(args=nil, &blk)
+        args = {:command => :all, :event => :all, :chat => :all} if args.nil? or args.eql?(:all)
+        args.each {|(msg_type, nodes)| add_before_filter(msg_type, {:nodes => nodes, :blk => blk})}
+      end
+
+      #.........................................................................................................
+      def include_module(mod)
+        include(mod)
+      end
+
+      #.........................................................................................................
+      # managment
+      #.........................................................................................................
+      def route(msg_type, nroute)
+        (routes[msg_type] ||= []).push(nroute).last
+      end
+     
+      #.........................................................................................................
+      def add_before_filter(msg_type, nodes)
+        (before_filters[msg_type] ||= []).push(nodes).last
+      end
+
+      #.........................................................................................................
+      def command_nodes(jid=nil)
+        (routes[:command] ||= []).inject([]) do |nodes, route|
+          if jid and not AgentXmpp.is_account_jid?(jid)
+            groups, access = Contact.find_by_jid(jid)[:groups], [route[:opts][:access] || []].flatten
+            (access.empty? or access.any?{|a| groups.include?(a)}) ? nodes << route[:node] : nodes
+          else; nodes << route[:node]; end
+        end
+      end
+
+      #.........................................................................................................
+      def subscriptions(service)
+        (routes[:event] ||= []).inject([]){|s,r| /#{r[:domain]}/.match(service) ? s << r[:node] : s}
+      end
+      
+      #.........................................................................................................
+      def event_domains
+        (routes[:event] ||= []).map{|r| r[:domain]}.uniq
+      end
+
+      #.........................................................................................................
+      def add_command_to_list(session_id, controller)
+        commands_list_mutex.synchronize do
+          commands_list[session_id] = {:controller=>controller, :created_at=>Time.now}
+        end
+      end
+
+      #.........................................................................................................
+      def remove_command_from_list(session_id)
+        if commands_list[session_id]
+          commands_list_mutex.synchronize{commands_list.delete(session_id)}
+        end
+      end
+
+    #### self
+    end
+
+    #.........................................................................................................
+    attr_reader :params, :pipe, :route, :params_list, :submits
+
+    #.........................................................................................................
+    def initialize(pipe, params)
+      @params, @pipe = params, pipe
+      @params_list, @submits = [params], []
+    end
+
+    #.........................................................................................................
+    def next(params)
+      @params = params
+      @params_list << params
+      self
+    end
+
+    #.........................................................................................................
+    # internal interface
+    #.......................................................................................................
+    def invoke_command
+      params[:sessionid] = Xmpp::IdGenerator.generate_id
+      invoke_command_on_route do
+        define_meta_class_method(:request, &route[:blk])
+        define_meta_class_method(:request_handler) do  
+          run_command(request)  
+        end
+        define_meta_class_method(:request_callback) do |*resp|
+          resp = resp.length.eql?(1)  ? resp.first : resp  
+          add_payload_to_container(resp)
+        end
+        process_request
+      end
+    end
+
+    #.......................................................................................................
+    def invoke_command_next
+      invoke_command_on_route do
+        define_meta_class_method(:request_handler) do  
+          if params[:x_data_type].eql?(:submit)
+            on_submit
+          end
+        end
+        process_request
+      end
+    end
+
+    #.......................................................................................................
+    def invoke_event
+      @route = get_route(:event)
+      unless route.nil?
+        define_meta_class_method(:request, &route[:blk])
+        define_meta_class_method(:request_handler) do
+          request; delegate_methods.delegate(pipe, self); flush_messages
+        end
+        process_request
+      else
+        AgentXmpp.logger.error "ROUTING ERROR: no route for {:node => '#{params[:node]}'}."
+      end
+    end
+
+    #.......................................................................................................
+    def invoke_chat
+      @route = chat_route
+      unless route.nil?
+        define_meta_class_method(:request_handler, &route[:blk])
+      else
+        define_meta_class_method(:request_handler) do
+          "#{AgentXmpp::AGENT_XMPP_NAME} #{AgentXmpp::VERSION}, #{AgentXmpp::OS_VERSION}"
+        end
+      end
+      define_meta_class_method(:request_callback) do |result|
+        add_payload_to_container(result) if result.kind_of?(String)
+      end
+      process_request
+    end
+
+    #.......................................................................................................
+    def delegate_methods
+      @delegate_methods ||= AgentXmpp::Delegate.new
+    end
+
+    #.......................................................................................................
+    def messages
+      @messages ||= []
+    end
+
+    #.......................................................................................................
+    def flush_messages
+      pipe.send_resp(messages); messages.clear
+    end
+
+    #.........................................................................................................
+    # application interface
+    #.......................................................................................................
+    def error(err, *args)
+      AgentXmpp::Error.new(err, *args)
+    end
+
+    #.......................................................................................................
+    def on(action, opts= {}, &blk)
+      if action.eql?(:submit)
+        @submits << {:opts=>opts, :blk=>blk}
+      else
+        define_meta_class_method(("on_"+action.to_s).to_sym, &blk)
+      end
+    end
+
+    #.......................................................................................................
+    def xmpp_msg(msg)
+      messages << msg
+    end
+
+    #.......................................................................................................
+    def delegate_to(methods)
+      delegate_methods.add_delegate_methods(methods); delegate_methods
+    end
+
+    #.........................................................................................................
+    def command_completed
+      Xmpp::IqCommand.send_command(:to=>params[:from], :node=>params[:node], :iq_type=>:result, :status=>:completed, 
+                                   :id => params[:id], :sessionid => params[:sessionid])
+    end
+
+    #.........................................................................................................
+    def command_request(args, &blk)
+      raise ArgmentError ':to and :node are required' unless args[:to] and args[:node]
+      Xmpp::IqCommand.send_command(:to=>args[:to], :node=>args[:node], :iq_type=>:set, :action=>:execute, :payload=>args[:payload], &blk)
+    end
+        
+    #.........................................................................................................
+    # managment
+    #.......................................................................................................
+    def on_submit
+      unless(sub = submits.shift).nil?
+        update_command_list 
+        blk, guard = sub[:blk], sub[:opts][:guard] 
+        call_blk = lambda{|| blk.arity.eql?(1) ? blk.call(Xmpp::XData.new('form')) : blk.call}
+        result = if guard.nil?
+                   call_blk[]
+                 else  
+                   (guard.arity.eql?(1) ? guard.call(self) : guard.call) ? call_blk[] : on_submit
+                 end
+        result.nil? ? on_submit : result         
+      end
+    end
+          
+    ####......................................................................................................
+    # private
+    ####......................................................................................................
+    def run_command(req)
+      request_method = ("on_"+(params[:x_data_type] || params[:action]).to_s).to_sym
+      if respond_to?(request_method)
+        if params[:action].eql?(:execute) and params[:x_data_type].nil?
+            form = Xmpp::XData.new('form')
+            on_execute(form); form
+        elsif params[:action].eql?(:cancel)
+            on_cancel
+        else
+          send(request_method)
+        end
+      else
+        req
+      end
+    end
+    
+    #.........................................................................................................
+    def process_request
+      if route and route[:opts] and route[:opts][:defer]
+        EventMachine.defer(method(:request_handler).to_proc, respond_to?(:request_callback) ? method(:request_callback).to_proc : nil)
+      else
+        respond_to?(:request_callback) ? request_callback(request_handler) : request_handler
+      end
+    end
+
+    #.........................................................................................................
+    # add payloads
+    #.........................................................................................................
+    def result_jabber_x_data(payload)
+      delegate_methods.delegate(pipe, self)  
+      flush_messages
+      if params[:action].eql?(:cancel)
+        command_canceled
+      elsif payload.kind_of?(AgentXmpp::Error)
+        payload.responce
+      elsif payload.kind_of?(AgentXmpp::Delegate) 
+        nil
+      elsif payload.kind_of?(AgentXmpp::Response)
+        payload
+      else
+        command_result(payload.nil? ? nil : payload.to_x_data, params[:sessionid])
+      end
+    end
+
+    #.........................................................................................................
+    def result_message_chat(payload)
+      Xmpp::Message.chat(params[:from], payload)
+    end
+    
+    #.........................................................................................................
+    def add_payload_to_container(payload)
+      meth = "result_#{params[:xmlns].gsub(/:/, "_")}".to_sym
+      if respond_to?(meth, true) 
+        if res = send(meth, payload)
+          pipe.send_resp(res)
+        end
+      else
+        AgentXmpp.logger.error "PAYLOAD ERROR: unsupported payload {:xmlns => '#{params[:xmlns]}', :node => '#{params[:node]}', :action => '#{params[:action]}'}."
+        Xmpp::ErrorResponse.unsupported_payload(params)
+      end
+    end
+    
+    #.........................................................................................................
+    # commands
+    #.........................................................................................................
+    def update_command_list
+      if not BaseController.commands_list[params[:sessionid]] and submits.length > 0
+        BaseController.add_command_to_list(params[:sessionid], self)
+      elsif BaseController.commands_list[params[:sessionid]] and submits.length.eql?(0)
+        BaseController.remove_command_from_list(params[:sessionid])
+      end
+    end
+
+    #.........................................................................................................
+    def command_result(payload, sessionid)
+      if payload
+        Xmpp::IqCommand.send_command(:to=>params[:from], :node=>params[:node], :status=>payload.type.eql?(:form) ? :executing : :completed, 
+                                     :id => params[:id], :sessionid => sessionid, :payload => payload, :iq_type=>:result)
+      else
+        Xmpp::IqCommand.send_command(:to=>params[:from], :node=>params[:node], :status=> :completed, :id => params[:id], 
+                                     :sessionid => sessionid, :iq_type=>:result)
+      end
+    end
+
+    #.........................................................................................................
+    def command_canceled
+      BaseController.remove_command_from_list(params[:sessionid])
+      Xmpp::IqCommand.send_command(:to=>params[:from], :node=>params[:node], :status=>:canceled, :id => params[:id], 
+                                   :sessionid => params[:sessionid], :iq_type=>:result)
+    end
+
+    #.......................................................................................................
+    def invoke_command_on_route
+      @route = get_route(:command)
+      unless route.nil?
+        if apply_before_filters(:command, params[:node])
+          yield
+        else
+          AgentXmpp.logger.error "ACCESS ERROR: before_filter prevented '#{params[:from]}' access {:node => '#{params[:node]}', :action => '#{params[:action]}'}."
+          Xmpp::ErrorResponse.forbidden(params)
+        end
+      else
+        AgentXmpp.logger.error "ROUTING ERROR: no route for {:node => '#{params[:node]}', :action => '#{params[:action]}'}."
+        Xmpp::ErrorResponse.no_route(params)
+      end
+    end
+
+    #.........................................................................................................
+    # routes
+    #.........................................................................................................
+    def get_route(msg_type) 
+      (BaseController.routes[msg_type] || []).select{|r| r[:node].eql?(params[:node].to_s)}.first
+    end
+
+    #.........................................................................................................
+    def chat_route 
+      (BaseController.routes[:chat] ||= []).first
+    end
+
+    #.........................................................................................................
+    # filters
+    #.........................................................................................................
+    def apply_before_filters(msg_type, node=nil)
+      (BaseController.before_filters[msg_type] || []).inject([]) do |fs, f|
+        nodes = [f[:nodes]].flatten
+        (nodes.include?(node) or nodes.include?(:all)) ? fs << f : fs
+      end.inject(true) do |r,f|
+        define_meta_class_method(:filter, &f[:blk])
+        r and filter
+      end
+    end
+    
+    #.........................................................................................................
+    private :add_payload_to_container, :chat_route, :get_route, :result_jabber_x_data, :result_message_chat, 
+            :process_request, :run_command, :command_result, :invoke_command_on_route, :update_command_list, 
+            :command_canceled
+    
+  #### BaseController
+  end
+
+  ##############################################################################################################
+  class Controller < BaseController
+
+  #### Controller
+  end
+
+#### AgentXmpp
+end
+