julien51-babylon 0.0.14 → 0.1.0

data/lib/babylon/component_connection.rb

@@ -18,12 +18,15 @@ module Babylon
     # We use a "tweak" here to send only the starting tag of stream:stream
     def connection_completed
       super
-      builder = Nokogiri::XML::Builder.new do
-        self.send('stream:stream', {'xmlns' => "jabber:component:accept", 'xmlns:stream' => 'http://etherx.jabber.org/streams', 'to' => @context.jid}) do
-          paste_content_here #  The stream:stream element should be cut here ;)
-        end
-      end
-      start, stop = builder.to_xml.split('<paste_content_here/>')
+      doc = Nokogiri::XML::Document.new 
+      stream = Nokogiri::XML::Node.new("stream", doc)
+      stream.add_namespace(nil, stream_namespace)
+      stream.add_namespace("stream", "http://etherx.jabber.org/streams")
+      stream["to"] = jid
+      doc.add_child(stream)
+      paste_content_here= Nokogiri::XML::Node.new("paste_content_here", doc)
+      stream.add_child(paste_content_here)
+      start, stop = doc.to_xml.split('<stream:paste_content_here/>')
       send_xml(start)
     end
 
@@ -33,7 +36,7 @@ module Babylon
     def receive_stanza(stanza)
       case @state
       when :connected # Most frequent case
-          super # Can be dispatched
+          super(stanza) # Can be dispatched
           
       when :wait_for_stream
         if stanza.name == "stream:stream" && stanza.attributes['id']
@@ -72,11 +75,12 @@ module Babylon
     
     def handshake(stanza)
       hash = Digest::SHA1::hexdigest(stanza.attributes['id'].content + @password)
-      handshake = Nokogiri::XML::Node.new("handshake", stanza.document)
+      doc = Nokogiri::XML::Document.new
+      handshake = Nokogiri::XML::Node.new("handshake", doc)
+      doc.add_child(handshake)
       handshake.content = hash
       handshake
     end
     
-    
   end
 end

data/lib/babylon/generator.rb

@@ -99,7 +99,7 @@ module Babylon
       ##
       # This is a hack since Templater doesn't offer any simple way to edit files right now...
       def add_route_for_actions_in_controller(actions, controller)
-        sentinel = "Babylon::CentralRouter.draw do"
+        sentinel = "Babylon.router.draw do"
         router_path = "config/routes.rb"
         actions.each do |action|
           to_inject = "xpath(\"#{action[2]}\").to(:controller => \"#{controller}\", :action => \"#{action[0]}\").priority(#{action[1]})"

data/lib/babylon/router.rb

@@ -1,108 +1,74 @@
 require File.dirname(__FILE__)+"/router/dsl"
 
 module Babylon
-  
-  
-  ## 
-  # Undefined stanza
-  class UndefinedStanza < Exception; end
-  
   ##
-  # The router is in charge of sending the right stanzas to the right controllers based on user defined Routes.
-  module Router
+  # 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
     
-    @@connection = nil
+    attr_reader :routes, :connection
     
-    ##
-    # Add several routes to the router
-    # Routes should be of form {name => params}
-    def add_routes(routes)
-      routes.each do |name, params|
-        add_route(Route.new(params))
-      end
+    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
-    
-    ## 
-    # Accessor for @@connection
-    def connection
-      @@connection
+      @connection = connection
     end
     
     ##
-    # Insert a route and makes sure that the routes are sorted
-    def add_route(route)
-      @routes ||= []
-      @routes << route
-      sort
-    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(stanza)
-      return false if !@@connection
-      @routes ||= []
-      @routes.each { |route|
-        if route.accepts?(stanza)
-          # Here should happen the magic : call the controller
-          Babylon.logger.info("ROUTING TO #{route.controller}::#{route.action}")
-          # Parsing the stanza
-          begin
-            controller = route.controller.new(Kernel.const_get(route.action.capitalize).new(stanza))
-          rescue NameError
-            raise UndefinedStanza
-          end
-          controller.perform(route.action) do |response|
-            # Response should be a Nokogiri::Nodeset
-            @@connection.send_xml(response)
-          end
-          return true
-        end
-      }
-      false
-    end
-
-    # Throw away all added routes from this router. Helpful for
-    # testing.
-    def purge_routes!
-      @routes = []
+    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, xml_stanza = nil)
+      Babylon.logger.info("ROUTING TO #{controller_name}::#{action_name}") 
+      stanza = nil
+      stanza = Kernel.const_get(action_name.capitalize).new(xml_stanza) if xml_stanza
+      controller = controller_name.new(stanza) 
+      controller.perform(action_name) 
+      connection.send_xml(controller.evaluate)
     end
-
-    # Run the router DSL.
-    def draw(&block)
-      r = Router::DSL.new
-      r.instance_eval(&block)
-      r.routes.each do |route|
-        raise("Route lacks destination: #{route.inspect}") unless route.is_a?(Route)
-      end
-      @routes ||= []
-      @routes += r.routes
+    
+    ##
+    # 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
-      }
+      @routes.sort! { |r1,r2| r2.priority <=> r1.priority }
     end
   end
 
-  ##
-  # Main router for a Babylon Application.
-  module CentralRouter
-    extend Router
-  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
     
     ##
@@ -110,21 +76,17 @@ module Babylon
     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"] if params["xpath"]
-      @css        = params["css"] if params["css"]
+      @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
+    # Checks that the route matches the stanzas and calls the the action on the controller.
     def accepts?(stanza)
-      if @xpath
-        stanza.xpath(@xpath, XpathHelper.new).first ? self : false
-      elsif @css
-        stanza.css(@css).first ? self : false
-      end
+      stanza.xpath(@xpath, XpathHelper.new).empty? ? false : self
     end
     
   end

data/lib/babylon/router/dsl.rb

@@ -14,12 +14,6 @@ module Babylon
         @routes << {"xpath" => path}
         self
       end
-      
-      # Match a css.
-      def css(path)
-        @routes << {"css" => path}
-        self
-      end
 
       # Set the priority of the last created route.
       def priority(n)

data/lib/babylon/runner.rb

@@ -4,6 +4,38 @@ module Babylon
   # Runner is in charge of running the application.
   class Runner
     
+    ## 
+    # Prepares the Application to run.
+    def self.prepare(env)
+      # Load the configuration
+      config_file = File.open('config/config.yaml')
+      Babylon.config = YAML.load(config_file)[Babylon.environment]
+      
+      # Add an outputter to the logger
+      Babylon.logger.add(Log4r::FileOutputter.new("#{Babylon.environment}", :filename => "log/#{Babylon.environment}.log", :trunc => false))
+      
+      # 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.
@@ -17,31 +49,7 @@ module Babylon
       EventMachine.epoll
       EventMachine.run do
         
-        # Add an outputter to the logger
-        Babylon.logger.add(Log4r::FileOutputter.new("#{Babylon.environment}", :filename => "log/#{Babylon.environment}.log", :trunc => false))
-        
-        # Requiring all models
-        Dir.glob('app/models/*.rb').each { |f| require f }
-
-        # Requiring all stanzas
-        Dir.glob('app/stanzas/*.rb').each { |f| require f }
-
-        # Load the controllers
-        Dir.glob('app/controllers/*_controller.rb').each {|f| require f }
-
-        # Evaluate routes defined with the new DSL router.
-        CentralRouter.draw do
-          eval File.read("config/routes.rb")
-        end
-        
-        config_file = File.open('config/config.yaml')
-        
-        # Caching views in production mode.
-        if Babylon.environment == "production"
-          Babylon.cache_views
-        end
-        
-        Babylon.config = YAML.load(config_file)[Babylon.environment] 
+        Runner.prepare(env)
         
         case Babylon.config["application_type"] 
         when "client"
@@ -63,18 +71,24 @@ module Babylon
     
     ##
     # Adding a connection observer. These observer will receive on_connected and on_disconnected events.
-    def self.add_connection_observer(object)
-      @@observers ||= Array.new
-      @@observers.push(object)
+    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::CentralRouter.connected(connection)
-      connection_observers.each do |conn_obs|
-        conn_obs.on_connected(connection) if conn_obs.respond_to?("on_connected")
+      Babylon.router.connected(connection)
+      connection_observers.each do |observer|
+        Babylon.router.execute_route(observer, "on_connected")
       end
     end
     
@@ -82,16 +96,24 @@ module Babylon
     # 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()
-      EventMachine.stop_event_loop
       connection_observers.each do |conn_obs|
-        conn_obs.on_disconnected if conn_obs.respond_to?("on_disconnected")
+        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)
-      Babylon::CentralRouter.route(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

data/lib/babylon/xmpp_connection.rb

@@ -1,40 +1,61 @@
 module Babylon
-
+  
   ## 
   # Connection Exception
-  class NotConnected < Exception; end
+  class NotConnected < StandardError; end
 
   ## 
   # xml-not-well-formed Exception
-  class XmlNotWellFormed < Exception; end
+  class XmlNotWellFormed < StandardError; end
 
   ##
   # Error when there is no connection to the host and port.
-  class NoConnection < Exception; end
+  class NoConnection < StandardError; end
 
   ##
   # Authentication Error (wrong password/jid combination). Used for Clients and Components
-  class AuthenticationError < Exception; end
+  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. I
+    # 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"]}") # Very low level Logging
+      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
-        Babylon.logger.error("CONNECTION ERROR : #{$!}") # Very low level Logging
+      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
@@ -53,17 +74,22 @@ module Babylon
     end
 
     ## 
-    # Instantiate the Handler (called internally by EventMachine) and attaches a new XmppParser
-    def initialize(params)
-      super()
+    # 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"]
-      @parser = XmppParser.new(&method(:receive_stanza))
+      @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.
@@ -73,7 +99,6 @@ module Babylon
       case stanza.name
       when "stream:error"
         if !stanza.children.empty? and stanza.children.first.name == "xml-not-well-formed"
-          # <stream:error><xml-not-well-formed xmlns:xmlns="urn:ietf:params:xml:ns:xmpp-streams"/></stream:error>
           Babylon.logger.error("DISCONNECTED DUE TO MALFORMED STANZA")
           raise XmlNotWellFormed
         end
@@ -89,40 +114,25 @@ module Babylon
     end 
 
     ## 
-    # Sends the Nokogiri::XML data (after converting to string) on the stream. It also appends the right "from" to be the component's JId if none has been mentionned. Eventually it displays this data for debugging purposes.
-    # This method also adds a "from" attribute to all stanza if it was ommited (the full jid) only if a "to" attribute is present. if not, we assume that we're speaking to the server and the server doesn't need a "from" to identify where the message is coming from.
+    # Sends the Nokogiri::XML data (after converting to string) on the stream. Eventually it displays this data for debugging purposes.
     def send_xml(xml)
-      raise NotConnected unless @connected
       if xml.is_a? Nokogiri::XML::NodeSet
-        xml.each do |node|
-          send_node(node)
+        xml.each do |element|
+          send_chunk(element.to_s)
         end
-      elsif xml.is_a? Nokogiri::XML::Node
-        send_node(xml)
       else
-        # We try a cast into a string.
-        send_string("#{xml}")
+        send_chunk(xml.to_s)
       end
     end
 
     private
 
-    ##
-    # Sends a node on the "line".
-    def send_node(node)
-      node["from"] ||= jid if node["to"]
-      send_string(node.to_xml)
-    end
-
-    ## 
-    # Sends a string on the line
-    def send_string(string)
-      begin
-        Babylon.logger.debug("SENDING : #{string}")
-        send_data("#{string}") 
-      rescue
-        Babylon.logger.error("#{$!}\n#{$!.backtrace.join("\n")}")
-      end
+    def send_chunk(string)
+      raise NotConnected unless @connected
+      return if string.blank?
+      raise StanzaTooBig if string.length > XmppConnection.max_stanza_size
+      Babylon.logger.debug("SENDING : " + string)
+      send_data string
     end
 
     ## 
@@ -130,7 +140,7 @@ module Babylon
     def receive_data(data)
       begin
         Babylon.logger.debug("RECEIVED : #{data}")
-        @parser.push(data)
+        @parser.push(data) 
       rescue
         Babylon.logger.error("#{$!}\n#{$!.backtrace.join("\n")}")
       end