bunny 0.7.13 → 0.8.0

data/lib/bunny/{client09.rb → client.rb}

@@ -3,7 +3,7 @@
 module Bunny
 
   # The Client class provides the major Bunny API methods.
-  class Client09 < Qrack::Client
+  class Client < Qrack::Client
 
     # Sets up a Bunny::Client object ready for connection to a broker.
     # {Client.status} is set to @:not_connected@.
@@ -32,20 +32,20 @@ module Bunny
     #   Number of seconds before {Qrack::ConnectionTimeout} is raised.@
     def initialize(connection_string_or_opts = Hash.new, opts = Hash.new)
       super
-      @spec = '0-9-1'
-      @port = self.__opts__[:port] || (self.__opts__[:ssl] ? Qrack::Protocol09::SSL_PORT : Qrack::Protocol09::PORT)
     end
 
     # Checks response from AMQP methods and takes appropriate action
     def check_response(received_method, expected_method, err_msg, err_class = Bunny::ProtocolError)
+      @last_method = received_method
+
       case
-      when received_method.is_a?(Qrack::Protocol09::Connection::Close)
+      when received_method.is_a?(Qrack::Protocol::Connection::Close)
         # Clean up the socket
         close_socket
 
         raise Bunny::ForcedConnectionCloseError, "Error Reply Code: #{received_method.reply_code}\nError Reply Text: #{received_method.reply_text}"
 
-      when received_method.is_a?(Qrack::Protocol09::Channel::Close)
+      when received_method.is_a?(Qrack::Protocol::Channel::Close)
         # Clean up the channel
         channel.active = false
 
@@ -63,11 +63,11 @@ module Bunny
       # Set client channel to zero
       switch_channel(0)
 
-      send_frame(Qrack::Protocol09::Connection::Close.new(:reply_code => 200, :reply_text => 'Goodbye', :class_id => 0, :method_id => 0))
+      send_frame(Qrack::Protocol::Connection::Close.new(:reply_code => 200, :reply_text => 'Goodbye', :class_id => 0, :method_id => 0))
 
       method = next_method
 
-      check_response(method, Qrack::Protocol09::Connection::CloseOk, "Error closing connection")
+      check_response(method, Qrack::Protocol::Connection::CloseOk, "Error closing connection")
 
     end
 
@@ -76,7 +76,7 @@ module Bunny
         return c if (!c.open? and c.number != 0)
       end
       # If no channel to re-use instantiate new one
-      Bunny::Channel09.new(self)
+      Bunny::Channel.new(self)
     end
 
     # Declares an exchange to the broker/server. If the exchange does not exist, a new one is created
@@ -103,17 +103,17 @@ module Bunny
     # @option opts [Boolean] :nowait (false)
     #   Ignored by Bunny, always @false@.
     #
-    # @return [Bunny::Exchange09]
+    # @return [Bunny::Exchange]
     def exchange(name, opts = {})
-      exchanges[name] || Bunny::Exchange09.new(self, name, opts)
+      exchanges[name] || Bunny::Exchange.new(self, name, opts)
     end
 
     def init_connection
-      write(Qrack::Protocol09::HEADER)
-      write([0, Qrack::Protocol09::VERSION_MAJOR, Qrack::Protocol09::VERSION_MINOR, Qrack::Protocol09::REVISION].pack('C4'))
+      write(Qrack::Protocol::HEADER)
+      write([0, Qrack::Protocol::VERSION_MAJOR, Qrack::Protocol::VERSION_MINOR, Qrack::Protocol::REVISION].pack('C4'))
 
       frame = next_frame
-      if frame.nil? or !frame.payload.is_a?(Qrack::Protocol09::Connection::Start)
+      if frame.nil? or !frame.payload.is_a?(Qrack::Protocol::Connection::Start)
         raise Bunny::ProtocolError, 'Connection initiation failed'
       end
     end
@@ -124,12 +124,8 @@ module Bunny
       case
       when channel.frame_buffer.size > 0
         frame = channel.frame_buffer.shift
-      when (timeout = opts[:timeout]) && timeout > 0
-        Bunny::Timer::timeout(timeout, Qrack::FrameTimeout) do
-          frame = Qrack::Transport09::Frame.parse(buffer)
-        end
       else
-        frame = Qrack::Transport09::Frame.parse(buffer)
+        frame = Qrack::Transport::Frame.parse(buffer, opts)
       end
 
       @logger.info("received") { frame } if @logging
@@ -140,7 +136,7 @@ module Bunny
       @message_in = true
 
       case
-      when frame.is_a?(Qrack::Transport09::Heartbeat)
+      when frame.is_a?(Qrack::Transport::Heartbeat)
         next_frame(opts)
       when frame.nil?
         frame
@@ -161,22 +157,20 @@ module Bunny
         :response => "\0" + @user + "\0" + @pass,
         :locale => 'en_US'
       }
-      send_frame(Qrack::Protocol09::Connection::StartOk.new(start_opts))
+      send_frame(Qrack::Protocol::Connection::StartOk.new(start_opts))
 
       frame = next_frame
       raise Bunny::ProtocolError, "Connection failed - user: #{@user}" if frame.nil?
 
       method = frame.payload
 
-      if method.is_a?(Qrack::Protocol09::Connection::Tune)
-        @frame_max = method.frame_max if method.frame_max > 0 && method.frame_max < @frame_max
-        @channel_max = method.channel_max if method.channel_max > 0 && method.channel_max < @channel_max
-        send_frame(Qrack::Protocol09::Connection::TuneOk.new(:channel_max => @channel_max, :frame_max => @frame_max, :heartbeat => @heartbeat))
+      if method.is_a?(Qrack::Protocol::Connection::Tune)
+        send_frame(Qrack::Protocol::Connection::TuneOk.new(:channel_max => @channel_max, :frame_max => @frame_max, :heartbeat => @heartbeat))
       end
 
-      send_frame(Qrack::Protocol09::Connection::Open.new(:virtual_host => @vhost, :reserved_1 => 0, :reserved_2 => false))
+      send_frame(Qrack::Protocol::Connection::Open.new(:virtual_host => @vhost, :reserved_1 => 0, :reserved_2 => false))
 
-      raise Bunny::ProtocolError, 'Cannot open connection' unless next_method.is_a?(Qrack::Protocol09::Connection::OpenOk)
+      raise Bunny::ProtocolError, 'Cannot open connection' unless next_method.is_a?(Qrack::Protocol::Connection::OpenOk)
     end
 
     # Requests a specific quality of service. The QoS can be specified for the current channel
@@ -206,11 +200,11 @@ module Bunny
     #
     # @return [Symbol] @:qos_ok@ if successful.
     def qos(opts = {})
-      send_frame(Qrack::Protocol09::Basic::Qos.new({ :prefetch_size => 0, :prefetch_count => 1, :global => false }.merge(opts)))
+      send_frame(Qrack::Protocol::Basic::Qos.new({ :prefetch_size => 0, :prefetch_count => 1, :global => false }.merge(opts)))
 
       method = next_method
 
-      check_response(method, Qrack::Protocol09::Basic::QosOk, "Error specifying Quality of Service")
+      check_response(method, Qrack::Protocol::Basic::QosOk, "Error specifying Quality of Service")
 
       # return confirmation
       :qos_ok
@@ -244,7 +238,7 @@ module Bunny
     # @option opts [Boolean] :nowait (false)
     #   Ignored by Bunny, always @false@.
     #
-    # @return [Bunny::Queue09]
+    # @return [Bunny::Queue]
     def queue(name = nil, opts = {})
       if name.is_a?(Hash)
         opts = name
@@ -252,7 +246,7 @@ module Bunny
       end
 
       # Queue is responsible for placing itself in the list of queues
-      queues[name] || Bunny::Queue09.new(self, name, opts)
+      queues[name] || Bunny::Queue.new(self, name, opts)
     end
 
     # Asks the broker to redeliver all unacknowledged messages on a specified channel. Zero or
@@ -263,12 +257,12 @@ module Bunny
     #   If set to @true@, the server will attempt to requeue the message, potentially
     #   then delivering it to an alternative subscriber.
     def recover(opts = {})
-      send_frame(Qrack::Protocol09::Basic::Recover.new({ :requeue => false }.merge(opts)))
+      send_frame(Qrack::Protocol::Basic::Recover.new({ :requeue => false }.merge(opts)))
     end
 
     def send_frame(*args)
       args.each do |data|
-        data         = data.to_frame(channel.number) unless data.is_a?(Qrack::Transport09::Frame)
+        data         = data.to_frame(channel.number) unless data.is_a?(Qrack::Transport::Frame)
         data.channel = channel.number
 
         @logger.info("send") { data } if @logging
@@ -283,7 +277,7 @@ module Bunny
 
     def send_heartbeat
       # Create a new heartbeat frame
-      hb = Qrack::Transport09::Heartbeat.new('')
+      hb = Qrack::Transport::Heartbeat.new('')
       # Channel 0 must be used
       switch_channel(0) if @channel.number > 0
       # Send the heartbeat to server
@@ -324,11 +318,11 @@ module Bunny
     #
     # @return [Symbol] @:commit_ok@ if successful.
     def tx_commit
-      send_frame(Qrack::Protocol09::Tx::Commit.new())
+      send_frame(Qrack::Protocol::Tx::Commit.new())
 
       method = next_method
 
-      check_response(method, Qrack::Protocol09::Tx::CommitOk, "Error commiting transaction")
+      check_response(method, Qrack::Protocol::Tx::CommitOk, "Error commiting transaction")
 
       # return confirmation
       :commit_ok
@@ -340,11 +334,11 @@ module Bunny
     #
     # @return [Symbol] @:rollback_ok@ if successful.
     def tx_rollback
-      send_frame(Qrack::Protocol09::Tx::Rollback.new())
+      send_frame(Qrack::Protocol::Tx::Rollback.new())
 
       method = next_method
 
-      check_response(method, Qrack::Protocol09::Tx::RollbackOk, "Error rolling back transaction")
+      check_response(method, Qrack::Protocol::Tx::RollbackOk, "Error rolling back transaction")
 
       # return confirmation
       :rollback_ok
@@ -356,26 +350,20 @@ module Bunny
     #
     # @return [Symbol] @:select_ok@ if successful.
     def tx_select
-      send_frame(Qrack::Protocol09::Tx::Select.new())
+      send_frame(Qrack::Protocol::Tx::Select.new())
 
       method = next_method
 
-      check_response(method, Qrack::Protocol09::Tx::SelectOk, "Error initiating transactions for current channel")
+      check_response(method, Qrack::Protocol::Tx::SelectOk, "Error initiating transactions for current channel")
 
       # return confirmation
       :select_ok
     end
 
-    protected
-
-    def check_returned_message(method)
-      check_response(method, Qrack::Protocol09::Basic::Return, "Expected a returned message")
-    end
-
     private
 
     def buffer
-      @buffer ||= Qrack::Transport09::Buffer.new(self)
+      @buffer ||= Qrack::Transport::Buffer.new(self)
     end
 
   end

data/lib/bunny/{exchange09.rb → exchange.rb}

@@ -24,7 +24,7 @@ module Bunny
   # If you want more information about exchanges, please consult the documentation for your
   # target broker/server or visit the "AMQP website":http://www.amqp.org to find the version of the
   # specification that applies to your target broker/server.
-  class Exchange09
+  class Exchange
 
     attr_reader :client, :type, :name, :opts, :key
 
@@ -58,11 +58,11 @@ module Bunny
           :deprecated_ticket => 0, :deprecated_auto_delete => false, :deprecated_internal => false
         }.merge(opts)
 
-        client.send_frame(Qrack::Protocol09::Exchange::Declare.new(opts))
+        client.send_frame(Qrack::Protocol::Exchange::Declare.new(opts))
 
         method = client.next_method
 
-        client.check_response(method, Qrack::Protocol09::Exchange::DeclareOk, "Error declaring exchange #{name}: type = #{type}")
+        client.check_response(method, Qrack::Protocol::Exchange::DeclareOk, "Error declaring exchange #{name}: type = #{type}")
       end
     end
 
@@ -83,11 +83,11 @@ module Bunny
 
       opts = { :exchange => name, :nowait => false, :deprecated_ticket => 0 }.merge(opts)
 
-      client.send_frame(Qrack::Protocol09::Exchange::Delete.new(opts))
+      client.send_frame(Qrack::Protocol::Exchange::Delete.new(opts))
 
       method = client.next_method
 
-      client.check_response(method, Qrack::Protocol09::Exchange::DeleteOk, "Error deleting exchange #{name}")
+      client.check_response(method, Qrack::Protocol::Exchange::DeleteOk, "Error deleting exchange #{name}")
 
       client.exchanges.delete(name)
 
@@ -128,34 +128,35 @@ module Bunny
       opts = opts.dup
       out = []
 
+
       # Set up options
       routing_key = opts.delete(:key) || key
       mandatory = opts.delete(:mandatory)
       immediate = opts.delete(:immediate)
       delivery_mode = opts.delete(:persistent) ? 2 : 1
       content_type = opts.delete(:content_type) || 'application/octet-stream'
+      reply_to = opts.delete(:reply_to)
+      correlation_id = opts.delete(:correlation_id)
+      user_id = opts.delete(:user_id)
 
-      out << Qrack::Protocol09::Basic::Publish.new({ :exchange => name,
+      out << Qrack::Protocol::Basic::Publish.new({ :exchange => name,
                                                      :routing_key => routing_key,
                                                      :mandatory => mandatory,
                                                      :immediate => immediate,
                                                      :deprecated_ticket => 0 })
       data = data.to_s
-      out << Qrack::Protocol09::Header.new(
-                                           Qrack::Protocol09::Basic,
+      out << Qrack::Protocol::Header.new(
+                                           Qrack::Protocol::Basic,
                                            data.bytesize, {
                                              :content_type  => content_type,
                                              :delivery_mode => delivery_mode,
+                                             :reply_to => reply_to,
+                                             :correlation_id => correlation_id,
+                                             :user_id => user_id,
                                              :priority      => 0
                                            }.merge(opts)
                                            )
-
-      limit = @client.frame_max - 8
-      i = 0
-      while i < data.bytesize
-        out << Qrack::Transport09::Body.new(data.byteslice(i, limit))
-        i += limit
-      end
+      out << Qrack::Transport::Body.new(data)
 
       client.send_frame(*out)
     end

data/lib/bunny/{queue09.rb → queue.rb}

@@ -4,7 +4,7 @@ module Bunny
 
   # Queues store and forward messages. Queues can be configured in the server or created at runtime.
   # Queues must be attached to at least one exchange in order to receive messages from publishers.
-  class Queue09 < Qrack::Queue
+  class Queue < Qrack::Queue
     def initialize(client, name, opts = {})
       # check connection to server
       raise Bunny::ConnectionError, 'Not connected to server' if client.status == :not_connected
@@ -31,11 +31,11 @@ module Bunny
 
       opts = { :queue => name || '', :nowait => false, :deprecated_ticket => 0 }.merge(opts)
 
-      client.send_frame(Qrack::Protocol09::Queue::Declare.new(opts))
+      client.send_frame(Qrack::Protocol::Queue::Declare.new(opts))
 
       method = client.next_method
 
-      client.check_response(method, Qrack::Protocol09::Queue::DeclareOk, "Error declaring queue #{name}")
+      client.check_response(method, Qrack::Protocol::Queue::DeclareOk, "Error declaring queue #{name}")
 
       @name = method.queue
       client.queues[@name] = self
@@ -54,7 +54,7 @@ module Bunny
     # @private
     def self.consumer_class
       # Bunny::Consumer
-      Bunny::Subscription09
+      Bunny::Subscription
     end # self.consumer_class
 
     # Acknowledges one or more messages delivered via the _Deliver_ or _Get_-_Ok_ methods. The client can
@@ -78,7 +78,7 @@ module Bunny
 
       opts = {:delivery_tag => delivery_tag, :multiple => false}.merge(opts)
 
-      client.send_frame(Qrack::Protocol09::Basic::Ack.new(opts))
+      client.send_frame(Qrack::Protocol::Basic::Ack.new(opts))
 
       # reset delivery tag
       self.delivery_tag = nil
@@ -111,11 +111,11 @@ module Bunny
         :deprecated_ticket => 0
       }.merge(opts)
 
-      client.send_frame(Qrack::Protocol09::Queue::Bind.new(opts))
+      client.send_frame(Qrack::Protocol::Queue::Bind.new(opts))
 
       method = client.next_method
 
-      client.check_response(method, Qrack::Protocol09::Queue::BindOk, "Error binding queue: #{name} to exchange: #{exchange}")
+      client.check_response(method, Qrack::Protocol::Queue::BindOk, "Error binding queue: #{name} to exchange: #{exchange}")
 
       # return message
       :bind_ok
@@ -144,11 +144,11 @@ module Bunny
 
       opts = { :queue => name, :nowait => false, :deprecated_ticket => 0 }.merge(opts)
 
-      client.send_frame(Qrack::Protocol09::Queue::Delete.new(opts))
+      client.send_frame(Qrack::Protocol::Queue::Delete.new(opts))
 
       method = client.next_method
 
-      client.check_response(method, Qrack::Protocol09::Queue::DeleteOk, "Error deleting queue #{name}")
+      client.check_response(method, Qrack::Protocol::Queue::DeleteOk, "Error deleting queue #{name}")
 
       client.queues.delete(name)
 
@@ -174,13 +174,13 @@ module Bunny
         :deprecated_ticket => 0
       }.merge(opts)
 
-      client.send_frame(Qrack::Protocol09::Basic::Get.new(opts))
+      client.send_frame(Qrack::Protocol::Basic::Get.new(opts))
 
       method = client.next_method
 
-      if method.is_a?(Qrack::Protocol09::Basic::GetEmpty) then
+      if method.is_a?(Qrack::Protocol::Basic::GetEmpty) then
         queue_empty = true
-      elsif !method.is_a?(Qrack::Protocol09::Basic::GetOk)
+      elsif !method.is_a?(Qrack::Protocol::Basic::GetOk)
         raise Bunny::ProtocolError, "Error getting message from queue #{name}"
       end
 
@@ -221,11 +221,11 @@ module Bunny
 
       opts = { :queue => name, :nowait => false, :deprecated_ticket => 0 }.merge(opts)
 
-      client.send_frame(Qrack::Protocol09::Queue::Purge.new(opts))
+      client.send_frame(Qrack::Protocol::Queue::Purge.new(opts))
 
       method = client.next_method
 
-      client.check_response(method,   Qrack::Protocol09::Queue::PurgeOk, "Error purging queue #{name}")
+      client.check_response(method,   Qrack::Protocol::Queue::PurgeOk, "Error purging queue #{name}")
 
       # return confirmation
       :purge_ok
@@ -234,7 +234,7 @@ module Bunny
     # @return [Hash] Hash with keys @:message_count@ and @consumer_count@.
     def status
       opts = { :queue => name, :passive => true, :deprecated_ticket => 0 }
-      client.send_frame(Qrack::Protocol09::Queue::Declare.new(opts))
+      client.send_frame(Qrack::Protocol::Queue::Declare.new(opts))
 
       method = client.next_method
       {:message_count => method.message_count, :consumer_count => method.consumer_count}
@@ -272,11 +272,11 @@ module Bunny
         :deprecated_ticket => 0
       }.merge(opts)
 
-      client.send_frame(Qrack::Protocol09::Queue::Unbind.new(opts))
+      client.send_frame(Qrack::Protocol::Queue::Unbind.new(opts))
 
       method = client.next_method
 
-      client.check_response(method, Qrack::Protocol09::Queue::UnbindOk, "Error unbinding queue #{name}")
+      client.check_response(method, Qrack::Protocol::Queue::UnbindOk, "Error unbinding queue #{name}")
 
       # return message
       :unbind_ok
@@ -291,6 +291,9 @@ module Bunny
     # @option opts [Boolean] :nowait (false)
     #   Ignored by Bunny, always @false@.
     #
+    # @option opts [Boolean] :nowait (false)
+    #   Ignored by Bunny, always @false@.
+    #
     # @return [Symbol] @:unsubscribe_ok@ if successful
     def unsubscribe(opts = {})
       # Default consumer_tag from subscription if not passed in
@@ -301,15 +304,15 @@ module Bunny
       "No consumer tag received" if !consumer_tag
 
       # Cancel consumer
-      client.send_frame(Qrack::Protocol09::Basic::Cancel.new(:consumer_tag => consumer_tag, :nowait => false))
-
-      method = client.next_method
-
-      client.check_response(method, Qrack::Protocol09::Basic::CancelOk, "Error unsubscribing from queue #{name}")
+      client.send_frame(Qrack::Protocol::Basic::Cancel.new(:consumer_tag => consumer_tag, :nowait => false))
 
       # Reset subscription
       @default_consumer = nil
 
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol::Basic::CancelOk, "Error unsubscribing from queue #{name}, got #{method.class}")
+
       # Return confirmation
       :unsubscribe_ok
     end
@@ -317,7 +320,7 @@ module Bunny
     private
 
     def exchange
-      @exchange ||= Bunny::Exchange09.new(client, '', :type => :direct, :key => name, :reserved_1 => 0, :reserved_2 => false, :reserved_3 => false)
+      @exchange ||= Bunny::Exchange.new(client, '', :type => :direct, :key => name, :reserved_1 => 0, :reserved_2 => false, :reserved_3 => false)
     end
 
   end

data/lib/bunny/{subscription09.rb → subscription.rb}

@@ -31,6 +31,12 @@ module Bunny
   # @option opts [Integer] :message_max
   #   When the required number of messages is processed subscribe loop is exited.
   #
+  # @option opts [IO] :cancellator (nil)
+  #   A cancellator can be used to for cancelling the subscribe loop from another
+  #   thread or from a signal handler. Whenever Bunny notices that this IO object has
+  #   become readable, the subscribe loop will be exited after the current message
+  #   has been processed.
+  #
   # h2. Operation
   #
   # Passes a hash of message information to the block, if one has been supplied. The hash contains
@@ -54,14 +60,13 @@ module Bunny
   #   :exchange
   #   :routing_key
   #
-  # If the :timeout option is specified then the subscription will
-  # automatically cease if the given number of seconds passes with no
-  # message arriving.
+  # If the :timeout option is specified then the subscription will automatically
+  # cease if the given number of seconds passes with no message arriving.
   #
   # @example
   #   my_queue.subscribe(timeout: 5) { |msg| puts msg[:payload] }
   #   my_queue.subscribe(message_max: 10, ack: true) { |msg| puts msg[:payload] }
-  class Subscription09 < Bunny::Consumer
+  class Subscription < Bunny::Consumer
 
     def setup_consumer
       subscription_options = {
@@ -73,11 +78,11 @@ module Bunny
         :nowait => false
       }.merge(@opts)
 
-      client.send_frame(Qrack::Protocol09::Basic::Consume.new(subscription_options))
+      client.send_frame(Qrack::Protocol::Basic::Consume.new(subscription_options))
 
       method = client.next_method
 
-      client.check_response(method, Qrack::Protocol09::Basic::ConsumeOk, "Error subscribing to queue #{queue.name}")
+      client.check_response(method, Qrack::Protocol::Basic::ConsumeOk, "Error subscribing to queue #{queue.name}, got #{method}")
 
       @consumer_tag = method.consumer_tag
     end

data/lib/bunny/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Bunny
-  VERSION = "0.7.13"
+  VERSION = "0.8.0"
 end

data/lib/bunny.rb

@@ -34,25 +34,21 @@ module Bunny
   # Instantiates new Bunny::Client
 
   def self.new(connection_string_or_opts = Hash.new, opts = Hash.new)
-    # Set up Bunny according to AMQP spec version required
+    # Set up Bunny
     if connection_string_or_opts.respond_to?(:keys) && opts.empty?
       opts = connection_string_or_opts
     end
 
-    spec_version = opts[:spec] || '08'
-
     # Return client
-    setup(spec_version, connection_string_or_opts, opts)
+    setup(connection_string_or_opts, opts)
   end
 
-  # Runs a code block using a short-lived connection
-
-  def self.run(opts = {}, &block)
+  # Runs a code block using a Bunny connection
+  def self.run(connection_string_or_opts = {}, opts = {}, &block)
     raise ArgumentError, 'Bunny#run requires a block' unless block
 
-    # Set up Bunny according to AMQP spec version required
-    spec_version = opts[:spec] || '08'
-    client = setup(spec_version, opts)
+    # Set up Bunny
+    client = setup(connection_string_or_opts, opts)
 
     begin
       client.start
@@ -78,32 +74,18 @@ module Bunny
 
   private
 
-  def self.setup(version, *args)
-    if version == '08'
-      # AMQP 0-8 specification
-      require 'qrack/qrack08'
-      require 'bunny/client08'
-      require 'bunny/exchange08'
-      require 'bunny/queue08'
-      require 'bunny/channel08'
-      require 'bunny/subscription08'
-
-      client = Bunny::Client.new(*args)
-    else
-      # AMQP 0-9-1 specification
-      require 'qrack/qrack09'
-      require 'bunny/client09'
-      require 'bunny/exchange09'
-      require 'bunny/queue09'
-      require 'bunny/channel09'
-      require 'bunny/subscription09'
-
-      client = Bunny::Client09.new(*args)
-    end
+  def self.setup(*args)
+    # AMQP 0-9-1 specification
+    require 'qrack/qrack'
+    require 'bunny/client'
+    require 'bunny/exchange'
+    require 'bunny/queue'
+    require 'bunny/channel'
+    require 'bunny/subscription'
 
     include Qrack
 
-    client
+    client = Bunny::Client.new(*args)
   end
 
 end