skates 0.1.11 → 0.2.1

data/README.rdoc

@@ -85,7 +85,7 @@ Skates's edge versions are located at Github : http://github.com/julien51/skates
 
 == REQUIREMENTS :
 
-Gems : Eventmachine, nokogiri (please, use build from the guthub repo, since 1.2.3 is not supported by Skates), YAML, log4r, sax-machine, templater
+Gems : Eventmachine, nokogiri, YAML, log4r, sax-machine, templater
 
 == LICENSE:
 

data/lib/skates/client_connection.rb

@@ -16,41 +16,40 @@ module Skates
     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.
+    # Connects the ClientConnection based on SRV records for the jid's domain, if no host has been provided.
+    # It will not resolve if params["host"] is an IP.
+    # And it will always use 
     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
-          Skates.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
+      params["host"] ||= params["jid"].split("/").first.split("@").last 
+      super(params, handler)
+    end
+
+    ##
+    # Resolution for clients, based on SRV records
+    def self.resolve(host, &block)
+      Resolv::DNS.open { |dns|
+        # If ruby version is too old and SRV is unknown, this will raise a NameError
+        # which is caught below
         Skates.logger.debug {
-          "Resolv::DNS does not support SRV records. Please upgrade to ruby-1.8.3 or later! \n#{$!} : #{$!.backtrace.join("\n")}"
+          "RESOLVING: #{srv_for_host(host)} (SRV)"
         }
-      end
+        begin
+          srv = dns.getresources("_xmpp-client._tcp.#{host}", 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|
+            ip    = record.target.to_s
+            port  = Integer(record.port)
+            break if block.call({"host" => ip, "port" => port}) 
+          }
+          block.call(false) # bleh, we couldn't resolve to any valid. Too bad.
+        rescue NameError
+          Skates.logger.debug {
+            "Resolv::DNS does not support SRV records. Please upgrade to ruby-1.8.3 or later! \n#{$!} : #{$!.backtrace.join("\n")}"
+          }
+        end
+      }
     end
 
     ##

data/lib/skates/component_connection.rb

@@ -4,6 +4,11 @@ module Skates
   # Upon stanza reception, and depending on the status (connected... etc), this component will handle or forward the stanzas.
   class ComponentConnection < XmppConnection
     
+    def self.connect(params, handler)
+      params["host"] ||= params["jid"]
+      super(params, handler)
+    end
+    
     ##
     # Creates a new ComponentConnection and waits for data in the stream
     def initialize(params)
@@ -72,6 +77,28 @@ module Skates
       'jabber:component:accept'
     end
     
+    ##
+    # Resolution for Components, based on SRV records
+    def self.resolve(host, &block)
+      Resolv::DNS.open { |dns|
+        # If ruby version is too old and SRV is unknown, this will raise a NameError
+        # which is caught below
+        Skates.logger.debug {
+          "RESOLVING: #{host} "
+        }
+        found = false
+        records = dns.getresources(host, Resolv::DNS::Resource::IN::A)
+        records.each do |record|
+          ip = record.address.to_s
+          if block.call({"host" => ip}) 
+            found = true
+            break
+          end
+        end
+        block.call(false) unless found # bleh, we couldn't resolve to any valid. Too bad.
+      }
+    end
+    
     private
     
     def handshake(stanza)

data/lib/skates/generator.rb

@@ -38,6 +38,9 @@ module Skates
       empty_directory :initializers_directory do |d|
         d.destination = "#{application_name}/config/initializers"
       end
+      empty_directory :destructors_directory do |d|
+        d.destination = "#{application_name}/config/destructors"
+      end
       empty_directory :tmp_directory do |d|
         d.destination = "#{application_name}/tmp"
       end 

data/lib/skates/xmpp_connection.rb

@@ -28,6 +28,13 @@ module Skates
     
     @@max_stanza_size = 65535
     
+    ##
+    # This will the host asynscrhonously and calls the block for each IP:Port pair.
+    # if the block returns true, no other record will be tried. If it returns false, the block will be called with the next pair.
+    def self.resolve(host, &block)
+      block.call(false)
+    end
+    
     ##
     # Maximum Stanza size. Default is 65535
     def self.max_stanza_size
@@ -45,16 +52,26 @@ module Skates
     # It passes itself (as handler) and the configuration
     # This can very well be overwritten by subclasses.
     def self.connect(params, handler)
-      Skates.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
-        Skates.logger.error {
-          "CONNECTION ERROR : #{$!.class} => #{$!}" # Very low level Logging
-        }
-        raise NotConnected
+      if params["host"] =~ /\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/ 
+        params["port"] = params["port"] ? params["port"].to_i : 5222 
+        _connect(params, handler)
+      else
+        resolve(params["host"]) do |host_info|
+          if host_info
+            begin
+              _connect(params.merge(host_info), handler)
+              true # connected! Yay!
+            rescue NotConnected
+              # It will try the next pair of ip/port
+              false
+            end
+          else
+            Skates.logger.error {
+              "Sorry, we couldn't resolve #{srv_for_host(params["host"])} to any host that accept XMPP connections. Please provide a params[\"host\"]."
+            }
+            EM.stop_event_loop
+          end
+        end
       end
     end
 
@@ -167,6 +184,26 @@ module Skates
         }
       end
     end
+  
+    def self.srv_for_host(host)
+      "#{host}"
+    end
+  
+    def self._connect(params, handler)
+      Skates.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
+        Skates.logger.error {
+          "CONNECTION ERROR : #{$!.class} => #{$!}" # Very low level Logging
+        }
+        raise NotConnected
+      end
+      
+    end
+    
   end
 
 end

data/spec/lib/babylon/client_connection_spec.rb

@@ -6,8 +6,8 @@ describe Skates::ClientConnection do
   include SkatesSpecHelper
 
   before(:each) do
-    @params = {"jid" => "jid@server.tld", "password" => "password", "port" => 1234, "host" => "myhost.com"}
-    @client = Skates::ClientConnection.connect(@params, handler_mock) 
+    @params = {"jid" => "jid@server.tld", "password" => "password"}
+    @client = Skates::ClientConnection.connect(@params.merge({"host" => "0.0.0.0", "port" => 5222}), handler_mock) 
     @client.stub!(:send_xml).and_return(true) 
   end
   
@@ -18,37 +18,42 @@ describe Skates::ClientConnection do
   end
   
   describe "connect" do
-    it "should not try to resolve the dns if both the port and host are provided" do
-      Resolv::DNS.should_not_receive(:open)
-      @client = Skates::ClientConnection.connect(@params, handler_mock) 
+  end
+  
+  describe "when resolving the hostname" do
+    before(:each) do
+      @params.delete("host")
+      @params.delete("port")
+      @srv = [
+        mock(Resolv::DNS::Resource, :priority => 10, :target => "12.13.14.15", :port => 1234),
+        mock(Resolv::DNS::Resource, :priority => 3, :target => "12.13.14.16", :port => 4567),
+        mock(Resolv::DNS::Resource, :priority => 100, :target => "12.13.14.17", :port => 8910)
+        ]
+      @mock_dns = mock(Object)
+      Resolv::DNS.stub!(:open).and_yield(@mock_dns)
+      @mock_dns.stub!(:getresources).and_return(@srv)
     end
     
-    describe "when host and port are not provided" do
-      before(:each) do
-        @params.delete("host")
-        @params.delete("port")
-        @srv = [
-          mock(Resolv::DNS::Resource, :priority => 10, :target => "xmpp.server.tld", :port => 1234),
-          mock(Resolv::DNS::Resource, :priority => 3, :target => "xmpp2.server.tld", :port => 4567),
-          mock(Resolv::DNS::Resource, :priority => 100, :target => "xmpp3.server.tld", :port => 8910)
-          ]
-        @mock_dns = mock(Object)
-        Resolv::DNS.stub!(:open).and_yield(@mock_dns)
-        @mock_dns.stub!(:getresources).with("_xmpp-client._tcp.server.tld", Resolv::DNS::Resource::IN::SRV).and_return(@srv)
-      end
-      
-      it "should get resources assiated with _xmpp-client._tcp.host.tld}" do
-        Resolv::DNS.should_receive(:open).and_yield(@mock_dns)
-        @mock_dns.should_receive(:getresources).with("_xmpp-client._tcp.server.tld", Resolv::DNS::Resource::IN::SRV).and_return(@srv)
-        @client = Skates::ClientConnection.connect(@params, handler_mock) 
-      end
-      
-      it "should sort the srv records" do
-        @client = Skates::ClientConnection.connect(@params, handler_mock) 
-        @srv.map {|srv| srv.target }.should == ["xmpp2.server.tld", "xmpp.server.tld", "xmpp3.server.tld"]
+    it "should get resources assiated with _xmpp-client._tcp.host.tld}" do
+      Resolv::DNS.should_receive(:open).and_yield(@mock_dns)
+      @mock_dns.should_receive(:getresources).with("_xmpp-client._tcp.server.tld", Resolv::DNS::Resource::IN::SRV).and_return(@srv)
+      Skates::ClientConnection.resolve("server.tld") 
+    end
+    
+    it "should call the block with the highest priority" do
+      Skates::ClientConnection.resolve("xmpp.server.tld") do |params|
+        params["host"].should == "12.13.14.16"
+        params["port"].should == 4567
+        true
+      end 
+    end
+    
+    it "should call the block as many times as needed if they're not connecting" do
+      conn = mock(Skates::ClientConnection, :_connect => false)
+      conn.should_receive(:_connect).exactly(3).times
+      Skates::ClientConnection.resolve("xmpp.server.tld") do |ip, port|
+        conn._connect(ip, port)
       end
-      
-      it "should try to connect to each record until one of the them actually connects" 
     end
   end
   

data/spec/lib/babylon/component_connection_spec.rb

@@ -6,7 +6,7 @@ describe Skates::ComponentConnection do
   include SkatesSpecHelper
 
   before(:each) do
-    @params = {"jid" => "jid@server", "password" => "password", "port" => 1234, "host" => "myhost.com"}
+    @params = {"jid" => "jid@server", "password" => "password", "port" => 1234, "host" => "0.0.0.0"}
     @component = Skates::ComponentConnection.connect(@params, handler_mock) 
     @component.stub!(:send_xml).and_return(true) 
   end
@@ -132,4 +132,13 @@ describe Skates::ComponentConnection do
     
   end
 
+  describe "when resolving" do
+    it "should resolve records" do
+      Skates::ComponentConnection.resolve("xmpp2.superfeedr.com") do |res|
+        res["host"].should == "173.45.226.99"
+        true
+      end
+    end
+  end
+
 end

data/spec/lib/babylon/xmpp_connection_spec.rb

@@ -7,24 +7,49 @@ describe Skates::XmppConnection do
   
   before(:each) do
     @params = {"jid" => "jid@server", "password" => "password", "port" => 1234, "host" => "myhost.com"}
-    @connection = Skates::XmppConnection.connect(@params, handler_mock)
+    @connection = Skates::XmppConnection._connect(@params, handler_mock)
   end
   
-  describe "connect" do    
+  describe "_connect" do    
     it "should connect EventMachine and return it" do
       EventMachine.should_receive(:connect).with(@params["host"], @params["port"], Skates::XmppConnection, hash_including("handler" => handler_mock)).and_return(@connection)
-      Skates::XmppConnection.connect(@params, handler_mock).should == @connection
+      Skates::XmppConnection._connect(@params, handler_mock).should == @connection
     end
     
     it "should rescue Connection Errors" do
       EventMachine.stub!(:connect).with(@params["host"], @params["port"], Skates::XmppConnection, hash_including("handler" => handler_mock)).and_raise(RuntimeError)
       lambda {
-        Skates::XmppConnection.connect(@params, handler_mock)
+        Skates::XmppConnection._connect(@params, handler_mock)
       }.should raise_error(Skates::NotConnected)
     end
 
   end
   
+  describe "connect" do
+    describe "connect" do
+      it "should not try to resolve the dns if a host IP has been provided" do
+        @params["host"] = "123.123.123.123"
+        Skates::XmppConnection.should_not_receive(:resolve)
+        Skates::XmppConnection.connect(@params, handler_mock) 
+      end
+
+      describe "when a host is provided, which is not an IP" do
+        it "should resolve it" do
+          @params["host"] = "domain.tld"
+          Skates::XmppConnection.should_receive(:resolve)
+          Skates::XmppConnection.connect(@params, handler_mock) 
+        end
+      end
+
+      describe "when no host is provided, and no port either" do
+        it "should resolve the host to an IP" do
+          Skates::XmppConnection.should_receive(:resolve)
+          Skates::XmppConnection.connect(@params, handler_mock) 
+        end
+      end
+    end
+  end
+  
   describe "initialize" do
     it "should assign @connected to false" do
       @connection.instance_variable_get("@connected").should be_false
@@ -193,5 +218,5 @@ describe Skates::XmppConnection do
       @connection.__send__(:receive_data, data)
     end
   end
-
+  
 end

data/templates/skates/config/boot.rb

@@ -13,4 +13,6 @@ require File.dirname(__FILE__) + "/dependencies"
 Skates::Runner::run(ARGV[0] || "development") do
   # Run the initializers, too. This is done here since some initializers might need EventMachine to be started.
   Dir.glob('config/initializers/*.rb').each { |f| require f }
-end
+end
+# Run the destructors, too. They're called when the app exits.
+Dir.glob('config/destructors/*.rb').each { |f| require f }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: skates
 version: !ruby/object:Gem::Version 
-  version: 0.1.11
+  version: 0.2.1
 platform: ruby
 authors: 
 - julien Genestoux