bunny 0.9.0.pre3 → 0.9.0.pre4

data/lib/bunny/channel.rb

@@ -138,7 +138,7 @@ module Bunny
       basic_reject(delivery_tag, requeue)
     end
 
-    def ack(delivery_tag, multiple)
+    def ack(delivery_tag, multiple = false)
       basic_ack(delivery_tag, multiple)
     end
     alias acknowledge ack
@@ -269,17 +269,17 @@ module Bunny
                                                                   exclusive,
                                                                   false,
                                                                   arguments))
-      Bunny::Timer.timeout(1, ClientTimeout) do
-        @last_basic_consume_ok = @continuations.pop
+      # helps avoid race condition between basic.consume-ok and basic.deliver if there are messages
+      # in the queue already. MK.
+      if consumer_tag && consumer_tag.strip != AMQ::Protocol::EMPTY_STRING
+        add_consumer(queue_name, consumer_tag, no_ack, exclusive, arguments, &block)
       end
 
-      @consumer_mutex.synchronize do
-        # make sure to use consumer tag from basic.consume-ok in case it was
-        # server-generated
-        c = Consumer.new(self, queue, @last_basic_consume_ok.consumer_tag, no_ack, exclusive, arguments)
-        c.on_delivery(&block) if block
-        @consumers[@last_basic_consume_ok.consumer_tag] = c
+      Bunny::Timer.timeout(1, ClientTimeout) do
+        @last_basic_consume_ok = @continuations.pop
       end
+      # covers server-generated consumer tags
+      add_consumer(queue_name, @last_basic_consume_ok.consumer_tag, no_ack, exclusive, arguments, &block)
 
       @last_basic_consume_ok
     end
@@ -296,15 +296,20 @@ module Bunny
                                                                   consumer.exclusive,
                                                                   false,
                                                                   consumer.arguments))
+
+      # helps avoid race condition between basic.consume-ok and basic.deliver if there are messages
+      # in the queue already. MK.
+      if consumer.consumer_tag && consumer.consumer_tag.strip != AMQ::Protocol::EMPTY_STRING
+        register_consumer(consumer.consumer_tag, consumer)
+      end
+
       Bunny::Timer.timeout(1, ClientTimeout) do
         @last_basic_consume_ok = @continuations.pop
       end
+      # covers server-generated consumer tags
+      register_consumer(@last_basic_consume_ok.consumer_tag, consumer)
 
-      @consumer_mutex.synchronize do
-        # update the tag in case it was server-generated
-        consumer.consumer_tag = @last_basic_consume_ok.consumer_tag
-        @consumers[@last_basic_consume_ok.consumer_tag] = consumer
-      end
+      raise_if_continuation_resulted_in_a_channel_error!
 
       @last_basic_consume_ok
     end
@@ -592,6 +597,20 @@ module Bunny
     # Implementation
     #
 
+    def register_consumer(consumer_tag, consumer)
+      @consumer_mutex.synchronize do
+        @consumers[consumer_tag] = consumer
+      end
+    end
+
+    def add_consumer(queue, consumer_tag, no_ack, exclusive, arguments, &block)
+      @consumer_mutex.synchronize do
+        c = Consumer.new(self, queue, consumer_tag, no_ack, exclusive, arguments)
+        c.on_delivery(&block) if block
+        @consumers[consumer_tag] = c
+      end
+    end
+
     def handle_method(method)
       # puts "Channel#handle_frame on channel #{@id}: #{method.inspect}"
       case method
@@ -670,6 +689,9 @@ module Bunny
         @work_pool.submit do
           consumer.call(DeliveryInfo.new(basic_deliver), MessageProperties.new(properties), content)
         end
+      else
+        # TODO: log it
+        puts "[warning] No consumer for tag #{basic_deliver.consumer_tag}"
       end
     end
 
@@ -730,6 +752,14 @@ module Bunny
       @exchanges[name]
     end
 
+    # Unique string supposed to be used as a consumer tag.
+    #
+    # @return [String]  Unique string.
+    # @api plugin
+    def generate_consumer_tag(name = "bunny")
+      "#{name}-#{Time.now.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
+    end
+
     protected
 
     def closed!
@@ -765,13 +795,5 @@ module Bunny
     def raise_if_no_longer_open!
       raise ChannelAlreadyClosed.new("cannot use a channel that was already closed! Channel id: #{@id}", self) if closed?
     end
-
-    # Unique string supposed to be used as a consumer tag.
-    #
-    # @return [String]  Unique string.
-    # @api plugin
-    def generate_consumer_tag(name = "bunny")
-      "#{name}-#{Time.now.to_i * 1000}-#{Kernel.rand(999_999_999_999)}"
-    end
   end
 end

data/lib/bunny/consumer.rb

@@ -14,7 +14,7 @@ module Bunny
 
 
 
-    def initialize(channel, queue, consumer_tag = "", no_ack = false, exclusive = false, arguments = {})
+    def initialize(channel, queue, consumer_tag = channel.generate_consumer_tag, no_ack = false, exclusive = false, arguments = {})
       @channel       = channel || raise(ArgumentError, "channel is nil")
       @queue         = queue   || raise(ArgumentError, "queue is nil")
       @consumer_tag  = consumer_tag
@@ -51,6 +51,10 @@ module Bunny
       end
     end
 
+    def cancel
+      @channel.basic_cancel(@consumer_tag)
+    end
+
     def inspect
       "#<#{self.class.name}:#{object_id} @channel_id=#{@channel.number} @queue=#{self.queue_name}> @consumer_tag=#{@consumer_tag} @exclusive=#{@exclusive} @no_ack=#{@no_ack}>"
     end

data/lib/bunny/delivery_info.rb

@@ -49,13 +49,14 @@ module Bunny
       @basic_deliver.consumer_tag
     end
 
-    def deliver_tag
-      @basic_deliver.deliver_tag
+    def delivery_tag
+      @basic_deliver.delivery_tag
     end
 
     def redelivered
       @basic_deliver.redelivered
     end
+    alias redelivered? redelivered
 
     def exchange
       @basic_deliver.exchange

data/lib/bunny/exceptions.rb

@@ -3,7 +3,13 @@ module Bunny
     attr_reader :hostname, :port
 
     def initialize(e, hostname, port)
-      super("Could not estabilish TCP connection to #{hostname}:#{port}: #{e.message}")
+      m = case e
+          when String then
+            e
+          when Exception then
+            e.message
+          end
+      super("Could not estabilish TCP connection to #{hostname}:#{port}: #{m}")
     end
   end
 

data/lib/bunny/exchange.rb

@@ -66,7 +66,7 @@ module Bunny
       @auto_delete      = @options[:auto_delete]
       @arguments        = @options[:arguments]
 
-      declare! unless opts[:no_declare] || (@name =~ /^amq\..+/) || (@name == AMQ::Protocol::EMPTY_STRING)
+      declare! unless opts[:no_declare] || (@name =~ /^amq\.(direct|fanout|topic|match|headers)/) || (@name == AMQ::Protocol::EMPTY_STRING)
 
       @channel.register_exchange(self)
     end
@@ -87,6 +87,9 @@ module Bunny
       @arguments
     end
 
+    def predeclared?
+      @name == AMQ::Protocol::EMPTY_STRING || (@name =~ /^amq\.(direct|fanout|topic|match|headers)/)
+    end
 
 
     def publish(payload, opts = {})
@@ -96,10 +99,10 @@ module Bunny
     end
 
 
-    # Deletes the exchange
+    # Deletes the exchange unless it is a default exchange
     # @api public
     def delete(opts = {})
-      @channel.exchange_delete(@name, opts)
+      @channel.exchange_delete(@name, opts) unless predeclared?
     end
 
 

data/lib/bunny/heartbeat_sender.rb

@@ -18,7 +18,11 @@ module Bunny
 
     def start(period = 30)
       @mutex.synchronize do
-        @period = period
+        # calculate interval as half the given period plus
+        # some compensation for Ruby's implementation inaccuracy
+        # (we cannot get at the nanos level the Java client uses, and
+        # our approach is simplistic). MK.
+        @interval = [(period / 2) - 1, 0.4].max
 
         @thread = Thread.new(&method(:run))
       end
@@ -39,7 +43,7 @@ module Bunny
         loop do
           self.beat
 
-          sleep (@period / 2)
+          sleep @interval
         end
       rescue IOError => ioe
         # ignored
@@ -51,7 +55,7 @@ module Bunny
     def beat
       now = Time.now
 
-      if now > (@last_activity_time + @period)
+      if now > (@last_activity_time + @interval)
         @transport.send_raw(AMQ::Protocol::HeartbeatFrame.encode)
       end
     end

data/lib/bunny/queue.rb

@@ -75,18 +75,18 @@ module Bunny
     end
 
     def subscribe(opts = {
-                    :consumer_tag    => "",
+                    :consumer_tag    => @channel.generate_consumer_tag,
                     :ack             => false,
                     :exclusive       => false,
                     :block           => false,
                     :on_cancellation => nil
                   }, &block)
 
-      ctag       = opts.fetch(:consumer_tag, "")
+      ctag       = opts.fetch(:consumer_tag, @channel.generate_consumer_tag)
       consumer   = Consumer.new(@channel,
                                 @name,
                                 ctag,
-                                opts[:no_ack],
+                                !opts[:ack],
                                 opts[:exclusive],
                                 opts[:arguments])
       consumer.on_delivery(&block)
@@ -98,12 +98,15 @@ module Bunny
         # the current thread for as long as the consumer pool is active
         @channel.work_pool.join
       end
+
+      consumer
     end
 
     def subscribe_with(consumer, opts = {:block => false})
       @channel.basic_consume_with(consumer)
 
       @channel.work_pool.join if opts[:block]
+      consumer
     end
 
     def pop(opts = {:ack => false}, &block)
@@ -129,6 +132,16 @@ module Bunny
       end
     end
 
+    # Publishes a message to the queue via default exchange.
+    #
+    # @see Bunny::Exchange#publish
+    # @see Bunny::Channel#default_exchange
+    def publish(payload, opts = {})
+      @channel.default_exchange.publish(payload, opts.merge(:routing_key => @name))
+
+      self
+    end
+
 
     # Deletes the queue
     # @api public

data/lib/bunny/session.rb

@@ -5,6 +5,9 @@ require "bunny/transport"
 require "bunny/channel_id_allocator"
 require "bunny/heartbeat_sender"
 require "bunny/main_loop"
+require "bunny/authentication/credentials_encoder"
+require "bunny/authentication/plain_mechanism_encoder"
+require "bunny/authentication/external_mechanism_encoder"
 
 require "bunny/concurrent/condition"
 
@@ -18,9 +21,8 @@ module Bunny
     DEFAULT_VHOST     = "/"
     DEFAULT_USER      = "guest"
     DEFAULT_PASSWORD  = "guest"
-    # 0 means "no heartbeat". This is the same default RabbitMQ Java client and amqp gem
-    # use.
-    DEFAULT_HEARTBEAT = 0
+    # the same value as RabbitMQ 3.0 uses. MK.
+    DEFAULT_HEARTBEAT = 600
     # 128K
     DEFAULT_FRAME_MAX = 131072
 
@@ -29,9 +31,8 @@ module Bunny
 
 
     DEFAULT_CLIENT_PROPERTIES = {
-      # once we support AMQP 0.9.1 extensions, this needs to be updated. MK.
       :capabilities => {
-        # :publisher_confirms         => true,
+        :publisher_confirms         => true,
         :consumer_cancel_notify     => true,
         :exchange_exchange_bindings => true,
         :"basic.nack"               => true
@@ -53,6 +54,10 @@ module Bunny
     attr_reader :server_capabilities, :server_properties, :server_authentication_mechanisms, :server_locales
     attr_reader :default_channel
     attr_reader :channel_id_allocator
+    # Authentication mechanism, e.g. "PLAIN" or "EXTERNAL"
+    # @return [String]
+    attr_reader :mechanism
+
 
     def initialize(connection_string_or_opts = Hash.new, optz = Hash.new)
       opts = case (ENV["RABBITMQ_URL"] || connection_string_or_opts)
@@ -80,13 +85,14 @@ module Bunny
       @client_channel_max = opts.fetch(:channel_max, 65536)
       @client_heartbeat   = self.heartbeat_from(opts)
 
-      @client_properties  = opts[:properties] || DEFAULT_CLIENT_PROPERTIES
-      @mechanism          = "PLAIN"
-      @locale             = @opts.fetch(:locale, DEFAULT_LOCALE)
-      @channel_mutex      = Mutex.new
-      @channels           = Hash.new
+      @client_properties   = opts[:properties] || DEFAULT_CLIENT_PROPERTIES
+      @mechanism           = opts.fetch(:auth_mechanism, "PLAIN")
+      @credentials_encoder = credentials_encoder_for(@mechanism)
+      @locale              = @opts.fetch(:locale, DEFAULT_LOCALE)
+      @channel_mutex       = Mutex.new
+      @channels            = Hash.new
 
-      @continuations      = ::Queue.new
+      @continuations       = ::Queue.new
     end
 
     def hostname;     self.host;  end
@@ -445,7 +451,12 @@ module Bunny
 
       @frame_max            = negotiate_value(@client_frame_max, connection_tune.frame_max)
       @channel_max          = negotiate_value(@client_channel_max, connection_tune.channel_max)
-      @heartbeat            = negotiate_value(@client_heartbeat, connection_tune.heartbeat)
+      # this allows for disabled heartbeats. MK.
+      @heartbeat            = if 0 == @client_heartbeat || @client_heartbeat.nil?
+                                0
+                              else
+                                negotiate_value(@client_heartbeat, connection_tune.heartbeat)
+                              end
 
       @channel_id_allocator = ChannelIdAllocator.new(@channel_max)
 
@@ -500,10 +511,13 @@ module Bunny
 
 
     # @api plugin
-    # @see http://tools.ietf.org/rfc/rfc2595.txt RFC 2595
     def encode_credentials(username, password)
-      "\0#{username}\0#{password}"
+      @credentials_encoder.encode_credentials(username, password)
     end # encode_credentials(username, password)
+
+    def credentials_encoder_for(mechanism)
+      Authentication::CredentialsEncoder.for_session(self)
+    end
   end # Session
 
   # backwards compatibility

data/lib/bunny/transport.rb

@@ -71,7 +71,14 @@ module Bunny
         end
       rescue Errno::EPIPE, Errno::EAGAIN, Bunny::ClientTimeout, IOError => e
         close
-        raise Bunny::ConnectionError, e.message
+
+        m = case e
+            when String then
+              e
+            when Exception then
+              e.message
+            end
+        raise Bunny::ConnectionError.new(m, @host, @port)
       end
     end
     alias send_raw write

data/lib/bunny/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Bunny
-  VERSION = "0.9.0.pre3"
+  VERSION = "0.9.0.pre4"
 end

data/spec/higher_level_api/integration/basic_cancel_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Bunny::Consumer, "#cancel" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+  let(:queue_name) { "bunny.queues.#{rand}" }
+
+  context "when the given consumer tag is valid" do
+    it "cancels the consumer" do
+      delivered_data = []
+
+      t = Thread.new do
+        ch         = connection.create_channel
+        q          = ch.queue(queue_name, :auto_delete => true, :durable => false)
+        consumer = q.subscribe(:block => false) do |_, _, payload|
+          delivered_data << payload
+        end
+
+        consumer.consumer_tag.should_not be_nil
+        cancel_ok = consumer.cancel
+        cancel_ok.consumer_tag.should == consumer.consumer_tag
+
+        ch.close
+      end
+      t.abort_on_exception = true
+      sleep 0.5
+
+      ch = connection.create_channel
+      ch.default_exchange.publish("", :routing_key => queue_name)
+
+      sleep 0.7
+      delivered_data.should be_empty
+    end
+  end
+end