julien51-babylon 0.0.4 → 0.0.5

data/README.rdoc

@@ -2,7 +2,9 @@
 
 == DESCRIPTION:
 
-Babylon is a framework to EventMachine based XMPP External Components in Ruby.
+Babylon is a framework to build XMPP Applications in Ruby. The framework uses EventMachine to handle network connections.
+
+This framework can use both an XMPP Component (XEP-0114) and an XMPP Client. However, we strongly discourage any production application using a regular client.
 
 == FEATURES/PROBLEMS:
 
@@ -11,11 +13,17 @@ Babylon is a framework to EventMachine based XMPP External Components in Ruby.
 
 == ROADMAP :
 
-- Instead of passing the stanzas as Nokogiri:XML:Node elements we should find a way to pass an "agnostic" datastructure, so that app developers don't have to learn/know/understand Nokogiri
-- Adding the ability to send several messages all at once (like render :collection in Rails)
+- Instead of passing the stanzas as Nokogiri:XML:Node elements we should find a way to pass an "agnostic" ruby data-structure, so that app developers don't have to learn/know/understand Nokogiri
+- HELPERS : 
+    * strip jids (...) 
+- Improve the Client Connection to support other authentication than PLAIN SASL
 
 == SYNOPSIS:
 
+You can build applications directly with Babylon, or you can use the Babylon::ClientConnection and Babylon::ComponentConnection to create simple apps, but you will then have to handle stanza routing and creation yourself. You can also use these classes in external gems.
+
+To create an Application with Babylon: 
+
 1. Install the gem
 2. The app contains a generator that will "build" a scaffold for your application. 
     
@@ -82,8 +90,9 @@ This code hasn't been tested at all! (yes, i know it's bad, but I couldn't have
 
 == REQUIREMENTS:
 
-Our goal is to limit the number of dependencies. Nokogiri seems to be only XML Library on Ruby that has a Push SAX Parser, that is why we are using it. It also seems pretty 'fast'.
-Gems : Eventmachine, nokogiri
+Gems : Eventmachine, nokogiri, YAML
+
+Our goal is to limit the number of dependencies. Nokogiri seems to be only XML Library on Ruby that has a Push SAX Parser, that is why we are using it. It also seems pretty 'fast'. However, we think it is bad to "force" the framework users to receive Nokogiri objects (too much coupling), so we're looking for a Ruby datastcuture that would have an easy mapping with XML. Any thoughts?
 
 == INSTALL:
 

data/lib/babylon.rb

@@ -4,12 +4,13 @@ $:.unshift(File.dirname(__FILE__)) unless
 require 'eventmachine'
 require 'nokogiri'
 
-require 'babylon/xmpp_connection'
-require 'babylon/component_connection'
-require 'babylon/router'
-require 'babylon/runner'
-require 'babylon/base/controller'
-require 'babylon/base/view'
+require 'babylon/xmpp_connection.rb'
+require 'babylon/component_connection.rb'
+require 'babylon/client_connection.rb'
+require 'babylon/router.rb'
+require 'babylon/runner.rb'
+require 'babylon/base/controller.rb'
+require 'babylon/base/view.rb'
 
 # Babylon is a XMPP Component Framework based on EventMachine. It uses the Nokogiri GEM, which is a Ruby wrapper for Libxml2.
 # It implements the MVC paradigm.
@@ -18,7 +19,7 @@ require 'babylon/base/view'
 # This will generate some folders and files for your application. Please see README for further instructions
 
 module Babylon
-  # 0.0.4 : Not suited for production, use at your own risks
-  VERSION = '0.0.4'
+  # 0.0.5 : Not suited for production, use at your own risks
+  VERSION = '0.0.5'
 end
 

data/lib/babylon/client_connection.rb

@@ -0,0 +1,147 @@
+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
+    require 'digest/sha1'
+    require 'base64'
+
+    attr_reader :binding_iq_id, :session_iq_id
+
+    ## 
+    # Returns true only if we're in connected state
+    def connected?
+      @state == :connected
+    end
+
+    ##
+    # Creates a new ClientConnection 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
+      builder = Nokogiri::XML::Builder.new do
+        self.send('stream:stream', {'xmlns' => @context.stream_namespace(), 'xmlns:stream' => 'http://etherx.jabber.org/streams', 'to' => @context.config['host'],  'version' => '1.0'}) do
+          paste_content_here #  The stream:stream element should be cut here ;)
+        end
+      end
+      @outstream = builder.doc
+      start_stream, stop_stream = builder.to_xml.split('<paste_content_here/>')
+      send_data(start_stream)
+    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
+        if stanza.name == "stream:stream" && stanza.attributes['id']
+          @state = :wait_for_auth_mechanisms unless @success
+          @state = :wait_for_bind if @success
+        end
+        
+      when :wait_for_auth_mechanisms
+        if stanza.name == "stream:features"
+          if stanza.at("starttls") # we shall start tls
+            starttls = Nokogiri::XML::Node.new("starttls", @outstream)
+            starttls["xmlns"] = stanza.at("starttls").namespaces.first.last
+            send(starttls)
+            @state = :wait_for_proceed
+          elsif stanza.at("mechanisms") # tls is ok
+            if stanza.at("mechanisms/[contains(mechanism,'PLAIN')]")
+              # auth_text = "#{jid.strip}\x00#{jid.node}\x00#{password}"
+              auth = Nokogiri::XML::Node.new("auth", @outstream)
+              auth['mechanism'] = "PLAIN"
+              auth['xmlns'] = stanza.at("mechanisms").namespaces.first.last
+              auth.content = Base64::encode64([@config['jid'],@config['jid'].split("@").first,@config['password']].join("\000")).gsub(/\s/, '')
+              send(auth)
+              @state = :wait_for_success
+            end
+          end
+        end
+      
+      when :wait_for_success
+        if stanza.name == "success" # Yay! Success
+          @success = true
+          @state = :wait_for_stream
+          send_data @outstream.root.to_xml.split('<paste_content_here/>').first
+        else
+          # Hum Failure...
+        end
+      
+      when :wait_for_bind
+        if stanza.name == "stream:features"
+          if stanza.at("bind")
+            # Let's build the binding_iq
+            @binding_iq_id = Integer(rand(10000))
+            builder = Nokogiri::XML::Builder.new do
+              iq(:type => "set", :id => @context.binding_iq_id) do
+                bind(:xmlns => "urn:ietf:params:xml:ns:xmpp-bind")  do                
+                  if @context.config['resource'] 
+                    resource(@context.config['resource'] )
+                  else
+                    resource("babylon_client_#{@context.binding_iq_id}")
+                  end
+                end
+              end
+            end
+            iq = @outstream.add_child(builder.doc.root)
+            send(iq)
+            @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
+        end
+        # And now, we must initiate the session
+        @session_iq_id = Integer(rand(10000))
+        builder = Nokogiri::XML::Builder.new do
+          iq(:type => "set", :id => @context.session_iq_id) do
+            session(:xmlns => "urn:ietf:params:xml:ns:xmpp-session")
+          end
+        end
+        iq = @outstream.add_child(builder.doc.root)
+        send(iq)
+        @state = :wait_for_confirmed_session
+        
+      when :wait_for_confirmed_session
+        if stanza.name == "iq" && stanza["type"] == "result" && Integer(stanza["id"]) ==  @session_iq_id && stanza.at("session")
+          # And now, send a presence!
+          presence = Nokogiri::XML::Node.new("presence", @outstream)
+          send(presence)
+          @state = :connected
+        end
+        
+      when :wait_for_proceed
+        start_tls() # starting TLS
+        @state = :wait_for_stream
+        send_data @outstream.root.to_xml.split('<paste_content_here/>').first
+      end
+
+    end
+
+    ##
+    # Namespace of the client
+    def stream_namespace
+      "jabber:client"
+    end
+
+  end
+end

data/lib/babylon/component_connection.rb

@@ -5,19 +5,42 @@ module Babylon
   class ComponentConnection < XmppConnection
     require 'digest/sha1'
     
+    ## 
+    # Returns true only if we're in connected state
+    def connected?
+      @state == :connected
+    end
+    
     ##
     # Creates a new ComponentConnection and waits for data in the stream
     def initialize(*a)
       super
       @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
+      builder = Nokogiri::XML::Builder.new do
+        self.send('stream:stream', {'xmlns' => "jabber:component:accept", 'xmlns:stream' => 'http://etherx.jabber.org/streams', 'to' => @context.config['jid']}) do
+          paste_content_here #  The stream:stream element should be cut here ;)
+        end
+      end
+      @start_stream, @stop_stream = builder.to_xml.split('<paste_content_here/>')
+      send_data(@start_stream)
+    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 # Can be dispatched
+          
       when :wait_for_stream
         if stanza.name == "stream:stream" && stanza.attributes['id']
           # This means the XMPP session started!
@@ -40,8 +63,6 @@ module Babylon
           raise
         end
 
-      when :connected
-        super # Can be dispatched
       end
     end
     
@@ -51,10 +72,5 @@ module Babylon
       'jabber:component:accept'
     end
     
-    ##
-    # Jid of the component
-    def stream_to
-      @config['jid']
-    end
   end
 end

data/lib/babylon/runner.rb

@@ -24,8 +24,15 @@ module Babylon
       # Starting the EventMachine
       EventMachine.epoll
       EventMachine::run do
-        Babylon::ComponentConnection.connect(config)
-        
+        if config["application_type"] == "client"
+          Babylon::ClientConnection.connect(config) do |stanza|
+            CentralRouter.route stanza # Upon reception of new stanza, we Route them through the controller
+          end
+        else
+          Babylon::ComponentConnection.connect(config) do |stanza|
+            CentralRouter.route stanza # Upon reception of new stanza, we Route them through the controller
+          end
+        end
         # And finally, let's allow the application to do all it wants to do after we started the EventMachine!
         callback.call if callback
       end

data/lib/babylon/xmpp_connection.rb

@@ -13,8 +13,8 @@ module Babylon
     ##
     # Connects the XmppConnection to the right host with the right port. 
     # It passes itself (as handler) and the configuration
-    def self.connect(config)
-      EventMachine::connect config['host'], config['port'], self, config
+    def self.connect(config, &block)
+      EventMachine::connect config['host'], config['port'], self, config.merge({:callback => block})
     end
 
     ##
@@ -34,40 +34,32 @@ module Babylon
     ##
     # Called when a full stanza has been received and returns it to the central router to be sent to the corresponding controller. Eventually it displays this data for debugging purposes
     def receive_stanza(stanza)
-      puts "<< #{stanza}\n"  if debug? # Low level Logging 
       # If not handled by subclass (for authentication)
-      CentralRouter.route stanza
-    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
-      builder = Nokogiri::XML::Builder.new {
-        self.send('stream:stream', 'xmlns' => "jabber:component:accept", 'xmlns:stream' => 'http://etherx.jabber.org/streams', 'to' => @context.config['jid']) {
-          paste_content_here #  The stream:stream element should be cut here ;)
-        }
-      }
-      @start_stream, @stop_stream = builder.to_xml.split('<paste_content_here/>')
-      send_data(@start_stream)
+      @config[:callback].call(stanza) if @config[:callback]
     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
     def send(xml)
       if !xml.attributes["from"]
-        xml["from"] = config['jid']
+        xml["from"] = jid
       end
-      puts ">> #{xml}\n" if debug? # Very low level Logging
+      puts "SENDING  #{xml}\n" if debug? # Very low level Logging
       send_data "#{xml}"
     end
+    
+    ##
+    # Memoizer for jid. The jid can actually be changed in subclasses (client will probbaly want to change it to include the resource) 
+    def jid
+      @jid ||= config['jid']
+    end
 
     private
 
     ## 
     # receive_data is called when data is received. It is then passed to the parser. 
     def receive_data(data)
+      puts "RECEIVED #{data}\n"  if debug? # Low level Logging 
       @parser.parse data
     end
     
@@ -121,8 +113,10 @@ module Babylon
       # If we don't have any elem yet, we are at the root
       @elem = @elem ? @elem.add_child(e) : (@root = e)
       
-      if @elem.parent.nil?
+      if @elem.name == "stream:stream"
         # Should be called only for stream:stream
+        @doc = Nokogiri::XML::Document.new
+        @root = @elem
         @doc.root = @elem
         @callback.call(@elem)
       end

data/templates/babylon/config/config.yaml

@@ -5,6 +5,7 @@
 #    host: host on which the XMPP server is running
 #    port: port to which your component should connect
 #    debug: outputs the xmpp stanzas
+#    application_type: client | component (by default it is component and we strongly discourage any client application in production)
 
 development:
     jid: component.server.com

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: julien51-babylon
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Julien Genestoux
@@ -47,6 +47,7 @@ files:
 - lib/babylon/base/controller.rb
 - lib/babylon/base/view.rb
 - lib/babylon/component_connection.rb
+- lib/babylon/client_connection.rb
 - lib/babylon/router.rb
 - lib/babylon/runner.rb
 - lib/babylon/xmpp_connection.rb