mohiam-babylon 0.1.7

data/lib/babylon/router.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__)+"/router/dsl"
+
+module Babylon
+  ##
+  # Routers are in charge of sending the right stanzas to the right controllers based on user defined Routes.
+  # Each application can have only one!
+  class StanzaRouter
+    
+    attr_reader :routes, :connection
+    
+    def initialize
+      @routes = []
+    end
+    
+    ##
+    # Connected is called by the XmppConnection to indicate that the XMPP connection has been established
+    def connected(connection)
+      @connection = connection
+    end
+    
+    ##
+    # Look for the first matching route and calls the corresponding action for the corresponding controller.
+    # Sends the response on the XMPP stream/ 
+    def route(xml_stanza) 
+      route = routes.select{ |r| r.accepts?(xml_stanza) }.first 
+      return false unless route 
+      execute_route(route.controller, route.action, xml_stanza)
+    end 
+    
+    ##
+    # Executes the route for the given xml_stanza, by instantiating the controller_name, calling action_name and sending 
+    # the result to the connection
+    def execute_route(controller_name, action_name, stanza = nil)
+      begin
+        stanza_class_name = Extlib::Inflection.camelize(action_name)
+        Babylon.logger.debug("looking for stanza #{stanza_class_name} for #{action_name}")
+        stanza = Kernel.const_get(stanza_class_name).new(stanza) if stanza
+        Babylon.logger.info {
+          "ROUTING TO #{controller_name}::#{action_name} with #{stanza.class}"
+        }
+      rescue NameError
+        Babylon.logger.info {
+          "ROUTING TO #{controller_name}::#{action_name} with #{stanza.class}"
+        }
+      end
+      controller = controller_name.new(stanza) 
+      controller.perform(action_name) 
+      connection.send_xml(controller.evaluate)
+    end
+    
+    ##
+    # Throw away all added routes from this router. Helpful for 
+    # testing. 
+    def purge_routes! 
+      @routes = [] 
+    end 
+    
+    ##
+    # Run the router DSL. 
+    def draw(&block) 
+      dsl = Router::DSL.new 
+      dsl.instance_eval(&block) 
+      dsl.routes.each do |route| 
+        raise("Route lacks destination: #{route.inspect}") unless route.is_a?(Route) 
+      end 
+      @routes += dsl.routes 
+      sort
+    end
+
+    private
+    
+    def sort
+      @routes.sort! { |r1,r2| r2.priority <=> r1.priority }
+    end
+  end
+
+  ##
+  # Route class which associate an XPATH match and a priority to a controller and an action
+  class Route
+    
+    attr_accessor :priority, :controller, :action, :xpath
+    
+    ##
+    # Creates a new route
+    def initialize(params)
+      raise("No controller given for route") unless params["controller"]
+      raise("No action given for route") unless params["action"]
+      raise("No xpath given for route") unless params["xpath"]
+      @priority   = params["priority"] || 0
+      @xpath      = params["xpath"] 
+      @controller = Kernel.const_get("#{params["controller"].capitalize}Controller")
+      @action     = params["action"]
+    end
+    
+    ##
+    # Checks that the route matches the stanzas and calls the the action on the controller.
+    def accepts?(stanza)
+      stanza.xpath(@xpath, XpathHelper.new).empty? ? false : self
+    end
+    
+  end
+  
+end

data/lib/babylon/router/dsl.rb

@@ -0,0 +1,61 @@
+module Babylon
+  module Router
+
+    # Creates a simple DSL for stanza routing.
+    class DSL
+      attr_reader :routes
+
+      def initialize
+        @routes = []
+      end
+
+      # Match an xpath.
+      def xpath(path)
+        @routes << {"xpath" => path}
+        self
+      end
+
+      # Set the priority of the last created route.
+      def priority(n)
+        set(:priority, n)
+        self
+      end
+
+      # Match a disco_info query.
+      def disco_info(node = nil)
+        disco_for(:info, node)
+      end
+
+      # Match a disco_items query.
+      def disco_items(node = nil)
+        disco_for(:items, node)
+      end
+
+      # Map a route to a specific controller and action.
+      def to(params)
+        set(:controller, params[:controller])
+        set(:action, params[:action])
+        # We now have all the properties we really need to create a route.
+        route = Route.new(@routes.pop)
+        @routes << route
+        self
+      end
+
+      protected
+      # We do this magic, or crap depending on your perspective, because we don't know whether we're setting values on a 
+      # Hash or a Route. We can't create the Route until we have a controller and action.
+      def set(property, value)
+        last = @routes.last
+        last[property.to_s] = value if last.is_a?(Hash)
+        last.send("#{property.to_s}=", value) if last.is_a?(Route)
+      end
+
+      def disco_for(type, node = nil)
+        str = "//iq[@type='get']/*[namespace(., 'query', 'http://jabber.org/protocol/disco##{type.to_s}')"
+        str += " and @node = '#{node}'" if node
+        str += "]"
+        xpath(str)
+      end
+    end
+  end
+end

data/lib/babylon/runner.rb

@@ -0,0 +1,148 @@
+module Babylon
+  
+  ##
+  # Runner is in charge of running the application.
+  class Runner
+    
+    ## 
+    # Prepares the Application to run.
+    def self.prepare(env)
+      
+      config_file = nil
+      
+      if env.kind_of? Hash
+        config_file = File.open( env[:config] ) if env[:config]
+      end
+      
+      # Load the configuration
+      config_file = File.open('config/config.yaml') if config_file.nil?
+      Babylon.config = YAML.load(config_file)[Babylon.environment]
+      
+      # Add an outputter to the logger
+      log_file = Log4r::RollingFileOutputter.new("#{Babylon.environment}", :filename => "log/#{Babylon.environment}.log", :trunc => false)
+      case Babylon.environment
+      when "production"
+        log_file.formatter = Log4r::PatternFormatter.new(:pattern => "%d (#{Process.pid}) [%l] :: %m", :date_pattern => "%d/%m %H:%M")      
+      when "development"
+        log_file.formatter = Log4r::PatternFormatter.new(:pattern => "%d (#{Process.pid}) [%l] :: %m", :date_pattern => "%d/%m %H:%M")      
+      else
+        log_file.formatter = Log4r::PatternFormatter.new(:pattern => "%d (#{Process.pid}) [%l] :: %m", :date_pattern => "%d/%m %H:%M")      
+      end
+      Babylon.logger.add(log_file)
+      
+      # Requiring all models, stanza, controllers
+      ['app/models/*.rb', 'app/stanzas/*.rb', 'app/controllers/*_controller.rb'].each do |dir|
+        Runner.require_directory(dir)
+      end
+      
+      # Create the router
+      Babylon.router = Babylon::StanzaRouter.new
+      
+      # Evaluate routes defined with the new DSL router.
+      require 'config/routes.rb'
+            
+      # Caching views
+      Babylon.cache_views
+      
+    end
+    
+    ##
+    # Convenience method to require files in a given directory
+    def self.require_directory(path)
+      Dir.glob(path).each { |f| require f }
+    end
+    
+    ##
+    # When run is called, it loads the configuration, the routes and add them into the router
+    # It then loads the models.
+    # Finally it starts the EventMachine and connect the ComponentConnection
+    # You can pass an additional block that will be called upon launching, when the eventmachine has been started.
+    def self.run(env)
+      
+      if env.kind_of? Hash
+        Babylon.environment = env[:env]
+      else
+        Babylon.environment = env
+      end
+      
+      # Starting the EventMachine
+      EventMachine.epoll
+      EventMachine.run do
+        
+        Runner.prepare(env)
+        
+        case Babylon.config["application_type"] 
+        when "client"
+          Babylon::ClientConnection.connect(Babylon.config, self) 
+        else # By default, we assume it's a component
+          Babylon::ComponentConnection.connect(Babylon.config, self) 
+        end
+        
+        # And finally, let's allow the application to do all it wants to do after we started the EventMachine!
+        yield(self) if block_given?
+      end
+    end
+    
+    ##
+    # Returns the list of connection observers
+    def self.connection_observers()
+      @@observers ||= Array.new
+    end
+    
+    ##
+    # Adding a connection observer. These observer will receive on_connected and on_disconnected events.
+    def self.add_connection_observer(observer)
+      @@observers ||= Array.new 
+      if observer.ancestors.include? Babylon::Base::Controller
+        Babylon.logger.debug {
+          "Added #{observer} to the list of Connection Observers"
+        }
+        @@observers.push(observer) unless @@observers.include? observer
+      else
+        Babylon.logger.error {
+          "Observer can only be Babylon::Base::Controller"
+        }
+        false
+      end
+    end
+    
+    ## 
+    # Will be called by the connection class once it is connected to the server.
+    # It "plugs" the router and then calls on_connected on the various observers.
+    def self.on_connected(connection)
+      Babylon.router.connected(connection)
+      connection_observers.each do |observer|
+        Babylon.router.execute_route(observer, "on_connected")
+      end
+    end
+    
+    ##
+    # Will be called by the connection class upon disconnection.
+    # It stops the event loop and then calls on_disconnected on the various observers.
+    def self.on_disconnected()
+      connection_observers.each do |conn_obs|
+        observer = conn_obs.new
+        observer.on_disconnected if observer.respond_to?("on_disconnected")
+      end
+      EventMachine.stop_event_loop
+    end
+    
+    ##
+    # Will be called by the connection class when it receives and parses a stanza.
+    def self.on_stanza(stanza)
+      begin
+        Babylon.router.route(stanza)
+      rescue Babylon::NotConnected
+        Babylon.logger.fatal {
+          "#{$!.class} => #{$!.inspect}\n#{$!.backtrace.join("\n")}"
+        }
+        EventMachine::stop_event_loop
+      rescue
+        Babylon.logger.error {
+          "#{$!.class} => #{$!.inspect}\n#{$!.backtrace.join("\n")}"
+        }
+      end
+    end
+    
+  end
+end

data/lib/babylon/xmpp_connection.rb

@@ -0,0 +1,172 @@
+module Babylon
+  
+  ## 
+  # Connection Exception
+  class NotConnected < StandardError; end
+
+  ## 
+  # xml-not-well-formed Exception
+  class XmlNotWellFormed < StandardError; end
+
+  ##
+  # Error when there is no connection to the host and port.
+  class NoConnection < StandardError; end
+
+  ##
+  # Authentication Error (wrong password/jid combination). Used for Clients and Components
+  class AuthenticationError < StandardError; end
+
+  ##
+  # Raised when the application tries to send a stanza that might be rejected by the server because it's too long.
+  class StanzaTooBig < StandardError; end
+
+  ##
+  # This class is in charge of handling the network connection to the XMPP server.
+  class XmppConnection < EventMachine::Connection
+    
+    attr_accessor :jid, :host, :port
+    
+    @@max_stanza_size = 65535
+    
+    ##
+    # Maximum Stanza size. Default is 65535
+    def self.max_stanza_size
+      @@max_stanza_size
+    end
+    
+    ##
+    # Setter for Maximum Stanza size.
+    def self.max_stanza_size=(_size)
+      @@max_stanza_size = _size
+    end
+
+    ##
+    # Connects the XmppConnection to the right host with the right port.
+    # It passes itself (as handler) and the configuration
+    # This can very well be overwritten by subclasses.
+    def self.connect(params, handler)
+      Babylon.logger.debug {
+        "CONNECTING TO #{params["host"]}:#{params["port"]} with #{handler.inspect} as connection handler" # Very low level Logging
+      }
+      begin
+        EventMachine.connect(params["host"], params["port"], self, params.merge({"handler" => handler}))
+      rescue RuntimeError
+        Babylon.logger.error {
+          "CONNECTION ERROR : #{$!.class} => #{$!}" # Very low level Logging
+        }
+        raise NotConnected
+      end
+    end
+
+    ##
+    # Called when the connection is completed.
+    def connection_completed
+      @connected = true
+      Babylon.logger.debug {
+        "CONNECTED"
+      } # Very low level Logging
+    end
+
+    ##
+    # Called when the connection is terminated and stops the event loop
+    def unbind()
+      @connected = false
+      Babylon.logger.debug {
+        "DISCONNECTED"
+      } # Very low level Logging
+      begin
+        @handler.on_disconnected() if @handler and @handler.respond_to?("on_disconnected")
+      rescue
+        Babylon.logger.error {
+          "on_disconnected failed : #{$!}\n#{$!.backtrace.join("\n")}"
+        }
+      end
+    end
+
+    ## 
+    # Instantiate the Handler (called internally by EventMachine)
+    def initialize(params = {})
+      @connected = false
+      @jid       = params["jid"]
+      @password  = params["password"]
+      @host      = params["host"]
+      @port      = params["port"]
+      @handler   = params["handler"]
+      @buffer    = "" 
+    end
+    
+    ##
+    # Attaches a new parser since the network connection has been established.
+    def post_init
+      @parser = XmppParser.new(method(:receive_stanza))
+    end   
+
+    ##
+    # Called when a full stanza has been received and returns it to the central router to be sent to the corresponding controller.
+    def receive_stanza(stanza)
+      Babylon.logger.debug {
+        "PARSED : #{stanza.to_xml}"
+      }
+      # If not handled by subclass (for authentication)
+      case stanza.name
+      when "stream:error"
+        if !stanza.children.empty? and stanza.children.first.name == "xml-not-well-formed"
+          Babylon.logger.error {
+            "DISCONNECTED DUE TO MALFORMED STANZA"
+          }
+          raise XmlNotWellFormed
+        end
+        # In any case, we need to close the connection.
+        close_connection
+      else
+        begin
+          @handler.on_stanza(stanza) if @handler and @handler.respond_to?("on_stanza")
+        rescue
+          Babylon.logger.error {
+            "on_stanza failed : #{$!}\n#{$!.backtrace.join("\n")}"
+          }
+        end
+      end 
+    end 
+
+    ## 
+    # Sends the Nokogiri::XML data (after converting to string) on the stream. Eventually it displays this data for debugging purposes.
+    def send_xml(xml)
+      if xml.is_a? Nokogiri::XML::NodeSet
+        xml.each do |element|
+          send_chunk(element.to_s)
+        end
+      else
+        send_chunk(xml.to_s)
+      end
+    end
+
+    private
+
+    def send_chunk(string)
+      raise NotConnected unless @connected
+      return if string.blank?
+      raise StanzaTooBig, "Stanza Too Big (#{string.length} vs. #{XmppConnection.max_stanza_size})\n #{string}" if string.length > XmppConnection.max_stanza_size
+      Babylon.logger.debug {
+        "SENDING : " + string
+      }
+      send_data string
+    end
+
+    ## 
+    # receive_data is called when data is received. It is then passed to the parser. 
+    def receive_data(data)
+      begin
+        # Babylon.logger.debug {
+        #   "RECEIVED : #{data}"
+        # }
+        @parser.push(data) 
+      rescue
+        Babylon.logger.error {
+          "#{$!}\n#{$!.backtrace.join("\n")}"
+        }
+      end
+    end
+  end
+
+end