beetle 0.2.11 → 0.3.0.rc.1

data/Rakefile

@@ -1,8 +1,9 @@
 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'
-require 'active_support'
 
 # 1.8/1.9 compatible way of loading lib/beetle.rb
 $:.unshift 'lib'

data/beetle.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name    = "beetle"
-  s.version = "0.2.11"
-  s.required_rubygems_version = ">= 1.3.1"
+  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')
   s.default_executable = "beetle"
@@ -28,15 +28,17 @@ Gem::Specification.new do |s|
   INFO
 
   s.specification_version = 3
-  s.add_runtime_dependency("uuid4r",                [">= 0.1.1"])
-  s.add_runtime_dependency("bunny",                 ["= 0.6.0"])
-  s.add_runtime_dependency("bunny-ext",             [">= 0.6.5"])
+  s.add_runtime_dependency("uuid4r",                [">= 0.1.2"])
+  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"])
+  s.add_runtime_dependency("amqp",                  ["~> 0.6.7"])
+  s.add_runtime_dependency("activesupport",         [">= 2.3.4"])
   s.add_runtime_dependency("daemons",               [">= 1.0.10"])
+  s.add_development_dependency("rake",              [">= 0.8.7"])
   s.add_development_dependency("mocha",             [">= 0"])
   s.add_development_dependency("rcov",              [">= 0"])
+  s.add_development_dependency("redgreen",          [">= 0"])
+  s.add_development_dependency("wirble",            [">= 0"])
   s.add_development_dependency("cucumber",          [">= 0.7.2"])
   s.add_development_dependency("daemon_controller", [">= 0"])
 end

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/features/support/env.rb

@@ -40,7 +40,9 @@ def first_redis_configuration_client_pid
 end
 
 def system_notification_log_path
-  tmp_path + "/system_notifications.log"
+  log_path = tmp_path + "/system_notifications.log"
+  `touch #{log_path}` unless File.exists?(log_path)
+  log_path
 end
 
 def tmp_path

data/features/support/test_daemons/redis.conf.erb

@@ -185,5 +185,5 @@ glueoutputbuf yes
 # WARNING: object sharing is experimental, don't enable this feature
 # in production before of Redis 1.0-stable. Still please try this feature in
 # your development environment so that we can test it better.
-shareobjects no
-shareobjectspoolsize 1024
+# shareobjects no
+# shareobjectspoolsize 1024

data/lib/beetle/base.rb

@@ -53,7 +53,7 @@ module Beetle
       queues[name] ||=
         begin
           opts = @client.queues[name]
-          error("You are trying to bind a queue #{name} which is not configured!") unless opts
+          raise UnknownQueue.new("You are trying to bind a queue #{name} which is not configured!") unless opts
           logger.debug("Beetle: binding queue #{name} with internal name #{opts[:amqp_name]} on server #{@server}")
           queue_name = opts[:amqp_name]
           creation_options = opts.slice(*QUEUE_CREATION_KEYS)

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,24 +176,28 @@ 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 a list of messages (default to all registered messages).
+    # start listening to all registered queues. Calls #listen_queues internally
     # runs the given block before entering the eventmachine loop.
-    def listen(messages=self.messages.keys, &block)
-      messages = messages.map(&:to_s)
-      messages.each{|m| raise UnknownMessage.new("unknown message #{m}") unless self.messages.include?(m)}
-      subscriber.listen(messages, &block)
+    def listen(_deprecated_messages=nil, &block)
+      raise Error.new("Beetle::Client#listen no longer works with arguments. Please use #listen_queues(['queue1', 'queue2']) instead") if _deprecated_messages
+      listen_queues(&block)
+    end
+
+    # 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, &block)
+      queues = determine_queue_names(queues)
+      subscriber.listen_queues(queues, &block)
     end
 
     # stops the eventmachine loop
@@ -207,19 +210,32 @@ module Beetle
       publisher.stop
     end
 
-    # traces messages without consuming them. useful for debugging message flow.
-    def trace(messages=self.messages.keys, &block)
-      queues.each do |name, opts|
+    # 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)
+      queues_to_trace.each do |name, opts|
         opts.merge! :durable => false, :auto_delete => true, :amqp_name => queue_name_for_tracing(opts[:amqp_name])
       end
-      register_handler(queues.keys) do |msg|
+      register_handler(queue_names) do |msg|
         puts "-----===== new message =====-----"
         puts "SERVER: #{msg.server}"
         puts "HEADER: #{msg.header.inspect}"
         puts "MSGID: #{msg.msg_id}"
         puts "DATA: #{msg.data}"
       end
-      listen(messages, &block)
+      listen_queues(queue_names, &block)
     end
 
     # evaluate the ruby files matching the given +glob+ pattern in the context of the client instance.
@@ -232,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,34 +12,46 @@ module Beetle
       @handlers = {}
       @amqp_connections = {}
       @mqs = {}
+      @subscriptions = {}
     end
 
-    # 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:
+    # the client calls this method to subscribe to a list of queues.
+    # this method does the following things:
     #
-    # * creates all exchanges which have been registered for the given messages
-    # * creates and binds queues which have been registered for the exchanges
+    # * creates all exchanges which have been registered for the given queues
+    # * creates and binds each listed queue queues
     # * subscribes the handlers for all these queues
     #
     # yields before entering the eventmachine loop (if a block was given)
-    def listen(messages) #:nodoc:
+    def listen_queues(queues) #:nodoc:
       EM.run do
-        exchanges = exchanges_for_messages(messages)
+        exchanges = exchanges_for_queues(queues)
         create_exchanges(exchanges)
-        queues = queues_for_exchanges(exchanges)
         bind_queues(queues)
         subscribe_queues(queues)
         yield if block_given?
       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:
       if @amqp_connections.empty?
         EM.stop_event_loop
       else
         server, connection = @amqp_connections.shift
+        logger.debug "Beetle: closing connection to #{server}"
         connection.close { stop! }
       end
     end
@@ -53,8 +65,8 @@ module Beetle
 
     private
 
-    def exchanges_for_messages(messages)
-      @client.messages.slice(*messages).map{|_, opts| opts[:exchange]}.uniq
+    def exchanges_for_queues(queues)
+      @client.bindings.slice(*queues).map{|_, opts| opts.map{|opt| opt[:exchange]}}.flatten.uniq
     end
 
     def queues_for_exchanges(exchanges)
@@ -88,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)
@@ -121,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
@@ -146,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,8 +1,10 @@
 $:.unshift(File.expand_path('..', __FILE__))
-require 'bunny-ext'
+require 'bunny'
 require 'uuid4r'
 require 'active_support'
+require 'active_support/core_ext'
 require 'redis'
+require 'set'
 
 module Beetle
 

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")
@@ -261,18 +269,36 @@ module Beetle
 
     test "should delegate listening to the subscriber instance" do
       client = Client.new
-      client.register_queue(:a)
-      client.register_message(:a)
-      client.register_queue(:b)
-      client.register_message(:b)
-      client.send(:subscriber).expects(:listen).with(["a", "b"]).yields
-      x = 0
-      client.listen([:a, "b"]) { x = 5 }
-      assert_equal 5, x
+      client.register_queue("b_queue")
+      client.register_queue("a_queue")
+      client.send(:subscriber).expects(:listen_queues).with {|value| value.include?("a_queue") && value.include?("b_queue")}.yields
+      client.listen
+    end
+
+    test "trying to listen to a message is no longer supported and should raise an exception" do
+      assert_raises(Error) { Client.new.listen([:a])}
+    end
+
+    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.listen_queues([:test])
     end
 
-    test "trying to listen to an unknown message should raise an exception" do
-      assert_raises(UnknownMessage) { Client.new.listen([:a])}
+    test "trying to listen to an unknown queue should raise an exception" do
+      client = Client.new
+      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
@@ -281,6 +307,20 @@ module Beetle
       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")
@@ -314,7 +354,7 @@ module Beetle
       client.register_queue("test")
       sub = client.send(:subscriber)
       sub.expects(:register_handler).with(client.queues.keys, {}, nil).yields(stub_everything("message"))
-      sub.expects(:listen)
+      sub.expects(:listen_queues)
       client.stubs(:puts)
       client.trace
       test_queue_opts = client.queues["test"]
@@ -324,5 +364,16 @@ module Beetle
       assert !test_queue_opts[:durable]
     end
 
+    test "limiting tracing to some queues" do
+      client = Client.new
+      client.register_queue("test")
+      client.register_queue("irrelevant")
+      sub = client.send(:subscriber)
+      sub.expects(:register_handler).with(["test"], {}, nil).yields(stub_everything("message"))
+      sub.expects(:listen_queues).with(["test"])
+      client.stubs(:puts)
+      client.trace(["test"])
+    end
+
   end
 end

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,24 +310,30 @@ 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 "listening should use eventmachine. create exchanges. bind queues. install subscribers. and yield." do
-      @client.register_queue(:a)
-      @client.register_message(:a)
+    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)
+
       EM.expects(:run).yields
-      @sub.expects(:create_exchanges).with(["a"])
-      @sub.expects(:bind_queues).with(["a"])
-      @sub.expects(:subscribe_queues).with(["a"])
-      @sub.listen(["a"]) {}
+      @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"]) {}
     end
   end
 

data/test/test_helper.rb

@@ -1,10 +1,13 @@
 require 'rubygems'
-require 'active_support'
-require 'active_support/testing/declarative'
 require 'test/unit'
+require 'mocha'
+require 'active_support/testing/declarative'
+
+require File.expand_path(File.dirname(__FILE__) + '/../lib/beetle')
+
 begin
   require 'redgreen' unless ENV['TM_FILENAME']
-rescue MissingSourceFile
+rescue LoadError => e
 end
 
 # we can remove this hack which is needed only for testing
@@ -17,8 +20,6 @@ rescue LoadError
   end
 end
 
-require 'mocha'
-require File.expand_path(File.dirname(__FILE__) + '/../lib/beetle')
 
 class Test::Unit::TestCase
   extend ActiveSupport::Testing::Declarative

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: beetle
 version: !ruby/object:Gem::Version 
-  hash: 1
-  prerelease: false
+  hash: 15424039
+  prerelease: 6
   segments: 
   - 0
-  - 2
-  - 11
-  version: 0.2.11
+  - 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-02-15 00:00:00 +01:00
+date: 2011-08-27 00:00:00 +02:00
 default_executable: beetle
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,12 +31,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 25
+        hash: 31
         segments: 
         - 0
         - 1
-        - 1
-        version: 0.1.1
+        - 2
+        version: 0.1.2
   type: :runtime
   version_requirements: *id001
 - !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,14 +70,14 @@ 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: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         hash: 9
         segments: 
@@ -100,14 +86,14 @@ 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: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
         hash: 11
         segments: 
@@ -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,6 +118,22 @@ dependencies:
         - 10
         version: 1.0.10
   type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
   version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: mocha
@@ -162,9 +164,37 @@ dependencies:
   type: :development
   version_requirements: *id009
 - !ruby/object:Gem::Dependency 
-  name: cucumber
+  name: redgreen
   prerelease: false
   requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id010
+- !ruby/object:Gem::Dependency 
+  name: wirble
+  prerelease: false
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id011
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id012 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -176,11 +206,11 @@ dependencies:
         - 2
         version: 0.7.2
   type: :development
-  version_requirements: *id010
+  version_requirements: *id012
 - !ruby/object:Gem::Dependency 
   name: daemon_controller
   prerelease: false
-  requirement: &id011 !ruby/object:Gem::Requirement 
+  requirement: &id013 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -190,7 +220,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id011
+  version_requirements: *id013
 description: A highly available, reliable messaging infrastructure
 email: developers@xing.com
 executables: 
@@ -210,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
@@ -290,16 +322,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 25
+      hash: 21
       segments: 
       - 1
       - 3
-      - 1
-      version: 1.3.1
+      - 7
+      version: 1.3.7
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: High Availability AMQP Messaging with Redundant Queues