right_agent 0.5.1 → 0.5.10

data/lib/right_agent/command/agent_manager_commands.rb

@@ -34,6 +34,7 @@ module RightScale
       :get_log_level    => 'Get log level',
       :ping             => 'Ping agent',
       :stats            => 'Get statistics about agent operation',
+      :profile          => 'Manage memory profiling',
       :terminate        => 'Terminate agent'
     }
 
@@ -117,6 +118,21 @@ module RightScale
       CommandIO.instance.reply(opts[:conn], @serializer.dump(@agent_manager.stats({:reset => opts[:reset]})))
     end
 
+    # Profile command
+    #
+    # === Parameters
+    # opts[:conn](EM::Connection):: Connection used to send reply
+    # opts[:start](Boolean):: Whether to start profiling
+    # opts[:stats](Boolean):: Whether to display profile statistics to stdout
+    # opts[:reset](Boolean):: Whether to reset profile statistics when after displaying them
+    # opts[:stop](Boolean):: Whether to stop profiling
+    #
+    # === Return
+    # true
+    def profile_command(opts)
+      CommandIO.instance.reply(opts[:conn], @serializer.dump(@agent_manager.profile(opts)))
+    end
+
     # Terminate command
     #
     # === Parameters

data/lib/right_agent/command/command_constants.rb

@@ -29,14 +29,5 @@ module RightScale
     BASE_INSTANCE_AGENT_SOCKET_PORT         = 60000
     BASE_INSTANCE_AGENT_CHECKER_SOCKET_PORT = 61000
 
-    BASE_CORE_AGENT_SOCKET_PORT             = 70000
-    BASE_LABORER_AGENT_SOCKET_PORT          = 71000
-    BASE_REPLICANT_AGENT_SOCKET_PORT        = 72000
-    BASE_PROXY_AGENT_SOCKET_PORT            = 73000
-    BASE_LIBRARY_AGENT_SOCKET_PORT          = 74000
-    BASE_WASABI_AGENT_SOCKET_PORT           = 75000
-
-    BASE_MAPPER_SOCKET_PORT                 = 79000
-
   end
 end

data/lib/right_agent/dispatcher.rb

@@ -27,6 +27,9 @@ module RightScale
 
     include StatsHelper
 
+    # Response queue name
+    RESPONSE_QUEUE = "response"
+
     # Cache for requests that have been dispatched recently
     # This cache is intended for use in checking for duplicate requests
     class Dispatched
@@ -50,7 +53,7 @@ module RightScale
       # === Return
       # true:: Always return true
       def store(token)
-        now ||= Time.now.to_i
+        now = Time.now.to_i
         if @cache.has_key?(token)
           @cache[token] = now
           @lru.push(@lru.delete(token))
@@ -180,7 +183,7 @@ module RightScale
             OperationResult.non_delivery(OperationResult::TTL_EXPIRATION)
           end
           result = Result.new(token, request.reply_to, non_delivery, @identity, request.from, request.tries, request.persistent)
-          exchange = {:type => :queue, :name => request.reply_to, :options => {:durable => true, :no_declare => @secure}}
+          exchange = {:type => :queue, :name => RESPONSE_QUEUE, :options => {:durable => true, :no_declare => @secure}}
           @broker.publish(exchange, result, :persistent => true, :mandatory => true)
         end
         return nil
@@ -222,7 +225,7 @@ module RightScale
           if request.kind_of?(Request)
             duration = @requests.finish(received_at, token)
             r = Result.new(token, request.reply_to, r, @identity, request.from, request.tries, request.persistent, duration)
-            exchange = {:type => :queue, :name => request.reply_to, :options => {:durable => true, :no_declare => @secure}}
+            exchange = {:type => :queue, :name => RESPONSE_QUEUE, :options => {:durable => true, :no_declare => @secure}}
             @broker.publish(exchange, r, :persistent => true, :mandatory => true, :log_filter => [:tries, :persistent, :duration])
           end
         rescue HABrokerClient::NoConnectedBrokers => e

data/lib/right_agent/ha_broker_client.rb

@@ -109,6 +109,8 @@ module RightScale
     #   :vhost(String):: Virtual host path name
     #   :insist(Boolean):: Whether to suppress redirection of connection
     #   :reconnect_interval(Integer):: Number of seconds between reconnect attempts, defaults to RECONNECT_INTERVAL
+    #   :heartbeat(Integer):: Number of seconds between AMQP connection heartbeats used to keep
+    #     connection alive (e.g., when AMQP broker is behind a firewall), nil or 0 means disable
     #   :host{String):: Comma-separated list of AMQP broker host names; if only one, it is reapplied
     #     to successive ports; if none, defaults to localhost; each host may be followed by ':'
     #     and a short string to be used as a broker index; the index defaults to the list index,
@@ -425,6 +427,18 @@ module RightScale
       @brokers.inject([]) { |c, b| b.failed? ? c << b.identity : c }
     end
 
+    # Change connection heartbeat frequency to be used for any new connections
+    #
+    # === Parameters
+    # heartbeat(Integer):: Number of seconds between AMQP connection heartbeats used to keep
+    #   connection alive (e.g., when AMQP broker is behind a firewall), nil or 0 means disable
+    #
+    # === Return
+    # (Integer|nil):: New heartbeat setting
+    def heartbeat=(heartbeat)
+      @options[:heartbeat] = heartbeat
+    end
+
     # Make new connection to broker at specified address unless already connected
     # or currently connecting
     #
@@ -454,17 +468,19 @@ module RightScale
         Log.info("Ignored request to reconnect #{identity} because already #{existing.status.to_s}")
         false
       else
+        old_identity = identity
         @brokers.each do |b|
           if index == b.index && (island.nil? || in_island?(b, island.id))
-            raise Exception, "Not allowed to change host or port of existing broker #{identity}, " +
-                             "alias #{b.alias}, to #{host} and #{port.inspect}"
+            # Changing host and/or port of existing broker client
+            old_identity = b.identity
+            break
           end
         end unless existing
 
         address = {:host => host, :port => port, :index => index}
         broker = BrokerClient.new(identity, address, @serializer, @exceptions, @options, island, existing)
         island_id = island && island.id
-        p, i = priority(identity, island_id)
+        p, i = priority(old_identity, island_id)
         if priority && priority < p
           @brokers.insert(i + priority, broker)
         elsif priority && priority > p
@@ -505,15 +521,24 @@ module RightScale
           if @brokers_hash[identity]
             old.delete(identity)
           else
-            new << identity if connect(a[:host], a[:port], a[:index], priority, i)
+            begin
+              new << identity if connect(a[:host], a[:port], a[:index], priority, i)
+            rescue Exception => e
+              Log.error("Failed to connect to broker #{identity}", e, :trace)
+              @exceptions.track("connect update", e)
+            end
           end
           priority += 1
         end
       end
 
       old.each do |identity|
-        b = @brokers_hash[identity]
-        remove(b.host, b.port)
+        if b = @brokers_hash[identity]
+          remove(b.host, b.port)
+        else
+          Log.error("Could not remove broker #{identity} during connection update because not found, " +
+                    "current broker configuration: #{status.inspect}")
+        end
       end
       { :add => new, :remove => old, :home => home }
     end
@@ -558,9 +583,10 @@ module RightScale
     # identities(Array):: Identity of brokers where successfully subscribed
     def subscribe(queue, exchange = nil, options = {}, &blk)
       identities = []
-      each_usable(options[:brokers]) { |b| identities << b.identity if b.subscribe(queue, exchange, options, &blk) }
+      brokers = options.delete(:brokers)
+      each_usable(brokers) { |b| identities << b.identity if b.subscribe(queue, exchange, options, &blk) }
       Log.info("Could not subscribe to queue #{queue.inspect} on exchange #{exchange.inspect} " +
-               "on brokers #{each_usable(options[:brokers]).inspect} when selected #{options[:brokers].inspect} " +
+               "on brokers #{each_usable(brokers).inspect} when selected #{brokers.inspect} " +
                "from usable #{usable.inspect}") if identities.empty?
       identities
     end
@@ -603,9 +629,10 @@ module RightScale
     # identities(Array):: Identity of brokers where successfully declared
     def declare(type, name, options = {})
       identities = []
-      each_usable(options[:brokers]) { |b| identities << b.identity if b.declare(type, name, options) }
-      Log.info("Could not declare #{type.to_s} #{name.inspect} on brokers #{each_usable(options[:brokers]).inspect} " +
-               "when selected #{options[:brokers].inspect} from usable #{usable.inspect}") if identities.empty?
+      brokers = options.delete(:brokers)
+      each_usable(brokers) { |b| identities << b.identity if b.declare(type, name, options) }
+      Log.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
 
@@ -727,7 +754,24 @@ module RightScale
     def delete(name, options = {})
       identities = []
       u = usable
-      ((options[:brokers] || u) & u).each { |i| identities << i if (b = @brokers_hash[i]) && b.delete(name, options) }
+      brokers = options.delete(:brokers)
+      ((brokers || u) & u).each { |i| identities << i if (b = @brokers_hash[i]) && b.delete(name, options) }
+      identities
+    end
+
+    # Delete queue resources from AMQP in all usable brokers
+    #
+    # === Parameters
+    # name(String):: Queue name
+    # options(Hash):: Queue declare options plus
+    #   :brokers(Array):: Identity of brokers in which queue is to be deleted
+    #
+    # === Return
+    # identities(Array):: Identity of brokers where queue was deleted
+    def delete_amqp_resources(name, options = {})
+      identities = []
+      u = usable
+      ((options[:brokers] || u) & u).each { |i| identities << i if (b = @brokers_hash[i]) && b.delete_amqp_resources(:queue, name) }
       identities
     end
 
@@ -891,12 +935,14 @@ module RightScale
     #   "exceptions"(Hash|nil):: Exceptions raised per category, or nil if none
     #     "total"(Integer):: Total exceptions for this category
     #     "recent"(Array):: Most recent as a hash of "count", "type", "message", "when", and "where"
+    #   "heartbeat"(Integer|nil):: Number of seconds between AMQP heartbeats, or nil if heartbeat disabled
     #   "returns"(Hash|nil):: Message return activity stats with keys "total", "percent", "last", and "rate"
     #     with percentage breakdown per return reason, or nil if none
     def stats(reset = false)
       stats = {
         "brokers"    => @brokers.map { |b| b.stats },
         "exceptions" => @exceptions.stats,
+        "heartbeat"  => @options[:heartbeat],
         "returns"    => @returns.all
       }
       reset_stats if reset
@@ -1140,8 +1186,8 @@ module RightScale
         persistent = options[:persistent]
         mandatory = true
         remaining = (context.brokers - context.failed) & all_connected
-        Log.info("RETURN reason #{reason} token #{token} brokers #{context.brokers.inspect} failed #{context.failed.inspect} " +
-                 " connected #{all_connected.inspect} remaining #{remaining.inspect}")
+        Log.info("RETURN reason #{reason} token <#{token}> to #{to} from #{context.from} brokers #{context.brokers.inspect} " +
+                 "failed #{context.failed.inspect} remaining #{remaining.inspect} connected #{all_connected.inspect}")
         if remaining.empty?
           if (persistent || one_way) &&
              ["ACCESS_REFUSED", "NO_CONSUMERS"].include?(reason) &&
@@ -1170,6 +1216,9 @@ module RightScale
                  "because no message context available for re-routing it to #{to}")
       end
       true
+    rescue Exception => e
+      Log.error("Failed to handle #{reason} return from #{identity} for message being routed to #{to}", e, :trace)
+      @exceptions.track("return", e)
     end
 
     # Helper for deferring block execution until specified number of actions have completed

data/lib/right_agent/log.rb

@@ -402,7 +402,7 @@ module RightScale
           logger.formatter.datetime_format = "%b %d %H:%M:%S"
         else
           $stderr.puts "Logging to syslog" if opts[:print]
-          logger = RightSupport::SystemLogger.new(@program_name || identity || 'RightAgent')
+          logger = RightSupport::Log::SystemLogger.new(@program_name || identity || 'RightAgent')
         end
 
         @logger = Multiplexer.new(logger)

data/lib/right_agent/minimal.rb

@@ -0,0 +1,43 @@
+#
+# Copyright (c) 2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# 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 'rubygems'
+require 'eventmachine'
+require 'fileutils'
+
+# load definition for File.normalize_path, etc.
+require File.expand_path(File.join(File.dirname(__FILE__), 'platform'))
+
+unless defined?(RIGHT_AGENT_BASE_DIR)
+  RIGHT_AGENT_BASE_DIR = File.normalize_path(File.dirname(__FILE__))
+end
+
+# require minimal gems needed to create a CommandClient and send a command.
+#
+# FIX: agent_controller is currently the only minimal-load use case so these
+# requires are oriented toward that. any additional use cases may require a
+# rethink of minimal loading.
+require File.normalize_path(File.join(RIGHT_AGENT_BASE_DIR, 'agent_config'))
+require File.normalize_path(File.join(RIGHT_AGENT_BASE_DIR, 'command'))
+require File.normalize_path(File.join(RIGHT_AGENT_BASE_DIR, 'log'))
+require File.normalize_path(File.join(RIGHT_AGENT_BASE_DIR, 'pid_file'))
+require File.normalize_path(File.join(RIGHT_AGENT_BASE_DIR, 'serialize', 'serializable'))

data/lib/right_agent/monkey_patches/amqp_patch.rb

@@ -20,170 +20,44 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-class MQ
-
-  class Queue
-    # Asks the broker to redeliver all unacknowledged messages on a
-    # specified channel. Zero or more messages may be redelivered.
-    #
-    # * requeue (default false)
-    # If this parameter is false, the message will be redelivered to the original recipient.
-    # If this flag is true, the server will attempt to requeue the message, potentially then
-    # delivering it to an alternative subscriber.
-    #
-    def recover(requeue = false)
-      @mq.callback{
-        @mq.send Protocol::Basic::Recover.new({ :requeue => requeue })
-      }
-      self
-    end
-  end
-
-  # May raise a MQ::Error exception when the frame payload contains a
-  # Protocol::Channel::Close object.
-  #
-  # This usually occurs when a client attempts to perform an illegal
-  # operation. A short, and incomplete, list of potential illegal operations
-  # follows:
-  # * publish a message to a deleted exchange (NOT_FOUND)
-  # * declare an exchange using the reserved 'amq.' naming structure (ACCESS_REFUSED)
-  #
-  def process_frame frame
-    log :received, frame
-
-    case frame
-    when Frame::Header
-      @header = frame.payload
-      @body = ''
-
-    when Frame::Body
-      @body << frame.payload
-      if @body.length >= @header.size
-        if @method.is_a? Protocol::Basic::Return
-          @on_return_message.call @method, @body if @on_return_message
-        else
-          @header.properties.update(@method.arguments)
-          @consumer.receive @header, @body if @consumer
-        end
-        @body = @header = @consumer = @method = nil
-      end
-
-    when Frame::Method
-      case method = frame.payload
-      when Protocol::Channel::OpenOk
-        send Protocol::Access::Request.new(:realm => '/data',
-                                           :read => true,
-                                           :write => true,
-                                           :active => true,
-                                           :passive => true)
-
-      when Protocol::Access::RequestOk
-        @ticket = method.ticket
-        callback{
-          send Protocol::Channel::Close.new(:reply_code => 200,
-                                            :reply_text => 'bye',
-                                            :method_id => 0,
-                                            :class_id => 0)
-        } if @closing
-        succeed
-
-      when Protocol::Basic::CancelOk
-        if @consumer = consumers[ method.consumer_tag ]
-          @consumer.cancelled
-        else
-          MQ.error "Basic.CancelOk for invalid consumer tag: #{method.consumer_tag}"
-        end
-
-      when Protocol::Queue::DeclareOk
-        queues[ method.queue ].receive_status method
-
-      when Protocol::Basic::Deliver, Protocol::Basic::GetOk
-        @method = method
-        @header = nil
-        @body = ''
-
-        if method.is_a? Protocol::Basic::GetOk
-          @consumer = get_queue{|q| q.shift }
-          MQ.error "No pending Basic.GetOk requests" unless @consumer
-        else
-          @consumer = consumers[ method.consumer_tag ]
-          MQ.error "Basic.Deliver for invalid consumer tag: #{method.consumer_tag}" unless @consumer
-        end
-
-      when Protocol::Basic::GetEmpty
-        if @consumer = get_queue{|q| q.shift }
-          @consumer.receive nil, nil
-        else
-          MQ.error "Basic.GetEmpty for invalid consumer"
-        end
-
-      when Protocol::Basic::Return
-        @method = method
-        @header = nil
-        @body = ''
-
-      when Protocol::Channel::Close
-        raise Error, "#{method.reply_text} in #{Protocol.classes[method.class_id].methods[method.method_id]} on #{@channel}"
-
-      when Protocol::Channel::CloseOk
-        @closing = false
-        conn.callback{ |c|
-          c.channels.delete @channel
-          c.close if c.channels.empty?
+begin
+  # Clean up AMQP connection when an error is raised after a broker request failure,
+  # otherwise AMQP becomes unusable
+  AMQP.module_eval do
+    def self.start *args, &blk
+      begin
+        EM.run{
+          @conn ||= connect *args
+          @conn.callback(&blk) if blk
+          @conn
         }
-
-      when Protocol::Basic::ConsumeOk
-        if @consumer = consumers[ method.consumer_tag ]
-          @consumer.confirm_subscribe
-        else
-          MQ.error "Basic.ConsumeOk for invalid consumer tag: #{method.consumer_tag}"
-        end
+      rescue Exception => e
+        @conn = nil
+        raise e
       end
     end
   end
 
-  # Provide callback to be activated when a message is returned
-  def return_message(&blk)
-    @on_return_message = blk
-  end
-
-end
-
-# monkey patch to the amqp gem that adds :no_declare => true option for new Queue objects.
-# This allows an instance that has no configuration privileges to enroll without blowing
-# up the AMQP gem when it tries to subscribe to its queue before it has been created.
-# Exchange :no_declare support is already in the eventmachine-0.12.10 gem.
-# temporary until we get this into amqp proper
-MQ::Queue.class_eval do
-  def initialize mq, name, opts = {}
-    @mq = mq
-    @opts = opts
-    @bindings ||= {}
-    @mq.queues[@name = name] ||= self
-    unless opts[:no_declare]
-      @mq.callback{
-        @mq.send AMQP::Protocol::Queue::Declare.new({ :queue => name,
-                                                      :nowait => true }.merge(opts))
-      }
-    end
-  end
-end
-
-begin
-  # Monkey patch AMQP reconnect backoff
   AMQP::Client.module_eval do
+    # Add callback for connection failure
     def initialize opts = {}
       @settings = opts
       extend AMQP.client
 
+      @_channel_mutex = Mutex.new
+
       @on_disconnect ||= proc{ @connection_status.call(:failed) if @connection_status }
 
       timeout @settings[:timeout] if @settings[:timeout]
       errback{ @on_disconnect.call } unless @reconnecting
 
-      @connected = false
+      # TCP connection "openness"
+      @tcp_connection_established = false
+      # AMQP connection "openness"
+      @connected                  = false
     end
 
+    # Add backoff controls to the reconnect algorithm
     def reconnect(force = false)
       if @reconnecting and not force
         # Wait after first reconnect attempt and in between each subsequent attempt
@@ -216,53 +90,88 @@ begin
         "#{RightScale::AgentIdentity.new('rs', 'broker', @settings[:port].to_i, @settings[:host].gsub('-', '~')).to_s}")
       log 'reconnecting'
       EM.reconnect(@settings[:host], @settings[:port], self)
+    rescue Exception => e
+      RightScale::Log.error("Exception caught during AMQP reconnect", e, :trace)
+      reconnect if @reconnecting
     end
-  end
 
-  # Monkey patch AMQP to clean up @conn when an error is raised after a broker request failure,
-  # otherwise AMQP becomes unusable
-  AMQP.module_eval do
-    def self.start *args, &blk
-      begin
-        EM.run{
-          @conn ||= connect *args
-          @conn.callback(&blk) if blk
-          @conn
-        }
-      rescue Exception => e
-        @conn = nil
-        raise e
-      end
-    end
-  end
-
-  # This monkey patch catches exceptions that would otherwise cause EM to stop or be in a bad
-  # state if a top level EM error handler was setup. Instead close the connection and leave EM
-  # alone.
-  # Don't log an error if the environment variable IGNORE_AMQP_FAILURES is set (used in the 
-  # enroll script)
-  AMQP::Client.module_eval do
+    # Catch exceptions that would otherwise cause EM to stop or be in a bad state if a top
+    # level EM error handler was setup. Instead close the connection and leave EM alone.
+    # Don't log an error if the environment variable IGNORE_AMQP_FAILURES is set
     alias :orig_receive_data :receive_data
     def receive_data(*args)
       begin
         orig_receive_data(*args)
       rescue Exception => e
-        RightScale::Log.error("Exception caught while processing AMQP frame, closing connection",
-                                   e, :trace) unless ENV['IGNORE_AMQP_FAILURES']
+        unless ENV['IGNORE_AMQP_FAILURES']
+          RightScale::Log.error("Exception caught while processing AMQP frame, closing connection", e, :trace)
+        end
         close_connection
       end
     end
+
+    # Make it log to RightScale when logging enabled
+    def log(*args)
+      return unless @settings[:logging] or AMQP.logging
+      require 'pp'
+      RightScale::Log.info("AMQP #{args.pretty_inspect.chomp}")
+    end
+  end
+
+  AMQP::Channel.class_eval do
+    # Detect message return and make callback
+    def check_content_completion
+      if @body.length >= @header.size
+        if @method.is_a? AMQP::Protocol::Basic::Return
+          @on_return_message.call @method, @body if @on_return_message
+        else
+          @header.properties.update(@method.arguments)
+          @consumer.receive @header, @body if @consumer
+        end
+        @body = @header = @consumer = @method = nil
+      end
+    end
+
+    # Provide callback to be activated when a message is returned
+    def return_message(&blk)
+      @on_return_message = blk
+    end
+
+    # Apply :no_declare option
+    def validate_parameters_match!(entity, parameters)
+      unless entity.opts == parameters || parameters[:passive] || parameters[:no_declare] || entity.opts[:no_declare]
+        raise AMQP::IncompatibleOptionsError.new(entity.name, entity.opts, parameters)
+      end
+    end
+
+    # Make it log to RightScale when logging enabled
+    def log(*args)
+      return unless AMQP.logging
+      require 'pp'
+      RightScale::Log.info("AMQP #{args.pretty_inspect.chomp}")
+    end
   end
 
-  # Add a new callback to amqp gem that triggers once the handshake with the broker completed
-  # The 'connected' status callback happens before the handshake is done and if it results in
-  # a lot of activity it might prevent EM from being able to call the code handling the
-  # incoming handshake packet in a timely fashion causing the broker to close the connection
-  AMQP::BasicClient.module_eval do
-    alias :orig_process_frame :process_frame
-    def process_frame(frame)
-      orig_process_frame(frame)
-      @connection_status.call(:ready) if @connection_status && frame.payload.is_a?(AMQP::Protocol::Connection::Start)
+  # Add :no_declare => true option for new Queue objects to allow an instance that has
+  # no configuration privileges to enroll without blowing up the AMQP gem when it tries
+  # to subscribe to its queue before it has been created (already supported in gem for
+  # Exchange)
+  AMQP::Queue.class_eval do
+    def initialize(mq, name, opts = {}, &block)
+      @mq = mq
+      @opts = self.class.add_default_options(name, opts, block)
+      @bindings ||= {}
+      @name = name unless name.empty?
+      @status = @opts[:nowait] ? :unknown : :unfinished
+      unless opts[:no_declare]
+        @mq.callback{
+          @mq.send AMQP::Protocol::Queue::Declare.new(@opts)
+        }
+      end
+
+      self.callback = block
+
+      block.call(self) if @opts[:nowait] && block
     end
   end