bunny 0.0.8

data/README.markdown

@@ -0,0 +1,127 @@
+# Bunny: A synchronous Ruby AMQP client
+
+Google Group: [bunny-amqp](http://groups.google.com/group/bunny-amqp)
+
+## Announcements
+
+**IMPORTANT**
+
+The Exchange#initialize method arguments have changed as of version 0.0.7
+
+You now create an exchange like this -
+
+    b = Bunny.new
+    exch = b.exchange('my_exchange', :type => :fanout)
+
+If you do not specify a :type option then a default of :direct is used.
+
+The old way was -
+
+    b = Bunny.new
+    exch = b.exchange(:fanout, 'my_exchange')
+
+## About
+
+*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.
+
+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. If you want to try to use it with other AMQP message brokers/servers please let me know how you get on.
+ 
+## Quick Start
+
+    require 'bunny'
+
+    b = Bunny.new(:logging => true)
+
+    # start a communication session with the amqp server
+    begin
+      b.start
+    rescue Exception => e
+      puts 'ERROR - Could not start a session: ' + e
+      exit
+    end
+
+    # 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.close
+
+## Bunny methods
+
+These are the Bunny methods that you will probably want to use -
+
+### Create a Bunny instance
+Bunny#new({_options_})
+
+### Start a communication session with the target server
+Bunny#start
+
+### Stop a communication session with the target server
+Bunny#stop
+
+### Create a Queue
+Bunny#queue(_**name**_, {_options_})
+
+### Create an Exchange
+Bunny#exchange(_**name**_, {_options_})
+
+### Return connection status ('CONNECTED' or 'NOT CONNECTED')
+Bunny#status               
+
+### Publish a message to an exchange
+Exchange#publish(_**data**_, {_options_})
+
+### Delete an exchange from the target server
+Exchange#delete({_options_})
+
+### Bind a queue to an exchange
+Queue#bind(_**exchange**_, {_options_})
+
+### Unbind a queue from an exchange
+Queue#unbind(_**exchange**_, {_options_})
+
+### Publish a message to a queue
+Queue#publish(_**data**_, {_options_})
+
+### Pop a message off of a queue
+Queue#pop({_options_})
+
+### Return queue message count
+Queue#message_count
+
+### Return queue consumer count
+Queue#consumer_count
+
+### Return queue status (array of message count and consumer_count)
+Queue#status
+
+### Send an acknowledge message to the server
+Queue#ack
+
+### Delete a queue from the target server
+Queue#delete({_options_})
+
+## Acknowledgements
+
+This project has borrowed heavily from the following two projects and owes their respective creators and collaborators a whole lot of gratitude:
+
+1. **amqp** by *tmm1* [http://github.com/tmm1/amqp/tree/master](http://github.com/tmm1/amqp/tree/master)
+2. **carrot** by *famoseagle* [http://github.com/famoseagle/carrot/tree/master](http://github.com/famoseagle/carrot/tree/master)
+
+## LICENSE
+
+Copyright (c) 2009 Chris Duncan; Published under The MIT License, see License

data/Rakefile

@@ -0,0 +1,12 @@
+task :codegen do
+  sh 'ruby protocol/codegen.rb > lib/amqp/spec.rb'
+	sh 'ruby lib/amqp/spec.rb'
+end
+
+task :spec do
+	require 'spec/rake/spectask'
+	Spec::Rake::SpecTask.new do |t|
+		t.spec_opts = ['--color']
+	end
+end
+	

data/examples/simple.rb

@@ -0,0 +1,35 @@
+# 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
+begin
+	b.start
+rescue Exception => e
+	puts 'ERROR - Could not start a session: ' + e
+	exit
+end
+
+# 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/lib/amqp.rb

@@ -0,0 +1,15 @@
+module AMQP
+	%w[ spec buffer protocol frame client ].each do |file|
+    require "amqp/#{file}"
+  end
+
+	# constants
+	CONNECTED = 'CONNECTED'
+	NOT_CONNECTED = 'NOT CONNECTED'
+
+	# specific error definitions
+	class ProtocolError   < StandardError; end
+	class ServerDown      < StandardError; end
+	class Overflow < StandardError; end
+  class InvalidType < StandardError; end
+end

data/lib/amqp/buffer.rb

@@ -0,0 +1,274 @@
+if [].map.respond_to? :with_index
+  class Array #:nodoc:
+    def enum_with_index
+      each.with_index
+    end
+  end
+else
+  require 'enumerator'
+end
+
+module AMQP
+  class Buffer #:nodoc: all
+    
+    def initialize data = ''
+      @data = data
+      @pos = 0
+    end
+
+    attr_reader :pos
+    
+    def data
+      @data.clone
+    end
+    alias :contents :data
+    alias :to_s :data
+
+    def << data
+      @data << data.to_s
+      self
+    end
+    
+    def length
+      @data.length
+    end
+    
+    def empty?
+      pos == length
+    end
+    
+    def rewind
+      @pos = 0
+    end
+    
+    def read_properties *types
+      types.shift if types.first == :properties
+      
+      i = 0
+      values = []
+
+      while props = read(:short)
+        (0..14).each do |n|
+          # no more property types
+          break unless types[i]
+          
+          # if flag is set
+          if props & (1<<(15-n)) != 0
+            if types[i] == :bit
+              # bit values exist in flags only
+              values << true
+            else
+              # save type name for later reading
+              values << types[i]
+            end
+          else
+            # property not set or is false bit
+            values << (types[i] == :bit ? false : nil)
+          end
+
+          i+=1
+        end
+
+        # bit(0) == 0 means no more property flags
+        break unless props & 1 == 1
+      end
+
+      values.map do |value|
+        value.is_a?(Symbol) ? read(value) : value
+      end
+    end
+
+    def read *types
+      if types.first == :properties
+        return read_properties(*types)
+      end
+
+      values = types.map do |type|
+        case type
+        when :octet
+          _read(1, 'C')
+        when :short
+          _read(2, 'n')
+        when :long
+          _read(4, 'N')
+        when :longlong
+          upper, lower = _read(8, 'NN')
+          upper << 32 | lower
+        when :shortstr
+          _read read(:octet)
+        when :longstr
+          _read read(:long)
+        when :timestamp
+          Time.at read(:longlong)
+        when :table
+          t = Hash.new
+
+          table = Buffer.new(read(:longstr))
+          until table.empty?
+            key, type = table.read(:shortstr, :octet)
+            key = key.intern
+            t[key] ||= case type
+                       when 83 # 'S'
+                         table.read(:longstr)
+                       when 73 # 'I'
+                         table.read(:long)
+                       when 68 # 'D'
+                         exp = table.read(:octet)
+                         num = table.read(:long)
+                         num / 10.0**exp
+                       when 84 # 'T'
+                         table.read(:timestamp)
+                       when 70 # 'F'
+                         table.read(:table)
+                       end
+          end
+
+          t
+        when :bit
+          if (@bits ||= []).empty?
+            val = read(:octet)
+            @bits = (0..7).map{|i| (val & 1<<i) != 0 }
+          end
+
+          @bits.shift
+        else
+          raise InvalidType, "Cannot read data of type #{type}"
+        end
+      end
+      
+      types.size == 1 ? values.first : values
+    end
+    
+    def write type, data
+      case type
+      when :octet
+        _write(data, 'C')
+      when :short
+        _write(data, 'n')
+      when :long
+        _write(data, 'N')
+      when :longlong
+        lower =  data & 0xffffffff
+        upper = (data & ~0xffffffff) >> 32
+        _write([upper, lower], 'NN')
+      when :shortstr
+        data = (data || '').to_s
+        _write([data.length, data], 'Ca*')
+      when :longstr
+        if data.is_a? Hash
+          write(:table, data)
+        else
+          data = (data || '').to_s
+          _write([data.length, data], 'Na*')
+        end
+      when :timestamp
+        write(:longlong, data.to_i)
+      when :table
+        data ||= {}
+        write :longstr, (data.inject(Buffer.new) do |table, (key, value)|
+                          table.write(:shortstr, key.to_s)
+
+                          case value
+                          when String
+                            table.write(:octet, 83) # 'S'
+                            table.write(:longstr, value.to_s)
+                          when Fixnum
+                            table.write(:octet, 73) # 'I'
+                            table.write(:long, value)
+                          when Float
+                            table.write(:octet, 68) # 'D'
+                            # XXX there's gotta be a better way to do this..
+                            exp = value.to_s.split('.').last.length
+                            num = value * 10**exp
+                            table.write(:octet, exp)
+                            table.write(:long, num)
+                          when Time
+                            table.write(:octet, 84) # 'T'
+                            table.write(:timestamp, value)
+                          when Hash
+                            table.write(:octet, 70) # 'F'
+                            table.write(:table, value)
+                          end
+
+                          table
+                        end)
+      when :bit
+        [*data].to_enum(:each_slice, 8).each{|bits|
+          write(:octet, bits.enum_with_index.inject(0){ |byte, (bit, i)|
+            byte |= 1<<i if bit
+            byte
+           })
+         }
+      when :properties
+        values = []
+        data.enum_with_index.inject(0) do |short, ((type, value), i)|
+          n = i % 15
+          last = i+1 == data.size
+
+          if (n == 0 and i != 0) or last
+            if data.size > i+1
+              short |= 1<<0
+            elsif last and value
+              values << [type,value]
+              short |= 1<<(15-n)
+            end
+
+            write(:short, short)
+            short = 0
+          end
+
+          if value and !last
+            values << [type,value] 
+            short |= 1<<(15-n)
+          end
+
+          short
+        end
+        
+        values.each do |type, value|
+          write(type, value) unless type == :bit
+        end
+      else
+        raise InvalidType, "Cannot write data of type #{type}"
+      end
+      
+      self
+    end
+
+    def extract
+      begin
+        cur_data, cur_pos = @data.clone, @pos
+        yield self
+      rescue Overflow
+        @data, @pos = cur_data, cur_pos
+        nil
+      end
+    end
+
+    def _read(size, pack = nil)
+      if @data.is_a?(Client)
+        raw = @data.read(size)
+        return raw if raw.nil? or pack.nil? 
+        return raw.unpack(pack).first
+      end
+
+      if @pos + size > length
+        raise Overflow
+      else
+        data = @data[@pos,size]
+        @data[@pos,size] = ''
+        if pack
+          data = data.unpack(pack)
+          data = data.pop if data.size == 1
+        end
+        data
+      end
+    end
+    
+    def _write data, pack = nil
+      data = [*data].pack(pack) if pack
+      @data[@pos,0] = data
+      @pos += data.length
+    end
+  end
+end