beetle 0.3.0.rc.3 → 0.3.0.rc.4

data/Rakefile

@@ -1,6 +1,8 @@
 require 'rake'
 require 'rake/testtask'
 require 'rcov/rcovtask'
+require 'bundler/gem_tasks'
+
 # rake 0.9.2 hack to supress deprecation warnings caused by cucumber
 include Rake::DSL if RAKEVERSION >= "0.9"
 require 'cucumber/rake/task'
@@ -30,7 +32,6 @@ namespace :test do
   end if RUBY_PLATFORM =~ /darwin/
 end
 
-
 namespace :beetle do
   task :test do
     Beetle::Client.new.test
@@ -108,8 +109,3 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('MIT-LICENSE')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
-
-desc "build the beetle gem"
-task :build do
-  system("gem build beetle.gemspec")
-end

data/beetle.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name    = "beetle"
-  s.version = "0.3.0.rc.3"
+  s.version = "0.3.0.rc.4"
   s.required_rubygems_version = ">= 1.3.7"
   s.authors            = ["Stefan Kaes", "Pascal Friederich", "Ali Jelveh", "Sebastian Roebke"]
   s.date               = Time.now.strftime('%Y-%m-%d')
@@ -29,10 +29,12 @@ Gem::Specification.new do |s|
 
   s.specification_version = 3
   s.add_runtime_dependency("uuid4r",                [">= 0.1.2"])
-  s.add_runtime_dependency("bunny",                 ["~> 0.7.1"])
+  s.add_runtime_dependency("bunny",                 ["= 0.7.8"])
   s.add_runtime_dependency("redis",                 ["= 2.2.0"])
   s.add_runtime_dependency("hiredis",               ["= 0.3.2"])
-  s.add_runtime_dependency("amqp",                  ["~> 0.6.7"])
+  s.add_runtime_dependency("amq-client",            ["= 0.8.3"])
+  s.add_runtime_dependency("amq-protocol",          ["= 0.8.1"])
+  s.add_runtime_dependency("amqp",                  ["= 0.8.0"])
   s.add_runtime_dependency("activesupport",         [">= 2.3.4"])
   s.add_runtime_dependency("daemons",               [">= 1.0.10"])
   s.add_development_dependency("rake",              [">= 0.8.7"])

data/examples/nonexistent_server.rb

@@ -0,0 +1,28 @@
+# nonexistent_server.rb
+# this example shows what happens when you try connect to a nonexistent server
+#
+# start it with ruby nonexistent_server.rb
+
+require "rubygems"
+require File.expand_path("../lib/beetle", File.dirname(__FILE__))
+
+# set Beetle log level to info, less noisy than debug
+Beetle.config.logger.level = Logger::INFO
+
+Beetle.config.servers = "unknown.railsexpress.de:5672"
+
+# setup client
+client = Beetle::Client.new
+client.register_queue(:test)
+client.register_message(:test)
+
+# register our handler to the message, check out the message.rb for more stuff you can get from the message object
+client.register_handler(:test) {|message| puts "got message: #{message.data}"}
+
+# start listening
+# this starts the event machine event loop using EM.run
+# the block passed to listen will be yielded as the last step of the setup process
+client.listen do
+  EM.add_timer(10) { client.stop_listening }
+end
+

data/examples/redundant.rb

@@ -58,7 +58,7 @@ end
 # this starts the event machine event loop using EM.run
 # the block passed to listen will be yielded as the last step of the setup process
 client.listen do
-  EM.add_timer(0.1) { client.stop_listening }
+  EM.add_timer(0.2) { client.stop_listening }
 end
 
 puts "Received #{k} test messages"

data/examples/rpc.rb

@@ -3,7 +3,7 @@ require "rubygems"
 require File.expand_path(File.dirname(__FILE__)+"/../lib/beetle")
 
 # suppress debug messages
-Beetle.config.logger.level = Logger::DEBUG
+Beetle.config.logger.level = Logger::INFO
 Beetle.config.servers = "localhost:5672, localhost:5673"
 # instantiate a client
 
@@ -28,12 +28,12 @@ if ARGV.include?("--server")
     trap("INT") { puts "stopped echo server"; client.stop_listening }
   end
 else
-  n = 100
+  n = 10000
   ms = Benchmark.ms do
     n.times do |i|
       content = "Hello #{i}"
       # puts "performing RPC with message content '#{content}'"
-      status, result = client.rpc(:echo, content)
+      status, result = client.rpc(:echo, content, :persistent => false)
       # puts "status  #{status}"
       # puts "result  #{result}"
       # puts

data/lib/beetle/base.rb

@@ -33,6 +33,10 @@ module Beetle
       @server = s
     end
 
+    def server_from_settings(settings)
+      settings.values_at(:host,:port).join(':')
+    end
+
     def each_server
       @servers.each { |s| set_current_server(s); yield }
     end

data/lib/beetle/message.rb

@@ -73,9 +73,10 @@ module Beetle
 
     # extracts various values form the AMQP header properties
     def decode #:nodoc:
-      amqp_headers = header.properties
+      # p header.attributes
+      amqp_headers = header.attributes
       @uuid = amqp_headers[:message_id]
-      headers = amqp_headers[:headers]
+      headers = amqp_headers[:headers].symbolize_keys
       @format_version = headers[:format_version].to_i
       @flags = headers[:flags].to_i
       @expires_at = headers[:expires_at].to_i

data/lib/beetle/subscriber.rb

@@ -1,5 +1,4 @@
 require 'amqp'
-require 'mq'
 
 module Beetle
   # Manages subscriptions and message processing on the receiver side of things.
@@ -10,9 +9,10 @@ module Beetle
       super
       @servers.concat @client.additional_subscription_servers
       @handlers = {}
-      @amqp_connections = {}
-      @mqs = {}
+      @connections = {}
+      @channels = {}
       @subscriptions = {}
+      @listened_queues = []
     end
 
     # the client calls this method to subscribe to a list of queues.
@@ -24,11 +24,12 @@ module Beetle
     #
     # yields before entering the eventmachine loop (if a block was given)
     def listen_queues(queues) #:nodoc:
+      @listened_queues = queues
+      @exchanges_for_queues = exchanges_for_queues(queues)
       EM.run do
-        exchanges = exchanges_for_queues(queues)
-        create_exchanges(exchanges)
-        bind_queues(queues)
-        subscribe_queues(queues)
+        each_server do
+          connect_server connection_settings
+        end
         yield if block_given?
       end
     end
@@ -47,10 +48,10 @@ module Beetle
 
     # closes all AMQP connections and stops the eventmachine loop
     def stop! #:nodoc:
-      if @amqp_connections.empty?
+      if @connections.empty?
         EM.stop_event_loop
       else
-        server, connection = @amqp_connections.shift
+        server, connection = @connections.shift
         logger.debug "Beetle: closing connection to #{server}"
         connection.close { stop! }
       end
@@ -74,30 +75,19 @@ module Beetle
     end
 
     def create_exchanges(exchanges)
-      each_server do
-        exchanges.each { |name| exchange(name) }
-      end
+      exchanges.each { |name| exchange(name) }
     end
 
     def bind_queues(queues)
-      each_server do
-        queues.each { |name| queue(name) }
-      end
+      queues.each { |name| queue(name) }
     end
 
     def subscribe_queues(queues)
-      each_server do
-        queues.each { |name| subscribe(name) if @handlers.include?(name) }
-      end
+      queues.each { |name| subscribe(name) if @handlers.include?(name) }
     end
 
-    # returns the mq object for the given server or returns a new one created with the
-    # prefetch(1) option. this tells it to just send one message to the receiving buffer
-    # (instead of filling it). this is necesssary to ensure that one subscriber always just
-    # handles one single message. we cannot ensure reliability if the buffer is filled with
-    # messages and crashes.
-    def mq(server=@server)
-      @mqs[server] ||= MQ.new(amqp_connection).prefetch(1)
+    def channel(server=@server)
+      @channels[server]
     end
 
     def subscriptions(server=@server)
@@ -116,12 +106,8 @@ module Beetle
       callback = create_subscription_callback(queue_name, amqp_queue_name, handler, opts)
       keys = opts.slice(*SUBSCRIPTION_KEYS).merge(:key => "#", :ack => true)
       logger.debug "Beetle: subscribing to queue #{amqp_queue_name} with key # on server #{@server}"
-      begin
-        queues[queue_name].subscribe(keys, &callback)
-        subscriptions[queue_name] = [keys, callback]
-      rescue MQ::Error
-        error("Beetle: binding multiple handlers for the same queue isn't possible.")
-      end
+      queues[queue_name].subscribe(keys, &callback)
+      subscriptions[queue_name] = [keys, callback]
     end
 
     def pause(queue_name)
@@ -147,13 +133,14 @@ module Beetle
           if result.reject?
             sleep 1
             header.reject(:requeue => true)
-          elsif reply_to = header.properties[:reply_to]
+          elsif reply_to = header.attributes[:reply_to]
+            # logger.info "Beetle: sending reply to queue #{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})
+            exchange = AMQP::Exchange.new(channel(server), :direct, "")
+            exchange.publish(m.handler_result.to_s, :routing_key => reply_to, :persistent => false, :headers => {:status => status})
           end
           # logger.debug "Beetle: processed message"
         rescue Exception
@@ -168,27 +155,63 @@ module Beetle
     end
 
     def create_exchange!(name, opts)
-      mq.__send__(opts[:type], name, opts.slice(*EXCHANGE_CREATION_KEYS))
+      channel.__send__(opts[:type], name, opts.slice(*EXCHANGE_CREATION_KEYS))
     end
 
     def bind_queue!(queue_name, creation_keys, exchange_name, binding_keys)
-      queue = mq.queue(queue_name, creation_keys)
+      queue = channel.queue(queue_name, creation_keys)
       exchange = exchange(exchange_name)
       queue.bind(exchange, binding_keys)
       queue
     end
 
-    def amqp_connection(server=@server)
-      @amqp_connections[server] ||= new_amqp_connection
+    def connection_settings
+      {
+        :host => current_host, :port => current_port, :logging => false,
+        :user => Beetle.config.user, :pass => Beetle.config.password, :vhost => Beetle.config.vhost,
+        :on_tcp_connection_failure => on_tcp_connection_failure
+      }
+    end
+
+    def on_tcp_connection_failure
+      Proc.new do |settings|
+        logger.warn "Beetle: connection failed: #{server_from_settings(settings)}"
+        EM::Timer.new(10) { connect_server(settings) }
+      end
     end
 
-    def new_amqp_connection
-      # FIXME: wtf, how to test that reconnection feature....
-      con = AMQP.connect(:host => current_host, :port => current_port, :logging => false,
-                         :user => Beetle.config.user, :pass => Beetle.config.password, :vhost => Beetle.config.vhost)
-      con.instance_variable_set("@on_disconnect", proc{ con.__send__(:reconnect) })
-      con
+    def on_tcp_connection_loss(connection, settings)
+      # reconnect in 10 seconds, without enforcement
+      logger.warn "Beetle: lost connection: #{server_from_settings(settings)}. reconnecting."
+      connection.reconnect(false, 10)
     end
 
+    def connect_server(settings)
+      server = server_from_settings settings
+      logger.info "Beetle: connecting to rabbit #{server}"
+      AMQP.connect(settings) do |connection|
+        connection.on_tcp_connection_loss(&method(:on_tcp_connection_loss))
+        @connections[server] = connection
+        open_channel_and_subscribe(connection, settings)
+      end
+    rescue EventMachine::ConnectionError => e
+      # something serious went wrong, for example DNS lookup failure
+      # in this case, the on_tcp_connection_failure callback is never called automatically
+      logger.error "Beetle: connection failed: #{e.class}(#{e})"
+      settings[:on_tcp_connection_failure].call(settings)
+    end
+
+    def open_channel_and_subscribe(connection, settings)
+      server = server_from_settings settings
+      AMQP::Channel.new(connection) do |channel|
+        channel.auto_recovery = true
+        channel.prefetch(1)
+        set_current_server server
+        @channels[server] = channel
+        create_exchanges(@exchanges_for_queues)
+        bind_queues(@listened_queues)
+        subscribe_queues(@listened_queues)
+      end
+    end
   end
 end

data/script/console~

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path("../lib",__FILE__))

data/test/beetle/amqp_gem_behavior_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require 'eventmachine'
+require 'amqp'
+
+class AMQPGemBehaviorTest < Test::Unit::TestCase
+  test "subscribing twice to the same queue raises a RuntimeError which throws us out of the event loop" do
+    begin
+      @exception = nil
+      EM.run do
+        AMQP.start do |connection|
+          begin
+            EM::Timer.new(1){ connection.close { EM.stop }}
+            channel = AMQP::Channel.new(connection)
+            channel.on_error { puts "woot"}
+            exchange = channel.topic("beetle_tests")
+            queue = AMQP::Queue.new(channel)
+            queue.bind(exchange, :key => "#")
+            queue.subscribe { }
+            queue.subscribe { }
+          rescue
+            # we never get here, because the subscription is deferred
+            # the only known way to avoid this is to use the block version of AMQP::Queue.new
+          end
+        end
+      end
+    rescue Exception => @exception
+    end
+    assert @exception
+  end
+end

data/test/beetle/base_test.rb

@@ -48,5 +48,9 @@ module Beetle
       @bs.send(:set_current_server, "xxx:123")
       assert_equal "xxx:123", @bs.server
     end
+
+    test "server_from_settings should create a valid server string from an AMQP settings hash" do
+      assert_equal "goofy:123", @bs.send(:server_from_settings, {:host => "goofy", :port => 123})
+    end
   end
 end

data/test/beetle/subscriber_test.rb

@@ -8,40 +8,18 @@ module Beetle
     end
 
     test "initially there should be no amqp connections" do
-      assert_equal({}, @sub.instance_variable_get("@amqp_connections"))
+      assert_equal({}, @sub.instance_variable_get("@connections"))
     end
 
-    test "initially there should be no instances of MQ" do
-      assert_equal({}, @sub.instance_variable_get("@mqs"))
+    test "initially there should be no channels" do
+      assert_equal({}, @sub.instance_variable_get("@channels"))
     end
 
-    test "acccessing an amq_connection for a server which doesn't have one should create it and associate it with the server" do
-      @sub.expects(:new_amqp_connection).returns(42)
-      # TODO: smarter way to test? what triggers the amqp_connection private method call?
-      assert_equal 42, @sub.send(:amqp_connection)
-      connections = @sub.instance_variable_get("@amqp_connections")
-      assert_equal 42, connections[@sub.server]
-    end
-
-    test "new amqp connections should be created using current host and port" do
-      m = mock("dummy")
-      expected_amqp_options = {
-        :host => @sub.send(:current_host), :port => @sub.send(:current_port),
-        :user => "guest", :pass => "guest", :vhost => "/", :logging => false
-      }
-      AMQP.expects(:connect).with(expected_amqp_options).returns(m)
-      # TODO: smarter way to test? what triggers the amqp_connection private method call?
-      assert_equal m, @sub.send(:new_amqp_connection)
-    end
-
-    test "mq instances should be created for the current server if accessed" do
-      @sub.expects(:amqp_connection).returns(11)
-      mq_mock = mock('mq')
-      mq_mock.expects(:prefetch).with(1).returns(42)
-      MQ.expects(:new).with(11).returns(mq_mock)
-      assert_equal 42, @sub.send(:mq)
-      mqs = @sub.instance_variable_get("@mqs")
-      assert_equal 42, mqs[@sub.server]
+    test "channel should return the channel associated with the current server, if there is one" do
+      channel = mock("donald")
+      @sub.instance_variable_set("@channels", {"donald:1" => channel})
+      assert_nil @sub.send(:channel, "goofy:123")
+      assert_equal channel, @sub.send(:channel, "donald:1")
     end
 
     test "stop! should close all amqp connections and then stop the event loop" do
@@ -49,7 +27,7 @@ module Beetle
       connection1.expects(:close).yields
       connection2 = mock('con2')
       connection2.expects(:close).yields
-      @sub.instance_variable_set "@amqp_connections", [["server1", connection1], ["server2",connection2]]
+      @sub.instance_variable_set "@connections", [["server1", connection1], ["server2",connection2]]
       EM.expects(:stop_event_loop)
       @sub.send(:stop!)
     end
@@ -156,31 +134,43 @@ module Beetle
       q.expects(:bind).with(:the_exchange, {:key => "haha.#"})
       m = mock("MQ")
       m.expects(:queue).with("some_queue", :durable => true, :passive => false, :auto_delete => false, :exclusive => false).returns(q)
-      @sub.expects(:mq).returns(m)
+      @sub.expects(:channel).returns(m)
 
       @sub.send(:queue, "some_queue")
       assert_equal q, @sub.send(:queues)["some_queue"]
     end
 
-    test "binding queues should iterate over all servers" do
-      s = sequence("binding")
+    test "binding queues should bind all queues" do
       @client.register_queue(:x)
       @client.register_queue(:y)
       @client.register_handler(%w(x y)){}
-      @sub.servers = %w(a b)
-      @sub.expects(:set_current_server).with("a").in_sequence(s)
-      @sub.expects(:queue).with("x").in_sequence(s)
-      @sub.expects(:queue).with("y").in_sequence(s)
-      @sub.expects(:set_current_server).with("b").in_sequence(s)
-      @sub.expects(:queue).with("x").in_sequence(s)
-      @sub.expects(:queue).with("y").in_sequence(s)
+      @sub.expects(:queue).with("x")
+      @sub.expects(:queue).with("y")
       @sub.send(:bind_queues, %W(x y))
     end
 
+    test "subscribing to queues should subscribe on all queues" do
+      @client.register_queue(:x)
+      @client.register_queue(:y)
+      @client.register_handler(%w(x y)){}
+      @sub.expects(:subscribe).with("x")
+      @sub.expects(:subscribe).with("y")
+      @sub.send(:subscribe_queues, %W(x y))
+    end
+
     test "should not try to bind a queue for an exchange which has no queue" do
       @client.register_message(:without_queue)
       assert_equal [], @sub.send(:queues_for_exchanges, ["without_queue"])
     end
+
+    test "should not subscribe on a queue for which there is no handler" do
+      @client.register_queue(:x)
+      @client.register_queue(:y)
+      @client.register_handler(%w(y)){}
+      @sub.expects(:subscribe).with("y")
+      @sub.send(:subscribe_queues, %W(x y))
+    end
+
   end
 
   class SubscriberExchangeManagementTest < Test::Unit::TestCase
@@ -197,26 +187,20 @@ module Beetle
       @client.register_exchange("some_exchange", "type" => "topic", "durable" => true)
       m = mock("AMQP")
       m.expects(:topic).with("some_exchange", :durable => true).returns(42)
-      @sub.expects(:mq).returns(m)
+      @sub.expects(:channel).returns(m)
       ex = @sub.send(:exchange, "some_exchange")
       assert @sub.send(:exchanges).include?("some_exchange")
       ex2 = @sub.send(:exchange, "some_exchange")
       assert_equal ex2, ex
     end
 
-    test "should create exchanges for all exchanges passed to create_exchanges, for all servers" do
-      @sub.servers = %w(x y)
+    test "should create exchanges for all exchanges passed to create_exchanges for the current server" do
       @client.register_queue(:donald, :exchange => 'duck')
       @client.register_queue(:mickey)
       @client.register_queue(:mouse, :exchange => 'mickey')
 
-      exchange_creation = sequence("exchange creation")
-      @sub.expects(:set_current_server).with('x').in_sequence(exchange_creation)
-      @sub.expects(:create_exchange!).with("duck", anything).in_sequence(exchange_creation)
-      @sub.expects(:create_exchange!).with("mickey", anything).in_sequence(exchange_creation)
-      @sub.expects(:set_current_server).with('y', anything).in_sequence(exchange_creation)
-      @sub.expects(:create_exchange!).with("duck", anything).in_sequence(exchange_creation)
-      @sub.expects(:create_exchange!).with("mickey", anything).in_sequence(exchange_creation)
+      @sub.expects(:create_exchange!).with("duck", anything)
+      @sub.expects(:create_exchange!).with("mickey", anything)
       @sub.send(:create_exchanges, %w(duck mickey))
     end
   end
@@ -240,7 +224,7 @@ module Beetle
       assert_nothing_raised { @callback.call(header, 'foo') }
     end
 
-    test "should call reject on the message header when processing the handler returns true on recover?" do
+    test "should call reject on the message header when processing the handler returns true on reject?" do
       header = header_with_params({})
       result = mock("result")
       result.expects(:reject?).returns(true)
@@ -256,10 +240,10 @@ module Beetle
       Message.any_instance.expects(:process).returns(result)
       Message.any_instance.expects(:handler_result).returns("response-data")
       mq = mock("MQ")
-      @sub.expects(:mq).with(@sub.server).returns(mq)
+      @sub.expects(:channel).with(@sub.server).returns(mq)
       exchange = mock("exchange")
-      exchange.expects(:publish).with("response-data", :headers => {:status => "OK"})
-      MQ::Exchange.expects(:new).with(mq, :direct, "", :key => "tmp-queue").returns(exchange)
+      exchange.expects(:publish).with("response-data", :routing_key => "tmp-queue", :headers => {:status => "OK"}, :persistent => false)
+      AMQP::Exchange.expects(:new).with(mq, :direct, "").returns(exchange)
       @callback.call(header, 'foo')
     end
 
@@ -269,10 +253,10 @@ module Beetle
       Message.any_instance.expects(:process).returns(result)
       Message.any_instance.expects(:handler_result).returns(nil)
       mq = mock("MQ")
-      @sub.expects(:mq).with(@sub.server).returns(mq)
+      @sub.expects(:channel).with(@sub.server).returns(mq)
       exchange = mock("exchange")
-      exchange.expects(:publish).with("", :headers => {:status => "FAILED"})
-      MQ::Exchange.expects(:new).with(mq, :direct, "", :key => "tmp-queue").returns(exchange)
+      exchange.expects(:publish).with("", :routing_key => "tmp-queue", :headers => {:status => "FAILED"}, :persistent => false)
+      AMQP::Exchange.expects(:new).with(mq, :direct, "").returns(exchange)
       @callback.call(header, 'foo')
     end
 
@@ -284,18 +268,6 @@ module Beetle
       @sub = @client.send(:subscriber)
     end
 
-    test "subscribe should create subscriptions on all queues for all servers" do
-      @sub.servers << "localhost:7777"
-      @client.register_message(:a)
-      @client.register_message(:b)
-      @client.register_queue(:a)
-      @client.register_queue(:b)
-      @client.register_handler(%W(a b)){}
-      @sub.expects(:subscribe).with("a").times(2)
-      @sub.expects(:subscribe).with("b").times(2)
-      @sub.send(:subscribe_queues, %W(a b))
-    end
-
     test "subscribe should subscribe with a subscription callback created from the registered block and remember the subscription" do
       @client.register_queue(:some_queue, :exchange => "some_exchange", :key => "some_key")
       server = @sub.server
@@ -312,28 +284,32 @@ module Beetle
       q = mock("QUEUE")
       subscription_options = {:ack => true, :key => "#"}
       q.expects(:subscribe).with(subscription_options).yields(header, "foo")
-      @sub.expects(:queues).returns({"some_queue" => q}).twice
+      @sub.expects(:queues).returns({"some_queue" => q}).once
       @sub.send(:subscribe, "some_queue")
       assert block_called
       assert @sub.__send__(:has_subscription?, "some_queue")
-      q.expects(:subscribe).with(subscription_options).raises(MQ::Error)
-      assert_raises(Error) { @sub.send(:subscribe, "some_queue") }
+      # q.expects(:subscribe).with(subscription_options).raises(MQ::Error)
+      # assert_raises(Error) { @sub.send(:subscribe, "some_queue") }
     end
 
     test "subscribe should fail if no handler exists for given message" do
       assert_raises(Error){ @sub.send(:subscribe, "some_queue") }
     end
 
-    test "listening on queues should use eventmachine. create exchanges. bind queues. install subscribers. and yield." do
+    test "listening on queues should use eventmachine, connect to each server, and yield" do
       @client.register_exchange(:an_exchange)
       @client.register_queue(:a_queue, :exchange => :an_exchange)
       @client.register_message(:a_message, :key => "foo", :exchange => :an_exchange)
+      @sub.servers << "localhost:7777"
 
+      @sub.expects(:connect_server).twice
       EM.expects(:run).yields
-      @sub.expects(:create_exchanges).with(["an_exchange"])
-      @sub.expects(:bind_queues).with(["a_queue"])
-      @sub.expects(:subscribe_queues).with(["a_queue"])
-      @sub.listen_queues(["a_queue"]) {}
+      # @sub.expects(:create_exchanges).with(["an_exchange"])
+      # @sub.expects(:bind_queues).with(["a_queue"])
+      # @sub.expects(:subscribe_queues).with(["a_queue"])
+      yielded = false
+      @sub.listen_queues(["a_queue"]) { yielded = true}
+      assert yielded
     end
   end
 
@@ -357,4 +333,64 @@ module Beetle
 
   end
 
+  class ConnectionTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @sub = @client.send(:subscriber)
+      @sub.send(:set_current_server, "mickey:42")
+      @settings = @sub.send(:connection_settings)
+    end
+
+    test "connection settings should use current host and port and specify connection failure callback" do
+      assert_equal "mickey", @settings[:host]
+      assert_equal 42, @settings[:port]
+      assert @settings.has_key?(:on_tcp_connection_failure)
+    end
+
+    test "tcp connection failure should try to connect again after 10 seconds" do
+      cb = @sub.send(:on_tcp_connection_failure)
+      EM::Timer.expects(:new).with(10).yields
+      @sub.expects(:connect_server).with(@settings)
+      @sub.logger.expects(:warn).with("Beetle: connection failed: mickey:42")
+      cb.call(@settings)
+    end
+
+    test "tcp connection loss handler tries to reconnect" do
+      connection = mock("connection")
+      connection.expects(:reconnect).with(false, 10)
+      @sub.logger.expects(:warn).with("Beetle: lost connection: mickey:42. reconnecting.")
+      @sub.send(:on_tcp_connection_loss, connection, {:host => "mickey", :port => 42})
+    end
+
+    test "event machine connection error" do
+      connection = mock("connection")
+      AMQP.expects(:connect).raises(EventMachine::ConnectionError)
+      @settings[:on_tcp_connection_failure].expects(:call).with(@settings)
+      @sub.send(:connect_server, @settings)
+    end
+
+    test "successfull connection to broker" do
+      connection = mock("connection")
+      connection.expects(:on_tcp_connection_loss)
+      @sub.expects(:open_channel_and_subscribe).with(connection, @settings)
+      AMQP.expects(:connect).with(@settings).yields(connection)
+      @sub.send(:connect_server, @settings)
+      assert_equal connection, @sub.instance_variable_get("@connections")["mickey:42"]
+    end
+
+    test "channel opening, exchange creation, queue bindings and subscription" do
+      connection = mock("connection")
+      channel = mock("channel")
+      channel.expects(:prefetch).with(1)
+      channel.expects(:auto_recovery=).with(true)
+      AMQP::Channel.expects(:new).with(connection).yields(channel)
+      @sub.expects(:create_exchanges)
+      @sub.expects(:bind_queues)
+      @sub.expects(:subscribe_queues)
+      @sub.send(:open_channel_and_subscribe, connection, @settings)
+      assert_equal channel, @sub.instance_variable_get("@channels")["mickey:42"]
+    end
+
+  end
+
 end

data/test/colorized_test_output.rb

@@ -0,0 +1,25 @@
+# colorized output for Test::Unit / MiniTest
+begin
+  if RUBY_VERSION < "1.9"
+    require 'redgreen'
+  else
+    module ColorizedDots
+      require 'ansi/code'
+      def run(runner)
+        r = super
+        ANSI.ansi(r, ANSI_COLOR_MAPPING[r])
+      end
+      ANSI_COLOR_MAPPING = Hash.new(:white).merge!('.' => :green, 'S' => :magenta, 'F' => :yellow, 'E' => :red )
+    end
+    class MiniTest::Unit
+      TestCase.send(:include, ColorizedDots)
+      def status(io = @@out)
+        format = "%d tests, %d assertions, %d failures, %d errors, %d skips"
+        color = (errors + failures) > 0 ? :red : :green
+        io.puts ANSI.ansi(format % [test_count, assertion_count, failures, errors, skips], color)
+      end
+    end
+  end
+rescue LoadError => e
+  # do nothing
+end unless ENV['TM_FILENAME']

data/test/test_helper.rb

@@ -4,11 +4,7 @@ require 'mocha'
 require 'active_support/testing/declarative'
 
 require File.expand_path(File.dirname(__FILE__) + '/../lib/beetle')
-
-begin
-  require 'redgreen' unless ENV['TM_FILENAME']
-rescue LoadError => e
-end
+require File.expand_path(File.dirname(__FILE__) + '/colorized_test_output')
 
 # we can remove this hack which is needed only for testing
 begin
@@ -29,13 +25,15 @@ end
 Beetle.config.logger = Logger.new(File.dirname(__FILE__) + '/../test.log')
 Beetle.config.redis_server = "localhost:6379"
 
+
 def header_with_params(opts = {})
   beetle_headers = Beetle::Message.publishing_options(opts)
   header = mock("header")
-  header.stubs(:properties).returns(beetle_headers)
+  header.stubs(:attributes).returns(beetle_headers)
   header
 end
 
+
 def redis_stub(name, opts = {})
   default_port = opts['port'] || "1234"
   default_host = opts['host'] || "foo"

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: beetle
 version: !ruby/object:Gem::Version 
-  hash: 15424035
+  hash: 15424045
   prerelease: 6
   segments: 
   - 0
   - 3
   - 0
   - rc
-  - 3
-  version: 0.3.0.rc.3
+  - 4
+  version: 0.3.0.rc.4
 platform: ruby
 authors: 
 - Stefan Kaes
@@ -20,7 +20,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-05 00:00:00 Z
+date: 2011-10-11 00:00:00 +02:00
+default_executable: beetle
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: uuid4r
@@ -44,14 +45,14 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - "="
       - !ruby/object:Gem::Version 
-        hash: 1
+        hash: 19
         segments: 
         - 0
         - 7
-        - 1
-        version: 0.7.1
+        - 8
+        version: 0.7.8
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -87,25 +88,57 @@ dependencies:
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: amqp
+  name: amq-client
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - "="
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: 57
         segments: 
         - 0
-        - 6
-        - 7
-        version: 0.6.7
+        - 8
+        - 3
+        version: 0.8.3
   type: :runtime
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: amq-protocol
   prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 0
+        - 8
+        - 1
+        version: 0.8.1
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: amqp
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 8
+        - 0
+        version: 0.8.0
+  type: :runtime
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -117,11 +150,11 @@ dependencies:
         - 4
         version: 2.3.4
   type: :runtime
-  version_requirements: *id006
+  version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   name: daemons
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -133,11 +166,11 @@ dependencies:
         - 10
         version: 1.0.10
   type: :runtime
-  version_requirements: *id007
+  version_requirements: *id009
 - !ruby/object:Gem::Dependency 
   name: rake
   prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  requirement: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -149,11 +182,11 @@ dependencies:
         - 7
         version: 0.8.7
   type: :development
-  version_requirements: *id008
+  version_requirements: *id010
 - !ruby/object:Gem::Dependency 
   name: mocha
   prerelease: false
-  requirement: &id009 !ruby/object:Gem::Requirement 
+  requirement: &id011 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -163,11 +196,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id009
+  version_requirements: *id011
 - !ruby/object:Gem::Dependency 
   name: rcov
   prerelease: false
-  requirement: &id010 !ruby/object:Gem::Requirement 
+  requirement: &id012 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -177,11 +210,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id010
+  version_requirements: *id012
 - !ruby/object:Gem::Dependency 
   name: redgreen
   prerelease: false
-  requirement: &id011 !ruby/object:Gem::Requirement 
+  requirement: &id013 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -191,11 +224,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id011
+  version_requirements: *id013
 - !ruby/object:Gem::Dependency 
   name: wirble
   prerelease: false
-  requirement: &id012 !ruby/object:Gem::Requirement 
+  requirement: &id014 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -205,11 +238,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id012
+  version_requirements: *id014
 - !ruby/object:Gem::Dependency 
   name: cucumber
   prerelease: false
-  requirement: &id013 !ruby/object:Gem::Requirement 
+  requirement: &id015 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -221,11 +254,11 @@ dependencies:
         - 2
         version: 0.7.2
   type: :development
-  version_requirements: *id013
+  version_requirements: *id015
 - !ruby/object:Gem::Dependency 
   name: daemon_controller
   prerelease: false
-  requirement: &id014 !ruby/object:Gem::Requirement 
+  requirement: &id016 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -235,7 +268,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id014
+  version_requirements: *id016
 description: A highly available, reliable messaging infrastructure
 email: developers@xing.com
 executables: 
@@ -255,6 +288,7 @@ files:
 - examples/handling_exceptions.rb
 - examples/multiple_exchanges.rb
 - examples/multiple_queues.rb
+- examples/nonexistent_server.rb
 - examples/pause_and_resume.rb
 - examples/redundant.rb
 - examples/rpc.rb
@@ -289,6 +323,7 @@ files:
 - features/support/test_daemons/redis_configuration_client.rb
 - features/support/test_daemons/redis_configuration_server.rb
 - script/console
+- script/console~
 - script/start_rabbit
 - beetle.gemspec
 - Rakefile
@@ -297,6 +332,7 @@ files:
 - REDIS_AUTO_FAILOVER.rdoc
 - RELEASE_NOTES.rdoc
 - MIT-LICENSE
+- test/beetle/amqp_gem_behavior_test.rb
 - test/beetle/base_test.rb
 - test/beetle/client_test.rb
 - test/beetle/configuration_test.rb
@@ -311,8 +347,10 @@ files:
 - test/beetle/redis_master_file_test.rb
 - test/beetle/subscriber_test.rb
 - test/beetle_test.rb
+- test/colorized_test_output.rb
 - test/test_helper.rb
 - bin/beetle
+has_rdoc: true
 homepage: http://xing.github.com/beetle/
 licenses: []
 
@@ -344,11 +382,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: High Availability AMQP Messaging with Redundant Queues
 test_files: 
+- test/beetle/amqp_gem_behavior_test.rb
 - test/beetle/base_test.rb
 - test/beetle/client_test.rb
 - test/beetle/configuration_test.rb
@@ -363,4 +402,5 @@ test_files:
 - test/beetle/redis_master_file_test.rb
 - test/beetle/subscriber_test.rb
 - test/beetle_test.rb
+- test/colorized_test_output.rb
 - test/test_helper.rb