bunny 0.5.2 → 0.5.3

data/lib/bunny/client09.rb

@@ -35,29 +35,29 @@ Sets up a Bunny::Client object ready for connection to a broker/server. _Client_
 =end
 
     def initialize(opts = {})
+			super
 			@spec = '0-9-1'
-			@host = opts[:host] || 'localhost'
 			@port = opts[:port] || Qrack::Protocol09::PORT
-      @user   = opts[:user]  || 'guest'
-      @pass   = opts[:pass]  || 'guest'
-      @vhost  = opts[:vhost] || '/'
-			@logfile = opts[:logfile] || nil
-			@logging = opts[:logging] || false
-			@status = :not_connected
-			@frame_max = opts[:frame_max] || 131072
-			@channel_max = opts[:channel_max] || 5
-			@heartbeat = opts[:heartbeat] || 0
-			@logger = nil
-			create_logger if @logging
-			@channels = []
-			# Create channel 0
-      @channel = Bunny::Channel09.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::Protocol09::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::Protocol09::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::Channel09.new(self)
+		end
+
 =begin rdoc
 
 === DESCRIPTION:
@@ -89,6 +89,97 @@ Exchange
 			return exchanges[name] if exchanges.has_key?(name)
 			exchanges[name] ||= Bunny::Exchange09.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'))
+
+      frame = next_frame
+			if frame.nil? or !frame.payload.is_a?(Qrack::Protocol09::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::Transport09::Frame.parse(buffer)
+	        end
+	      else
+	        frame = Qrack::Transport09::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::Transport09::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
+
+=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::Protocol09::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::Protocol09::Basic::QosOk)
+
+      # return confirmation
+      :qos_ok
+    end
 
 =begin rdoc
 
@@ -134,130 +225,54 @@ Queue
 
       Bunny::Queue09.new(self, name, opts)
 	  end
-		
-		def send_heartbeat
-			# Create a new heartbeat frame
-			hb = Qrack::Transport09::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         = data.to_frame(channel.number) unless data.is_a?(Qrack::Transport09::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::Transport09::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::Transport09::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::Protocol09::Basic::Recover.new({ :requeue => false }.merge(opts))
+	    )
 
-			# Close TCP socket
-      close_socket
-    end
+	  end
+	
+		def send_frame(*args)
+      args.each do |data|
+        data         = data.to_frame(channel.number) unless data.is_a?(Qrack::Transport09::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::Transport09::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
 
 === DESCRIPTION:
@@ -298,68 +313,51 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
 =begin rdoc
 
 === DESCRIPTION:
+This method commits all messages published and acknowledged in
+the current transaction. A new transaction starts immediately
+after a commit.
 
-Asks the broker to redeliver all unacknowledged messages on a specified channel. Zero or
-more messages may be redelivered.
-
-==== Options:
+==== RETURNS:
 
-* <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.
+<tt>:commit_ok</tt> if successful.
 
 =end
 
-		def recover(opts = {})
+		def tx_commit
+			send_frame(Qrack::Protocol09::Tx::Commit.new())
 
-	    send_frame(
-	      Qrack::Protocol09::Basic::Recover.new({ :requeue => false }.merge(opts))
-	    )
+			raise Bunny::ProtocolError,
+        "Error commiting transaction" unless
+ 				next_method.is_a?(Qrack::Protocol09::Tx::CommitOk)
 
-	  end
-	
+			# return confirmation
+			:commit_ok
+		end
+		
 =begin rdoc
 
 === DESCRIPTION:
+This method abandons all messages published and acknowledged in
+the current transaction. A new transaction starts immediately
+after a rollback.
 
-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.
+==== RETURNS:
 
-==== 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.
+<tt>:rollback_ok</tt> if successful.
 
 =end
 
-		def qos(opts = {})
-
-      send_frame(
-        Qrack::Protocol09::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::Protocol09::Basic::QosOk)
+		def tx_rollback
+			send_frame(Qrack::Protocol09::Tx::Rollback.new())
 
-      # return confirmation
-      :qos_ok
-    end
+			raise Bunny::ProtocolError,
+        "Error rolling back transaction" unless
+ 				next_method.is_a?(Qrack::Protocol09::Tx::RollbackOk)
 
+			# return confirmation
+			:rollback_ok
+		end
+	
 =begin rdoc
 
 === DESCRIPTION:
@@ -367,6 +365,10 @@ 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.
 
+==== RETURNS:
+
+<tt>:select_ok</tt> if successful.
+
 =end
 
 		def tx_select
@@ -380,82 +382,6 @@ using the Commit or Rollback methods.
 			: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.
-
-=end
-		
-		def tx_commit
-			send_frame(Qrack::Protocol09::Tx::Commit.new())
-			
-			raise Bunny::ProtocolError,
-        "Error commiting transaction" unless
- 				next_method.is_a?(Qrack::Protocol09::Tx::CommitOk)
-
-			# return confirmation
-			:commit_ok
-		end
-		
-=begin rdoc
-
-=== DESCRIPTION:
-This method abandons all messages published and acknowledged in
-the current transaction. A new transaction starts immediately
-after a rollback.
-
-=end
-		
-		def tx_rollback
-			send_frame(Qrack::Protocol09::Tx::Rollback.new())
-			
-			raise Bunny::ProtocolError,
-        "Error rolling back transaction" unless
- 				next_method.is_a?(Qrack::Protocol09::Tx::RollbackOk)
-
-			# 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::Channel09.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::Protocol09::HEADER)
-      write([0, Qrack::Protocol09::VERSION_MAJOR, Qrack::Protocol09::VERSION_MINOR, Qrack::Protocol09::REVISION].pack('C4'))
-
-      frame = next_frame
-			if frame.nil? or !frame.payload.is_a?(Qrack::Protocol09::Connection::Start)
-				raise Bunny::ProtocolError, 'Connection initiation failed'
-			end
-		end
-		
 		def open_connection
 			send_frame(
         Qrack::Protocol09::Connection::StartOk.new(
@@ -483,16 +409,6 @@ after a rollback.
 
       raise Bunny::ProtocolError, 'Cannot open connection' unless next_method.is_a?(Qrack::Protocol09::Connection::OpenOk)
 		end
-		
-		def close_connection
-			# 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)
-      )
-      raise Bunny::ProtocolError, "Error closing connection" unless next_method.is_a?(Qrack::Protocol09::Connection::CloseOk)
-		end
 
   private
 
@@ -500,47 +416,5 @@ after a rollback.
       @buffer ||= Qrack::Transport09::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