fotonauts-bunny 0.4.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Chris Duncan
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,52 @@
+= 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:
+
+Bunny is an AMQP[http://www.amqp.org] (Advanced Message Queuing Protocol) client, written in Ruby, that is intended to allow you to interact with AMQP-compliant message brokers/servers such as RabbitMQ[http://www.rabbitmq.com] in a synchronous fashion.
+
+It is based on a great deal of useful code from amqp[http://github.com/tmm1/amqp] by Aman Gupta and Carrot[http://github.com/famoseagle/carrot] by Amos Elliston.
+
+You can use Bunny to -
+
+* Create and delete exchanges
+* Create and delete queues
+* Publish and consume messages
+
+Bunny is known to work with RabbitMQ version 1.5.4 and version 0-8 of the AMQP specification.
+
+=== INSTALL:
+
+*Rubyforge*: <tt>gem install bunny</tt>
+
+*GitHub*: <tt>gem install celldee-bunny</tt>
+
+=== QUICK START:
+
+   require 'bunny'
+
+   b = Bunny.new(:logging => true)
+
+   # start a communication session with the amqp server
+   b.start
+
+   # declare a queue
+   q = b.queue('test1')
+
+   # publish a message to the queue
+   q.publish('Hello everybody!')
+
+   # get message from the queue
+   msg = q.pop
+
+   puts 'This is the message: ' + msg + "\n\n"
+
+   # close the connection
+   b.stop
+
+=== OTHER:
+Please see the _examples_ directory for additional usage information.

data/Rakefile

@@ -0,0 +1,6 @@
+task :spec do
+	require 'spec/rake/spectask'
+	Spec::Rake::SpecTask.new do |t|
+		t.spec_opts = ['--color']
+	end
+end

data/bunny.gemspec

@@ -0,0 +1,38 @@
+Gem::Specification.new do |s|
+  s.name = %q{bunny}
+  s.version = "0.4.0"
+  
+  s.authors = ["Chris Duncan"]
+  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}
+  s.has_rdoc = true
+ 	s.extra_rdoc_files = [ "README" ]
+  s.rdoc_options = [ "--main", "README" ]
+  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",
+	 "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/examples/simple.rb

@@ -0,0 +1,30 @@
+# simple.rb
+
+# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
+# and that it is running on 'localhost'.
+
+# If this is not the case, please change the 'Bunny.new' call below to include
+# the relevant arguments e.g. b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'bunny'
+
+b = Bunny.new(:logging => true)
+
+# start a communication session with the amqp server
+b.start
+
+# declare a queue
+q = b.queue('test1')
+
+# publish a message to the queue
+q.publish('Hello everybody!')
+
+# get message from the queue
+msg = q.pop
+
+puts 'This is the message: ' + msg + "\n\n"
+
+# close the client connection
+b.stop

data/examples/simple_ack.rb

@@ -0,0 +1,33 @@
+# simple_ack.rb
+
+# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
+# and that it is running on 'localhost'.
+
+# If this is not the case, please change the 'Bunny.new' call below to include
+# the relevant arguments e.g. b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'bunny'
+
+b = Bunny.new(:logging => true)
+
+# start a communication session with the amqp server
+b.start
+
+# declare a queue
+q = b.queue('test1')
+
+# publish a message to the queue
+q.publish('Testing acknowledgements')
+
+# get message from the queue
+msg = q.pop(:ack => true)
+
+# acknowledge receipt of message
+q.ack
+
+puts 'This is the message: ' + msg + "\n\n"
+
+# close the client connection
+b.stop

data/examples/simple_consumer.rb

@@ -0,0 +1,55 @@
+# consumer.rb
+
+# N.B. To be used in conjunction with simple_publisher.rb
+
+# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
+# and that it is running on 'localhost'.
+
+# If this is not the case, please change the 'Bunny.new' call below to include
+# the relevant arguments e.g. b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
+
+# How this example works
+#=======================
+#
+# Open up two console windows start this program in one of them by typing -
+#
+# ruby simple_consumer.rb
+#
+# Then switch to the other console window and type -
+#
+# ruby simple_publisher.rb
+#
+# A message will be printed out by the simple_consumer and it will wait for the next message
+#
+# Run simple_publisher 3 more times. After the last run simple_consumer will stop.
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'bunny'
+
+b = Bunny.new(:logging => true)
+
+# start a communication session with the amqp server
+b.start
+
+# create/get queue
+q = b.queue('po_box')
+
+# create/get exchange
+exch = b.exchange('sorting_room')
+
+# bind queue to exchange
+q.bind(exch, :key => 'fred')
+
+# initialize counter
+i = 1
+
+# subscribe to queue
+q.subscribe(:consumer_tag => 'testtag1') do |msg|
+	puts i.to_s + ': ' + msg
+	i+=1
+	q.unsubscribe(:consumer_tag => 'testtag1') if i == 5
+end
+
+# close the connection
+b.stop

data/examples/simple_fanout.rb

@@ -0,0 +1,39 @@
+# fanout.rb
+
+# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
+# and that it is running on 'localhost'.
+
+# If this is not the case, please change the 'Bunny.new' call below to include
+# the relevant arguments e.g. b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'bunny'
+
+b = Bunny.new(:logging => true)
+
+# start a communication session with the amqp server
+b.start
+
+# declare queues
+q1 = b.queue('test_fan1')
+q2 = b.queue('test_fan2')
+
+# create a fanout exchange
+exch = b.exchange('test_fan', :type => :fanout)
+
+# bind the queues to the exchange
+q1.bind(exch)
+q2.bind(exch)
+
+# publish a message to the exchange
+exch.publish('This message will be fanned out')
+
+# get message from the queues
+msg = q1.pop
+puts 'This is the message from q1: ' + msg + "\n\n"
+msg = q2.pop
+puts 'This is the message from q2: ' + msg + "\n\n"
+
+# close the client connection
+b.stop

data/examples/simple_publisher.rb

@@ -0,0 +1,27 @@
+# simple_publisher.rb
+
+# N.B. To be used in conjunction with simple_consumer.rb. See simple_consumer.rb for explanation.
+
+# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
+# and that it is running on 'localhost'.
+
+# If this is not the case, please change the 'Bunny.new' call below to include
+# the relevant arguments e.g. b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'bunny'
+
+b = Bunny.new(:logging => true)
+
+# start a communication session with the amqp server
+b.start
+
+# create/get exchange
+exch = b.exchange('sorting_room')
+
+# publish message to exchange
+exch.publish('This is a message from the publisher', :key => 'fred')
+
+# message should now be picked up by the consumer so we can stop
+b.stop

data/examples/simple_topic.rb

@@ -0,0 +1,59 @@
+# simple_topic.rb
+
+# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
+# and that it is running on 'localhost'.
+
+# If this is not the case, please change the 'Bunny.new' call below to include
+# the relevant arguments e.g. b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'bunny'
+
+b = Bunny.new
+
+# start a communication session with the amqp server
+b.start
+
+# declare queues
+soccer = b.queue('topic_soccer')
+cricket = b.queue('topic_cricket')
+rugby = b.queue('topic_rugby')
+allsport = b.queue('topic_allsport')
+
+# create a topic exchange
+sports_results = b.exchange('sports_results', :type => :topic)
+
+# bind the queues to the exchange
+soccer.bind(sports_results, :key => 'soccer.*')
+cricket.bind(sports_results, :key => 'cricket.*')
+rugby.bind(sports_results, :key => 'rugby.*')
+allsport.bind(sports_results, :key => '*.result')
+
+# publish messages to the exchange
+sports_results.publish('Manchester United 1 : Hull City 4', :key => 'soccer.result')
+sports_results.publish('England beat Australia by 5 wickets in first test', :key => 'cricket.result')
+sports_results.publish('British Lions 15 : South Africa 12', :key => 'rugby.result')
+
+# get message from the queues
+
+# soccer queue got the soccer message
+msg = soccer.pop
+puts 'This is a message from the soccer q: ' + msg + "\n\n"
+
+# cricket queue got the cricket message
+msg = cricket.pop
+puts 'This is a message from the cricket q: ' + msg + "\n\n"
+
+# rugby queue got the rugby message
+msg = rugby.pop
+puts 'This is a message from the rugby q: ' + msg + "\n\n"
+
+# allsport queue got all of the messages
+until msg == :queue_empty do
+	msg = allsport.pop
+	puts 'This is a message from the allsport q: ' + msg + "\n\n" unless msg == :queue_empty
+end
+
+# close the client connection
+b.stop

data/lib/bunny/client.rb

@@ -0,0 +1,324 @@
+module Bunny
+	
+=begin rdoc
+
+=== DESCRIPTION:
+
+The Client class provides the major Bunny API methods.
+
+=end
+
+  class Client < Qrack::Client
+    CONNECT_TIMEOUT = 1.0
+    RETRY_DELAY     = 10.0
+
+    attr_reader   :status, :host, :vhost, :port
+    attr_accessor :channel, :logging, :exchanges, :queues, :ticket
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+Sets up a Bunny::Client object ready for connection to a broker/server. _Client_._status_ is set to
+<tt>:not_connected</tt>.
+
+==== OPTIONS:
+
+* <tt>:host => '_hostname_' (default = 'localhost')</tt>
+* <tt>:port => _portno_ (default = 5672)</tt>
+* <tt>:vhost => '_vhostname_' (default = '/')</tt>
+* <tt>:user => '_username_' (default = 'guest')</tt>
+* <tt>:pass => '_password_' (default = 'guest')</tt>
+* <tt>:logging => true or false (_default_)</tt> - If set to _true_, session information is sent
+  to STDOUT.
+* <tt>:insist => true or false (_default_)</tt> - In a configuration with multiple load-sharing
+  servers, the server may respond to a Connection.Open method with a Connection.Redirect. The insist
+  option, if set to _true_, tells the server that the client is insisting on a connection to the
+  specified server.
+
+=end
+
+    def initialize(opts = {})
+			@host = opts[:host] || 'localhost'
+			@port = opts[:port] || Qrack::Protocol::PORT
+      @user   = opts[:user]  || 'guest'
+      @pass   = opts[:pass]  || 'guest'
+      @vhost  = opts[:vhost] || '/'
+			@logging = opts[:logging] || false
+      @insist = opts[:insist]
+      @status = :not_connected
+    end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+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.
+
+==== OPTIONS:
+
+* <tt>:type => one of :direct (_default_), :fanout, :topic, :headers</tt>
+* <tt>:passive => true or false</tt> - 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.
+* <tt>:durable => true or false (_default_)</tt> - 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.
+* <tt>:auto_delete => true or false (_default_)</tt> - If set to _true_, the exchange is deleted
+  when all queues have finished using it.
+* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
+
+==== RETURNS:
+
+Exchange
+
+=end
+
+		def exchange(name, opts = {})
+			exchanges[name] ||= Bunny::Exchange.new(self, name, opts)
+		end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+Returns hash of exchanges declared by Bunny.
+
+=end
+
+		def exchanges
+			@exchanges ||= {}
+		end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+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.
+
+==== OPTIONS:
+
+* <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
+  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
+  to a transient queue.
+* <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
+  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_.
+
+==== RETURNS:
+
+Queue
+
+=end
+		
+		def queue(name, opts = {})
+	    queues[name] ||= Bunny::Queue.new(self, name, opts)
+	  end
+	
+=begin rdoc
+
+=== DESCRIPTION:
+
+Returns hash of queues declared by Bunny.
+
+=end
+		
+		def queues
+			@queues ||= {}
+		end
+
+    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?(Qrack::Transport::Frame)
+        data.channel = channel
+
+        log :send, data
+        write(data.to_s)
+      end
+      nil
+    end
+
+    def next_frame
+      frame = Qrack::Transport::Frame.parse(buffer)
+      log :received, frame
+      frame
+    end
+
+    def next_method
+      next_payload
+    end
+
+    def next_payload
+      frame = next_frame
+      frame and frame.payload
+    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>.
+
+==== RETURNS:
+
+<tt>:not_connected</tt> if successful.
+
+=end
+
+    def close
+      send_frame(
+        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?(Qrack::Protocol::Channel::CloseOk)
+
+      self.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)
+
+      close_socket
+    end
+
+		alias stop close
+
+    def read(*args)
+      send_command(:read, *args)
+    end
+
+    def write(*args)
+      send_command(:write, *args)
+    end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+Opens a communication channel and starts a connection. If an error occurs, a
+_Bunny_::_ProtocolError_ is raised. If successful, _Client_._status_ is set to <tt>:connected</tt>.
+
+==== RETURNS:
+
+<tt>:connected</tt> if successful.
+
+=end
+		
+		def start_session
+      @channel = 0
+      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(
+        Qrack::Protocol::Connection::StartOk.new(
+          {:platform => 'Ruby', :product => 'Bunny', :information => 'http://github.com/celldee/bunny', :version => VERSION},
+          'AMQPLAIN',
+          {:LOGIN => @user, :PASSWORD => @pass},
+          'en_US'
+        )
+      )
+			
+			method = next_method
+			raise Bunny::ProtocolError, "Connection failed - user: #{@user}, pass: #{@pass}" if method.nil?
+
+      if method.is_a?(Qrack::Protocol::Connection::Tune)
+        send_frame(
+          Qrack::Protocol::Connection::TuneOk.new( :channel_max => 0, :frame_max => 131072, :heartbeat => 0)
+        )
+      end
+
+      send_frame(
+        Qrack::Protocol::Connection::Open.new(:virtual_host => @vhost, :capabilities => '', :insist => @insist)
+      )
+      raise Bunny::ProtocolError, 'Cannot open connection' unless next_method.is_a?(Qrack::Protocol::Connection::OpenOk)
+
+      @channel = 1
+      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(
+        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 status
+			status
+    end
+
+		alias start start_session
+
+  private
+
+    def buffer
+      @buffer ||= Qrack::Transport::Buffer.new(self)
+    end
+
+    def send_command(cmd, *args)
+      begin
+        timeout(1.5) do
+          socket.__send__(cmd, *args)
+        end
+      rescue => e
+        @status = :not_connected
+        raise Bunny::ServerDownError, e.message
+      end
+    end
+
+    def socket
+      return @socket if @socket and (@status == :connected) and not @socket.closed?
+
+      begin
+        @status = :not_connected
+   
+        # 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
+        @status   = :connected
+      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 log(*args)
+      return unless logging
+      require 'pp'
+      pp args
+	    puts
+    end
+
+  end
+end