bunny 1.0.7 → 2.24.0

data/examples/guides/extensions/queue_lease.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require "rubygems"
-require "bunny"
-
-puts "=> Demonstrating queue TTL (queue leases)"
-puts
-
-conn = Bunny.new
-conn.start
-
-ch   = conn.create_channel
-q    = ch.queue("", :exclusive => true, :arguments => {"x-expires" => 300})
-
-sleep 0.4
-begin
-  # this will raise because the queue is already deleted
-  q.message_count
-rescue Bunny::NotFound => nfe
-  puts "Got a 404 response: the queue has already been removed"
-end
-
-sleep 0.7
-puts "Closing..."
-conn.close

data/examples/guides/extensions/sender_selected_distribution.rb

@@ -1,32 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require "rubygems"
-require "bunny"
-
-puts "=> Demonstrating sender-selected distribution"
-puts
-
-conn = Bunny.new
-conn.start
-
-ch   = conn.create_channel
-x    = ch.direct("bunny.examples.ssd.exchange")
-q1   = ch.queue("", :exclusive => true).bind(x, :routing_key => "one")
-q2   = ch.queue("", :exclusive => true).bind(x, :routing_key => "two")
-q3   = ch.queue("", :exclusive => true).bind(x, :routing_key => "three")
-q4   = ch.queue("", :exclusive => true).bind(x, :routing_key => "four")
-
-10.times do |i|
-  x.publish("Message #{i}", :routing_key => "one", :headers => {"CC" => ["two", "three"]})
-end
-
-sleep 0.2
-puts "Queue #{q1.name} now has #{q1.message_count} messages in it"
-puts "Queue #{q2.name} now has #{q2.message_count} messages in it"
-puts "Queue #{q3.name} now has #{q3.message_count} messages in it"
-puts "Queue #{q4.name} now has #{q4.message_count} messages in it"
-
-sleep 0.7
-puts "Closing..."
-conn.close

data/examples/guides/getting_started/blabbr.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require "rubygems"
-require "bunny"
-
-conn = Bunny.new
-conn.start
-
-ch  = conn.create_channel
-x   = ch.fanout("nba.scores")
-
-ch.queue("joe",   :auto_delete => true).bind(x).subscribe do |delivery_info, properties, payload|
-  puts "#{payload} => joe"
-end
-
-ch.queue("aaron", :auto_delete => true).bind(x).subscribe do |delivery_info, properties, payload|
-  puts "#{payload} => aaron"
-end
-
-ch.queue("bob",   :auto_delete => true).bind(x).subscribe do |delivery_info, properties, payload|
-  puts "#{payload} => bob"
-end
-
-x.publish("BOS 101, NYK 89").publish("ORL 85, ALT 88")
-
-conn.close

data/examples/guides/getting_started/hello_world.rb

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require "rubygems"
-require "bunny"
-
-conn = Bunny.new
-conn.start
-
-ch = conn.create_channel
-q  = ch.queue("bunny.examples.hello_world", :auto_delete => true)
-
-q.subscribe do |delivery_info, properties, payload|
-  puts "Received #{payload}"
-end
-
-q.publish("Hello!", :routing_key => q.name)
-
-sleep 1.0
-conn.close

data/examples/guides/getting_started/weathr.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require "rubygems"
-require "bunny"
-
-connection = Bunny.new
-connection.start
-
-channel  = connection.create_channel
-# topic exchange name can be any string
-exchange = channel.topic("weathr", :auto_delete => true)
-
-# Subscribers.
-channel.queue("", :exclusive => true).bind(exchange, :routing_key => "americas.north.#").subscribe do |delivery_info, properties, payload|
-  puts "An update for North America: #{payload}, routing key is #{delivery_info.routing_key}"
-end
-channel.queue("americas.south").bind(exchange, :routing_key => "americas.south.#").subscribe do |delivery_info, properties, payload|
-  puts "An update for South America: #{payload}, routing key is #{delivery_info.routing_key}"
-end
-channel.queue("us.california").bind(exchange, :routing_key => "americas.north.us.ca.*").subscribe do |delivery_info, properties, payload|
-  puts "An update for US/California: #{payload}, routing key is #{delivery_info.routing_key}"
-end
-channel.queue("us.tx.austin").bind(exchange, :routing_key => "#.tx.austin").subscribe do |delivery_info, properties, payload|
-  puts "An update for Austin, TX: #{payload}, routing key is #{delivery_info.routing_key}"
-end
-channel.queue("it.rome").bind(exchange, :routing_key => "europe.italy.rome").subscribe do |delivery_info, properties, payload|
-  puts "An update for Rome, Italy: #{payload}, routing key is #{delivery_info.routing_key}"
-end
-channel.queue("asia.hk").bind(exchange, :routing_key => "asia.southeast.hk.#").subscribe do |delivery_info, properties, payload|
-  puts "An update for Hong Kong: #{payload}, routing key is #{delivery_info.routing_key}"
-end
-
-exchange.publish("San Diego update", :routing_key => "americas.north.us.ca.sandiego").
-  publish("Berkeley update",         :routing_key => "americas.north.us.ca.berkeley").
-  publish("San Francisco update",    :routing_key => "americas.north.us.ca.sanfrancisco").
-  publish("New York update",         :routing_key => "americas.north.us.ny.newyork").
-  publish("São Paolo update",        :routing_key => "americas.south.brazil.saopaolo").
-  publish("Hong Kong update",        :routing_key => "asia.southeast.hk.hongkong").
-  publish("Kyoto update",            :routing_key => "asia.southeast.japan.kyoto").
-  publish("Shanghai update",         :routing_key => "asia.southeast.prc.shanghai").
-  publish("Rome update",             :routing_key => "europe.italy.roma").
-  publish("Paris update",            :routing_key => "europe.france.paris")
-
-sleep 1.0
-
-connection.close

data/examples/guides/queues/one_off_consumer.rb

@@ -1,23 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require "rubygems"
-require "bunny"
-
-conn = Bunny.new
-conn.start
-
-ch = conn.create_channel
-q  = ch.queue("bunny.examples.hello_world", :auto_delete => true)
-
-q.publish("Hello!", :routing_key => q.name)
-
-# demonstrates a blocking consumer that needs to cancel itself
-# in the message handler
-q.subscribe(:block => true) do |delivery_info, properties, payload|
-  puts "Received #{payload}, cancelling"
-  delivery_info.consumer.cancel
-end
-
-sleep 1.0
-conn.close

data/examples/guides/queues/redeliveries.rb

@@ -1,79 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require "rubygems"
-require "bunny"
-
-puts "=> Subscribing for messages using explicit acknowledgements model"
-puts
-
-connection1 = Bunny.new
-connection1.start
-
-connection2 = Bunny.new
-connection2.start
-
-connection3 = Bunny.new
-connection3.start
-
-ch1 = connection1.create_channel
-ch1.prefetch(1)
-
-ch2 = connection2.create_channel
-ch2.prefetch(1)
-
-ch3 = connection3.create_channel
-ch3.prefetch(1)
-
-x   = ch3.direct("amq.direct")
-q1  = ch1.queue("bunny.examples.acknowledgements.explicit", :auto_delete => false)
-q1.purge
-
-q1.bind(x).subscribe(:ack => true, :block => false) do |delivery_info, properties, payload|
-  # do some work
-  sleep(0.2)
-
-  # acknowledge some messages, they will be removed from the queue
-  if rand > 0.5
-    # FYI: there is a shortcut, Bunny::Channel.ack
-    ch1.acknowledge(delivery_info.delivery_tag, false)
-    puts "[consumer1] Got message ##{properties.headers['i']}, redelivered?: #{delivery_info.redelivered?}, ack-ed"
-  else
-    # some messages are not ack-ed and will remain in the queue for redelivery
-    # when app #1 connection is closed (either properly or due to a crash)
-    puts "[consumer1] Got message ##{properties.headers['i']}, SKIPPED"
-  end
-end
-
-q2   = ch2.queue("bunny.examples.acknowledgements.explicit", :auto_delete => false)
-q2.bind(x).subscribe(:ack => true, :block => false) do |delivery_info, properties, payload|
-  # do some work
-  sleep(0.2)
-
-  ch2.acknowledge(delivery_info.delivery_tag, false)
-  puts "[consumer2] Got message ##{properties.headers['i']}, redelivered?: #{delivery_info.redelivered?}, ack-ed"
-end
-
-t1 = Thread.new do
-  i = 0
-  loop do
-    sleep 0.5
-
-    x.publish("Message ##{i}", :headers => { :i => i })
-    i += 1
-  end
-end
-t1.abort_on_exception = true
-
-t2 = Thread.new do
-  sleep 4.0
-
-  connection1.close
-  puts "----- Connection 1 is now closed (we pretend that it has crashed) -----"
-end
-t2.abort_on_exception = true
-
-
-sleep 7.0
-connection2.close
-connection3.close

data/lib/bunny/compatibility.rb

@@ -1,24 +0,0 @@
-module Bunny
-  # Helper methods necessary to stay mostly backwards-compatible with legacy (0.7.x, 0.8.x) Bunny
-  # releases that hide channels completely from the API.
-  #
-  # @private
-  module Compatibility
-
-    #
-    # API
-    #
-
-    # @private
-    def channel_from(channel_or_connection)
-      # Bunny 0.8.x and earlier completely hide channels from the API. So, queues and exchanges are
-      # instantiated with a "Bunny object", which is a session. This function coerces two types of input to a
-      # channel.
-      if channel_or_connection.is_a?(Bunny::Session)
-        channel_or_connection.default_channel
-      else
-        channel_or_connection
-      end
-    end
-  end
-end

data/lib/bunny/concurrent/linked_continuation_queue.rb

@@ -1,61 +0,0 @@
-if !defined?(JRUBY_VERSION)
-  raise "Bunny::Concurrent::LinkedContinuationQueue can only be used on JRuby!"
-end
-
-require "java"
-
-java_import java.util.concurrent.LinkedBlockingQueue
-java_import java.util.concurrent.TimeUnit
-
-module Bunny
-  module Concurrent
-    # Continuation queue implementation for JRuby.
-    #
-    # On JRuby, we'd rather use reliable and heavily battle tested j.u.c.
-    # primitives with well described semantics than informally specified, clumsy
-    # and limited Ruby standard library parts.
-    #
-    # This is an implementation of the continuation queue on top of the linked blocking
-    # queue in j.u.c.
-    #
-    # Compared to the Ruby standard library Queue, there is one limitation: you cannot
-    # push a nil on the queue, it will fail with a null pointer exception.
-    # @private
-    class LinkedContinuationQueue
-      def initialize(*args, &block)
-        @q = LinkedBlockingQueue.new
-      end
-
-      def push(el, timeout_in_ms = nil)
-        if timeout_in_ms
-          @q.offer(el, timeout_in_ms, TimeUnit::MILLISECONDS)
-        else
-          @q.offer(el)
-        end
-      end
-      alias << push
-
-      def pop
-        @q.take
-      end
-
-      def poll(timeout_in_ms = nil)
-        if timeout_in_ms
-          v = @q.poll(timeout_in_ms, TimeUnit::MILLISECONDS)
-          raise ::Timeout::Error.new("operation did not finish in #{timeout_in_ms} ms") if v.nil?
-          v
-        else
-          @q.poll
-        end
-      end
-
-      def clear
-        @q.clear
-      end
-
-      def method_missing(selector, *args, &block)
-        @q.__send__(selector, *args, &block)
-      end
-    end
-  end
-end

data/lib/bunny/jruby/socket.rb

@@ -1,40 +0,0 @@
-require "bunny/cruby/socket"
-
-module Bunny
-  module JRuby
-    # TCP socket extension that uses Socket#readpartial to avoid excessive CPU
-    # burn after some time. See issue #165.
-    # @private
-    class Socket < Bunny::Socket
-
-      # Reads given number of bytes with an optional timeout
-      #
-      # @param [Integer] count How many bytes to read
-      # @param [Integer] timeout Timeout
-      #
-      # @return [String] Data read from the socket
-      # @api public
-      def read_fully(count, timeout = nil)
-        return nil if @__bunny_socket_eof_flag__
-
-        value = ''
-        begin
-          loop do
-            value << readpartial(count - value.bytesize)
-            break if value.bytesize >= count
-          end
-        rescue EOFError
-          # @eof will break Rubinius' TCPSocket implementation. MK.
-          @__bunny_socket_eof_flag__ = true
-        rescue *READ_RETRY_EXCEPTION_CLASSES
-          if IO.select([self], nil, nil, timeout)
-            retry
-          else
-            raise Timeout::Error, "IO timeout when reading #{count} bytes"
-          end
-        end
-        value
-      end # read_fully
-    end
-  end
-end

data/lib/bunny/jruby/ssl_socket.rb

@@ -1,53 +0,0 @@
-module Bunny
-  module JRuby
-    begin
-      require "bunny/cruby/ssl_socket"
-      require "openssl"
-
-      # TLS-enabled TCP socket that implements convenience
-      # methods found in Bunny::Socket.
-      class SSLSocket < Bunny::SSLSocket
-
-        # Reads given number of bytes with an optional timeout
-        #
-        # @param [Integer] count How many bytes to read
-        # @param [Integer] timeout Timeout
-        #
-        # @return [String] Data read from the socket
-        # @api public
-        def read_fully(count, timeout = nil)
-          return nil if @__bunny_socket_eof_flag__
-
-          value = ''
-          begin
-            loop do
-              value << read_nonblock(count - value.bytesize)
-              break if value.bytesize >= count
-            end
-          rescue EOFError => e
-            @__bunny_socket_eof_flag__ = true
-          rescue OpenSSL::SSL::SSLError => e
-            if e.message == "read would block"
-              if IO.select([self], nil, nil, timeout)
-                retry
-              else
-                raise Timeout::Error, "IO timeout when reading #{count} bytes"
-              end
-            else
-              raise e
-            end
-          rescue *READ_RETRY_EXCEPTION_CLASSES => e
-            if IO.select([self], nil, nil, timeout)
-              retry
-            else
-              raise Timeout::Error, "IO timeout when reading #{count} bytes"
-            end
-          end
-          value
-        end
-      end
-    rescue LoadError => le
-      puts "Could not load OpenSSL"
-    end
-  end
-end

data/lib/bunny/system_timer.rb

@@ -1,20 +0,0 @@
-# -*- encoding: utf-8; mode: ruby -*-
-
-require "system_timer"
-
-module Bunny
-  # Used for Ruby before 1.9
-  class SystemTimer
-    # Executes a block of code, raising if the execution does not finish
-    # in the alloted period of time, in seconds.
-    def self.timeout(seconds, exception = nil)
-      if seconds
-        ::SystemTimer.timeout_after(seconds, exception) do
-          yield
-        end
-      else
-        yield
-      end
-    end
-  end # SystemTimer
-end # Bunny

data/profiling/basic_publish/with_4K_messages.rb

@@ -1,33 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require "rubygems"
-require "bunny"
-require "ruby-prof"
-
-conn = Bunny.new
-conn.start
-
-puts
-puts "-" * 80
-puts "Benchmarking on #{RUBY_DESCRIPTION}"
-
-n  = 50_000
-ch = conn.create_channel
-x  = ch.default_exchange
-s  = "z" * 4096
-
-# warm up the JIT, etc
-puts "Doing a warmup run..."
-16000.times { x.publish(s, :routing_key => "anything") }
-
-# give OS, the server and so on some time to catch
-# up
-sleep 2.0
-
-result = RubyProf.profile do
-  n.times { x.publish(s, :routing_key => "anything") }
-end
-
-printer = RubyProf::FlatPrinter.new(result)
-printer.print(STDOUT, {})

data/repl

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-bundle exec irb -Ilib -r'bunny'

data/spec/compatibility/queue_declare_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue, "backwards compatibility API" do
-  let(:connection) do
-    c = Bunny.new
-    c.start
-    c
-  end
-
-  after :all do
-    connection.close if connection.open?
-  end
-
-  context "when queue name is specified" do
-    let(:name) { "a queue declared at #{Time.now.to_i}" }
-
-    it "declares a new queue with that name" do
-      q    = Bunny::Queue.new(connection, name)
-      q.name.should == name
-    end
-  end
-
-
-  context "when queue name is passed on as an empty string" do
-    it "uses server-assigned queue name" do
-      q = Bunny::Queue.new(connection, "")
-      q.name.should_not be_empty
-      q.name.should =~ /^amq.gen.+/
-      q.should be_server_named
-      q.delete
-    end
-  end
-
-
-  context "when queue name is completely omitted" do
-    it "uses server-assigned queue name" do
-      q = Bunny::Queue.new(connection)
-      q.name.should_not be_empty
-      q.name.should =~ /^amq.gen.+/
-      q.should be_server_named
-      q.delete
-    end
-  end
-end

data/spec/compatibility/queue_declare_with_default_channel_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Session do
-  let(:connection) do
-    c = Bunny.new
-    c.start
-    c
-  end
-
-  after :all do
-    connection.close if connection.open?
-  end
-
-  it "proxies #queue to the pre-opened channel for backwards compatibility" do
-    q = connection.queue("", :exclusive => true)
-    q.name.should =~ /^amq.gen/
-  end
-
-  it "proxies #fanout to the pre-opened channel for backwards compatibility" do
-    x = connection.fanout("amq.fanout")
-    x.name.should == "amq.fanout"
-  end
-
-  it "proxies #topic to the pre-opened channel for backwards compatibility" do
-    x = connection.topic("amq.topic")
-    x.name.should == "amq.topic"
-  end
-
-  it "proxies #direct to the pre-opened channel for backwards compatibility" do
-    x = connection.topic("amq.direct")
-    x.name.should == "amq.direct"
-  end
-end

data/spec/higher_level_api/integration/basic_ack_spec.rb

@@ -1,71 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#ack" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  end
-
-  after :each do
-    connection.close if connection.open?
-  end
-
-  context "with a valid (known) delivery tag" do
-    it "acknowledges a message" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", :routing_key => q.name)
-      sleep 0.5
-      q.message_count.should == 1
-      delivery_details, properties, content = q.pop(:ack => true)
-
-      ch.ack(delivery_details.delivery_tag, true)
-      q.message_count.should == 0
-
-      ch.close
-    end
-  end
-
-
-  context "with a valid (known) delivery tag and automatic ack mode" do
-    it "results in a channel exception" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", :exclusive => true)
-      x  = ch.default_exchange
-
-      q.subscribe(:manual_ack => false) do |delivery_info, properties, payload|
-        ch.ack(delivery_info.delivery_tag, false)
-      end
-
-      x.publish("bunneth", :routing_key => q.name)
-      sleep 0.5
-      lambda do
-        q.message_count
-      end.should raise_error(Bunny::ChannelAlreadyClosed)
-    end
-  end
-
-  context "with an invalid (random) delivery tag" do
-    it "causes a channel-level error" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.unknown-delivery-tag", :exclusive => true)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", :routing_key => q.name)
-      sleep 0.5
-      q.message_count.should == 1
-      _, _, content = q.pop(:ack => true)
-
-      ch.on_error do |ch, channel_close|
-        @channel_close = channel_close
-      end
-      ch.ack(82, true)
-      sleep 0.25
-
-      @channel_close.reply_code.should == AMQ::Protocol::PreconditionFailed::VALUE
-    end
-  end
-end