bunny 0.6.3.rc2 → 0.7

data/lib/bunny.rb

@@ -1,48 +1,59 @@
-$:.unshift File.expand_path(File.dirname(__FILE__))
+# encoding: utf-8
 
-# Ruby standard libraries
-%w[socket thread timeout logger].each do |file|
-	require file
-end
+require "socket"
+require "thread"
+require "timeout"
+require "logger"
 
-require "bunny/version"
+require File.expand_path("../bunny/version", __FILE__)
+# if we don't require the version file the same way as in the gemspec,
+# the version file will be loaded twice. and we hate warnings.
 
 module Bunny
 
-	class ConnectionError < StandardError; end
-	class ForcedChannelCloseError < StandardError; end
-	class ForcedConnectionCloseError < StandardError; end
-	class MessageError < StandardError; end
-	class ProtocolError < StandardError; end
-	class ServerDownError < StandardError; end
-	class UnsubscribeError < StandardError; end
-	class AcknowledgementError < StandardError; end
-	
-	# Returns the Bunny version number
-
-	def self.version
-		VERSION
-	end
-	
-	# Instantiates new Bunny::Client
-
-	def self.new(opts = {})
-		# Set up Bunny according to AMQP spec version required
-		spec_version = opts[:spec] || '08'
-
-		# Return client
-		setup(spec_version, opts)
-	end
-	
-	# Runs a code block using a short-lived connection
+  class ConnectionError < StandardError; end
+  class ForcedChannelCloseError < StandardError; end
+  class ForcedConnectionCloseError < StandardError; end
+  class MessageError < StandardError; end
+  class ProtocolError < StandardError; end
+  class ServerDownError < StandardError; end
+  class UnsubscribeError < StandardError; end
+  class AcknowledgementError < StandardError; end
+
+  # Returns the Bunny version number
+
+  def self.version
+    VERSION
+  end
+
+  # Print deprecation warning.
+  def self.deprecation_warning(method, version)
+    warn "~ #{method} will be removed in Bunny #{version}."
+  end
+
+  # 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
+    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)
+  end
+
+  # Runs a code block using a short-lived connection
 
   def self.run(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 according to AMQP spec version required
+    spec_version = opts[:spec] || '08'
+    client = setup(spec_version, opts)
+
     begin
       client.start
       block.call(client)
@@ -50,38 +61,49 @@ module Bunny
       client.stop
     end
 
-		# Return success
-		:run_ok
+    # Return success
+    :run_ok
   end
 
-	private
-	
-	def self.setup(version, opts)	
-		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(opts)
-		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(opts)
-		end			
-		
-		include Qrack
+  Timer = if RUBY_VERSION < "1.9"
+            begin
+              require 'system_timer'
+              SystemTimer
+            rescue LoadError
+              Timeout
+            end
+          else
+            Timeout
+          end
+
+  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
+
+    include Qrack
 
     client
-	end
+  end
 
-end
+end

data/lib/bunny/channel08.rb

@@ -1,39 +1,39 @@
+# encoding: utf-8
+
 module Bunny
-	class Channel < Qrack::Channel
-		
-		def initialize(client)
-			super
-		end
-		
-		def open
-			client.channel = self
-			client.send_frame(Qrack::Protocol::Channel::Open.new)
-			
-			method = client.next_method
-			
-			client.check_response(method, Qrack::Protocol::Channel::OpenOk, "Cannot open channel #{number}")
-
-			@active = true
-			:open_ok
-		end
-		
-		def close
-			client.channel = self
-			client.send_frame(
-	      Qrack::Protocol::Channel::Close.new(:reply_code => 200, :reply_text => 'bye', :method_id => 0, :class_id => 0)
-	    )
-	
-			method = client.next_method
-			
-			client.check_response(method, Qrack::Protocol::Channel::CloseOk, "Error closing channel #{number}")
-	
-			@active = false
-			:close_ok
-		end
-		
-		def open?
-			active
-		end
-		
-	end
-end
+  class Channel < Qrack::Channel
+
+    def initialize(client)
+      super
+    end
+
+    def open
+      client.channel = self
+      client.send_frame(Qrack::Protocol::Channel::Open.new)
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol::Channel::OpenOk, "Cannot open channel #{number}")
+
+      @active = true
+      :open_ok
+    end
+
+    def close
+      client.channel = self
+      client.send_frame(Qrack::Protocol::Channel::Close.new(:reply_code => 200, :reply_text => 'bye', :method_id => 0, :class_id => 0))
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol::Channel::CloseOk, "Error closing channel #{number}")
+
+      @active = false
+      :close_ok
+    end
+
+    def open?
+      active
+    end
+
+  end
+end

data/lib/bunny/channel09.rb

@@ -1,39 +1,39 @@
+# encoding: utf-8
+
 module Bunny
-	class Channel09 < Qrack::Channel
-		
-		def initialize(client)
-			super
-		end
-		
-		def open
-			client.channel = self
-			client.send_frame(Qrack::Protocol09::Channel::Open.new)
-			
+  class Channel09 < Qrack::Channel
+
+    def initialize(client)
+      super
+    end
+
+    def open
+      client.channel = self
+      client.send_frame(Qrack::Protocol09::Channel::Open.new)
+
       method = client.next_method
-			
-			client.check_response(method, Qrack::Protocol09::Channel::OpenOk, "Cannot open channel #{number}")
-
-			@active = true
-			:open_ok
-		end
-		
-		def close
-			client.channel = self
-			client.send_frame(
-	      Qrack::Protocol09::Channel::Close.new(:reply_code => 200, :reply_text => 'bye', :method_id => 0, :class_id => 0)
-	    )
-	
-	    method = client.next_method
-			
-			client.check_response(method, Qrack::Protocol09::Channel::CloseOk, "Error closing channel #{number}")
-	
-			@active = false
-			:close_ok
-		end
-		
-		def open?
-			active
-		end
-		
-	end
-end
+
+      client.check_response(method, Qrack::Protocol09::Channel::OpenOk, "Cannot open channel #{number}")
+
+      @active = true
+      :open_ok
+    end
+
+    def close
+      client.channel = self
+      client.send_frame(Qrack::Protocol09::Channel::Close.new(:reply_code => 200, :reply_text => 'bye', :method_id => 0, :class_id => 0))
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol09::Channel::CloseOk, "Error closing channel #{number}")
+
+      @active = false
+      :close_ok
+    end
+
+    def open?
+      active
+    end
+
+  end
+end

data/lib/bunny/client08.rb

@@ -1,5 +1,7 @@
+# encoding: utf-8
+
 module Bunny
-	
+
 =begin rdoc
 
 === DESCRIPTION:
@@ -9,8 +11,8 @@ The Client class provides the major Bunny API methods.
 =end
 
   class Client < Qrack::Client
-	
-		attr_accessor :ticket
+
+    attr_accessor :ticket
 
 =begin rdoc
 
@@ -46,10 +48,10 @@ Sets up a Bunny::Client object ready for connection to a broker/server. _Client_
 
 =end
 
-    def initialize(opts = {})
-			super
-			@spec = '0-8'
-			@port = opts[:port] || (opts[:ssl] ? Qrack::Protocol::SSL_PORT : Qrack::Protocol::PORT)
+    def initialize(connection_string_or_opts = Hash.new, opts = Hash.new)
+      super
+      @spec = '0-8'
+      @port = opts[:port] || (opts[:ssl] ? Qrack::Protocol::SSL_PORT : Qrack::Protocol::PORT)
       @insist = opts[:insist]
     end
 
@@ -61,51 +63,46 @@ Checks response from AMQP methods and takes appropriate action
 
 =end
 
-		def check_response(received_method, expected_method, err_msg, err_class = Bunny::ProtocolError)
-			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
+    def check_response(received_method, expected_method, err_msg, err_class = Bunny::ProtocolError)
+      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")
-	    
+
+      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
+    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
 
 =begin rdoc
 
@@ -133,92 +130,82 @@ Exchange
 
 =end
 
-		def exchange(name, opts = {})
+    def exchange(name, opts = {})
       exchanges[name] || Bunny::Exchange.new(self, name, opts)
-		end
-		
-		def init_connection
-			write(Qrack::Protocol::HEADER)
+    end
+
+    def init_connection
+      write(Qrack::Protocol::HEADER)
       write([1, 1, Qrack::Protocol::VERSION_MAJOR, Qrack::Protocol::VERSION_MINOR].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 = 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
-				when opts.has_key?(:timeout)
-	        Timeout::timeout(opts[:timeout], Qrack::ClientTimeout) do
-	          frame = Qrack::Transport::Frame.parse(buffer)
-	        end
-	      else
-	        frame = Qrack::Transport::Frame.parse(buffer)
+
+      case
+      when channel.frame_buffer.size > 0
+        frame = channel.frame_buffer.shift
+      when (timeout = opts[:timeout]) && timeout > 0
+        Bunny::Timer::timeout(timeout, Qrack::ClientTimeout) do
+          frame = Qrack::Transport::Frame.parse(buffer)
+        end
+      else
+        frame = Qrack::Transport::Frame.parse(buffer)
+      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
-			
-			@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
-			send_frame(
-        Qrack::Protocol::Connection::StartOk.new(
-          {:platform => 'Ruby', :product => 'Bunny', :information => 'http://github.com/celldee/bunny', :version => VERSION},
-          'AMQPLAIN',
-          {:LOGIN => @user, :PASSWORD => @pass},
-          'en_US'
-        )
-      )
+    def open_connection
+      client_opts = { :platform => 'Ruby', :product => 'Bunny', :information => 'http://github.com/ruby-amqp/bunny', :version => VERSION }
+
+      send_frame(Qrack::Protocol::Connection::StartOk.new(client_opts, 'AMQPLAIN', {:LOGIN => @user, :PASSWORD => @pass}, 'en_US'))
 
       frame = next_frame
-			raise Bunny::ProtocolError, "Connection failed - user: #{@user}" if frame.nil?
-			
-			method = frame.payload
+      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)
-        )
+        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, :capabilities => '', :insist => @insist)
-      )
+      send_frame(Qrack::Protocol::Connection::Open.new(:virtual_host => @vhost, :capabilities => '', :insist => @insist))
 
       case method = next_method
       when Qrack::Protocol::Connection::OpenOk
         :ok
       when Qrack::Protocol::Connection::Redirect
-				raise Bunny::ConnectionError, "Cannot connect to the specified server - host: #{@host}, port: #{@port}" if @insist
-				
+        raise Bunny::ConnectionError, "Cannot connect to the specified server - host: #{@host}, port: #{@port}" if @insist
+
         @host, @port = method.host.split(':')
         close_socket
       else
         raise Bunny::ProtocolError, 'Cannot open connection'
       end
-		end
+    end
 
 =begin rdoc
 
@@ -252,15 +239,12 @@ true, they are applied to the entire connection.
 
 =end
 
-		def qos(opts = {})
+    def qos(opts = {})
+      send_frame(Qrack::Protocol::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
 
-			method = next_method
-			
-			check_response(method, Qrack::Protocol::Basic::QosOk, "Error specifying Quality of Service")
+      check_response(method, Qrack::Protocol::Basic::QosOk, "Error specifying Quality of Service")
 
       # return confirmation
       :qos_ok
@@ -280,7 +264,7 @@ occurs a _Bunny_::_ProtocolError_ is raised.
 * <tt>:passive => true or false (_default_)</tt> - 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.
-* <tt>:durable => true or false (_default_)</tt> - 	If set to _true_ when creating a new queue, the
+* <tt>:durable => true or false (_default_)</tt> -      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 queues) 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
@@ -288,8 +272,8 @@ occurs a _Bunny_::_ProtocolError_ is raised.
 * <tt>:exclusive => true or false (_default_)</tt> - 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'.
-* <tt>:auto_delete => true or false (_default_)</tt> - 	If set to _true_, the queue is deleted
-  when all consumers have finished	using it. Last consumer can be cancelled either explicitly
+* <tt>:auto_delete => true or false (_default_)</tt> -  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.
 * <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
@@ -299,8 +283,8 @@ occurs a _Bunny_::_ProtocolError_ is raised.
 Queue
 
 =end
-		
-		def queue(name = nil, opts = {})
+
+    def queue(name = nil, opts = {})
       if name.is_a?(Hash)
         opts = name
         name = nil
@@ -308,7 +292,7 @@ Queue
 
       # Queue is responsible for placing itself in the list of queues
       queues[name] || Bunny::Queue.new(self, name, opts)
-	  end
+    end
 
 =begin rdoc
 
@@ -325,27 +309,21 @@ the message, potentially then delivering it to an alternative subscriber.
 
 =end
 
-		def recover(opts = {})
-
-	    send_frame(
-	      Qrack::Protocol::Basic::Recover.new({ :requeue => false }.merge(opts))
-	    )
+    def recover(opts = {})
+      send_frame(Qrack::Protocol::Basic::Recover.new({ :requeue => false }.merge(opts)))
+    end
 
-	  end
-	
-		def request_access
-			send_frame(
-        Qrack::Protocol::Access::Request.new(:realm => '/data', :read => true, :write => true, :active => true, :passive => true)
-      )
+    def request_access
+      send_frame(Qrack::Protocol::Access::Request.new(:realm => '/data', :read => true, :write => true, :active => true, :passive => true))
 
       method = next_method
-			
-			check_response(method, Qrack::Protocol::Access::RequestOk, "Access denied")
-      
+
+      check_response(method, Qrack::Protocol::Access::RequestOk, "Access denied")
+
       self.ticket = method.ticket
-		end
-	
-		def send_frame(*args)
+    end
+
+    def send_frame(*args)
       args.each do |data|
         data.ticket  = ticket if ticket and data.respond_to?(:ticket=)
         data         = data.to_frame(channel.number) unless data.is_a?(Qrack::Transport::Frame)
@@ -354,21 +332,21 @@ the message, potentially then delivering it to an alternative subscriber.
         @logger.info("send") { data } if @logging
         write(data.to_s)
 
-				# Monitor client activity for heartbeat purposes
-				@message_out = true
+        # 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
+
+    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
 
 =begin rdoc
 
@@ -382,36 +360,36 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
 <tt>:connected</tt> if successful.
 
 =end
-		
-		def start_session
-			@connecting = true
-			
+
+    def start_session
+      @connecting = true
+
       loop do
-				# Create/get socket
-				socket
-				
-				# Initiate connection
-				init_connection
-
-				# Open connection
-				break if open_connection == :ok
+        # Create/get socket
+        socket
+
+        # Initiate connection
+        init_connection
+
+        # Open connection
+        break if open_connection == :ok
       end
 
-			# Open another channel because channel zero is used for specific purposes
-			c = create_channel()
-			c.open
-			
-			# Get access ticket
-			request_access
-
-			@connecting = false
-			
-			# return status
-			@status = :connected
+      # Open another channel because channel zero is used for specific purposes
+      c = create_channel()
+      c.open
+
+      # Get access ticket
+      request_access
+
+      @connecting = false
+
+      # return status
+      @status = :connected
     end
 
-		alias start start_session
-		
+    alias start start_session
+
 =begin rdoc
 
 === DESCRIPTION:
@@ -425,17 +403,17 @@ after a commit.
 
 =end
 
-		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
-		
+    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
+
 =begin rdoc
 
 === DESCRIPTION:
@@ -449,16 +427,16 @@ after a rollback.
 
 =end
 
-		def tx_rollback
-			send_frame(Qrack::Protocol::Tx::Rollback.new())
+    def tx_rollback
+      send_frame(Qrack::Protocol::Tx::Rollback.new())
 
-			method = next_method
-			
-			check_response(method, Qrack::Protocol::Tx::RollbackOk, "Error rolling back transaction")
+      method = next_method
+
+      check_response(method, Qrack::Protocol::Tx::RollbackOk, "Error rolling back transaction")
 
-			# return confirmation
-			:rollback_ok
-		end
+      # return confirmation
+      :rollback_ok
+    end
 
 =begin rdoc
 
@@ -473,18 +451,18 @@ using the Commit or Rollback methods.
 
 =end
 
-		def tx_select
-			send_frame(Qrack::Protocol::Tx::Select.new())
+    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")
+      method = next_method
+
+      check_response(method, Qrack::Protocol::Tx::SelectOk, "Error initiating transactions for current channel")
 
-			# return confirmation
-			:select_ok
-		end
+      # return confirmation
+      :select_ok
+    end
 
-  private
+    private
 
     def buffer
       @buffer ||= Qrack::Transport::Buffer.new(self)