bunny 0.8.0 → 0.9.0.pre1

data/ext/config.yml

@@ -1,4 +0,0 @@
----
-:spec_out: '../lib/qrack/protocol/spec.rb'
-:frame_out: '../lib/qrack/transport/frame.rb'
-:spec_in: 'amqp-0.9.1.json'

data/ext/qparser.rb

@@ -1,426 +0,0 @@
-# encoding: utf-8
-
-require 'json'
-require 'erb'
-require 'pathname'
-require 'yaml'
-
-def spec_details(spec)
-  meta = {}
-
-  meta['major']     = spec['major-version']
-  meta['minor']     = spec['minor-version']
-  meta['revision']  = spec['revision']
-  meta['port']      = spec['port']
-  meta['ssl_port']  = spec['ssl_port']
-  meta['comment']   = "AMQ Protocol version #{meta['major']}.#{meta['minor']}.#{meta['revision']}"
-
-  meta
-end
-
-def process_constants(spec)
-  # AMQP constants
-
-  frame_constants = {}
-  other_constants = {}
-
-  spec['constants'].each do |constant|
-    if constant['name'].match(/^frame/i)
-      frame_constants[constant['value'].to_i] =
-      constant['name'].sub(/^frame./i,'').split(/\s|-/).map{|w| w.downcase.capitalize}.join
-    else
-      other_constants[constant['value']] = constant['name']
-    end
-  end
-
-  [frame_constants.sort, other_constants.sort]
-end
-
-def domain_types(spec, major, minor, revision)
-  # AMQP domain types
-  dt_arr = []
-  spec["domains"].each do |domain|
-    # JSON spec gives domain types as two element arrays like ["channel-id", "longstr"]
-    dt_arr << domain.last
-  end
-
-  # Return sorted array
-  dt_arr.uniq.sort
-end
-
-def classes(spec, major, minor, revision)
-  # AMQP classes
-  spec['classes'].map do |amqp_class|
-    cls_hash = {}
-    cls_hash[:name]   = amqp_class['name']
-    cls_hash[:index]  = amqp_class['id']
-    # Get fields for class
-    cls_hash[:fields] = fields(amqp_class) # are these amqp_class["properties"] ?
-    # Get methods for class
-    meth_arr          = class_methods(amqp_class)
-    # Add array to class hash
-    cls_hash[:methods] = meth_arr
-    cls_hash
-  end
-end
-
-# Get methods for class
-def class_methods(amqp_class)
-  amqp_class['methods'].map do |method|
-    meth_hash = {}
-    meth_hash[:name]  = method['name']
-    meth_hash[:index] = method['id']
-    # Get fields for method
-    meth_hash[:fields] = fields(method)
-    meth_hash
-  end
-end
-
-# Get the fields for a class or method
-def fields(element)
-  # The JSON spec puts these in "properties" for a class and "arguments" for a
-  # method
-  (element['arguments'] || element['properties'] || []).map do |field|
-    field_hash = {}
-    field_hash[:name]   = field['name'].tr(' ', '-')
-    field_hash[:domain] = field['type'] || field['domain']
-
-    # Convert domain type if necessary
-    conv_arr = convert_type(field_hash[:domain])
-    field_hash[:domain] = conv_arr.last unless conv_arr.empty?
-
-    field_hash
-  end
-end
-
-def convert_type(name)
-  type_arr = @type_conversion.select {|k,v| k == name}.flatten
-end
-
-# Start of Main program
-
-# Read in config options
-CONFIG = YAML::load(File.read('config.yml'))
-
-# Get path to the spec file and the spec file name on its own
-specpath = CONFIG[:spec_in]
-path = Pathname.new(specpath)
-specfile = path.basename.to_s
-
-# Read in the spec file
-spec = JSON.parse(IO.read(specpath))
-
-# Declare type conversion hash
-@type_conversion = {'path' => 'shortstr',
-                    'known hosts' => 'shortstr',
-                    'known-hosts' => 'shortstr',
-                    'reply code' => 'short',
-                    'reply-code' => 'short',
-                    'reply text' => 'shortstr',
-                    'reply-text' => 'shortstr',
-                    'class id' => 'short',
-                    'class-id' => 'short',
-                    'method id' => 'short',
-                    'method-id' => 'short',
-                    'channel-id' => 'longstr',
-                    'access ticket' => 'short',
-                    'access-ticket' => 'short',
-                    'exchange name' => 'shortstr',
-                    'exchange-name' => 'shortstr',
-                    'queue name' => 'shortstr',
-                    'queue-name' => 'shortstr',
-                    'consumer tag' => 'shortstr',
-                    'consumer-tag' => 'shortstr',
-                    'delivery tag' => 'longlong',
-                    'delivery-tag' => 'longlong',
-                    'redelivered' => 'bit',
-                    'no ack' => 'bit',
-                    'no-ack' => 'bit',
-                    'no local' => 'bit',
-                    'no-local' => 'bit',
-                    'peer properties' => 'table',
-                    'peer-properties' => 'table',
-                    'destination' => 'shortstr',
-                    'duration' => 'longlong',
-                    'security-token' => 'longstr',
-                    'reject-code' => 'short',
-                    'reject-text' => 'shortstr',
-                    'offset' => 'longlong',
-                    'no-wait' => 'bit',
-                    'message-count' => 'long'
-                   }
-
-# Spec details
-spec_info = spec_details(spec)
-
-# Constants
-constants = process_constants(spec)
-
-# Frame constants
-frame_constants = constants[0].select {|k,v| k <= 8}
-frame_footer = constants[0].select {|k,v| v == 'End'}[0][0]
-
-# Other constants
-other_constants = constants[1]
-
-# Domain types
-data_types = domain_types(spec, spec_info['major'], spec_info['minor'], spec_info['revision'])
-
-# Classes
-class_defs = classes(spec, spec_info['major'], spec_info['minor'], spec_info['revision'])
-
-# Generate spec.rb
-spec_rb = File.open(CONFIG[:spec_out], 'w')
-spec_rb.puts(
-ERB.new(%q[
-  # encoding: utf-8
-  
-
-  #:stopdoc:
-  # this file was autogenerated on <%= Time.now.to_s %>
-  # using <%= specfile.ljust(16) %> (mtime: <%= File.mtime(specpath) %>)
-  #
-  # DO NOT EDIT! (edit ext/qparser.rb and config.yml instead, and run 'ruby qparser.rb')
-
-  module Qrack
-    module Protocol
-      HEADER        = "AMQP".freeze
-      VERSION_MAJOR = <%= spec_info['major'] %>
-      VERSION_MINOR = <%= spec_info['minor'] %>
-      REVISION      = <%= spec_info['revision'] %>
-      PORT          = <%= spec_info['port'] %>
-      SSL_PORT      = <%= spec_info['ssl_port'] %>
-
-      RESPONSES = {
-        <%- other_constants.each do |value, name| -%>
-        <%= value %> => :<%= name.gsub(/\s|-/, '_').upcase -%>,
-        <%- end -%>
-      }
-
-      FIELDS = [
-        <%- data_types.each do |d| -%>
-        :<%= d -%>,
-        <%- end -%>
-      ]
-
-      class Class
-        class << self
-          FIELDS.each do |f|
-            class_eval %[
-              def #{f} name
-                properties << [ :#{f}, name ] unless properties.include?([:#{f}, name])
-                attr_accessor name
-              end
-            ]
-          end
-
-          def properties() @properties ||= [] end
-
-          def id()   self::ID end
-          def name() self::NAME.to_s end
-        end
-
-        class Method
-          class << self
-            FIELDS.each do |f|
-              class_eval %[
-                def #{f} name
-                  arguments << [ :#{f}, name ] unless arguments.include?([:#{f}, name])
-                  attr_accessor name
-                end
-              ]
-            end
-
-            def arguments() @arguments ||= [] end
-
-            def parent() Protocol.const_get(self.to_s[/Protocol::(.+?)::/,1]) end
-            def id()     self::ID end
-            def name()   self::NAME.to_s end
-          end
-
-          def == b
-            self.class.arguments.inject(true) do |eql, (type, name)|
-              eql and __send__("#{name}") == b.__send__("#{name}")
-            end
-          end
-        end
-
-        def self.methods() @methods ||= {} end
-
-        def self.Method(id, name)
-          @_base_methods ||= {}
-          @_base_methods[id] ||= ::Class.new(Method) do
-            class_eval %[
-              def self.inherited klass
-                klass.const_set(:ID, #{id})
-                klass.const_set(:NAME, :#{name.to_s})
-                klass.parent.methods[#{id}] = klass
-                klass.parent.methods[klass::NAME] = klass
-              end
-            ]
-          end
-        end
-      end
-
-      def self.classes() @classes ||= {} end
-
-      def self.Class(id, name)
-        @_base_classes ||= {}
-        @_base_classes[id] ||= ::Class.new(Class) do
-          class_eval %[
-            def self.inherited klass
-              klass.const_set(:ID, #{id})
-              klass.const_set(:NAME, :#{name.to_s})
-              Protocol.classes[#{id}] = klass
-              Protocol.classes[klass::NAME] = klass
-            end
-          ]
-        end
-      end
-    end
-  end
-
-  module Qrack
-    module Protocol
-      <%- class_defs.each do |h| -%>
-      class <%= h[:name].capitalize.ljust(12) %> < Class( <%= h[:index].to_s.rjust(3) %>, :<%= h[:name].ljust(12) %> ); end
-      <%- end -%>
-
-      <%- class_defs.each do |c| -%>
-      class <%= c[:name].capitalize %>
-        <%- c[:fields].each do |p| -%>
-        <%= p[:domain].ljust(10) %> :<%= p[:name].tr('-','_') %>
-        <%- end if c[:fields] -%>
-
-        <%- c[:methods].each do |m| -%>
-        class <%= m[:name].capitalize.gsub(/-(.)/){ "#{$1.upcase}"}.ljust(12) %> < Method( <%= m[:index].to_s.rjust(3) %>, :<%= m[:name].tr('- ','_').ljust(14) %> ); end
-        <%- end -%>
-
-        <%- c[:methods].each do |m| -%>
-
-        class <%= m[:name].capitalize.gsub(/-(.)/){ "#{$1.upcase}"} %>
-          <%- m[:fields].each do |a| -%>
-          <%- if a[:domain] -%>
-          <%= a[:domain].ljust(16) %> :<%= a[:name].tr('- ','_') %>
-          <%- end -%>
-          <%- end -%>
-        end
-        <%- end -%>
-
-      end
-
-      <%- end -%>
-    end
-
-  end
-].gsub!(/^  /,''), nil, '>-%').result(binding)
-)
-
-# Close spec.rb file
-spec_rb.close
-
-# Generate frame.rb file
-
-frame_rb = File.open(CONFIG[:frame_out], 'w')
-frame_rb.puts(
-ERB.new(%q[
-  # encoding: utf-8
-  
-  
-  #:stopdoc:
-  # this file was autogenerated on <%= Time.now.to_s %>
-  #
-  # DO NOT EDIT! (edit ext/qparser.rb and config.yml instead, and run 'ruby qparser.rb')
-
-  module Qrack
-    module Transport
-      class Frame
-
-        FOOTER = <%= frame_footer %>
-        ID = 0
-
-        @types = {
-                       <%- frame_constants.each do |value, name| -%>
-                   <%= value %> => '<%= name %>',
-                 <%- end -%>
-                 }
-
-        attr_accessor :channel, :payload
-
-        def initialize payload = nil, channel = 0
-          @channel, @payload = channel, payload
-        end
-
-        def id
-          self.class::ID
-        end
-
-        def to_binary
-          buf = Transport::Buffer.new
-          buf.write :octet, id
-          buf.write :short, channel
-          buf.write :longstr, payload
-          buf.write :octet, FOOTER
-          buf.rewind
-          buf
-        end
-
-        def to_s
-          to_binary.to_s
-        end
-
-        def == frame
-          [ :id, :channel, :payload ].inject(true) do |eql, field|
-            eql and __send__(field) == frame.__send__(field)
-          end
-        end
-
-        def self.parse(buf, cancellator = nil)
-          buf = Transport::Buffer.new(buf) unless buf.is_a? Transport::Buffer
-          buf.extract do
-            id, channel, payload, footer = buf.read(cancellator, :octet, :short, :longstr, :octet)
-            Qrack::Transport.const_get(@types[id]).new(payload, channel) if footer == FOOTER
-          end
-        end
-
-      end
-
-      class Method < Frame
-
-        ID = 1
-
-        def initialize payload = nil, channel = 0
-          super
-          unless @payload.is_a? Protocol::Class::Method or @payload.nil?
-            @payload = Protocol.parse(@payload)
-          end
-        end
-      end
-
-      class Header < Frame
-
-        ID = 2
-
-        def initialize payload = nil, channel = 0
-          super
-          unless @payload.is_a? Protocol::Header or @payload.nil?
-            @payload = Protocol::Header.new(@payload)
-          end
-        end
-      end
-
-      <%- frame_constants.each do |value, name| -%>
-      <%- if value > 2 -%>
-      class <%= name %> < Frame
-        ID = <%= value %>
-      end
-
-      <%- end -%>
-      <%- end -%>
-    end
-  end
-  ].gsub!(/^  /,''), nil, '>-%').result(binding)
-  )
-
-  # Close frame.rb file
-  frame_rb.close

data/lib/bunny/client.rb

@@ -1,370 +0,0 @@
-# encoding: utf-8
-
-module Bunny
-
-  # The Client class provides the major Bunny API methods.
-  class Client < Qrack::Client
-
-    # Sets up a Bunny::Client object ready for connection to a broker.
-    # {Client.status} is set to @:not_connected@.
-    #
-    # @option opts [String] :host ("localhost")
-    # @option opts [Integer] :port (5672 or 5671 if :ssl set to true)
-    # @option opts [String] :vhost ("/")
-    # @option opts [String] :user ("guest")
-    # @option opts [String] :pass ("guest")
-    # @option opts [Boolean] :ssl (false)
-    #   If set to @true@, ssl encryption will be used and port will default to 5671.
-    # @option opts [Boolean] :verify_ssl (true)
-    #   If ssl is enabled, this will cause OpenSSL to validate
-    #   the server certificate unless this parameter is set to @false@.
-    # @option opts [String] :logfile (nil)
-    # @option opts [Boolean] :logging (false)
-    #   If set to @true@, session information is sent to STDOUT if @:logfile@
-    #   has not been specified. Otherwise, session information is written to @:logfile@.
-    # @option opts [Integer] :frame_max (131072)
-    #   Maximum frame size in bytes.
-    # @option opts [Integer] :channel_max (0)
-    #   Maximum number of channels. Defaults to 0 which means no maximum.
-    # @option opts [Integer] :heartbeat (0)
-    #   Number of seconds. Defaults to 0 which means no heartbeat.
-    # @option opts [Integer] :connect_timeout (5)
-    #   Number of seconds before {Qrack::ConnectionTimeout} is raised.@
-    def initialize(connection_string_or_opts = Hash.new, opts = Hash.new)
-      super
-    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::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::Protocol::Channel::Close)
-        # Clean up the channel
-        channel.active = false
-
-        raise Bunny::ForcedChannelCloseError, "Error Reply Code: #{received_method.reply_code}\nError Reply Text: #{received_method.reply_text}"
-
-      when !received_method.is_a?(expected_method)
-        raise err_class, err_msg
-
-      else
-        :response_ok
-      end
-    end
-
-    def close_connection
-      # Set client channel to zero
-      switch_channel(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::Protocol::Connection::CloseOk, "Error closing connection")
-
-    end
-
-    def create_channel
-      channels.each do |c|
-        return c if (!c.open? and c.number != 0)
-      end
-      # If no channel to re-use instantiate new one
-      Bunny::Channel.new(self)
-    end
-
-    # Declares an exchange to the broker/server. If the exchange does not exist, a new one is created
-    # using the arguments passed in. If the exchange already exists, a reference to it is created, provided
-    # that the arguments passed in do not conflict with the existing attributes of the exchange. If an error
-    # occurs a _Bunny_::_ProtocolError_ is raised.
-    #
-    # @option opts [Symbol] :type (:direct)
-    #   One of :direct@, @:fanout@, @:topic@, or @:headers@.
-    #
-    # @option opts [Boolean] :passive
-    #   If set to @true@, the server will not create the exchange.
-    #   The client can use this to check whether an exchange exists without modifying the server state.
-    #
-    # @option opts [Boolean] :durable (false)
-    #   If set to @true@ when creating a new exchange, the exchange
-    #   will be marked as durable. Durable exchanges remain active
-    #   when a server restarts. Non-durable exchanges (transient exchanges)
-    #   are purged if/when a server restarts.
-    #
-    # @option opts [Boolean] :auto_delete (false)
-    #   If set to @true@, the exchange is deleted when all queues have finished using it.
-    #
-    # @option opts [Boolean] :nowait (false)
-    #   Ignored by Bunny, always @false@.
-    #
-    # @return [Bunny::Exchange]
-    def exchange(name, opts = {})
-      exchanges[name] || Bunny::Exchange.new(self, name, opts)
-    end
-
-    def init_connection
-      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::Protocol::Connection::Start)
-        raise Bunny::ProtocolError, 'Connection initiation failed'
-      end
-    end
-
-    def next_frame(opts = {})
-      frame = nil
-
-      case
-      when channel.frame_buffer.size > 0
-        frame = channel.frame_buffer.shift
-      else
-        frame = Qrack::Transport::Frame.parse(buffer, opts)
-      end
-
-      @logger.info("received") { frame } if @logging
-
-      raise Bunny::ConnectionError, 'No connection to server' if (frame.nil? and !connecting?)
-
-      # Monitor server activity and discard heartbeats
-      @message_in = true
-
-      case
-      when frame.is_a?(Qrack::Transport::Heartbeat)
-        next_frame(opts)
-      when frame.nil?
-        frame
-      when ((frame.channel != channel.number) and (frame.channel != 0))
-        channel.frame_buffer << frame
-        next_frame(opts)
-      else
-        frame
-      end
-
-    end
-
-    def open_connection
-      client_props = { :platform => 'Ruby', :product => 'Bunny', :information => 'http://github.com/ruby-amqp/bunny', :version => VERSION }
-      start_opts = {
-        :client_properties => client_props,
-        :mechanism => 'PLAIN',
-        :response => "\0" + @user + "\0" + @pass,
-        :locale => 'en_US'
-      }
-      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::Protocol::Connection::Tune)
-        send_frame(Qrack::Protocol::Connection::TuneOk.new(:channel_max => @channel_max, :frame_max => @frame_max, :heartbeat => @heartbeat))
-      end
-
-      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::Protocol::Connection::OpenOk)
-    end
-
-    # Requests a specific quality of service. The QoS can be specified for the current channel
-    # or for all channels on the connection. The particular properties and semantics of a QoS
-    # method always depend on the content class semantics. Though the QoS method could in principle
-    # apply to both peers, it is currently meaningful only for the server.
-    #
-    # @option opts [Integer] :prefetch_size (0)
-    #   Size in number of octets. The client can request that messages be sent in advance
-    #   so that when the client finishes processing a message, the following message is
-    #   already held locally, rather than needing to be sent down the channel. refetching
-    #   gives a performance improvement. This field specifies the prefetch window size
-    #   in octets. The server will send a message in advance if it is equal to or smaller
-    #   in size than the available prefetch size (and also falls into other prefetch limits).
-    #   May be set to zero, meaning "no specific limit", although other prefetch limits may
-    #   still apply. The prefetch-size is ignored if the no-ack option is set.
-    #
-    # @option opts [Integer] :prefetch_count (1)
-    #   Number of messages to prefetch. Specifies a prefetch window in terms of whole messages.
-    #   This field may be used in combination with the prefetch-size field; a message will only
-    #   be sent in advance if both prefetch windows (and those at the channel and connection level)
-    #   allow it. The prefetch-count is ignored if the no-ack option is set.
-    #
-    # @option opts [Boolean] :global (false)
-    #   By default the QoS settings apply to the current channel only. If set to true,
-    #   they are applied to the entire connection.
-    #
-    # @return [Symbol] @:qos_ok@ if successful.
-    def qos(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::Protocol::Basic::QosOk, "Error specifying Quality of Service")
-
-      # return confirmation
-      :qos_ok
-    end
-
-    # Declares a queue to the broker/server. If the queue does not exist, a new one is created
-    # using the arguments passed in. If the queue already exists, a reference to it is created, provided
-    # that the arguments passed in do not conflict with the existing attributes of the queue. If an error
-    # occurs a {Bunny::ProtocolError} is raised.
-    #
-    # @option opts [Boolean] :passive (false)
-    #   If set to @true@, the server will not create the queue. The client can use this to check
-    #   whether a queue exists without modifying the server state.
-    #
-    # @option opts [Boolean] :durable (false)
-    #   If set to @true@ when creating a new queue, the queue will be marked as durable.
-    #   Durable queues remain active when a server restarts. Non-durable queues (transient ones)
-    #   are purged if/when a server restarts. Note that durable queues do not necessarily hold
-    #   persistent messages, although it does not make sense to send persistent messages
-    #   to a transient queue.
-    #
-    # @option opts [Boolean] :exclusive (false)
-    #   If set to @true@, requests an exclusive queue. Exclusive queues may only be consumed
-    #   from by the current connection. Setting the 'exclusive' flag always implies 'auto-delete'.
-    #
-    # @option opts [Boolean] :auto_delete (false)
-    #   If set to @true@, the queue is deleted when all consumers have finished using it.
-    #   Last consumer can be cancelled either explicitly or because its channel is closed.
-    #   If there has never been a consumer on the queue, it is not deleted.
-    #
-    # @option opts [Boolean] :nowait (false)
-    #   Ignored by Bunny, always @false@.
-    #
-    # @return [Bunny::Queue]
-    def queue(name = nil, opts = {})
-      if name.is_a?(Hash)
-        opts = name
-        name = nil
-      end
-
-      # Queue is responsible for placing itself in the list of queues
-      queues[name] || Bunny::Queue.new(self, name, opts)
-    end
-
-    # Asks the broker to redeliver all unacknowledged messages on a specified channel. Zero or
-    # more messages may be redelivered.
-    #
-    # @option opts [Boolean] :requeue (false)
-    #   If set to @false@, the message will be redelivered to the original recipient.
-    #   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::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::Transport::Frame)
-        data.channel = channel.number
-
-        @logger.info("send") { data } if @logging
-        write(data.to_s)
-
-        # Monitor client activity for heartbeat purposes
-        @message_out = true
-      end
-
-      nil
-    end
-
-    def send_heartbeat
-      # Create a new heartbeat frame
-      hb = Qrack::Transport::Heartbeat.new('')
-      # Channel 0 must be used
-      switch_channel(0) if @channel.number > 0
-      # Send the heartbeat to server
-      send_frame(hb)
-    end
-
-    # Opens a communication channel and starts a connection. If an error occurs, a
-    # {Bunny::ProtocolError} is raised. If successful, {Client.status} is set to @:connected@.
-    #
-    # @return [Symbol] @:connected@ if successful.
-    def start_session
-      @connecting = true
-
-      # Create/get socket
-      socket
-
-      # Initiate connection
-      init_connection
-
-      # Open connection
-      open_connection
-
-      # Open another channel because channel zero is used for specific purposes
-      c = create_channel()
-      c.open
-
-      @connecting = false
-
-      # return status
-      @status = :connected
-    end
-
-    alias start start_session
-
-    # This method commits all messages published and acknowledged in
-    # the current transaction. A new transaction starts immediately
-    # after a commit.
-    #
-    # @return [Symbol] @:commit_ok@ if successful.
-    def tx_commit
-      send_frame(Qrack::Protocol::Tx::Commit.new())
-
-      method = next_method
-
-      check_response(method, Qrack::Protocol::Tx::CommitOk, "Error commiting transaction")
-
-      # return confirmation
-      :commit_ok
-    end
-
-    # This method abandons all messages published and acknowledged in
-    # the current transaction. A new transaction starts immediately
-    # after a rollback.
-    #
-    # @return [Symbol] @:rollback_ok@ if successful.
-    def tx_rollback
-      send_frame(Qrack::Protocol::Tx::Rollback.new())
-
-      method = next_method
-
-      check_response(method, Qrack::Protocol::Tx::RollbackOk, "Error rolling back transaction")
-
-      # return confirmation
-      :rollback_ok
-    end
-
-    # This method sets the channel to use standard transactions. The
-    # client must use this method at least once on a channel before
-    # using the Commit or Rollback methods.
-    #
-    # @return [Symbol] @:select_ok@ if successful.
-    def tx_select
-      send_frame(Qrack::Protocol::Tx::Select.new())
-
-      method = next_method
-
-      check_response(method, Qrack::Protocol::Tx::SelectOk, "Error initiating transactions for current channel")
-
-      # return confirmation
-      :select_ok
-    end
-
-    private
-
-    def buffer
-      @buffer ||= Qrack::Transport::Buffer.new(self)
-    end
-
-  end
-end