bunny 0.5.2 → 0.5.3

data/bunny.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |s|
   s.name = %q{bunny}
-  s.version = "0.5.2"
+  s.version = "0.5.3"
   s.authors = ["Chris Duncan"]
-  s.date = %q{2009-08-17}
+  s.date = %q{2009-09-07}
   s.description = %q{Another synchronous Ruby AMQP client}
   s.email = %q{celldee@gmail.com}
   s.rubyforge_project = %q{bunny-amqp}
@@ -39,6 +39,8 @@ Gem::Specification.new do |s|
 		"lib/bunny/queue08.rb",
 		"lib/bunny/queue09.rb",
 		"lib/qrack/client.rb",
+		"lib/qrack/channel.rb",
+		"lib/qrack/queue.rb",
 		"lib/qrack/protocol/protocol08.rb",
 		"lib/qrack/protocol/protocol09.rb",
 		"lib/qrack/protocol/spec08.rb",

data/examples/simple_consumer_08.rb

@@ -48,12 +48,12 @@ q.bind(exch, :key => 'fred')
 i = 1
 
 # subscribe to queue
-ret = q.subscribe(:consumer_tag => 'testtag1', :timeout => 30) do |msg|
-	puts "#{i.to_s}: #{msg}"
-	i+=1
-end
-
-if ret == :timed_out
+begin
+	ret = q.subscribe(:consumer_tag => 'testtag1', :timeout => 30) do |msg|
+		puts "#{i.to_s}: #{msg}"
+		i+=1
+	end
+rescue Qrack::ClientTimeout
 	puts '==== simple_consumer_08.rb timed out - closing down ===='
 	q.unsubscribe(:consumer_tag => 'testtag1')
 	# close the connection

data/examples/simple_consumer_09.rb

@@ -48,12 +48,12 @@ q.bind(exch, :key => 'fred')
 i = 1
 
 # subscribe to queue
-ret = q.subscribe(:consumer_tag => 'testtag1', :timeout => 30) do |msg|
-	puts "#{i.to_s}: #{msg}"
-	i+=1
-end
-
-if ret == :timed_out
+begin
+	ret = q.subscribe(:consumer_tag => 'testtag1', :timeout => 30) do |msg|
+		puts "#{i.to_s}: #{msg}"
+		i+=1
+	end
+rescue Qrack::ClientTimeout
 	puts '==== simple_consumer_09.rb timed out - closing down ===='
 	q.unsubscribe(:consumer_tag => 'testtag1')
 	# close the connection

data/lib/bunny.rb

@@ -12,7 +12,7 @@ module Bunny
 	class ConnectionError < StandardError; end
 	class MessageError < StandardError; end
 	
-	VERSION = '0.5.2'
+	VERSION = '0.5.3'
 	
 	# Returns the Bunny version number
 

data/lib/bunny/channel08.rb

@@ -1,13 +1,8 @@
 module Bunny
-	class Channel
-		attr_accessor :number, :active
-		attr_reader :client
+	class Channel < Qrack::Channel
 		
-		def initialize(client, zero = false)
-			@client = client
-			zero ? @number = 0 : @number = client.channels.size
-			@active = false
-			client.channels[@number] ||= self
+		def initialize(client)
+			super
 		end
 		
 		def open

data/lib/bunny/channel09.rb

@@ -1,13 +1,8 @@
 module Bunny
-	class Channel09
-		attr_accessor :number, :active
-		attr_reader :client
+	class Channel09 < Qrack::Channel
 		
-		def initialize(client, zero = false)
-			@client = client
-			zero ? @number = 0 : @number = client.channels.size
-			@active = false
-			client.channels[@number] ||= self
+		def initialize(client)
+			super
 		end
 		
 		def open

data/lib/bunny/client08.rb

@@ -41,30 +41,30 @@ Sets up a Bunny::Client object ready for connection to a broker/server. _Client_
 =end
 
     def initialize(opts = {})
+			super
 			@spec = '0-8'
-			@host = opts[:host] || 'localhost'
 			@port = opts[:port] || Qrack::Protocol::PORT
-      @user   = opts[:user]  || 'guest'
-      @pass   = opts[:pass]  || 'guest'
-      @vhost  = opts[:vhost] || '/'
-			@logfile = opts[:logfile] || nil
-			@logging = opts[:logging] || false
       @insist = opts[:insist]
-      @status = :not_connected
-			@frame_max = opts[:frame_max] || 131072
-			@channel_max = opts[:channel_max] || 0
-			@heartbeat = opts[:heartbeat] || 0
-			@logger = nil
-			create_logger if @logging
-			@channels = []
-			# Create channel 0
-      @channel = Bunny::Channel.new(self, true)
-			@exchanges = {}
-			@queues = {}
-			@heartbeat_in = false
-			@connecting = false
     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)
+	    )
+	    raise Bunny::ProtocolError, "Error closing connection" unless next_method.is_a?(Qrack::Protocol::Connection::CloseOk)
+    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
 
 === DESCRIPTION:
@@ -95,6 +95,135 @@ Exchange
 			return exchanges[name] if exchanges.has_key?(name)
 			Bunny::Exchange.new(self, name, opts)
 		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 = 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)
+      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'
+        )
+      )
+
+      frame = next_frame
+			raise Bunny::ProtocolError, "Connection failed - user: #{@user}, pass: #{@pass}" 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, :capabilities => '', :insist => @insist)
+      )
+
+      case method = next_method
+      when Qrack::Protocol::Connection::OpenOk
+        return :ok
+      when Qrack::Protocol::Connection::Redirect
+				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
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+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.
+
+==== Options:
+
+* <tt>:prefetch_size => size in no. of octets (default = 0)</tt> - 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. Prefetching 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.
+* <tt>:prefetch_count => no. messages (default = 1)</tt> - 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.
+* <tt>:global => true or false (_default_)</tt> - By default the QoS settings apply to the current channel only. If set to
+true, they are applied to the entire connection.
+
+==== RETURNS:
+
+<tt>:qos_ok</tt> if successful.
+
+=end
+
+		def qos(opts = {})
+
+      send_frame(
+        Qrack::Protocol::Basic::Qos.new({ :prefetch_size => 0, :prefetch_count => 1, :global => false }.merge(opts))
+      )
+
+      raise Bunny::ProtocolError,
+        "Error specifying Quality of Service" unless
+ 				next_method.is_a?(Qrack::Protocol::Basic::QosOk)
+
+      # return confirmation
+      :qos_ok
+    end
 
 =begin rdoc
 
@@ -140,131 +269,63 @@ Queue
 
       Bunny::Queue.new(self, name, opts)
 	  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_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)
-        data.channel = channel.number
-
-        @logger.info("send") { data } if @logging
-        write(data.to_s)
-      end
-
-      nil
-    end
-
-    def next_frame(opts = {})
-			secs = opts[:timeout] || 0
-			
-			begin
-				Timeout::timeout(secs) do
-					@frame = Qrack::Transport::Frame.parse(buffer)
-				end
-			rescue Timeout::Error
-				return :timed_out
-			end
-			
-			@logger.info("received") { @frame } if @logging
-						
-			raise Bunny::ConnectionError, 'No connection to server' if (@frame.nil? and !connecting?)
-
-			if @frame.is_a?(Qrack::Transport::Heartbeat)
-				@heartbeat_in = true
-				next_frame
-			end
-			
-			@frame
-    end
-
-    def next_payload
-      frame = next_frame			
-			frame.payload
-    end
-
-		alias next_method next_payload
-		
-=begin rdoc
-
-=== DESCRIPTION:
-
-Checks to see whether or not an undeliverable message has been returned as a result of a publish
-with the <tt>:immediate</tt> or <tt>:mandatory</tt> options.
-
-==== OPTIONS:
-
-* <tt>:timeout => number of seconds (default = 0.1) - The method will wait for a return
-  message until this timeout interval is reached.
-
-==== RETURNS:
-
-<tt>:no_return</tt> if message was not returned before timeout .
-<tt>{:header, :return_details, :payload}</tt> if message is returned. <tt>:return_details</tt> is
-a hash <tt>{:reply_code, :reply_text, :exchange, :routing_key}</tt>.
-
-=end
-		
-		def returned_message(opts = {})
-			secs = opts[:timeout] || 0.1		
-			frame = next_frame(:timeout => secs)
-			
-			if frame.is_a?(Symbol)
-				return :no_return if frame == :timed_out
-			end
-
-			method = frame.payload
-			header = next_payload
-	    msg = next_payload
-	    raise Bunny::MessageError, 'unexpected length' if msg.length < header.size
-			
-			# Return the message and related info
-			{:header => header, :payload => msg, :return_details => method.arguments}
-		end
 
 =begin rdoc
 
 === DESCRIPTION:
 
-Closes the current communication channel and connection. If an error occurs a
-_Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <tt>:not_connected</tt>.
+Asks the broker to redeliver all unacknowledged messages on a specified channel. Zero or
+more messages may be redelivered.
 
-==== RETURNS:
+==== Options:
 
-<tt>:not_connected</tt> if successful.
+* <tt>:requeue => true or false (_default_)</tt> - 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.
 
 =end
 
-    def close
-			# Close all active channels
-			channels.each do |c|
-				c.close if c.open?
-			end
+		def recover(opts = {})
 
-			# Close connection to AMQP server
-			close_connection
+	    send_frame(
+	      Qrack::Protocol::Basic::Recover.new({ :requeue => false }.merge(opts))
+	    )
 
-			# Close TCP Socket
-      close_socket
-    end
+	  end
+	
+		def request_access
+			send_frame(
+        Qrack::Protocol::Access::Request.new(:realm => '/data', :read => true, :write => true, :active => true, :passive => true)
+      )
+      method = next_method
+      raise Bunny::ProtocolError, 'Access denied' unless method.is_a?(Qrack::Protocol::Access::RequestOk)
+      self.ticket = method.ticket
+		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)
+        data.channel = channel.number
 
-		alias stop close
+        @logger.info("send") { data } if @logging
+        write(data.to_s)
 
-    def read(*args)
-      send_command(:read, *args)
-    end
+				# Monitor client activity for heartbeat purposes
+				@message_out = true
+      end
 
-    def write(*args)
-      send_command(:write, *args)
+      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
 
 =begin rdoc
 
@@ -310,101 +371,20 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
 		
 =begin rdoc
 
-=== DESCRIPTION:
-
-Asks the broker to redeliver all unacknowledged messages on a specified channel. Zero or
-more messages may be redelivered.
-
-==== Options:
-
-* <tt>:requeue => true or false (_default_)</tt> - 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.
-
-=end
-
-		def recover(opts = {})
-
-	    send_frame(
-	      Qrack::Protocol::Basic::Recover.new({ :requeue => false }.merge(opts))
-	    )
-
-	  end
-
-=begin rdoc
-
-=== DESCRIPTION:
-
-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.
-
-==== Options:
-
-* <tt>:prefetch_size => size in no. of octets (default = 0)</tt> - 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. Prefetching 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.
-* <tt>:prefetch_count => no. messages (default = 1)</tt> - 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.
-* <tt>:global => true or false (_default_)</tt> - By default the QoS settings apply to the current channel only. If set to
-true, they are applied to the entire connection.
-
-=end
-			
-		def qos(opts = {})
-      
-      send_frame(
-        Qrack::Protocol::Basic::Qos.new({ :prefetch_size => 0, :prefetch_count => 1, :global => false }.merge(opts))
-      )
-
-      raise Bunny::ProtocolError,
-        "Error specifying Quality of Service" unless
- 				next_method.is_a?(Qrack::Protocol::Basic::QosOk)
-      
-      # return confirmation
-      :qos_ok
-    end
-
-=begin rdoc
-
-=== DESCRIPTION:
-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.
-
-=end
-
-		def tx_select
-			send_frame(Qrack::Protocol::Tx::Select.new())
-			
-			raise Bunny::ProtocolError,
-        "Error initiating transactions for current channel" unless
- 				next_method.is_a?(Qrack::Protocol::Tx::SelectOk)
-
-			# return confirmation
-			:select_ok
-		end
-		
-=begin rdoc
-
 === DESCRIPTION:
 This method commits all messages published and acknowledged in
 the current transaction. A new transaction starts immediately
 after a commit.
 
+==== RETURNS:
+
+<tt>:commit_ok</tt> if successful.
+
 =end
-		
+
 		def tx_commit
 			send_frame(Qrack::Protocol::Tx::Commit.new())
-			
+
 			raise Bunny::ProtocolError,
         "Error commiting transaction" unless
  				next_method.is_a?(Qrack::Protocol::Tx::CommitOk)
@@ -420,11 +400,15 @@ This method abandons all messages published and acknowledged in
 the current transaction. A new transaction starts immediately
 after a rollback.
 
+==== RETURNS:
+
+<tt>:rollback_ok</tt> if successful.
+
 =end
-		
+
 		def tx_rollback
 			send_frame(Qrack::Protocol::Tx::Rollback.new())
-			
+
 			raise Bunny::ProtocolError,
         "Error rolling back transaction" unless
  				next_method.is_a?(Qrack::Protocol::Tx::RollbackOk)
@@ -432,98 +416,29 @@ after a rollback.
 			# return confirmation
 			:rollback_ok
 		end
-	
-		def logging=(bool)
-			@logging = bool
-			create_logger if @logging
-		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 switch_channel(chann)
-			if (0...channels.size).include? chann
-				@channel = channels[chann]
-				chann
-			else
-				raise RuntimeError, "Invalid channel number - #{chann}"
-			end
-		end
-		
-		def connecting?
-			connecting
-		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 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'
-        )
-      )
+=begin rdoc
 
-      frame = next_frame
-			raise Bunny::ProtocolError, "Connection failed - user: #{@user}, pass: #{@pass}" if frame.nil?
-			
-			method = frame.payload
+=== DESCRIPTION:
+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.
 
-      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
+==== RETURNS:
 
-      send_frame(
-        Qrack::Protocol::Connection::Open.new(:virtual_host => @vhost, :capabilities => '', :insist => @insist)
-      )
+<tt>:select_ok</tt> if successful.
 
-      case method = next_method
-      when Qrack::Protocol::Connection::OpenOk
-        return :ok
-      when Qrack::Protocol::Connection::Redirect
-				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
 
-		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)
-	    )
-	    raise Bunny::ProtocolError, "Error closing connection" unless next_method.is_a?(Qrack::Protocol::Connection::CloseOk)
-    end
+		def tx_select
+			send_frame(Qrack::Protocol::Tx::Select.new())
+			
+			raise Bunny::ProtocolError,
+        "Error initiating transactions for current channel" unless
+ 				next_method.is_a?(Qrack::Protocol::Tx::SelectOk)
 
-		def request_access
-			send_frame(
-        Qrack::Protocol::Access::Request.new(:realm => '/data', :read => true, :write => true, :active => true, :passive => true)
-      )
-      method = next_method
-      raise Bunny::ProtocolError, 'Access denied' unless method.is_a?(Qrack::Protocol::Access::RequestOk)
-      self.ticket = method.ticket
+			# return confirmation
+			:select_ok
 		end
 
   private
@@ -532,47 +447,5 @@ after a rollback.
       @buffer ||= Qrack::Transport::Buffer.new(self)
     end
 
-    def send_command(cmd, *args)
-      begin
-				raise Bunny::ConnectionError, 'No connection - socket has not been created' if !@socket
-        @socket.__send__(cmd, *args)
-      rescue Errno::EPIPE, IOError => e
-        raise Bunny::ServerDownError, e.message
-      end
-    end
-
-    def socket
-      return @socket if @socket and (@status == :connected) and not @socket.closed?
-
-      begin  
-        # Attempt to connect.
-        @socket = timeout(CONNECT_TIMEOUT) do
-          TCPSocket.new(host, port)
-        end
-
-        if Socket.constants.include? 'TCP_NODELAY'
-          @socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
-        end
-      rescue => e
-        @status = :not_connected
-        raise Bunny::ServerDownError, e.message
-      end
-
-      @socket
-    end
-
-    def close_socket(reason=nil)
-      # Close the socket. The server is not considered dead.
-      @socket.close if @socket and not @socket.closed?
-      @socket   = nil
-      @status   = :not_connected
-    end
-
-    def create_logger
-			@logfile ? @logger = Logger.new("#{logfile}") : @logger = Logger.new(STDOUT)
-			@logger.level = Logger::INFO
-			@logger.datetime_format = "%Y-%m-%d %H:%M:%S"
-    end
-
   end
 end