mohiam-babylon 0.1.7

data/lib/babylon/base/stanza.rb

@@ -0,0 +1,23 @@
+module Babylon
+  module Base
+    ##
+    # Class used to Parse a Stanza on the XMPP stream.
+    # You should have a Stanza subsclass for each of your controller actions, as they allow you to define which stanzas and which information is passed to yoru controllers.
+    #
+    # You can define your own macthing pretty easily with the element and elements methods, as explained in the SaxMachine Documentation: http://github.com/pauldix/sax-machine/tree/master
+    # if your stanza is a message stanza, you can match the following for example:
+    # element :message, :value => :to, :as => :to 
+    # element :message, :value => :from, :as => :from 
+    # element :message, :value => :id, :as => :stanza_id 
+    # element :message, :value => :type, :as => :stanza_type 
+    # element :message, :value => :"xml:lang", :as => :lang 
+    #
+    class Stanza
+      include SAXMachine
+      
+      def initialize(xml = nil)
+        parse(xml.to_s)
+      end
+    end
+  end
+end

data/lib/babylon/base/view.rb

@@ -0,0 +1,49 @@
+module Babylon
+  module Base
+    
+    class ViewFileNotFound < Errno::ENOENT; end
+    
+    ##
+    # Your application's views (stanzas) should be descendant of this class.
+    class View 
+      attr_reader :view_template 
+      
+      ##
+      # Used to 'include' another view inside an existing view. 
+      # The caller needs to pass the context in which the partial will be rendered
+      # Render must be called with :partial as well (other options will be supported later). The partial vale should be a relative path
+      # to another file view, from the calling view.
+      def render(xml, options = {})
+        # First, we need to identify the partial file path, based on the @view_template path.
+        partial_path = (@view_template.split("/")[0..-2] + options[:partial].split("/")).join("/").gsub(".xml.builder", "") + ".xml.builder"
+        raise ViewFileNotFound, "No such file #{partial_path}" unless Babylon.views[partial_path] 
+        eval(Babylon.views[partial_path], binding, partial_path, 1)
+      end
+      
+      ##
+      # Instantiate a new view with the various varibales passed in assigns and the path of the template to render.
+      def initialize(path = "", assigns = {}) 
+        @view_template = path 
+        
+        assigns.each do |key, value| 
+          # Babylon.logger.debug("assigning @#{key}='#{value}'")
+          instance_variable_set(:"@#{key}", value) 
+        end 
+      end 
+      
+      ## 
+      # "Loads" the view file, and uses the Nokogiri Builder to build the XML stanzas that will be sent. 
+      def evaluate 
+        return if @view_template == ""
+        
+        # Babylon.logger.debug("eval with template #{@view_template} - looking thru #{Babylon.views}")
+        raise ViewFileNotFound, "No such file #{@view_template}" unless Babylon.views[@view_template]
+        builder = Nokogiri::XML::Builder.new 
+        builder.stream do |xml|
+          eval(Babylon.views[@view_template], binding, @view_template, 1)
+        end
+        builder.doc.root.children # we output the document built 
+      end 
+    end 
+  end 
+end

data/lib/babylon/client_connection.rb

@@ -0,0 +1,210 @@
+module Babylon
+
+  ##
+  # ClientConnection is in charge of the XMPP connection for a Regular XMPP Client.
+  # So far, SASL Plain authenticationonly is supported
+  # Upon stanza reception, and depending on the status (connected... etc), this component will handle or forward the stanzas.
+  class ClientConnection < XmppConnection
+
+    attr_reader :binding_iq_id, :session_iq_id
+
+    ##
+    # Creates a new ClientConnection and waits for data in the stream
+    def initialize(params)
+      super(params)
+      @state = :wait_for_stream
+    end
+
+    ##
+    # Connects the ClientConnection based on SRV records for the jid's domain, if no host or port has been specified.
+    # In any case, we give priority to the specified host and port.
+    def self.connect(params, handler = nil)
+      return super(params, handler) if params["host"] && params["port"]
+
+      begin
+        srv = []
+        Resolv::DNS.open { |dns|
+          # If ruby version is too old and SRV is unknown, this will raise a NameError
+          # which is caught below
+          host_from_jid = params["jid"].split("/").first.split("@").last
+          Babylon.logger.debug {
+            "RESOLVING: _xmpp-client._tcp.#{host_from_jid} (SRV)"
+          }
+          srv = dns.getresources("_xmpp-client._tcp.#{host_from_jid}", Resolv::DNS::Resource::IN::SRV)
+        }
+        # Sort SRV records: lowest priority first, highest weight first
+        srv.sort! { |a,b| (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight) }
+        # And now, for each record, let's try to connect.
+        srv.each { |record|
+          begin
+            params["host"] = record.target.to_s
+            params["port"] = Integer(record.port)
+            super(params, handler)
+            # Success
+            break
+          rescue NotConnected
+            # Try next SRV record
+          end
+        }
+      rescue NameError
+        Babylon.logger.debug {
+          "Resolv::DNS does not support SRV records. Please upgrade to ruby-1.8.3 or later! \n#{$!} : #{$!.backtrace.join("\n")}"
+        }
+      end
+    end
+
+    ##
+    # Builds the stream stanza for this client
+    def stream_stanza
+      doc = Nokogiri::XML::Document.new
+      stream = Nokogiri::XML::Node.new("stream:stream", doc)
+      doc.add_child(stream)
+      stream["xmlns"] = stream_namespace
+      stream["xmlns:stream"] = "http://etherx.jabber.org/streams"
+      stream["to"] = jid.split("/").first.split("@").last
+      stream["version"] = "1.0"
+      paste_content_here = Nokogiri::XML::Node.new("paste_content_here", doc)
+      stream.add_child(paste_content_here)
+      doc.to_xml.split('<paste_content_here/>').first
+    end
+
+    ##
+    # Connection_completed is called when the connection (socket) has been established and is in charge of "building" the XML stream 
+    # to establish the XMPP connection itself.
+    # We use a "tweak" here to send only the starting tag of stream:stream
+    def connection_completed
+      super
+      send_xml(stream_stanza)
+    end
+
+    ##
+    # Called upon stanza reception
+    # Marked as connected when the client has been SASLed, authenticated, biund to a resource and when the session has been created
+    def receive_stanza(stanza)
+        case @state
+        when :connected
+          super # Can be dispatched
+
+        when :wait_for_stream_authenticated
+          if stanza.name == "stream:stream" && stanza.attributes['id']
+            @state = :wait_for_bind
+          end
+
+        when :wait_for_stream
+          if stanza.name == "stream:stream" && stanza.attributes['id']
+            @state = :wait_for_auth_mechanisms
+          end
+
+        when :wait_for_auth_mechanisms
+          if stanza.name == "stream:features"
+            if stanza.at("starttls") # we shall start tls
+              doc = Nokogiri::XML::Document.new
+              starttls = Nokogiri::XML::Node.new("starttls", doc)
+              doc.add_child(starttls)
+              starttls["xmlns"] = "urn:ietf:params:xml:ns:xmpp-tls"
+              send_xml(starttls.to_s)
+              @state = :wait_for_proceed
+            elsif stanza.at("mechanisms") # tls is ok
+              if stanza.at("mechanisms").children.map() { |m| m.text }.include? "PLAIN"
+                doc = Nokogiri::XML::Document.new
+                auth = Nokogiri::XML::Node.new("auth", doc)
+                doc.add_child(auth)
+                auth['mechanism'] = "PLAIN"
+                auth["xmlns"] = "urn:ietf:params:xml:ns:xmpp-sasl"
+                auth.content = Base64::encode64([jid, jid.split("@").first, @password].join("\000")).gsub(/\s/, '')
+                send_xml(auth.to_s)
+                @state = :wait_for_success
+              end
+            end
+          end
+
+        when :wait_for_success
+          if stanza.name == "success" # Yay! Success
+            @state = :wait_for_stream_authenticated
+            @parser.reset
+            send_xml(stream_stanza)
+          elsif stanza.name == "failure"
+            if stanza.at("bad-auth") || stanza.at("not-authorized")
+              raise AuthenticationError
+            else
+            end
+          else
+            # Hum Failure...
+          end
+
+        when :wait_for_bind
+          if stanza.name == "stream:features"
+            if stanza.at("bind")
+              doc = Nokogiri::XML::Document.new
+              # Let's build the binding_iq
+              @binding_iq_id = Integer(rand(10000000))
+              iq = Nokogiri::XML::Node.new("iq", doc)
+              doc.add_child(iq)
+              iq["type"] = "set"
+              iq["id"] = binding_iq_id.to_s
+              bind = Nokogiri::XML::Node.new("bind", doc)
+              bind["xmlns"] = "urn:ietf:params:xml:ns:xmpp-bind"
+              iq.add_child(bind)
+              resource = Nokogiri::XML::Node.new("resource", doc)
+              if jid.split("/").size == 2 
+                resource.content = (@jid.split("/").last)
+              else
+                resource.content = "babylon_client_#{binding_iq_id}"
+              end
+              bind.add_child(resource)
+              send_xml(iq.to_s)
+              @state = :wait_for_confirmed_binding
+            end
+          end
+
+        when :wait_for_confirmed_binding
+          if stanza.name == "iq" && stanza["type"] == "result" && Integer(stanza["id"]) ==  binding_iq_id
+            if stanza.at("jid")
+              @jid = stanza.at("jid").text
+            end
+            # And now, we must initiate the session
+            @session_iq_id = Integer(rand(10000))
+            doc = Nokogiri::XML::Document.new
+            iq = Nokogiri::XML::Node.new("iq", doc)
+            doc.add_child(iq)
+            iq["type"] = "set"
+            iq["id"] = session_iq_id.to_s
+            session = Nokogiri::XML::Node.new("session", doc)
+            session["xmlns"] = "urn:ietf:params:xml:ns:xmpp-session"
+            iq.add_child(session)
+            send_xml(iq.to_s)
+            @state = :wait_for_confirmed_session
+          end
+
+        when :wait_for_confirmed_session
+          if stanza.name == "iq" && stanza["type"] == "result" && Integer(stanza["id"]) == session_iq_id
+            # And now, send a presence!
+            doc = Nokogiri::XML::Document.new
+            presence = Nokogiri::XML::Node.new("presence", doc)
+            send_xml(presence.to_s)
+            begin
+              @handler.on_connected(self) if @handler and @handler.respond_to?("on_connected")
+            rescue
+              Babylon.logger.error {
+                "on_connected failed : #{$!}\n#{$!.backtrace.join("\n")}"
+              }
+            end
+            @state = :connected
+          end
+
+        when :wait_for_proceed
+          start_tls() # starting TLS
+          @state = :wait_for_stream
+          @parser.reset
+          send_xml stream_stanza
+        end
+    end
+
+    ##
+    # Namespace of the client
+    def stream_namespace
+      "jabber:client"
+    end
+
+  end
+end

data/lib/babylon/component_connection.rb

@@ -0,0 +1,87 @@
+module Babylon
+  ##
+  # ComponentConnection is in charge of the XMPP connection itself.
+  # Upon stanza reception, and depending on the status (connected... etc), this component will handle or forward the stanzas.
+  class ComponentConnection < XmppConnection
+    
+    ##
+    # Creates a new ComponentConnection and waits for data in the stream
+    def initialize(params)
+      super(params)
+      @state = :wait_for_stream
+    end
+    
+    ##
+    # Connection_completed is called when the connection (socket) has been established and is in charge of "building" the XML stream 
+    # to establish the XMPP connection itself.
+    # We use a "tweak" here to send only the starting tag of stream:stream
+    def connection_completed
+      super
+      doc = Nokogiri::XML::Document.new 
+      stream = Nokogiri::XML::Node.new("stream:stream", doc)
+      stream["xmlns"] = stream_namespace
+      stream["xmlns: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('<paste_content_here/>')
+      send_xml(start)
+    end
+
+    ##
+    # XMPP Component handshake as defined in XEP-0114:
+    # http://xmpp.org/extensions/xep-0114.html
+    def receive_stanza(stanza)
+      case @state
+      when :connected # Most frequent case
+          super(stanza) # Can be dispatched
+          
+      when :wait_for_stream
+        if stanza.name == "stream:stream" && stanza.attributes['id']
+          # This means the XMPP session started!
+          # We must send the handshake now.
+          send_xml(handshake(stanza))
+          @state = :wait_for_handshake
+        else
+          raise
+        end
+
+      when :wait_for_handshake
+        if stanza.name == "handshake"
+          begin
+            @handler.on_connected(self) if @handler and @handler.respond_to?("on_connected")
+          rescue
+            Babylon.logger.error {
+              "on_connected failed : #{$!}\n#{$!.backtrace.join("\n")}"
+            }
+          end
+          @state = :connected
+        elsif stanza.name == "stream:error"
+          raise AuthenticationError
+        else
+          raise
+        end
+
+      end
+    end
+    
+    ##
+    # Namespace of the component
+    def stream_namespace
+      'jabber:component:accept'
+    end
+    
+    private
+    
+    def handshake(stanza)
+      hash = Digest::SHA1::hexdigest(stanza.attributes['id'].content + @password)
+      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

@@ -0,0 +1,139 @@
+module Babylon
+  module Generator
+    extend Templater::Manifold
+    
+    desc <<-DESC
+      Babylon is a framework to generate XMPP Applications in Ruby."
+    DESC
+    
+    ##
+    # Generates a Babylon Application
+    class ApplicationGenerator < Templater::Generator
+      desc <<-DESC
+        Generates the file architecture for a Babylon Application. To run, you MUST provide an application name"
+      DESC
+      
+      first_argument :application_name, :required => true, :desc => "Your application name."
+      
+      def self.source_root
+        File.join(File.dirname(__FILE__), '../../templates/babylon')
+      end
+      
+      # Create all subsdirectories
+      empty_directory :app_directory do |d|
+        d.destination = "#{application_name}/app"
+      end
+      empty_directory :controllers_directory do |d|
+        d.destination = "#{application_name}/app/controllers"
+      end
+      empty_directory :views_directory do |d|
+        d.destination = "#{application_name}/app/views"
+      end
+      empty_directory :views_directory do |d|
+        d.destination = "#{application_name}/app/stanzas"
+      end
+      empty_directory :models_directory do |d|
+        d.destination = "#{application_name}/app/models"
+      end
+      empty_directory :initializers_directory do |d|
+        d.destination = "#{application_name}/config/initializers"
+      end
+      empty_directory :tmp_directory do |d|
+        d.destination = "#{application_name}/tmp"
+      end 
+      empty_directory :log_directory do |d|
+        d.destination = "#{application_name}/log"
+      end
+      empty_directory :pid_directory do |d|
+        d.destination = "#{application_name}/tmp/pids"
+      end
+           
+      # And now add the critical files
+      file :boot_file do |f|
+        f.source = "#{source_root}/config/boot.rb"
+        f.destination = "#{application_name}/config/boot.rb"
+      end
+      file :config_file do |f|
+        f.source = "#{source_root}/config/config.yaml"
+        f.destination = "#{application_name}/config/config.yaml"
+      end
+      file :dependencies_file do |f|
+        f.source = "#{source_root}/config/dependencies.rb"
+        f.destination = "#{application_name}/config/dependencies.rb"
+      end
+      file :dependencies_file do |f|
+        f.source = "#{source_root}/config/routes.rb"
+        f.destination = "#{application_name}/config/routes.rb"
+      end
+      template :component_file do |f|
+        f.source = "#{source_root}/script/component"
+        f.destination = "#{application_name}/script/component"
+      end
+      
+    end
+    
+    ##
+    # Generates a new controller, with the corresponding stanzas and routes.
+    class ControllerGenerator < Templater::Generator
+      desc <<-DESC
+        Generates a new controller for the current Application. It also adds the corresponding routes and actions, based on a Xpath and priority. \nSyntax: babylon controller <controller_name> [<action_name>:<priority>:<xpath>],[...]"
+      DESC
+      
+      first_argument  :controller_name, :required => true,   :desc => "Name of the Controller."
+      second_argument :actions_arg,      :required => true,  :as => :array,      :default => [], :desc => "Actions implemented by this controller. Use the following syntax : name:priority:xpath"
+      
+      def self.source_root
+        File.join(File.dirname(__FILE__), '../../templates/babylon/app/controllers')
+      end
+      
+      def controller_actions
+        @controller_actions ||= actions_arg.map { |a| a.split(":") }
+      end
+      
+      def controller_class_name
+        "#{controller_name.capitalize}Controller"
+      end
+      
+      ##
+      # 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.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]})"
+          if File.exist?(router_path)
+            content = File.read(router_path).gsub(/(#{Regexp.escape(sentinel)})/mi){|match| "#{match}\n\t#{to_inject}"}
+            File.open(router_path, 'wb') { |file| file.write(content) }
+          end
+        end
+      end
+      
+      template :controller do |t|
+        t.source = "#{source_root}/controller.rb"
+        t.destination = "app/controllers/#{controller_name}_controller.rb"
+        self.add_route_for_actions_in_controller(controller_actions, controller_name)
+        # This is a hack since Templater doesn't offer any simple way to write several files from one...
+        FileUtils.mkdir("app/views/#{controller_name}") unless File.exists?("app/views/#{controller_name}")
+        controller_actions.each do |action|
+          FileUtils.cp("#{source_root}/../views/view.rb", "app/views/#{controller_name}/#{action[0]}.xml.builder")
+        end
+        
+        # And now, let's create the stanza files
+        controller_actions.each do |action|
+          FileUtils.cp("#{source_root}/../stanzas/stanza.rb", "app/stanzas/#{action[0]}.rb")
+          # We need to replace 
+          # "class Stanza < Babylon::Base::Stanza" with "class #{action[0]} < Babylon::Base::Stanza"
+          content = File.read("app/stanzas/#{action[0]}.rb").gsub("class Stanza < Babylon::Base::Stanza", "class #{action[0].capitalize} < Babylon::Base::Stanza")
+          File.open("app/stanzas/#{action[0]}.rb", 'wb') { |file| file.write(content) }
+        end
+      end
+    end
+    
+    # The generators are added to the manifold, and assigned the names 'wiki' and 'blog'.
+    # So you can call them <script name> blog merb-blog-in-10-minutes and
+    # <script name> blog merb-wiki-in-10-minutes, respectively
+    add :application, ApplicationGenerator
+    add :controller, ControllerGenerator
+    
+  end
+end