beetle 0.1 → 0.2.1

data/lib/beetle/redis_ext.rb

@@ -0,0 +1,79 @@
+# Redis convenience and compatibility layer
+class Redis #:nodoc:
+  def self.from_server_string(server_string, options = {})
+    host, port = server_string.split(':')
+    options = {:host => host, :port => port}.update(options)
+    new(options)
+  end
+
+  # Redis 2 removed some useful methods. add them back.
+  def host; @client.host; end
+  def port; @client.port; end
+  def server; "#{host}:#{port}"; end
+
+  def master!
+    slaveof("no", "one")
+  end
+
+  def slave_of!(host, port)
+    slaveof(host, port)
+  end
+
+  # Redis 2 tries to establish a connection on inspect. this is evil!
+  def inspect
+    super
+  end
+
+  def info_with_rescue
+    info
+  rescue Exception
+    {}
+  end
+
+  def available?
+    info_with_rescue != {}
+  end
+
+  def role
+    info_with_rescue["role"] || "unknown"
+  end
+
+  def master?
+    role == "master"
+  end
+
+  def slave?
+    role == "slave"
+  end
+
+  def slave_of?(host, port)
+    info = info_with_rescue
+    info["role"] == "slave" && info["master_host"] == host && info["master_port"] == port.to_s
+  end
+end
+
+class Redis::Client #:nodoc:
+  protected
+  def connect_to(host, port)
+    if @timeout != 0 and Redis::Timer
+      begin
+        Redis::Timer.timeout(@timeout){ @sock = TCPSocket.new(host, port) }
+      rescue Timeout::Error
+        @sock = nil
+        raise Timeout::Error, "Timeout connecting to the server"
+      end
+    else
+      @sock = TCPSocket.new(host, port)
+    end
+
+    @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+
+    # If the timeout is set we set the low level socket options in order
+    # to make sure a blocking read will return after the specified number
+    # of seconds. This hack is from memcached ruby client.
+    self.timeout = @timeout
+
+  rescue Errno::ECONNREFUSED
+    raise Errno::ECONNREFUSED, "Unable to connect to Redis on #{host}:#{port}"
+  end
+end

data/lib/beetle/redis_master_file.rb

@@ -0,0 +1,35 @@
+module Beetle
+  module RedisMasterFile #:nodoc:
+    private
+    def master_file_exists?
+      File.exist?(master_file)
+    end
+
+    def redis_master_from_master_file
+      redis.find(read_redis_master_file)
+    end
+
+    def clear_redis_master_file
+      write_redis_master_file("")
+    end
+
+    def read_redis_master_file
+      File.read(master_file).chomp
+    end
+
+    def write_redis_master_file(redis_server_string)
+      logger.warn "Writing '#{redis_server_string}' to redis master file '#{master_file}'"
+      File.open(master_file, "w"){|f| f.puts redis_server_string }
+    end
+
+    def master_file
+      config.redis_server
+    end
+
+    def verify_redis_master_file_string
+      if master_file =~ /^[0-9a-z.]+:[0-9]+$/
+        raise ConfigurationError.new("To use the redis failover, redis_server config option must point to a file")
+      end
+    end
+  end
+end

data/lib/beetle/redis_server_info.rb

@@ -0,0 +1,65 @@
+module Beetle
+  # class used by the RedisConfigurationServer to hold information about the current state of the configured redis servers
+  class RedisServerInfo
+    include Logging
+
+    def initialize(config, options) #:nodoc:
+      @config = config
+      @options = options
+      reset
+    end
+
+    # all configured redis servers
+    def instances
+      @instances ||= @config.redis_servers.split(/ *, */).map{|s| Redis.from_server_string(s, @options)}
+    end
+
+    # fetches the server from the insatnces whith the given <tt>server</tt> string
+    def find(server)
+      instances.find{|r| r.server == server}
+    end
+
+    # refresh connectivity/role information
+    def refresh
+      logger.debug "Updating redis server info"
+      reset
+      instances.each {|r| @server_info[r.role] << r}
+    end
+
+    # subset of instances which are masters
+    def masters
+      @server_info["master"]
+    end
+
+    # subset of instances which are slaves
+    def slaves
+      @server_info["slave"]
+    end
+
+    # subset of instances which are not reachable
+    def unknowns
+      @server_info["unknown"]
+    end
+
+    # subset of instances which are set up as slaves of the given <tt>master</tt>
+    def slaves_of(master)
+      slaves.select{|r| r.slave_of?(master.host, master.port)}
+    end
+
+    # determine a master if we have one master and all other servers are slaves
+    def auto_detect_master
+      return nil unless master_and_slaves_reachable?
+      masters.first
+    end
+
+    private
+
+    def master_and_slaves_reachable?
+      masters.size == 1 && slaves.size == instances.size - 1
+    end
+
+    def reset
+      @server_info = Hash.new {|h,k| h[k]= []}
+    end
+  end
+end

data/lib/beetle/subscriber.rb

@@ -10,7 +10,7 @@ module Beetle
       @mqs = {}
     end
 
-    # the client calls this method to subcsribe to all queues on all servers which have
+    # the client calls this method to subscribe to all queues on all servers which have
     # handlers registered for the given list of messages. this method does the following
     # things:
     #
@@ -105,6 +105,9 @@ module Beetle
             sleep 1
             mq(server).recover
           elsif reply_to = header.properties[:reply_to]
+            # require 'ruby-debug'
+            # Debugger.start
+            # debugger
             status = result == Beetle::RC::OK ? "OK" : "FAILED"
             exchange = MQ::Exchange.new(mq(server), :direct, "", :key => reply_to)
             exchange.publish(m.handler_result.to_s, :headers => {:status => status})

data/test/beetle/configuration_test.rb

@@ -1,5 +1,17 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
+require 'tempfile'
 
 module Beetle
-end
+  class ConfigurationTest < Test::Unit::TestCase
+    test "should load it's settings from a config file if that file exists" do
+      config    = Configuration.new
+      old_value = config.gc_threshold
+      new_value = old_value + 1
+      config_file_content = "gc_threshold: #{new_value}\n"
+      IO.expects(:read).returns(config_file_content)
+
+      config.config_file = "some/path/to/a/file"
+      assert_equal new_value, config.gc_threshold
+    end
+  end
+end

data/test/beetle/deduplication_store_test.rb

@@ -14,75 +14,93 @@ module Beetle
     end
 
     test "msetnx returns 0 or 1" do
-      assert_equal 1, @r.msetnx("a" => 1, "b" => 2)
+      assert_equal 1, @r.msetnx("a", 1, "b", 2)
       assert_equal "1", @r.get("a")
       assert_equal "2", @r.get("b")
-      assert_equal 0, @r.msetnx("a" => 3, "b" => 4)
+      assert_equal 0, @r.msetnx("a", 3, "b", 4)
       assert_equal "1", @r.get("a")
       assert_equal "2", @r.get("b")
     end
   end
 
-  class RedisFailoverTest < Test::Unit::TestCase
+  class RedisServerStringTest < Test::Unit::TestCase
+    def setup
+      @original_redis_server = Beetle.config.redis_server
+      @store = DeduplicationStore.new
+      @server_string = "my_test_host_from_file:9999"
+      Beetle.config.redis_server = @server_string
+    end
+
+    def teardown
+      Beetle.config.redis_server = @original_redis_server
+    end
+
+    test "redis should match the redis server string" do
+      assert_equal @server_string, @store.redis.server
+    end
+  end
+
+  class RedisServerFileTest < Test::Unit::TestCase
     def setup
-      @store = DeduplicationStore.new("localhost:1, localhost:2")
+      @original_redis_server = Beetle.config.redis_server
+      @store = DeduplicationStore.new
+      @server_string = "my_test_host_from_file:6379"
+      Beetle.config.redis_server = redis_test_master_file(@server_string)
+    end
+
+    def teardown
+      Beetle.config.redis_server = @original_redis_server
+    end
+
+    test "redis should match the redis master file" do
+      assert_equal @server_string, @store.redis.server
     end
 
-    test "redis instances should be created for all servers" do
-      instances = @store.redis_instances
-      assert_equal ["localhost:1", "localhost:2" ], instances.map(&:server)
+    test "redis should be nil if the redis master file is blank" do
+      redis_test_master_file("")
+      assert_nil @store.redis
     end
 
-    test "searching a redis master should find one if there is one" do
-      instances = @store.redis_instances
-      instances.first.expects(:info).returns(:role => "slave")
-      instances.second.expects(:info).returns(:role => "master")
-      assert_equal instances.second, @store.redis
+    test "should keep using the current redis if the redis master file hasn't changed since the last request" do
+      @store.expects(:read_master_file).once.returns("localhost:1")
+      2.times { @store.redis }
     end
 
-    test "searching a redis master should find one even if one cannot be accessed" do
-      instances = @store.redis_instances
-      instances.first.expects(:info).raises("murks")
-      instances.second.expects(:info).returns(:role => "master")
-      assert_equal instances.second, @store.redis
+    test "should return nil if the master file doesn't exist" do
+      Beetle.config.redis_server = "/tmp/__i_don_not_exist__.txt"
+      assert_equal nil, @store.redis_master_from_master_file
     end
 
-    test "searching a redis master should raise an exception if there is none" do
-      instances = @store.redis_instances
-      instances.first.expects(:info).returns(:role => "slave")
-      instances.second.expects(:info).returns(:role => "slave")
-      assert_raises(NoRedisMaster) { @store.find_redis_master }
+    private
+    def redis_test_master_file(server_string)
+      path = File.expand_path("../../../tmp/redis-master-for-unit-tests", __FILE__)
+      File.open(path, "w"){|f| f.puts server_string}
+      path
     end
+  end
 
-    test "searching a redis master should raise an exception if there is more than one" do
-      instances = @store.redis_instances
-      instances.first.expects(:info).returns(:role => "master")
-      instances.second.expects(:info).returns(:role => "master")
-      assert_raises(TwoRedisMasters) { @store.find_redis_master }
+  class RedisFailoverTest < Test::Unit::TestCase
+    def setup
+      @store = DeduplicationStore.new
+      Beetle.config.expects(:redis_failover_timeout).returns(1)
     end
 
     test "a redis operation protected with a redis failover block should succeed if it can find a new master" do
-      instances = @store.redis_instances
+      redis1 = stub("redis 1")
+      redis2 = stub("redis 2")
       s = sequence("redis accesses")
-      instances.first.expects(:info).returns(:role => "master").in_sequence(s)
-      instances.second.expects(:info).returns(:role => "slave").in_sequence(s)
-      assert_equal instances.first, @store.redis
-      instances.first.expects(:get).with("foo:x").raises("disconnected").in_sequence(s)
-      instances.first.expects(:info).raises("disconnected").in_sequence(s)
-      instances.second.expects(:info).returns(:role => "master").in_sequence(s)
-      instances.second.expects(:get).with("foo:x").returns("42").in_sequence(s)
+      @store.expects(:redis).returns(redis1).in_sequence(s)
+      redis1.expects(:get).with("foo:x").raises("disconnected").in_sequence(s)
+      @store.expects(:redis).returns(redis2).in_sequence(s)
+      redis2.expects(:get).with("foo:x").returns("42").in_sequence(s)
       assert_equal("42", @store.get("foo", "x"))
     end
 
     test "a redis operation protected with a redis failover block should fail if it cannot find a new master" do
-      instances = @store.redis_instances
-      instances.first.expects(:info).returns(:role => "master")
-      instances.second.expects(:info).returns(:role => "slave")
-      assert_equal instances.first, @store.redis
-      instances.first.stubs(:get).with("foo:x").raises("disconnected")
-      instances.first.stubs(:info).raises("disconnected")
-      instances.second.stubs(:info).returns(:role => "slave")
-      @store.expects(:sleep).times(119)
+      redis1 = stub()
+      @store.stubs(:redis).returns(redis1)
+      redis1.stubs(:get).with("foo:x").raises("disconnected")
+      @store.stubs(:sleep)
       assert_raises(NoRedisMaster) { @store.get("foo", "x") }
     end
   end

data/test/beetle/message_test.rb

@@ -4,6 +4,11 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 module Beetle
 
   class EncodingTest < Test::Unit::TestCase
+    test "an exception during decoding should be stored in the exception attribute" do
+      header = stub_everything("raising header")
+      m = Message.new("queue", header, 'foo')
+      assert_instance_of NoMethodError, m.exception
+    end
 
     test "a message should encode/decode the message format version correctly" do
       header = header_with_params({})
@@ -371,6 +376,17 @@ module Beetle
       @store.flushdb
     end
 
+    test "a message with an exception set should not be processed at all, but it should be acked" do
+      header = {}
+      message = Message.new("somequeue", header, 'foo')
+      assert message.exception
+
+      proc = mock("proc")
+      proc.expects(:call).never
+      message.expects(:ack!)
+      assert_equal RC::DecodingError, message.__send__(:process_internal, proc)
+    end
+
     test "a completed existing message should be just acked and not run the handler" do
       header = header_with_params({})
       message = Message.new("somequeue", header, 'foo', :attempts => 2, :store => @store)
@@ -379,7 +395,6 @@ module Beetle
       assert message.completed?
 
       proc = mock("proc")
-      s = sequence("s")
       header.expects(:ack)
       proc.expects(:call).never
       assert_equal RC::OK, message.__send__(:process_internal, proc)
@@ -394,7 +409,6 @@ module Beetle
       assert message.delayed?
 
       proc = mock("proc")
-      s = sequence("s")
       header.expects(:ack).never
       proc.expects(:call).never
       assert_equal RC::Delayed, message.__send__(:process_internal, proc)
@@ -412,7 +426,6 @@ module Beetle
       assert !message.timed_out?
 
       proc = mock("proc")
-      s = sequence("s")
       header.expects(:ack).never
       proc.expects(:call).never
       assert_equal RC::HandlerNotYetTimedOut, message.__send__(:process_internal, proc)
@@ -577,7 +590,7 @@ module Beetle
       @store.flushdb
     end
 
-    test "a handler running longer than the specified timeout should be aborted" do
+    test "a handler running longer than the specified timeout should be aborted (when given a float timeout number)" do
       header = header_with_params({})
       header.expects(:ack)
       message = Message.new("somequeue", header, 'foo', :timeout => 0.1, :attempts => 2, :store => @store)
@@ -586,6 +599,17 @@ module Beetle
       result = message.process(handler)
       assert_equal RC::ExceptionsLimitReached, result
     end
+
+    test "a handler running longer than the specified timeout should be aborted (when using active_support seconds)" do
+      header = header_with_params({})
+      header.expects(:ack)
+      message = Message.new("somequeue", header, 'foo', :timeout => 1.seconds, :attempts => 2, :store => @store)
+      action = lambda{|*args| while true; end}
+      handler = Handler.create(action)
+      result = message.process(handler)
+      assert_equal RC::ExceptionsLimitReached, result
+    end
+
   end
 
   class SettingsTest < Test::Unit::TestCase

data/test/beetle/publisher_test.rb

@@ -284,7 +284,7 @@ module Beetle
       assert_kind_of Time, dead["localhost:2222"]
     end
 
-    test "recycle_dead_servers should move servers from the dead server hash to the servers list only if the have been markd dead for longer than 10 seconds" do
+    test "recycle_dead_servers should move servers from the dead server hash to the servers list only if they have been markd dead for longer than 10 seconds" do
       @pub.servers = ["a:1", "b:2"]
       @pub.send(:set_current_server, "a:1")
       @pub.send(:mark_server_dead)
@@ -299,6 +299,19 @@ module Beetle
       assert_equal({}, dead)
     end
 
+    test "recycle_dead_servers should recycle the server which has been dead for the longest time if all servers are dead " do
+      @pub.servers = ["a:1", "b:2"]
+      @pub.send(:set_current_server, "a:1")
+      @pub.send(:mark_server_dead)
+      @pub.send(:mark_server_dead)
+      assert_equal [], @pub.servers
+      dead = @pub.instance_variable_get("@dead_servers")
+      assert_equal ["a:1", "b:2"], dead.keys.sort
+      @pub.send(:recycle_dead_servers)
+      assert_equal ["b:2"], dead.keys
+      assert_equal ["a:1"], @pub.servers
+    end
+
     test "select_next_server should cycle through the list of all servers" do
       @pub.servers = ["a:1", "b:2"]
       @pub.send(:set_current_server, "a:1")
@@ -308,12 +321,13 @@ module Beetle
       assert_equal "a:1", @pub.server
     end
 
-    test "select_next_server should return 0 if there are no servers to publish to" do
+    test "select_next_server should log an error if there are no servers to publish to" do
       @pub.servers = []
       logger = mock('logger')
       logger.expects(:error).returns(true)
       @pub.expects(:logger).returns(logger)
-      assert_equal 0, @pub.send(:select_next_server)
+      @pub.expects(:set_current_server).never
+      @pub.send(:select_next_server)
     end
 
     test "stop should shut down all bunnies" do