beetle 0.2.9.11 → 0.2.12

data/beetle.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name    = "beetle"
-  s.version = "0.2.9.11"
+  s.version = "0.2.12"
   s.required_rubygems_version = ">= 1.3.1"
   s.authors            = ["Stefan Kaes", "Pascal Friederich", "Ali Jelveh", "Sebastian Roebke"]
   s.date               = Time.now.strftime('%Y-%m-%d')

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

@@ -66,7 +66,7 @@ module Beetle
     def register_exchange(name, options={})
       name = name.to_s
       raise ConfigurationError.new("exchange #{name} already configured") if exchanges.include?(name)
-      exchanges[name] = options.symbolize_keys.merge(:type => :topic, :durable => true)
+      exchanges[name] = options.symbolize_keys.merge(:type => :topic, :durable => true, :queues => [])
     end
 
     # register a durable, non passive, non auto_deleted queue with the given _name_ and an _options_ hash:
@@ -101,7 +101,7 @@ module Beetle
       key = (opts[:key] || name).to_s
       (bindings[name] ||= []) << {:exchange => exchange, :key => key}
       register_exchange(exchange) unless exchanges.include?(exchange)
-      queues = (exchanges[exchange][:queues] ||= [])
+      queues = exchanges[exchange][:queues]
       queues << name unless queues.include?(name)
     end
 
@@ -189,12 +189,17 @@ module Beetle
       publisher.purge(queue_name)
     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=self.queues.keys, &block)
+      subscriber.listen_queues(queues, &block)
     end
 
     # stops the eventmachine loop
@@ -207,19 +212,20 @@ 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|
+    # 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.

data/lib/beetle/subscriber.rb

@@ -14,26 +14,25 @@ module Beetle
       @mqs = {}
     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
 
+
     # closes all AMQP connections and stops the eventmachine loop
     def stop! #:nodoc:
       if @amqp_connections.empty?
@@ -53,6 +52,10 @@ module Beetle
 
     private
 
+    def exchanges_for_queues(queues)
+      @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

data/lib/beetle.rb

@@ -2,6 +2,7 @@ $:.unshift(File.expand_path('..', __FILE__))
 require 'bunny-ext'
 require 'uuid4r'
 require 'active_support'
+require 'active_support/core_ext'
 require 'redis'
 
 module Beetle

data/test/beetle/client_test.rb

@@ -40,7 +40,7 @@ module Beetle
     test "registering an exchange should store it in the configuration with symbolized option keys and force a topic queue and durability" do
       opts = {"durable" => false, "type" => "fanout"}
       @client.register_exchange("some_exchange", opts)
-      assert_equal({:durable => true, :type => :topic}, @client.exchanges["some_exchange"])
+      assert_equal({:durable => true, :type => :topic, :queues => []}, @client.exchanges["some_exchange"])
     end
 
     test "should convert exchange name to a string when registering an exchange" do
@@ -53,6 +53,12 @@ module Beetle
       assert_raises(ConfigurationError){ @client.register_exchange("some_exchange") }
     end
 
+    test "registering an exchange should initialize the list of queues bound to it" do
+      @client.register_exchange("some_exchange")
+      assert_equal [], @client.exchanges["some_exchange"][:queues]
+      assert_raises(ConfigurationError){ @client.register_exchange("some_exchange") }
+    end
+
     test "registering a queue should automatically register the corresponding exchange if it doesn't exist yet" do
       @client.register_queue("some_queue", "durable" => false, "exchange" => "some_exchange")
       assert @client.exchanges.include?("some_exchange")
@@ -119,14 +125,14 @@ module Beetle
     test "registering a message should register a corresponding exchange if it hasn't been registered yet" do
       opts = { "exchange" => "some_exchange" }
       @client.register_message("some_message", opts)
-      assert_equal({:durable => true, :type => :topic}, @client.exchanges["some_exchange"])
+      assert_equal({:durable => true, :type => :topic, :queues => []}, @client.exchanges["some_exchange"])
     end
 
     test "registering a message should not fail if the exchange has already been registered" do
       opts = { "exchange" => "some_exchange" }
       @client.register_exchange("some_exchange")
       @client.register_message("some_message", opts)
-      assert_equal({:durable => true, :type => :topic}, @client.exchanges["some_exchange"])
+      assert_equal({:durable => true, :type => :topic, :queues => []}, @client.exchanges["some_exchange"])
     end
 
     test "should convert message name to a string when registering a message" do
@@ -255,18 +261,26 @@ 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 "should delegate stop_listening to the subscriber instance" do
@@ -308,7 +322,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"]
@@ -318,5 +332,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/publisher_test.rb

@@ -290,7 +290,7 @@ module Beetle
 
     test "accessing a given exchange should create it using the config. further access should return the created exchange" do
       m = mock("Bunny")
-      m.expects(:exchange).with("some_exchange", :type => :topic, :durable => true).returns(42)
+      m.expects(:exchange).with("some_exchange", :type => :topic, :durable => true, :queues => []).returns(42)
       @client.register_exchange("some_exchange", :type => :topic, :durable => true)
       @pub.expects(:bunny).returns(m)
       ex  = @pub.send(:exchange, "some_exchange")

data/test/beetle/subscriber_test.rb

@@ -249,14 +249,16 @@ module Beetle
       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 "listeninging 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
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: beetle
 version: !ruby/object:Gem::Version 
-  hash: 109
+  hash: 15
   prerelease: false
   segments: 
   - 0
   - 2
-  - 9
-  - 11
-  version: 0.2.9.11
+  - 12
+  version: 0.2.12
 platform: ruby
 authors: 
 - Stefan Kaes
@@ -19,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-27 00:00:00 +01:00
+date: 2011-02-17 00:00:00 +01:00
 default_executable: beetle
 dependencies: 
 - !ruby/object:Gem::Dependency