juggernaut 0.5.7 → 0.5.8

data/lib/juggernaut/runner.rb

@@ -7,12 +7,12 @@ module Juggernaut
     include Juggernaut::Miscel
     
     class << self
-      def run
-        self.new
+      def run(argv = ARGV)
+        self.new(argv)
       end
     end
     
-    def initialize
+    def initialize(argv = ARGV)
       self.options = {
         :host => "0.0.0.0",
         :port => 5001,
@@ -28,7 +28,7 @@ module Juggernaut
         :config_path => config_path
       })
       
-      parse_options
+      parse_options(argv)
       
       if !File.exists?(config_path)
         puts "You must generate a config file (juggernaut -g filename.yml)"
@@ -52,7 +52,7 @@ module Juggernaut
     end
     
     def start
-      puts "Starting Juggernaut server on port: #{options[:port]}..."
+      puts "Starting Juggernaut server #{Juggernaut::VERSION} on port: #{options[:port]}..."
       
       trap("INT") {
         stop
@@ -70,7 +70,7 @@ module Juggernaut
       end
       
       EventMachine::run {
-        EventMachine::add_periodic_timer( options[:cleanup_timer].to_i ) { Juggernaut::Client.send_logouts_after_timeout }
+        EventMachine::add_periodic_timer( options[:cleanup_timer] || 2 ) { Juggernaut::Client.send_logouts_after_timeout }
         EventMachine::start_server(options[:host], options[:port].to_i, Juggernaut::Server)
         EM.set_effective_user( options[:user] ) if options[:user]
       }
@@ -82,7 +82,7 @@ module Juggernaut
       EventMachine::stop
     end
     
-    def parse_options
+    def parse_options(argv)
       OptionParser.new do |opts|
         opts.summary_width = 25
         opts.banner = "Juggernaut (#{VERSION})\n\n",
@@ -162,7 +162,7 @@ module Juggernaut
           puts "Juggernaut #{VERSION}"
           exit
         end
-      end.parse!
+      end.parse!(argv)
       options
     end
     

data/lib/juggernaut/server.rb

@@ -52,13 +52,14 @@ module Juggernaut
     attr_reader   :logout_timeout
     attr_reader   :status
     attr_reader   :channels
+    attr_reader   :client
 
     # EM methods
     
     def post_init
       logger.debug "New client [#{client_ip}]"
+      @client         = nil
       @channels       = []
-      @messages       = []
       @current_msg_id = 0
       @connected      = true
       @logout_timeout = nil
@@ -69,7 +70,6 @@ module Juggernaut
     # so we need to buffer the data until we find the
     # terminating "\0"
     def receive_data(data)
-      logger.debug "Receiving data: #{data}"
       @buffer << data
       @buffer = process_whole_messages(@buffer)
     end
@@ -120,9 +120,14 @@ module Juggernaut
       end
       
       case @request[:command].to_sym
-        when :broadcast: broadcast_command
-        when :subscribe: subscribe_command
-        when :query:     query_command
+        when :broadcast
+          broadcast_command
+        when :subscribe
+          subscribe_command
+        when :query
+          query_command
+        when :noop
+          noop_command
       else
         raise InvalidCommand, @request
       end
@@ -136,16 +141,18 @@ module Juggernaut
     end
     
     def unbind
-      @client.logout_connection_request(@channels) if @client # todo - should be called after timeout?
-      logger.debug "Lost client: #{@client.id}" if @client
+      if @client
+        # todo - should be called after timeout?
+        @client.logout_connection_request(@channels)
+        logger.debug "Lost client #{@client.friendly_id}"
+      end
       mark_dead('Unbind called')
     end
     
     # As far as I'm aware, send_data
     # never throws an exception
     def publish(msg)
-      logger.debug "Sending msg: #{msg.to_s}"
-      logger.debug "To client: #{@client.id}" if @client
+      logger.debug "Sending msg: #{msg.to_s} to client #{@request[:client_id]} (session #{@request[:session_id]})"
       send_data(msg.to_s + CR)
     end
     
@@ -153,7 +160,6 @@ module Juggernaut
     
     def broadcast(bdy)
       msg = Juggernaut::Message.new(@current_msg_id += 1, bdy, self.signature)
-      @messages << msg if options[:store_messages]
       publish(msg)
     end
     
@@ -162,9 +168,7 @@ module Juggernaut
       # attempt would hook onto a new em instance. A client
       # usually dies through an unbind 
       @connected = false
-      @logout_timeout = Time::now + (options[:timeout] || 30)
-			@status = "DEAD: %s: Could potentially logout at %s" %
-				[ reason, @logout_timeout ]
+      @client.remove_connection(self) if @client
     end
     
     def alive?
@@ -203,25 +207,6 @@ module Juggernaut
       end
     end
     
-    def broadcast_all_messages_from(msg_id, signature_id)
-      return unless msg_id or signature_id
-      client = Juggernaut::Client.find_by_signature(signature)
-      return if !client
-      msg_id = Integer(msg_id)
-      return if msg_id >= client.current_msg_id
-      client.messages.select {|msg| 
-        (msg_id..client.current_msg_id).include?(msg.id)
-      }.each {|msg| publish(msg) }
-    end
-    
-    # todo - how should this be called - if at all?
-    def clean_up_old_messages(how_many_to_keep = 1000)
-      while @messages.length > how_many_to_keep
-        # We need to shift, as we want to remove the oldest first
-        @messages.shift
-      end
-    end
-    
     protected
     
       # Commands
@@ -262,6 +247,13 @@ module Juggernaut
               client = Juggernaut::Client.find_by_id(client_id)
               client.remove_channels!(@request[:channels]) if client
             end
+          when :show_channels_for_client
+            query_needs :client_id
+            if client = Juggernaut::Client.find_by_id(@request[:client_id])
+              publish client.channels.to_json
+            else
+              publish nil.to_json
+            end
           when :show_clients
             if @request[:client_ids] and @request[:client_ids].any?
               clients = @request[:client_ids].collect{ |client_id| Client.find_by_id(client_id) }.compact.uniq
@@ -280,7 +272,13 @@ module Juggernaut
         end
       end
     
-      def subscribe_command        
+      def noop_command
+        logger.debug "NOOP"
+      end
+    
+      def subscribe_command
+        logger.debug "SUBSCRIBE: #{@request.inspect}"
+        
         if channels = @request[:channels]
           add_channels(channels)
         end
@@ -291,10 +289,8 @@ module Juggernaut
           raise UnauthorisedSubscription, @client
         end
         
-        Juggernaut::Client.add_client(@client)
-        
         if options[:store_messages]
-          broadcast_all_messages_from(@request[:last_msg_id], @request[:signature])
+          @client.send_queued_messages(self)
         end
       end
     
@@ -366,7 +362,7 @@ module Juggernaut
       end
       
       def client_ip
-        Socket.unpack_sockaddr_in(get_peername)[1]
+        Socket.unpack_sockaddr_in(get_peername)[1] rescue nil
       end
   end
-end
+end

data/test/test_client.rb

@@ -0,0 +1,176 @@
+
+$:.unshift "../lib"
+require "juggernaut"
+require "test/unit"
+require "shoulda"
+require "mocha"
+
+class TestClient < Test::Unit::TestCase
+  
+  CONFIG = File.join(File.dirname(__FILE__), "files", "juggernaut.yml")
+  
+  class DummySubscriber; end
+  
+  EXAMPLE_URL = "http://localhost:5000/callbacks/example"
+  SECURE_URL = "https://localhost:5000/callbacks/example"
+  
+  context "Client" do
+    
+    setup do
+      Juggernaut.options = {
+        :logout_connection_url => "http://localhost:5000/callbacks/logout_connection",
+        :logout_url => "http://localhost:5000/callbacks/logout",
+        :subscription_url => "http://localhost:5000/callbacks/subscription"
+      }
+      @s1 = DummySubscriber.new
+      @request = {
+        :client_id => "jonny",
+        :session_id => rand(1_000_000).to_s(16)
+      }
+      @client = Juggernaut::Client.find_or_create(@s1, @request)
+    end
+    
+    teardown do
+      Juggernaut::Client.reset!
+    end
+    
+    should "have correct JSON representation" do
+      assert_nothing_raised do
+        json = {
+          "client_id"  => "jonny",
+          "num_connections" => 1,
+          "session_id" => @request[:session_id]
+        }
+        assert_equal json, JSON.parse(@client.to_json)
+      end
+    end
+    
+    should "return the client based on subscriber's signature" do
+      @s1.stubs(:signature).returns("012345")
+      assert_equal @client, Juggernaut::Client.find_by_signature("012345")
+    end
+    
+    should "return the client based on client ID and channel list" do
+      @client.stubs(:has_channels?).with(%w(a couple of channels)).returns(true)
+      assert_equal @client, Juggernaut::Client.find_by_id_and_channels("jonny", %w(a couple of channels))
+      assert_nil Juggernaut::Client.find_by_id_and_channels("peter", %w(a couple of channels))
+      @client.stubs(:has_channels?).with(%w(something else)).returns(false)
+      assert_nil Juggernaut::Client.find_by_id_and_channels("jonny", %w(something else))
+    end
+    
+    should "automatically be registered, and can unregister" do
+      assert @client.send(:registered?)
+      assert_equal @client, @client.send(:unregister)
+      assert_equal false, @client.send(:registered?)
+    end
+    
+    should "be alive if at least one subscriber is alive" do
+      @s1.stubs(:alive?).returns(true)
+      @s2 = DummySubscriber.new
+      @client.add_new_connection(@s2)
+      @s2.stubs(:alive?).returns(false)
+      assert @client.alive?
+    end
+    
+    should "not be alive if no subscriber is alive" do
+      @s1.stubs(:alive?).returns(false)
+      @s2 = DummySubscriber.new
+      @client.add_new_connection(@s2)
+      @s2.stubs(:alive?).returns(false)
+      assert_equal false, @client.alive?
+    end
+
+    should "not give up if within the timeout period" do
+      Juggernaut.options[:timeout] = 10
+      @s1.stubs(:alive?).returns(false)
+      @client.send(:reset_logout_timeout!)
+      assert_equal false, @client.give_up?
+    end
+
+    should "not give up if at least one subscriber is alive" do
+      Juggernaut.options[:timeout] = 0
+      @s1.stubs(:alive?).returns(true)
+      @client.send(:reset_logout_timeout!)
+      assert_equal false, @client.give_up?
+    end
+    
+    should "send logouts after timeout" do
+      Juggernaut.options[:timeout] = 0
+      @s1.stubs(:alive?).returns(false)
+      @client.send(:reset_logout_timeout!)
+      @client.expects(:logout_request).once
+      Juggernaut::Client.send_logouts_after_timeout
+    end
+    
+    %w(subscription logout_connection).each do |type|
+      
+      context "#{type} request" do
+        
+        should "post to the correct URL" do
+          @client.expects(:post_request).with(Juggernaut.options[:"#{type}_url"], %w(master), :timeout => 5).returns(true)
+          assert_equal true, @client.send("#{type}_request", %w(master))
+        end
+        
+        should "not raise exceptions if posting raises an exception" do
+          @client.expects(:post_request).with(Juggernaut.options[:"#{type}_url"], %w(master), :timeout => 5).returns(false)
+          assert_nothing_raised {
+            assert_equal false, @client.send("#{type}_request", %w(master))
+          }
+        end
+        
+      end
+      
+    end
+    
+    context "post to URL" do
+      
+      should "return true when successful" do
+        Net::HTTP.any_instance.
+          expects(:post).
+          with("/callbacks/example", "client_id=jonny&session_id=#{@request[:session_id]}&channels[]=master&channels[]=slave", {"User-Agent" => "Ruby/#{RUBY_VERSION}"}).
+          returns([Net::HTTPOK.new('1.1', '200', 'OK'), ''])
+        assert_equal true, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
+      end
+      
+      should "return false on an internal server error" do
+        Net::HTTP.any_instance.expects(:post).returns([Net::HTTPInternalServerError.new('1.1', '500', 'Internal Server Error'), ''])
+        assert_equal false, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
+      end
+      
+      should "return false when a runtime error is caught" do
+        Net::HTTP.any_instance.expects(:post).raises(RuntimeError)
+        assert_equal false, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
+      end
+      
+      should "return false when callback times out" do
+        Net::HTTP.any_instance.expects(:post).raises(Timeout::Error)
+        assert_equal false, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
+      end
+      
+      context "using a secure URL" do
+        
+        should "return true when successful" do
+          Net::HTTP.any_instance.expects(:post).returns([Net::HTTPOK.new('1.1', '200', 'OK'), ''])
+          Net::HTTP.any_instance.expects(:use_ssl=).with(true).returns(true)
+          assert_equal true, @client.send(:post_request, SECURE_URL, %w(master slave))
+        end
+        
+      end
+      
+    end
+    
+    context "channel list" do
+      
+      should "be the unique list of all channels in the subscribers" do
+        @s1.stubs(:channels).returns(%w(master slave1))
+        @s2 = DummySubscriber.new
+        @s2.stubs(:channels).returns(%w(master slave2))
+        @client.add_new_connection(@s2)
+        assert_same_elements %w(master slave1 slave2), @client.channels
+      end
+      
+    end
+    
+  end
+  
+end

data/test/test_juggernaut.rb

@@ -0,0 +1,34 @@
+
+$:.unshift "../lib"
+require "juggernaut"
+require "test/unit"
+require "shoulda"
+require "mocha"
+
+class TestJuggernaut < Test::Unit::TestCase
+  
+  context "Juggernaut" do
+    
+    setup do
+      Juggernaut.options = { }
+    end
+    
+    should "set options correctly" do
+      options = {
+        :host => "0.0.0.0",
+        :port => 5001,
+        :debug => false
+      }
+      Juggernaut.options = options
+      assert_equal options, Juggernaut.options
+    end
+    
+    should "have a debug logger by default" do
+      log = Juggernaut.logger
+      assert_not_nil log
+      assert_equal Logger::DEBUG, log.level
+    end
+    
+  end
+  
+end

data/test/test_message.rb

@@ -0,0 +1,26 @@
+
+$:.unshift "../lib"
+require "juggernaut"
+require "test/unit"
+require "shoulda"
+require "mocha"
+
+class TestMessage < Test::Unit::TestCase
+  
+  context "Message" do
+    
+    setup do
+      @msg = Juggernaut::Message.new(1, "A pre-determined message body", "a81fef13919")
+      assert_not_nil @msg
+    end
+    
+    should "generate valid JSON" do
+      obj = {"signature" => "a81fef13919", "body" => "A pre-determined message body", "id" => "1"}
+      assert_nothing_raised do
+        assert_equal obj, JSON.parse(@msg.to_s)
+      end
+    end
+    
+  end
+  
+end