beetle 0.2.13 → 0.3.0.rc.1

data/Rakefile

@@ -1,6 +1,8 @@
 require 'rake'
 require 'rake/testtask'
 require 'rcov/rcovtask'
+# rake 0.9.2 hack to supress deprecation warnings caused by cucumber
+include Rake::DSL if RAKEVERSION >= "0.9"
 require 'cucumber/rake/task'
 
 # 1.8/1.9 compatible way of loading lib/beetle.rb

data/beetle.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name    = "beetle"
-  s.version = "0.2.13"
+  s.version = "0.3.0.rc.1"
   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,8 +29,7 @@ Gem::Specification.new do |s|
 
   s.specification_version = 3
   s.add_runtime_dependency("uuid4r",                [">= 0.1.2"])
-  s.add_runtime_dependency("bunny",                 ["= 0.6.0"])
-  s.add_runtime_dependency("bunny-ext",             [">= 0.6.5"])
+  s.add_runtime_dependency("bunny",                 ["~> 0.7.1"])
   s.add_runtime_dependency("redis",                 ["= 2.0.4"])
   s.add_runtime_dependency("amqp",                  ["~> 0.6.7"])
   s.add_runtime_dependency("activesupport",         [">= 2.3.4"])

data/examples/attempts.rb

@@ -47,7 +47,7 @@ class Handler < Beetle::Handler
   # we're stopping the event loop so this script stops after that
   def failure(result)
     super
-    $client.stop_listening
+    EM.add_timer(1){$client.stop_listening}
   end
 end
 
@@ -62,5 +62,5 @@ $client.listen
 
 # error handling, if everything went right this shouldn't happen.
 if $exceptions != $max_exceptions + 1
-  raise "something is fishy. Failed #{$exceptions} times"
+  raise "Something is fishy. Failed #{$exceptions} times"
 end

data/examples/pause_and_resume.rb

@@ -0,0 +1,75 @@
+# attempts.rb
+# this example shows you how to use the exception limiting feature of beetle
+# it allows you to control the number of retries your handler will go through
+# with one message before giving up on it
+#
+# ! check the examples/README.rdoc for information on starting your redis/rabbit !
+#
+# start it with ruby attempts.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
+
+# setup client
+$client = Beetle::Client.new
+$client.register_queue(:test)
+$client.register_message(:test)
+
+# purge the test queue
+$client.purge(:test)
+
+# initially, our service is online
+$online = true
+
+# declare a handler class for message processing
+# in this example we've not only overwritten the process method but also the
+# error and failure methods of the handler baseclass
+class Handler < Beetle::Handler
+
+  # called when the handler receives the message - fail everytime
+  def process
+    puts "received message #{message.data} online=#{$online}"
+    unless $online
+      $client.pause_listening(:test)
+      raise "offline"
+    end
+  end
+
+  # called when handler process raised an exception
+  def error(exception)
+    puts "execution failed: #{exception}"
+  end
+
+end
+
+# publish a decent amount of messages
+# 1000.times do |i|
+#   $client.publish(:test, i)
+# end
+# $client.stop_publishing
+
+# register our handler to the message, configure it to our max_exceptions limit, we configure a delay of 0 to have it not wait before retrying
+$client.register_handler(:test, Handler, :exceptions => 1, :delay => 0)
+
+# and start our listening loop...
+$client.listen do
+  n = 0
+  ptimer = EM.add_periodic_timer(0.1) do
+    data = (n+=1)
+    puts "publishing message #{data}"
+    $client.publish(:test, data)
+  end
+
+  EM.add_periodic_timer(2) do
+    $online = !$online
+    $client.resume_listening(:test) if $online
+  end
+
+  EM.add_timer(10) do
+    $client.pause_listening
+    EM.add_timer(1) { $client.stop_listening }
+  end
+end

data/examples/simple.rb

@@ -5,7 +5,7 @@
 #
 # ! check the examples/README.rdoc for information on starting your redis/rabbit !
 #
-# start it with ruby multiple_exchanges.rb
+# start it with ruby simple.rb
 
 require "rubygems"
 require File.expand_path("../lib/beetle", File.dirname(__FILE__))
@@ -27,8 +27,8 @@ client.deduplication_store.flushdb
 # 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}"}
 
-# publish our message
-client.publish(:test, 'bam')
+# publish our message (NOTE: empty message bodies don't work, most likely due to bugs in bunny/amqp)
+puts client.publish(:test, 'bam')
 
 # start listening
 # this starts the event machine event loop using EM.run

data/examples/test_publisher.rb

@@ -0,0 +1,32 @@
+# attempts.rb
+# this example shows you how to use the exception limiting feature of beetle
+# it allows you to control the number of retries your handler will go through
+# with one message before giving up on it
+#
+# ! check the examples/README.rdoc for information on starting your redis/rabbit !
+#
+# start it with ruby attempts.rb
+
+require "rubygems"
+require File.expand_path("../lib/beetle", File.dirname(__FILE__))
+require "eventmachine"
+
+# set Beetle log level to info, less noisy than debug
+Beetle.config.logger.level = Logger::INFO
+
+# setup client
+client = Beetle::Client.new
+client.register_message(:test)
+
+n = 0
+EM.run do
+  EM.add_periodic_timer(0.1) do
+    data = (n+=1)
+    client.logger.info "publishing #{data}"
+    client.publish(:test, data)
+  end
+  trap("INT") do
+    client.stop_publishing
+    EM.stop_event_loop
+  end
+end

data/lib/beetle/client.rb

@@ -140,8 +140,7 @@ module Beetle
     # For details on handler classes see class Beetle::Handler
 
     def register_handler(queues, *args, &block)
-      queues = Array(queues).map(&:to_s)
-      queues.each {|q| raise UnknownQueue.new(q) unless self.queues.include?(q)}
+      queues = determine_queue_names(Array(queues))
       opts = args.last.is_a?(Hash) ? args.pop : {}
       handler = args.shift
       raise ArgumentError.new("too many arguments for handler registration") unless args.empty?
@@ -167,9 +166,9 @@ module Beetle
     end
 
     # publishes a message. the given options hash is merged with options given on message registration.
+    # WARNING: empty message bodies can lead to problems.
     def publish(message_name, data=nil, opts={})
-      message_name = message_name.to_s
-      raise UnknownMessage.new("unknown message #{message_name}") unless messages.include?(message_name)
+      message_name = validated_message_name(message_name)
       publisher.publish(message_name, data, opts)
     end
 
@@ -177,16 +176,14 @@ module Beetle
     #
     # unexpected behavior can ensue if the message gets routed to more than one recipient, so be careful.
     def rpc(message_name, data=nil, opts={})
-      message_name = message_name.to_s
-      raise UnknownMessage.new("unknown message #{message_name}") unless messages.include?(message_name)
+      message_name = validated_message_name(message_name)
       publisher.rpc(message_name, data, opts)
     end
 
-    # purges the given queue on all configured servers
-    def purge(queue_name)
-      queue_name = queue_name.to_s
-      raise UnknownQueue.new("unknown queue #{queue_name}") unless queues.include?(queue_name)
-      publisher.purge(queue_name)
+    # purges the given queues on all configured servers
+    def purge(*queues)
+      queues = determine_queue_names(queues)
+      publisher.purge(queues)
     end
 
     # start listening to all registered queues. Calls #listen_queues internally
@@ -198,7 +195,8 @@ module Beetle
 
     # start listening to a list of queues (default to all registered queues).
     # runs the given block before entering the eventmachine loop.
-    def listen_queues(queues=self.queues.keys, &block)
+    def listen_queues(*queues, &block)
+      queues = determine_queue_names(queues)
       subscriber.listen_queues(queues, &block)
     end
 
@@ -212,6 +210,18 @@ module Beetle
       publisher.stop
     end
 
+    # pause listening on a list of queues
+    def pause_listening(*queues)
+      queues = determine_queue_names(queues)
+      subscriber.pause_listening(queues)
+    end
+
+    # resume listening on a list of queues
+    def resume_listening(*queues)
+      queues = determine_queue_names(queues)
+      subscriber.resume_listening(queues)
+    end
+
     # traces queues without consuming them. useful for debugging message flow.
     def trace(queue_names=self.queues.keys, &block)
       queues_to_trace = self.queues.slice(*queue_names)
@@ -238,6 +248,26 @@ module Beetle
 
     private
 
+    def determine_queue_names(queues)
+      if queues.empty?
+        self.queues.keys
+      else
+        queues.flatten.map{|q| validated_queue_name(q)}
+      end
+    end
+
+    def validated_queue_name(queue_name)
+      queue_name = queue_name.to_s
+      raise UnknownQueue.new("unknown queue #{queue_name}") unless queues.include?(queue_name)
+      queue_name
+    end
+
+    def validated_message_name(message_name)
+      message_name = message_name.to_s
+      raise UnknownMessage.new("unknown message #{message_name}") unless messages.include?(message_name)
+      message_name
+    end
+
     class Configurator #:nodoc:all
       def initialize(client, options={})
         @client = client

data/lib/beetle/handler.rb

@@ -11,13 +11,16 @@ module Beetle
     # the Message instance which caused the handler to be created
     attr_reader :message
 
-    def self.create(block_or_handler, opts={}) #:nodoc:
-      if block_or_handler.is_a? Handler
-        block_or_handler
-      elsif block_or_handler.is_a?(Class) && block_or_handler.ancestors.include?(Handler)
-        block_or_handler.new
+    def self.create(handler, opts={}) #:nodoc:
+      if handler.is_a? Handler
+        # a handler instance
+        handler
+      elsif handler.is_a?(Class) && handler.ancestors.include?(Handler)
+        # handler class
+        handler.new
       else
-        new(block_or_handler, opts)
+        # presumably something which responds to call
+        new(handler, opts)
       end
     end
 
@@ -70,6 +73,13 @@ module Beetle
       Beetle::reraise_expectation_errors!
     end
 
+    # should not be overriden in subclasses
+    def processing_completed
+      completed
+    rescue Exception
+      Beetle::reraise_expectation_errors!
+    end
+
     # called when handler execution raised an exception and no error callback was
     # specified when the handler instance was created
     def error(exception)
@@ -83,6 +93,12 @@ module Beetle
       logger.error "Beetle: handler has finally failed"
     end
 
+    # called after all normal processing has been completed. flushes the loggger, if it responds to flush.
+    def completed
+      logger.debug "Beetle: message processing completed"
+      logger.flush if logger.respond_to?(:flush)
+    end
+
     # returns the configured Beetle logger
     def self.logger
       Beetle.config.logger

data/lib/beetle/publisher.rb

@@ -16,7 +16,7 @@ module Beetle
         Bunny::ConnectionError, Bunny::ForcedChannelCloseError, Bunny::ForcedConnectionCloseError,
         Bunny::MessageError, Bunny::ProtocolError, Bunny::ServerDownError, Bunny::UnsubscribeError,
         Bunny::AcknowledgementError, Qrack::BufferOverflowError, Qrack::InvalidTypeError,
-        Errno::EHOSTUNREACH, Errno::ECONNRESET
+        Errno::EHOSTUNREACH, Errno::ECONNRESET, Timeout::Error
       ]
     end
 
@@ -130,8 +130,12 @@ module Beetle
       [status, result]
     end
 
-    def purge(queue_name) #:nodoc:
-      each_server { queue(queue_name).purge rescue nil }
+    def purge(queue_names) #:nodoc:
+      each_server do
+        queue_names.each do |name|
+          queue(name).purge rescue nil
+        end
+      end
     end
 
     def stop #:nodoc:
@@ -210,7 +214,7 @@ module Beetle
           end
         end
       rescue Exception => e
-        logger.error "Beetle: error closing down bunny #{e}"
+        logger.warn "Beetle: error closing down bunny #{e}"
         Beetle::reraise_expectation_errors!
       ensure
         @bunnies[@server] = nil

data/lib/beetle/subscriber.rb

@@ -12,6 +12,7 @@ module Beetle
       @handlers = {}
       @amqp_connections = {}
       @mqs = {}
+      @subscriptions = {}
     end
 
     # the client calls this method to subscribe to a list of queues.
@@ -32,6 +33,17 @@ module Beetle
       end
     end
 
+    def pause_listening(queues)
+      each_server do
+        queues.each { |name| pause(name) if has_subscription?(name) }
+      end
+    end
+
+    def resume_listening(queues)
+      each_server do
+        queues.each { |name| resume(name) if has_subscription?(name) }
+      end
+    end
 
     # closes all AMQP connections and stops the eventmachine loop
     def stop! #:nodoc:
@@ -39,6 +51,7 @@ module Beetle
         EM.stop_event_loop
       else
         server, connection = @amqp_connections.shift
+        logger.debug "Beetle: closing connection to #{server}"
         connection.close { stop! }
       end
     end
@@ -56,10 +69,6 @@ module Beetle
       @client.bindings.slice(*queues).map{|_, opts| opts.map{|opt| opt[:exchange]}}.flatten.uniq
     end
 
-    def exchanges_for_messages(messages)
-      @client.messages.slice(*messages).map{|_, opts| opts[:exchange]}.uniq
-    end
-
     def queues_for_exchanges(exchanges)
       @client.exchanges.slice(*exchanges).map{|_, opts| opts[:queues]}.flatten.compact.uniq
     end
@@ -91,24 +100,46 @@ module Beetle
       @mqs[server] ||= MQ.new(amqp_connection).prefetch(1)
     end
 
+    def subscriptions(server=@server)
+      @subscriptions[server] ||= {}
+    end
+
+    def has_subscription?(name)
+      subscriptions.include?(name)
+    end
+
     def subscribe(queue_name)
       error("no handler for queue #{queue_name}") unless @handlers.include?(queue_name)
       opts, handler = @handlers[queue_name]
       queue_opts = @client.queues[queue_name][:amqp_name]
       amqp_queue_name = queue_opts
       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(opts.slice(*SUBSCRIPTION_KEYS).merge(:key => "#", :ack => true), &callback)
+        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
     end
 
+    def pause(queue_name)
+      return unless queues[queue_name].subscribed?
+      queues[queue_name].unsubscribe
+    end
+
+    def resume(queue_name)
+      return if queues[queue_name].subscribed?
+      keys, callback = subscriptions[queue_name]
+      queues[queue_name].subscribe(keys, &callback)
+    end
+
     def create_subscription_callback(queue_name, amqp_queue_name, handler, opts)
       server = @server
       lambda do |header, data|
         begin
+          # logger.debug "Beetle: received message"
           processor = Handler.create(handler, opts)
           message_options = opts.merge(:server => server, :store => @client.deduplication_store)
           m = Message.new(amqp_queue_name, header, data, message_options)
@@ -124,10 +155,14 @@ module Beetle
             exchange = MQ::Exchange.new(mq(server), :direct, "", :key => reply_to)
             exchange.publish(m.handler_result.to_s, :headers => {:status => status})
           end
+          # logger.debug "Beetle: processed message"
         rescue Exception
           Beetle::reraise_expectation_errors!
           # swallow all exceptions
           logger.error "Beetle: internal error during message processing: #{$!}: #{$!.backtrace.join("\n")}"
+        ensure
+          # processing_completed swallows all exceptions, so we don't need to protect this call
+          processor.processing_completed
         end
       end
     end
@@ -149,7 +184,7 @@ module Beetle
 
     def new_amqp_connection
       # FIXME: wtf, how to test that reconnection feature....
-      con = AMQP.connect(:host => current_host, :port => current_port,
+      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

data/lib/beetle.rb

@@ -1,5 +1,5 @@
 $:.unshift(File.expand_path('..', __FILE__))
-require 'bunny-ext'
+require 'bunny'
 require 'uuid4r'
 require 'active_support'
 require 'active_support/core_ext'

data/test/beetle/client_test.rb

@@ -236,14 +236,14 @@ module Beetle
     test "should delegate queue purging to the publisher instance" do
       client = Client.new
       client.register_queue(:queue)
-      client.send(:publisher).expects(:purge).with("queue").returns("ha!")
+      client.send(:publisher).expects(:purge).with(["queue"]).returns("ha!")
       assert_equal "ha!", client.purge("queue")
     end
 
     test "purging a queue should convert the queue name to a string" do
       client = Client.new
       client.register_queue(:queue)
-      client.send(:publisher).expects(:purge).with("queue").returns("ha!")
+      client.send(:publisher).expects(:purge).with(["queue"]).returns("ha!")
       assert_equal "ha!", client.purge(:queue)
     end
 
@@ -251,6 +251,14 @@ module Beetle
       assert_raises(UnknownQueue) { Client.new.purge(:mumu) }
     end
 
+    test "should be possible to purge multiple queues with a single call" do
+      client = Client.new
+      client.register_queue(:queue1)
+      client.register_queue(:queue2)
+      client.send(:publisher).expects(:purge).with(["queue1","queue2"]).returns("ha!")
+      assert_equal "ha!", client.purge(:queue1, :queue2)
+    end
+
     test "should delegate rpc calls to the publisher instance" do
       client = Client.new
       client.register_message("deadletter")
@@ -274,7 +282,7 @@ module Beetle
     test "should delegate listening to queues to the subscriber instance" do
       client = Client.new
       client.register_queue(:test)
-      client.send(:subscriber).expects(:listen_queues).with([:test]).yields
+      client.send(:subscriber).expects(:listen_queues).with(['test']).yields
       client.listen_queues([:test])
     end
 
@@ -283,12 +291,36 @@ module Beetle
       assert_raises(UnknownQueue) { Client.new.listen_queues([:foobar])}
     end
 
+    test "trying to pause listening on an unknown queue should raise an exception" do
+      client = Client.new
+      assert_raises(UnknownQueue) { Client.new.pause_listening(:foobar)}
+    end
+
+    test "trying to resume listening on an unknown queue should raise an exception" do
+      client = Client.new
+      assert_raises(UnknownQueue) { Client.new.pause_listening(:foobar)}
+    end
+
     test "should delegate stop_listening to the subscriber instance" do
       client = Client.new
       client.send(:subscriber).expects(:stop!)
       client.stop_listening
     end
 
+    test "should delegate pause_listening to the subscriber instance" do
+      client = Client.new
+      client.register_queue(:test)
+      client.send(:subscriber).expects(:pause_listening).with(%w(test))
+      client.pause_listening(:test)
+    end
+
+    test "should delegate resume_listening to the subscriber instance" do
+      client = Client.new
+      client.register_queue(:test)
+      client.send(:subscriber).expects(:resume_listening).with(%w(test))
+      client.resume_listening(:test)
+    end
+
     test "should delegate handler registration to the subscriber instance" do
       client = Client.new
       client.register_queue("huhu")

data/test/beetle/handler_test.rb

@@ -77,17 +77,18 @@ module Beetle
       assert_equal Beetle.config.logger, Handler.logger
     end
 
-    test "default implementation of error and process and failure should not crash" do
+    test "default implementation of error and process and failure and completed should not crash" do
       handler = Handler.create(lambda {})
       handler.process
       handler.error('barfoo')
       handler.failure('razzmatazz')
+      handler.completed
     end
 
     test "should silently rescue exceptions in the process_exception call" do
       mock = mock('error handler')
       e = Exception.new
-      mock.expects(:call).with('message', e).raises(RuntimeError)
+      mock.expects(:call).with('message', e).raises(Exception)
       handler = Handler.create(lambda {}, :errback => mock)
       handler.instance_variable_set(:@message, 'message')
       assert_nothing_raised {handler.process_exception(e)}
@@ -95,11 +96,17 @@ module Beetle
 
     test "should silently rescue exceptions in the process_failure call" do
       mock = mock('failure handler')
-      mock.expects(:call).with('message', 1).raises(RuntimeError)
+      mock.expects(:call).with('message', 1).raises(Exception)
       handler = Handler.create(lambda {}, :failback => mock)
       handler.instance_variable_set(:@message, 'message')
       assert_nothing_raised {handler.process_failure(1)}
     end
 
+    test "should silently rescue exceptions in the processing_completed call" do
+      handler = Handler.create(lambda {})
+      handler.expects(:completed).raises(Exception)
+      assert_nothing_raised {handler.processing_completed}
+    end
+
   end
 end

data/test/beetle/publisher_test.rb

@@ -274,7 +274,7 @@ module Beetle
       @pub.expects(:set_current_server).with("b").in_sequence(s)
       @pub.expects(:queue).with("queue").returns(queue).in_sequence(s)
       queue.expects(:purge).in_sequence(s)
-      @pub.purge("queue")
+      @pub.purge(["queue"])
     end
   end
 

data/test/beetle/subscriber_test.rb

@@ -27,7 +27,7 @@ module Beetle
       m = mock("dummy")
       expected_amqp_options = {
         :host => @sub.send(:current_host), :port => @sub.send(:current_port),
-        :user => "guest", :pass => "guest", :vhost => "/"
+        :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?
@@ -56,6 +56,75 @@ module Beetle
 
   end
 
+  class SubscriberPauseAndResumeTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @sub = @client.send(:subscriber)
+      @sub.servers << "localhost:7777"
+      @server1, @server2 = @sub.servers
+      @client.register_message(:a)
+      @client.register_queue(:a)
+      @client.register_handler(%W(a)){}
+    end
+
+    test "should pause on all servers when a handler has been registered" do
+      @sub.expects(:pause).with("a").times(2)
+      @sub.stubs(:has_subscription?).returns(true)
+      @sub.pause_listening(%w(a))
+    end
+
+    test "should resume on all servers when a handler has been registered" do
+      @sub.expects(:resume).with("a").times(2)
+      @sub.stubs(:has_subscription?).returns(true)
+      @sub.resume_listening(%w(a))
+    end
+
+    test "should pause on no servers when no handler has been registered" do
+      @sub.expects(:pause).never
+      @sub.stubs(:has_subscription?).returns(false)
+      @sub.pause_listening(%w(a))
+    end
+
+    test "should resume on no servers when no handler has been registered" do
+      @sub.expects(:resume).never
+      @sub.stubs(:has_subscription?).returns(false)
+      @sub.resume_listening(%w(a))
+    end
+
+    test "pausing a single queue should call amqp unsubscribe" do
+      q = mock("queue a")
+      q.expects(:subscribed?).returns(true)
+      q.expects(:unsubscribe)
+      @sub.stubs(:queues).returns({"a" =>q})
+      @sub.__send__(:pause, "a")
+    end
+
+    test "pausing a single queue which is already paused should not call amqp unsubscribe" do
+      q = mock("queue a")
+      q.expects(:subscribed?).returns(false)
+      q.expects(:unsubscribe).never
+      @sub.stubs(:queues).returns({"a" =>q})
+      @sub.__send__(:pause, "a")
+    end
+
+    test "resuming a single queue should call amqp subscribe" do
+      q = mock("queue a")
+      q.expects(:subscribed?).returns(false)
+      q.expects(:subscribe)
+      @sub.stubs(:queues).returns({"a" =>q})
+      @sub.__send__(:resume, "a")
+    end
+
+    test "resuming a single queue which is already subscribed should not call amqp subscribe" do
+      q = mock("queue a")
+      q.expects(:subscribed?).returns(true)
+      q.expects(:subscribe).never
+      @sub.stubs(:queues).returns({"a" =>q})
+      @sub.__send__(:resume, "a")
+    end
+
+  end
+
   class AdditionalSubscriptionServersTest < Test::Unit::TestCase
     def setup
       @config = Configuration.new
@@ -160,6 +229,8 @@ module Beetle
       @sub = client.send(:subscriber)
       @exception = Exception.new "murks"
       @handler = Handler.create(lambda{|*args| raise @exception})
+      # handler method 'processing_completed' should be called under all circumstances
+      @handler.expects(:processing_completed).once
       @callback = @sub.send(:create_subscription_callback, "my myessage", @queue, @handler, :exceptions => 1)
     end
 
@@ -225,7 +296,7 @@ module Beetle
       @sub.send(:subscribe_queues, %W(a b))
     end
 
-    test "subscribe should subscribe with a subscription callback created from the registered block" do
+    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
       header = header_with_params({})
@@ -239,17 +310,21 @@ module Beetle
       end
       @sub.register_handler("some_queue", &proc)
       q = mock("QUEUE")
-      q.expects(:subscribe).with({:ack => true, :key => "#"}).yields(header, "foo")
-      @sub.expects(:queues).returns({"some_queue" => q})
+      subscription_options = {:ack => true, :key => "#"}
+      q.expects(:subscribe).with(subscription_options).yields(header, "foo")
+      @sub.expects(:queues).returns({"some_queue" => q}).twice
       @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") }
     end
 
     test "subscribe should fail if no handler exists for given message" do
       assert_raises(Error){ @sub.send(:subscribe, "some_queue") }
     end
 
-    test "listeninging on queues should use eventmachine. create exchanges. bind queues. install subscribers. and yield." do
+    test "listening on queues should use eventmachine. create exchanges. bind queues. install subscribers. 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)

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: beetle
 version: !ruby/object:Gem::Version 
-  hash: 13
-  prerelease: 
+  hash: 15424039
+  prerelease: 6
   segments: 
   - 0
-  - 2
-  - 13
-  version: 0.2.13
+  - 3
+  - 0
+  - rc
+  - 1
+  version: 0.3.0.rc.1
 platform: ruby
 authors: 
 - Stefan Kaes
@@ -18,7 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-15 00:00:00 +02:00
+date: 2011-08-27 00:00:00 +02:00
 default_executable: beetle
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,36 +45,20 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 1
         segments: 
         - 0
-        - 6
-        - 0
-        version: 0.6.0
+        - 7
+        - 1
+        version: 0.7.1
   type: :runtime
   version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: bunny-ext
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 0
-        - 6
-        - 5
-        version: 0.6.5
-  type: :runtime
-  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: redis
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - "="
@@ -84,11 +70,11 @@ dependencies:
         - 4
         version: 2.0.4
   type: :runtime
-  version_requirements: *id004
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: amqp
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -100,11 +86,11 @@ dependencies:
         - 7
         version: 0.6.7
   type: :runtime
-  version_requirements: *id005
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: activesupport
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -116,11 +102,11 @@ dependencies:
         - 4
         version: 2.3.4
   type: :runtime
-  version_requirements: *id006
+  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: daemons
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -132,11 +118,11 @@ dependencies:
         - 10
         version: 1.0.10
   type: :runtime
-  version_requirements: *id007
+  version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: rake
   prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -148,11 +134,11 @@ dependencies:
         - 7
         version: 0.8.7
   type: :development
-  version_requirements: *id008
+  version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: mocha
   prerelease: false
-  requirement: &id009 !ruby/object:Gem::Requirement 
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -162,11 +148,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id009
+  version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   name: rcov
   prerelease: false
-  requirement: &id010 !ruby/object:Gem::Requirement 
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -176,11 +162,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id010
+  version_requirements: *id009
 - !ruby/object:Gem::Dependency 
   name: redgreen
   prerelease: false
-  requirement: &id011 !ruby/object:Gem::Requirement 
+  requirement: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -190,11 +176,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id011
+  version_requirements: *id010
 - !ruby/object:Gem::Dependency 
   name: wirble
   prerelease: false
-  requirement: &id012 !ruby/object:Gem::Requirement 
+  requirement: &id011 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -204,11 +190,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id012
+  version_requirements: *id011
 - !ruby/object:Gem::Dependency 
   name: cucumber
   prerelease: false
-  requirement: &id013 !ruby/object:Gem::Requirement 
+  requirement: &id012 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -220,11 +206,11 @@ dependencies:
         - 2
         version: 0.7.2
   type: :development
-  version_requirements: *id013
+  version_requirements: *id012
 - !ruby/object:Gem::Dependency 
   name: daemon_controller
   prerelease: false
-  requirement: &id014 !ruby/object:Gem::Requirement 
+  requirement: &id013 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -234,7 +220,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id014
+  version_requirements: *id013
 description: A highly available, reliable messaging infrastructure
 email: developers@xing.com
 executables: 
@@ -254,9 +240,11 @@ files:
 - examples/handling_exceptions.rb
 - examples/multiple_exchanges.rb
 - examples/multiple_queues.rb
+- examples/pause_and_resume.rb
 - examples/redundant.rb
 - examples/rpc.rb
 - examples/simple.rb
+- examples/test_publisher.rb
 - lib/beetle/base.rb
 - lib/beetle/client.rb
 - lib/beetle/commands/configuration_client.rb
@@ -287,7 +275,6 @@ 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

data/script/console~

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