celldee-bunny 0.3.1 → 0.4.0

data/README

@@ -1,6 +1,9 @@
 = Bunny: A synchronous Ruby AMQP client
 
 *GitHub* *repo*: http://github.com/celldee/bunny
+*Rubyforge*: http://rubyforge.org/projects/bunny-amqp
+*Twitter*: http://twitter.com/bunny_amqp
+*Google* *Group*: http://groups.google.com/group/bunny-amqp
      
 === DESCRIPTION:
 

data/Rakefile

@@ -1,8 +1,3 @@
-task :codegen do
-  sh 'ruby ext/codegen.rb > lib/bunny/protocol/spec.rb'
-	sh 'ruby lib/bunny/protocol/spec.rb'
-end
-
 task :spec do
 	require 'spec/rake/spectask'
 	Spec::Rake::SpecTask.new do |t|

data/bunny.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |s|
   s.name = %q{bunny}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
   s.authors = ["Chris Duncan"]
-  s.date = %q{2009-05-10}
+  s.date = %q{2009-05-15}
   s.description = %q{Another synchronous Ruby AMQP client}
   s.email = %q{celldee@gmail.com}
   s.rubyforge_project = %q{bunny-amqp}
@@ -12,26 +12,26 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/celldee/bunny}
   s.summary = %q{A synchronous Ruby AMQP client that enables interaction with AMQP-compliant brokers/servers.}
   s.files = ["LICENSE",
- "README",
- "Rakefile",
- "bunny.gemspec",
- "examples/simple.rb",
- "examples/simple_ack.rb",
- "examples/simple_consumer.rb",
- "examples/simple_fanout.rb",
- "examples/simple_publisher.rb",
- "examples/simple_topic.rb",
- "ext/amqp-0.8.json",
- "ext/codegen.rb",
- "lib/bunny.rb",
- "lib/bunny/client.rb",
- "lib/bunny/exchange.rb",
- "lib/bunny/protocol/protocol.rb",
- "lib/bunny/protocol/spec.rb",
- "lib/bunny/queue.rb",
- "lib/bunny/transport/buffer.rb",
- "lib/bunny/transport/frame.rb",
- "spec/bunny_spec.rb",
- "spec/exchange_spec.rb",
- "spec/queue_spec.rb"]
+	 "README",
+	 "Rakefile",
+	 "bunny.gemspec",
+	 "examples/simple.rb",
+	 "examples/simple_ack.rb",
+	 "examples/simple_consumer.rb",
+	 "examples/simple_fanout.rb",
+	 "examples/simple_publisher.rb",
+	 "examples/simple_topic.rb",
+	 "lib/bunny.rb",
+	 "lib/bunny/client.rb",
+	 "lib/bunny/exchange.rb",
+	 "lib/bunny/queue.rb",
+	 "lib/qrack/client.rb",
+	 "lib/qrack/protocol/protocol.rb",
+	 "lib/qrack/protocol/spec.rb",
+	 "lib/qrack/qrack.rb",
+	 "lib/qrack/transport/buffer.rb",
+	 "lib/qrack/transport/frame.rb",
+	 "spec/bunny_spec.rb",
+	 "spec/exchange_spec.rb",
+	 "spec/queue_spec.rb"]
 end

data/lib/bunny/client.rb

@@ -8,7 +8,7 @@ The Client class provides the major Bunny API methods.
 
 =end
 
-  class Client
+  class Client < Qrack::Client
     CONNECT_TIMEOUT = 1.0
     RETRY_DELAY     = 10.0
 
@@ -40,7 +40,7 @@ Sets up a Bunny::Client object ready for connection to a broker/server. _Client_
 
     def initialize(opts = {})
 			@host = opts[:host] || 'localhost'
-			@port = opts[:port] || Protocol::PORT
+			@port = opts[:port] || Qrack::Protocol::PORT
       @user   = opts[:user]  || 'guest'
       @pass   = opts[:pass]  || 'guest'
       @vhost  = opts[:vhost] || '/'
@@ -145,7 +145,7 @@ Returns hash of queues declared by Bunny.
     def send_frame(*args)
       args.each do |data|
         data.ticket  = ticket if ticket and data.respond_to?(:ticket=)
-        data         = data.to_frame(channel) unless data.is_a?(Transport::Frame)
+        data         = data.to_frame(channel) unless data.is_a?(Qrack::Transport::Frame)
         data.channel = channel
 
         log :send, data
@@ -155,7 +155,7 @@ Returns hash of queues declared by Bunny.
     end
 
     def next_frame
-      frame = Transport::Frame.parse(buffer)
+      frame = Qrack::Transport::Frame.parse(buffer)
       log :received, frame
       frame
     end
@@ -166,7 +166,7 @@ Returns hash of queues declared by Bunny.
 
     def next_payload
       frame = next_frame
-      frame.payload
+      frame and frame.payload
     end
 
 =begin rdoc
@@ -184,15 +184,15 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
 
     def close
       send_frame(
-        Protocol::Channel::Close.new(:reply_code => 200, :reply_text => 'bye', :method_id => 0, :class_id => 0)
+        Qrack::Protocol::Channel::Close.new(:reply_code => 200, :reply_text => 'bye', :method_id => 0, :class_id => 0)
       )
-      raise Bunny::ProtocolError, "Error closing channel #{channel}" unless next_method.is_a?(Protocol::Channel::CloseOk)
+      raise Bunny::ProtocolError, "Error closing channel #{channel}" unless next_method.is_a?(Qrack::Protocol::Channel::CloseOk)
 
       self.channel = 0
       send_frame(
-        Protocol::Connection::Close.new(:reply_code => 200, :reply_text => 'Goodbye', :class_id => 0, :method_id => 0)
+        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?(Protocol::Connection::CloseOk)
+      raise Bunny::ProtocolError, "Error closing connection" unless next_method.is_a?(Qrack::Protocol::Connection::CloseOk)
 
       close_socket
     end
@@ -222,12 +222,12 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
 		
 		def start_session
       @channel = 0
-      write(Protocol::HEADER)
-      write([1, 1, Protocol::VERSION_MAJOR, Protocol::VERSION_MINOR].pack('C4'))
-      raise Bunny::ProtocolError, 'Connection initiation failed' unless next_method.is_a?(Protocol::Connection::Start)
+      write(Qrack::Protocol::HEADER)
+      write([1, 1, Qrack::Protocol::VERSION_MAJOR, Qrack::Protocol::VERSION_MINOR].pack('C4'))
+      raise Bunny::ProtocolError, 'Connection initiation failed' unless next_method.is_a?(Qrack::Protocol::Connection::Start)
 
       send_frame(
-        Protocol::Connection::StartOk.new(
+        Qrack::Protocol::Connection::StartOk.new(
           {:platform => 'Ruby', :product => 'Bunny', :information => 'http://github.com/celldee/bunny', :version => VERSION},
           'AMQPLAIN',
           {:LOGIN => @user, :PASSWORD => @pass},
@@ -238,26 +238,26 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
 			method = next_method
 			raise Bunny::ProtocolError, "Connection failed - user: #{@user}, pass: #{@pass}" if method.nil?
 
-      if method.is_a?(Protocol::Connection::Tune)
+      if method.is_a?(Qrack::Protocol::Connection::Tune)
         send_frame(
-          Protocol::Connection::TuneOk.new( :channel_max => 0, :frame_max => 131072, :heartbeat => 0)
+          Qrack::Protocol::Connection::TuneOk.new( :channel_max => 0, :frame_max => 131072, :heartbeat => 0)
         )
       end
 
       send_frame(
-        Protocol::Connection::Open.new(:virtual_host => @vhost, :capabilities => '', :insist => @insist)
+        Qrack::Protocol::Connection::Open.new(:virtual_host => @vhost, :capabilities => '', :insist => @insist)
       )
-      raise Bunny::ProtocolError, 'Cannot open connection' unless next_method.is_a?(Protocol::Connection::OpenOk)
+      raise Bunny::ProtocolError, 'Cannot open connection' unless next_method.is_a?(Qrack::Protocol::Connection::OpenOk)
 
       @channel = 1
-      send_frame(Protocol::Channel::Open.new)
-      raise Bunny::ProtocolError, "Cannot open channel #{channel}" unless next_method.is_a?(Protocol::Channel::OpenOk)
+      send_frame(Qrack::Protocol::Channel::Open.new)
+      raise Bunny::ProtocolError, "Cannot open channel #{channel}" unless next_method.is_a?(Qrack::Protocol::Channel::OpenOk)
 
       send_frame(
-        Protocol::Access::Request.new(:realm => '/data', :read => true, :write => true, :active => true, :passive => true)
+        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?(Protocol::Access::RequestOk)
+      raise Bunny::ProtocolError, 'Access denied' unless method.is_a?(Qrack::Protocol::Access::RequestOk)
       self.ticket = method.ticket
 
 			# return status
@@ -269,7 +269,7 @@ _Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <
   private
 
     def buffer
-      @buffer ||= Transport::Buffer.new(self)
+      @buffer ||= Qrack::Transport::Buffer.new(self)
     end
 
     def send_command(cmd, *args)

data/lib/bunny/exchange.rb

@@ -58,14 +58,14 @@ specification that applies to your target broker/server.
       
       unless name == "amq.#{type}" or name == ''
         client.send_frame(
-          Protocol::Exchange::Declare.new(
+          Qrack::Protocol::Exchange::Declare.new(
             { :exchange => name, :type => type, :nowait => false }.merge(opts)
           )
         )
 
         raise Bunny::ProtocolError,
           "Error declaring exchange #{name}: type = #{type}" unless
-          client.next_method.is_a?(Protocol::Exchange::DeclareOk)
+          client.next_method.is_a?(Qrack::Protocol::Exchange::DeclareOk)
       end
     end
 
@@ -98,19 +98,19 @@ nil
     def publish(data, opts = {})
       out = []
 
-      out << Protocol::Basic::Publish.new(
+      out << Qrack::Protocol::Basic::Publish.new(
         { :exchange => name, :routing_key => opts.delete(:key) || key }.merge(opts)
       )
       data = data.to_s
-      out << Protocol::Header.new(
-        Protocol::Basic,
+      out << Qrack::Protocol::Header.new(
+        Qrack::Protocol::Basic,
         data.length, {
           :content_type  => 'application/octet-stream',
           :delivery_mode => (opts.delete(:persistent) ? 2 : 1),
           :priority      => 0 
         }.merge(opts)
       )
-      out << Transport::Frame::Body.new(data)
+      out << Qrack::Transport::Frame::Body.new(data)
 
       client.send_frame(*out)
     end
@@ -140,12 +140,12 @@ if successful. If an error occurs raises _Bunny_::_ProtocolError_.
       opts.delete(:nowait)
       
       client.send_frame(
-        Protocol::Exchange::Delete.new({ :exchange => name, :nowait => false }.merge(opts))
+        Qrack::Protocol::Exchange::Delete.new({ :exchange => name, :nowait => false }.merge(opts))
       )
 
       raise Bunny::ProtocolError,
         "Error deleting exchange #{name}" unless
-        client.next_method.is_a?(Protocol::Exchange::DeleteOk)
+        client.next_method.is_a?(Qrack::Protocol::Exchange::DeleteOk)
 
       client.exchanges.delete(name)
       

data/lib/bunny/queue.rb

@@ -27,10 +27,10 @@ Queues must be attached to at least one exchange in order to receive messages fr
 			opts.delete(:nowait)
 			
 	    client.send_frame(
-	      Protocol::Queue::Declare.new({ :queue => name, :nowait => false }.merge(opts))
+	      Qrack::Protocol::Queue::Declare.new({ :queue => name, :nowait => false }.merge(opts))
 	    )
 	
-			raise Bunny::ProtocolError, "Error declaring queue #{name}" unless client.next_method.is_a?(Protocol::Queue::DeclareOk)
+			raise Bunny::ProtocolError, "Error declaring queue #{name}" unless client.next_method.is_a?(Qrack::Protocol::Queue::DeclareOk)
 	  end
 
 =begin rdoc
@@ -52,7 +52,7 @@ ask to confirm a single message or a set of messages up to and including a speci
 	
 		def ack
       client.send_frame(
-        Protocol::Basic::Ack.new(:delivery_tag => delivery_tag)
+        Qrack::Protocol::Basic::Ack.new(:delivery_tag => delivery_tag)
       )
 
 			# reset delivery tag
@@ -91,7 +91,7 @@ a hash <tt>{:delivery_tag, :redelivered, :exchange, :routing_key, :message_count
 			ack = opts.delete(:ack)
 			
 	    client.send_frame(
-	      Protocol::Basic::Get.new({ :queue => name,
+	      Qrack::Protocol::Basic::Get.new({ :queue => name,
 																	 :consumer_tag => name,
 																	 :no_ack => !ack,
 																	 :nowait => true }.merge(opts))
@@ -99,9 +99,9 @@ a hash <tt>{:delivery_tag, :redelivered, :exchange, :routing_key, :message_count
 	
 			method = client.next_method
 			
-			if method.is_a?(Protocol::Basic::GetEmpty) then
+			if method.is_a?(Qrack::Protocol::Basic::GetEmpty) then
 				return :queue_empty
-			elsif	!method.is_a?(Protocol::Basic::GetOk)
+			elsif	!method.is_a?(Qrack::Protocol::Basic::GetOk)
 				raise Bunny::ProtocolError, "Error getting message from queue #{name}"
 			end
 			
@@ -169,7 +169,7 @@ Returns hash {:message_count, :consumer_count}.
  
 	  def status
 	    client.send_frame(
-	      Protocol::Queue::Declare.new({ :queue => name, :passive => true })
+	      Qrack::Protocol::Queue::Declare.new({ :queue => name, :passive => true })
 	    )
 	    method = client.next_method
 	    {:message_count => method.message_count, :consumer_count => method.consumer_count}
@@ -220,7 +220,7 @@ If <tt>:header => false</tt> only message payload is returned.
 			ack = opts.delete(:ack)
 			
 			client.send_frame(
-				Protocol::Basic::Consume.new({ :queue => name,
+				Qrack::Protocol::Basic::Consume.new({ :queue => name,
 																	 		 :consumer_tag => consumer_tag,
 																	 		 :no_ack => !ack,
 																	 		 :nowait => false }.merge(opts))
@@ -228,12 +228,12 @@ If <tt>:header => false</tt> only message payload is returned.
 			
 			raise Bunny::ProtocolError,
 				"Error subscribing to queue #{name}" unless
-				client.next_method.is_a?(Protocol::Basic::ConsumeOk)
+				client.next_method.is_a?(Qrack::Protocol::Basic::ConsumeOk)
 			
 			while true
 				method = client.next_method
 
-				break if method.is_a?(Protocol::Basic::CancelOk)
+				break if method.is_a?(Qrack::Protocol::Basic::CancelOk)
 			
 				# get delivery tag to use for acknowledge
 				self.delivery_tag = method.delivery_tag if ack
@@ -269,7 +269,7 @@ the server will not send any more messages for that consumer.
 			# response from the server causing an error
 			opts.delete(:nowait)
 			
-      client.send_frame( Protocol::Basic::Cancel.new({ :consumer_tag => consumer_tag }.merge(opts)))
+      client.send_frame( Qrack::Protocol::Basic::Cancel.new({ :consumer_tag => consumer_tag }.merge(opts)))
 			
     end
 
@@ -299,7 +299,7 @@ bound to the direct exchange '' by default. If error occurs, a _Bunny_::_Protoco
 			
 	    bindings[exchange] = opts
 	    client.send_frame(
-	      Protocol::Queue::Bind.new({ :queue => name,
+	      Qrack::Protocol::Queue::Bind.new({ :queue => name,
 		 																:exchange => exchange,
 		 																:routing_key => opts.delete(:key),
 		 																:nowait => false }.merge(opts))
@@ -307,7 +307,7 @@ bound to the direct exchange '' by default. If error occurs, a _Bunny_::_Protoco
 	
 			raise Bunny::ProtocolError,
 				"Error binding queue #{name}" unless
-				client.next_method.is_a?(Protocol::Queue::BindOk)
+				client.next_method.is_a?(Qrack::Protocol::Queue::BindOk)
 				
 			# return message
 			:bind_ok
@@ -340,7 +340,7 @@ Removes a queue binding from an exchange. If error occurs, a _Bunny_::_ProtocolE
 	    bindings.delete(exchange)
 
 	    client.send_frame(
-	      Protocol::Queue::Unbind.new({ :queue => name,
+	      Qrack::Protocol::Queue::Unbind.new({ :queue => name,
 		 																	:exchange => exchange,
 		 																	:routing_key => opts.delete(:key),
 		 																	:nowait => false }.merge(opts)
@@ -349,7 +349,7 @@ Removes a queue binding from an exchange. If error occurs, a _Bunny_::_ProtocolE
 	
 			raise Bunny::ProtocolError,
 				"Error unbinding queue #{name}" unless
-				client.next_method.is_a?(Protocol::Queue::UnbindOk)
+				client.next_method.is_a?(Qrack::Protocol::Queue::UnbindOk)
 				
 			# return message
 			:unbind_ok
@@ -384,12 +384,12 @@ from queues if successful. If an error occurs raises _Bunny_::_ProtocolError_.
 			opts.delete(:nowait)
 			
 	    client.send_frame(
-	      Protocol::Queue::Delete.new({ :queue => name, :nowait => false }.merge(opts))
+	      Qrack::Protocol::Queue::Delete.new({ :queue => name, :nowait => false }.merge(opts))
 	    )
 	
 			raise Bunny::ProtocolError,
 				"Error deleting queue #{name}" unless
-				client.next_method.is_a?(Protocol::Queue::DeleteOk)
+				client.next_method.is_a?(Qrack::Protocol::Queue::DeleteOk)
 	
 			client.queues.delete(name)
 			

data/lib/bunny.rb

@@ -5,29 +5,22 @@ $:.unshift File.expand_path(File.dirname(__FILE__))
 	require file
 end
 
+require 'qrack/qrack'
+
 require 'bunny/client'
 require 'bunny/exchange'
 require 'bunny/queue'
 
-require 'bunny/protocol/spec'
-require 'bunny/protocol/protocol'
-
-require 'bunny/transport/buffer'
-require 'bunny/transport/frame'
-
 module Bunny
 	
-	include Protocol
-	include Transport
+	include Qrack
 
 	class ProtocolError < StandardError; end
 	class ServerDownError < StandardError; end
-	class BufferOverflowError < StandardError; end
-  class InvalidTypeError < StandardError; end
 	class ConnectionError < StandardError; end
 	class MessageError < StandardError; end
 	
-	VERSION = '0.3.1'
+	VERSION = '0.4.0'
 	
 	# Returns the Bunny version number
 

data/lib/qrack/client.rb

@@ -0,0 +1,5 @@
+module Qrack
+	# Client ancestor class
+	class Client
+	end
+end

data/lib/{bunny → qrack}/protocol/protocol.rb

@@ -1,4 +1,4 @@
-module Bunny
+module Qrack
 	module Protocol
 	  #:stopdoc:
 	  class Class::Method