right_amqp 0.6.1 → 0.7.0

data/lib/right_amqp/ha_client/broker_client.rb

@@ -334,6 +334,38 @@ module RightAMQP
       end
     end
 
+    # Check status of specified queues
+    # Silently ignore unknown queues
+    # If a queue whose status is being checked does not exist in the broker,
+    # this broker connection will fail and become unusable
+    #
+    # === Parameters
+    # queue_names(Array):: Names of queues previously subscribed to
+    #
+    # === Block
+    # Optional block to be called each time that status for a queue is retrieved with
+    # parameters queue name, message count, and consumer count; the counts are nil
+    # if there was a failure while trying to retrieve them; the block is not called
+    # for queues to which this client is not currently subscribed
+    #
+    # === Return
+    # (Boolean):: true if connected, otherwise false, in which case block never gets called
+    def queue_status(queue_names, &block)
+      return false unless connected?
+      @queues.each do |q|
+        if queue_names.include?(q.name)
+          begin
+            q.status { |messages, consumers| block.call(q.name, messages, consumers) if block }
+          rescue Exception => e
+            logger.exception("Failed checking status of queue #{q.name} on broker #{@alias}", e, :trace)
+            @exception_stats.track("queue_status", e)
+            block.call(q.name, nil, nil) if block
+          end
+        end
+      end
+      true
+    end
+
     # Publish message to AMQP exchange
     #
     # === Parameters

data/lib/right_amqp/ha_client/ha_broker_client.rb

@@ -352,7 +352,7 @@ module RightAMQP
     # === Return
     # (Array):: Serialized identity of usable brokers
     def usable
-      each_usable.map { |b| b.identity }
+      each(:usable).map { |b| b.identity }
     end
 
     # Get serialized identity of unusable brokers
@@ -490,9 +490,9 @@ module RightAMQP
     def subscribe(queue, exchange = nil, options = {}, &blk)
       identities = []
       brokers = options.delete(:brokers)
-      each_usable(brokers) { |b| identities << b.identity if b.subscribe(queue, exchange, options, &blk) }
+      each(:usable, brokers) { |b| identities << b.identity if b.subscribe(queue, exchange, options, &blk) }
       logger.info("Could not subscribe to queue #{queue.inspect} on exchange #{exchange.inspect} " +
-                  "on brokers #{each_usable(brokers).inspect} when selected #{brokers.inspect} " +
+                  "on brokers #{each(:usable, brokers).inspect} when selected #{brokers.inspect} " +
                   "from usable #{usable.inspect}") if identities.empty?
       identities
     end
@@ -510,7 +510,7 @@ module RightAMQP
     # === Return
     # true:: Always return true
     def unsubscribe(queue_names, timeout = nil, &blk)
-      count = each_usable.inject(0) do |c, b|
+      count = each(:usable).inject(0) do |c, b|
         c + b.queues.inject(0) { |c, q| c + (queue_names.include?(q.name) ? 1 : 0) }
       end
       if count == 0
@@ -518,7 +518,7 @@ module RightAMQP
       else
         handler = CountedDeferrable.new(count, timeout)
         handler.callback { blk.call if blk }
-        each_usable { |b| b.unsubscribe(queue_names) { handler.completed_one } }
+        each(:usable) { |b| b.unsubscribe(queue_names) { handler.completed_one } }
       end
       true
     end
@@ -536,12 +536,51 @@ module RightAMQP
     def declare(type, name, options = {})
       identities = []
       brokers = options.delete(:brokers)
-      each_usable(brokers) { |b| identities << b.identity if b.declare(type, name, options) }
-      logger.info("Could not declare #{type.to_s} #{name.inspect} on brokers #{each_usable(brokers).inspect} " +
+      each(:usable, brokers) { |b| identities << b.identity if b.declare(type, name, options) }
+      logger.info("Could not declare #{type.to_s} #{name.inspect} on brokers #{each(:usable, brokers).inspect} " +
                   "when selected #{brokers.inspect} from usable #{usable.inspect}") if identities.empty?
       identities
     end
 
+    # Check status of specified queues for connected brokers
+    # Silently ignore unknown queues
+    # If a queue whose status is being checked does not exist,
+    # the associated broker connection will fail and be unusable
+    #
+    # === Parameters
+    # queue_names(Array):: Names of queues previously subscribed to that are to be checked
+    # timeout(Integer):: Number of seconds to wait for all status checks, defaults to no timeout
+    #
+    # === Block
+    # Optional block to be called after all queue statuses are obtained with hash parameter
+    # containing statuses with queue name as key and value that is a hash with broker identity
+    # as key and hash of :messages and :consumers as value; the :messages and :consumers
+    # values are nil if there is a failure retrieving them for the given queue
+    #
+    # === Return
+    # true:: Always return true
+    def queue_status(queue_names, timeout = nil, &blk)
+      count = 0
+      status = {}
+      each(:connected) { |b| b.queues.each { |q| count += 1 if queue_names.include?(q.name) } }
+      if count == 0
+        blk.call(status) if blk
+      else
+        handler = CountedDeferrable.new(count, timeout)
+        handler.callback { blk.call(status) if blk }
+        each(:connected) do |b|
+          if b.queue_status(queue_names) do |name, messages, consumers|
+               (status[name] ||= {})[b.identity] = {:messages => messages, :consumers => consumers}
+               handler.completed_one
+             end
+           else
+             b.queues.each { |q| handler.completed_one if queue_names.include?(q.name) }
+           end
+        end
+      end
+      true
+    end
+
     # Publish message to AMQP exchange of first connected broker
     #
     # === Parameters
@@ -559,7 +598,7 @@ module RightAMQP
     #   :immediate(Boolean):: Return message for the same reasons as :mandatory plus if all
     #     of the queues associated with the exchange are not immediately ready to consume the message
     #   :fanout(Boolean):: true means publish to all connected brokers
-    #   :brokers(Array):: Identity of brokers selected for use, defaults to all home brokers
+    #   :brokers(Array):: Identity of brokers selected for use, defaults to all brokers
     #     if nil or empty
     #   :order(Symbol):: Broker selection order: :random or :priority,
     #     defaults to @select if :brokers is nil, otherwise defaults to :priority
@@ -881,25 +920,26 @@ module RightAMQP
       bytes.unpack('H*')[0]
     end
 
-    # Iterate over clients that are usable, i.e., connecting or confirmed connected
+    # Iterate over clients that have the specified status
     #
     # === Parameters
+    # status(String):: Status for selecting: :usable, :connected, :failed
     # identities(Array):: Identity of brokers to be considered, nil or empty array means all brokers
     #
     # === Block
-    # Optional block with following parameters to be called for each usable broker client
+    # Optional block with following parameters to be called for each broker client selected
     #   broker(BrokerClient):: Broker client
     #
     # === Return
-    # (Array):: Usable broker clients
-    def each_usable(identities = nil)
+    # (Array):: Selected broker clients
+    def each(status, identities = nil)
       choices = if identities && !identities.empty?
-        choices = identities.inject([]) { |c, i| if b = @brokers_hash[i] then c << b else c end }
+        identities.inject([]) { |c, i| if b = @brokers_hash[i] then c << b else c end }
       else
         @brokers
       end
       choices.select do |b|
-        if b.usable?
+        if b.send("#{status}?".to_sym)
           yield(b) if block_given?
           true
         end
@@ -910,7 +950,7 @@ module RightAMQP
     #
     # === Parameters
     # options(Hash):: Selection options:
-    #   :brokers(Array):: Identity of brokers selected for use, defaults to all home brokers if nil or empty
+    #   :brokers(Array):: Identity of brokers selected for use, defaults to all brokers if nil or empty
     #   :order(Symbol):: Broker selection order: :random or :priority,
     #     defaults to @select if :brokers is nil, otherwise defaults to :priority
     #
@@ -968,18 +1008,18 @@ module RightAMQP
           update = if v[:boundary] == :all
             if b.size < n && a.size == n
               :connected
-            elsif b.size == n && a.size < n
-              :disconnected
             elsif (f - failed).empty?
               :failed
+            elsif b.size == n && a.size < n
+              :disconnected
             end
           else
             if b.size == 0 && a.size > 0
               :connected
-            elsif b.size > 0 && a.size == 0
-              :disconnected
             elsif (f - failed).empty?
               :failed
+            elsif b.size > 0 && a.size == 0
+              :disconnected
             end
           end
           if update

data/right_amqp.gemspec

@@ -24,8 +24,8 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name      = 'right_amqp'
-  spec.version   = '0.6.1'
-  spec.date      = '2013-07-23'
+  spec.version   = '0.7.0'
+  spec.date      = '2013-08-04'
   spec.authors   = ['Lee Kirchhoff']
   spec.email     = 'lee@rightscale.com'
   spec.homepage  = 'https://github.com/rightscale/right_amqp'

data/spec/ha_client/broker_client_spec.rb

@@ -577,6 +577,58 @@ describe RightAMQP::BrokerClient do
 
   end # when declaring
 
+  context "when checking status" do
+
+    before(:each) do
+      @direct = flexmock("direct")
+      @bind = flexmock("bind", :subscribe => true)
+      @queue = flexmock("queue", :bind => @bind, :name => "queue1")
+      @channel.should_receive(:queue).and_return(@queue).by_default
+      @channel.should_receive(:direct).and_return(@direct).by_default
+      flexmock(MQ).should_receive(:new).with(@connection).and_return(@channel).by_default
+      @broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      @broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"}) {|_, _|}
+      @broker.send(:update_status, :ready)
+    end
+
+    it "should return false if client not connected" do
+      @broker.send(:update_status, :disconnected)
+      @broker.queue_status(["queue1"]).should be_false
+    end
+
+    it "should request the status of each queue and pass it to the supplied block" do
+      @queue.should_receive(:status).and_yield(1, 2).once
+      called = 0
+      @broker.queue_status(["queue1"]) do |name, messages, consumers|
+        name.should == "queue1"
+        messages.should == 1
+        consumers.should == 2
+        called += 1
+      end.should be_true
+      called.should == 1
+    end
+
+    it "should not require a block" do
+      @queue.should_receive(:status).once
+      @broker.queue_status(["queue1"]).should be_true
+    end
+
+    it "should log unexpected exceptions and call block with nil status" do
+      @logger.should_receive(:error).with(/Failed checking status of queue/).once
+      @exceptions.should_receive(:track).once
+      @queue.should_receive(:status).and_raise(Exception).once
+      called = 0
+      @broker.queue_status(["queue1"]) do |name, messages, consumers|
+        name.should == "queue1"
+        messages.should be_nil
+        consumers.should be_nil
+        called += 1
+      end.should be_true
+      called.should == 1
+    end
+
+  end # when checking status
+
   context "when publishing" do
 
     before(:each) do

data/spec/ha_client/ha_broker_client_spec.rb

@@ -20,6 +20,8 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+require 'json'
+
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'right_amqp'))
 
@@ -679,6 +681,59 @@ describe RightAMQP::HABrokerClient do
 
     end # declaring
 
+    context "checking status" do
+
+      before(:each) do
+        @timeout = 10
+        @timer = flexmock("timer", :cancel => true).by_default
+        flexmock(EM::Timer).should_receive(:new).with(@timeout, Proc).and_return(@timer).by_default
+        @queue_name = "my_queue"
+        @queue = flexmock("queue", :name => @queue_name)
+        @queues = [@queue]
+        @broker1.should_receive(:queues).and_return(@queues).by_default
+        @broker1.should_receive(:connected?).and_return(true).by_default
+        @broker1.should_receive(:queue_status).and_return(true).by_default
+        @broker2.should_receive(:queues).and_return(@queues).by_default
+        @broker2.should_receive(:connected?).and_return(true).by_default
+        @broker2.should_receive(:queue_status).and_return(true).by_default
+        @ha = RightAMQP::HABrokerClient.new(@serializer, :host => "first, second")
+      end
+
+      it "should not check status if there are no queues" do
+        @ha.queue_status([]).should be_true
+      end
+
+      it "should make block call with empty status if there are no queues" do
+        called = 0
+        @ha.queue_status(["my_other_queue"], @timeout) { |status| status.should == {}; called += 1 }.should be_true
+        called.should == 1
+      end
+
+      it "should wait to make callback until the status of all queues is obtained" do
+        @broker1.should_receive(:queue_status).with([@queue_name], Proc).and_return(true).and_yield(@queue_name, 0, 1).once
+        @broker2.should_receive(:queue_status).with([@queue_name], Proc).and_return(true).and_yield(@queue_name, 1, 2).once
+        called = 0
+        @ha.queue_status([@queue_name], @timeout) do |status|
+          status.should == {@queue_name => {@broker1.identity => {:messages => 0, :consumers => 1},
+                                            @broker2.identity => {:messages => 1, :consumers => 2}}}
+          called += 1
+        end.should be_true
+        called.should == 1
+      end
+
+      it "should account for queues for which status cannot be obtained" do
+        called = 0
+        @broker1.should_receive(:queue_status).with([@queue_name], Proc).and_return(false).once
+        @broker2.should_receive(:queue_status).with([@queue_name], Proc).and_return(true).and_yield(@queue_name, 1, 2).once
+        @ha.queue_status([@queue_name], @timeout) do |status|
+          status.should == {@queue_name => {@broker2.identity => {:messages => 1, :consumers => 2}}}
+          called += 1
+        end.should be_true
+        called.should == 1
+      end
+
+    end # checking status
+
     context "publishing" do
 
       before(:each) do
@@ -987,24 +1042,39 @@ describe RightAMQP::HABrokerClient do
         @broker3.should_receive(:failed?).and_return(false).by_default
       end
 
-      it "should give access to or list usable brokers" do
-        ha = RightAMQP::HABrokerClient.new(@serializer, :host => "first, second, third")
-        aliases = []
-        res = ha.__send__(:each_usable) { |b| aliases << b.alias }
-        aliases.should == ["b0", "b1", "b2"]
-        res.size.should == 3
-        res[0].alias.should == "b0"
-        res[1].alias.should == "b1"
-        res[2].alias.should == "b2"
+      [:usable, :connected].each do |status|
+        status_query = "#{status}?".to_sym
 
-        @broker1.should_receive(:usable?).and_return(true)
-        @broker2.should_receive(:usable?).and_return(false)
-        @broker3.should_receive(:usable?).and_return(false)
-        aliases = []
-        res = ha.__send__(:each_usable) { |b| aliases << b.alias }
-        aliases.should == ["b0"]
-        res.size.should == 1
-        res[0].alias.should == "b0"
+        it "should give access to or list #{status} brokers" do
+          ha = RightAMQP::HABrokerClient.new(@serializer, :host => "first, second, third")
+          aliases = []
+          res = ha.__send__(:each, status) { |b| aliases << b.alias }
+          aliases.should == ["b0", "b1", "b2"]
+          res.size.should == 3
+          res[0].alias.should == "b0"
+          res[1].alias.should == "b1"
+          res[2].alias.should == "b2"
+
+          @broker1.should_receive(status_query).and_return(true)
+          @broker2.should_receive(status_query).and_return(false)
+          @broker3.should_receive(status_query).and_return(false)
+          aliases = []
+          res = ha.__send__(:each, status) { |b| aliases << b.alias }
+          aliases.should == ["b0"]
+          res.size.should == 1
+          res[0].alias.should == "b0"
+        end
+
+        it "should give access to each selected #{status} broker" do
+          ha = RightAMQP::HABrokerClient.new(@serializer, :host => "first, second, third")
+          @broker2.should_receive(status_query).and_return(true)
+          @broker3.should_receive(status_query).and_return(false)
+          aliases = []
+          res = ha.__send__(:each, status, [@identity2, @identity3]) { |b| aliases << b.alias }
+          aliases.should == ["b1"]
+          res.size.should == 1
+          res[0].alias.should == "b1"
+        end
       end
 
       it "should give list of unusable brokers" do
@@ -1015,17 +1085,6 @@ describe RightAMQP::HABrokerClient do
         ha.unusable.should == [@identity2, @identity3]
       end
 
-      it "should give access to each selected usable broker" do
-        ha = RightAMQP::HABrokerClient.new(@serializer, :host => "first, second, third")
-        @broker2.should_receive(:usable?).and_return(true)
-        @broker3.should_receive(:usable?).and_return(false)
-        aliases = []
-        res = ha.__send__(:each_usable, [@identity2, @identity3]) { |b| aliases << b.alias }
-        aliases.should == ["b1"]
-        res.size.should == 1
-        res[0].alias.should == "b1"
-      end
-
       it "should tell whether a broker is connected" do
         ha = RightAMQP::HABrokerClient.new(@serializer, :host => "first, second, third")
         @broker2.should_receive(:connected?).and_return(false)
@@ -1233,11 +1292,68 @@ describe RightAMQP::HABrokerClient do
         ha.__send__(:update_status, @broker, false)
         @broker.should_receive(:status).and_return(:disconnected)
         @broker.should_receive(:connected?).and_return(false)
+        @broker.should_receive(:failed?).and_return(false)
         ha.__send__(:update_status, @broker, true)
         called1.should == 1
         called2.should == 2
       end
 
+      it "should provide failed connection status callback when all broker connections fail with :any option" do
+        ha = RightAMQP::HABrokerClient.new(@serializer, :host => "first, second")
+        connected = disconnected = failed = 0
+        ha.connection_status(:boundary => :any) do |status|
+          if status == :connected
+            connected += 1
+          elsif status == :disconnected
+            disconnected += 1
+          elsif status == :failed
+            (ha.brokers[0].failed? &&
+             ha.brokers[1].failed?).should be_true
+            failed += 1
+          end
+        end
+        @broker2.should_receive(:failed?).and_return(true)
+        @broker2.should_receive(:connected?).and_return(false)
+        ha.__send__(:update_status, @broker2, true)
+        connected.should == 0
+        disconnected.should == 0
+        failed.should == 0
+        @broker1.should_receive(:failed?).and_return(true)
+        @broker1.should_receive(:connected?).and_return(false)
+        ha.__send__(:update_status, @broker1, true)
+        connected.should == 0
+        disconnected.should == 0
+        failed.should == 1
+      end
+
+      it "should provide failed connection status callback when all broker connections fail with :all option" do
+        ha = RightAMQP::HABrokerClient.new(@serializer, :host => "first, second")
+        connected = disconnected = failed = 0
+        ha.connection_status(:boundary => :all) do |status|
+          if status == :connected
+            connected += 1
+          elsif status == :disconnected
+            disconnected += 1
+          elsif status == :failed
+            (ha.brokers[0].failed? &&
+             ha.brokers[1].failed?).should be_true
+            failed += 1
+          end
+        end
+        @broker2.should_receive(:failed?).and_return(true)
+        @broker2.should_receive(:connected?).and_return(false)
+        ha.__send__(:update_status, @broker2, true)
+        connected.should == 0
+        disconnected.should == 1
+        failed.should == 0
+        @broker1.should_receive(:failed?).and_return(true)
+        @broker1.should_receive(:connected?).and_return(false)
+        ha.__send__(:update_status, @broker1, true)
+        connected.should == 0
+        disconnected.should == 1
+        failed.should == 1
+      end
+
       it "should provide failed connection status callback when all brokers fail to connect" do
         ha = RightAMQP::HABrokerClient.new(@serializer, :host => "first, second, third")
         connected = disconnected = failed = 0

metadata

@@ -1,87 +1,70 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: right_amqp
-version: !ruby/object:Gem::Version 
-  hash: 5
-  prerelease: false
-  segments: 
-  - 0
-  - 6
-  - 1
-  version: 0.6.1
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Lee Kirchhoff
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-07-23 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+date: 2013-08-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: right_support
+  requirement: &2157007400 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 1
-        - 2
-        version: "1.2"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
     - - <
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 3
-        - 0
-        version: "3.0"
-  requirement: *id001
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
-  name: right_support
   prerelease: false
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2157007400
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &2156993280 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 59
-        segments: 
-        - 0
-        - 12
-        - 10
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.12.10
     - - <
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 2
-        - 0
-        version: "2.0"
-  requirement: *id002
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
-  name: eventmachine
   prerelease: false
-description: |
-  RightAMQP provides a high availability client for interfacing with the
+  version_requirements: *2156993280
+description: ! 'RightAMQP provides a high availability client for interfacing with
+  the
+
   RightScale RabbitMQ broker using the AMQP protocol. The AMQP version on which
+
   this gem is based is 0.6.7 but beyond that it contains a number of bug fixes and
+
   enhancements including reconnect, message return, heartbeat, and UTF-8 support.
+
   The high availability is achieved by maintaining multiple broker connections
+
   such that failed connections automatically reconnect and only connected
+
   brokers are used when routing a message. Although the HABrokerClient class
+
   is the intended primary means for accessing RabbitMQ services with this gem,
+
   alternatively the underlying AMQP services may be used directly.
 
+'
 email: lee@rightscale.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
-files: 
+files:
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -112,44 +95,35 @@ files:
 - spec/ha_client/ha_broker_client_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: https://github.com/rightscale/right_amqp
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.rdoc
 - --title
 - RightAMQP
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 57
-      segments: 
-      - 1
-      - 8
-      - 7
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
+      hash: -2424550966493205520
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Client for interfacing to RightScale RabbitMQ broker using AMQP
 test_files: []
-