fotonauts-bunny 0.4.0

data/lib/qrack/qrack.rb

@@ -0,0 +1,28 @@
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'protocol/spec'
+require 'protocol/protocol'
+
+require 'transport/buffer'
+require 'transport/frame'
+
+require 'client'
+
+module Qrack
+	
+	include Protocol
+	include Transport
+	
+	# Errors
+	class BufferOverflowError < StandardError; end
+  class InvalidTypeError < StandardError; end
+
+  # Qrack version number
+  VERSION = '0.0.1'
+
+  # Return the Qrack version
+  def self.version
+    VERSION
+  end
+
+end

data/lib/qrack/transport/buffer.rb

@@ -0,0 +1,267 @@
+module Qrack
+	module Transport #:nodoc: all
+	  class Buffer
+    	require 'enumerator' if RUBY_VERSION < '1.8.7'
+
+	    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 Qrack::InvalidTypeError, "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 Qrack::InvalidTypeError, "Cannot write data of type #{type}"
+	      end
+      
+	      self
+	    end
+
+	    def extract
+	      begin
+	        cur_data, cur_pos = @data.clone, @pos
+	        yield self
+	      rescue Qrack::BufferOverflowError
+	        @data, @pos = cur_data, cur_pos
+	        nil
+	      end
+	    end
+
+	    def _read(size, pack = nil)
+	      if @data.is_a?(Qrack::Client)
+	        raw = @data.read(size)
+	        return raw if raw.nil? or pack.nil? 
+	        return raw.unpack(pack).first
+	      end
+
+	      if @pos + size > length
+	        raise Qrack::BufferOverflowError
+	      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
+end

data/lib/qrack/transport/frame.rb

@@ -0,0 +1,100 @@
+
+#:stopdoc:
+# this file was autogenerated on Fri May 15 10:11:23 +0100 2009
+#
+# DO NOT EDIT! (edit ext/qparser.rb and config.yml instead, and run 'ruby qparser.rb')
+
+module Qrack
+  module Transport
+    class Frame
+      def self.types
+        @types ||= {}
+      end
+
+      def self.Frame id
+        (@_base_frames ||= {})[id] ||= Class.new(Frame) do
+          class_eval %[
+            def self.inherited klass
+              klass.const_set(:ID, #{id})
+              Frame.types[#{id}] = klass
+            end
+          ]
+        end
+      end
+
+      class Method    < Frame( 1 ); end
+      class Header    < Frame( 2 ); end
+      class Body      < Frame( 3 ); end
+      class OobMethod < Frame( 4 ); end
+      class OobHeader < Frame( 5 ); end
+      class OobBody   < Frame( 6 ); end
+      class Trace     < Frame( 7 ); end
+      class Heartbeat < Frame( 8 ); end
+
+      FOOTER = 206
+    end
+  end
+end
+
+module Qrack
+  module Transport
+    class Frame
+      def initialize payload = nil, channel = 0
+        @channel, @payload = channel, payload
+      end
+      attr_accessor :channel, :payload
+
+      def id
+        self.class::ID
+      end
+  
+      def to_binary
+        buf = Transport::Buffer.new
+        buf.write :octet, id
+        buf.write :short, channel
+        buf.write :longstr, payload
+        buf.write :octet, Transport::Frame::FOOTER
+        buf.rewind
+        buf
+      end
+
+      def to_s
+        to_binary.to_s
+      end
+
+      def == frame
+        [ :id, :channel, :payload ].inject(true) do |eql, field|
+          eql and __send__(field) == frame.__send__(field)
+        end
+      end
+  
+      class Method
+        def initialize payload = nil, channel = 0
+          super
+          unless @payload.is_a? Protocol::Class::Method or @payload.nil?
+            @payload = Protocol.parse(@payload)
+          end
+        end
+      end
+
+      class Header
+        def initialize payload = nil, channel = 0
+          super
+          unless @payload.is_a? Protocol::Header or @payload.nil?
+            @payload = Protocol::Header.new(@payload)
+          end
+        end
+      end
+
+      class Body; end
+
+      def self.parse buf
+        buf = Transport::Buffer.new(buf) unless buf.is_a? Transport::Buffer
+        buf.extract do
+          id, channel, payload, footer = buf.read(:octet, :short, :longstr, :octet)
+          Transport::Frame.types[id].new(payload, channel) if footer == Transport::Frame::FOOTER
+        end
+      end
+    end
+  end
+end

data/spec/bunny_spec.rb

@@ -0,0 +1,36 @@
+# bunny_spec.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')
+
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib bunny]))
+
+describe Bunny do
+	
+	before(:each) do
+    @b = Bunny.new
+		@b.start
+	end
+	
+  it "should connect to an AMQP server" do
+    @b.status.should == :connected
+  end
+
+	it "should be able to create an exchange" do
+		exch = @b.exchange('test_exchange')
+		exch.should be_an_instance_of Bunny::Exchange
+		exch.name.should == 'test_exchange'
+		@b.exchanges.has_key?('test_exchange').should be true
+	end
+
+	it "should be able to create a queue" do
+		q = @b.queue('test1')
+		q.should be_an_instance_of Bunny::Queue
+		q.name.should == 'test1'
+		@b.queues.has_key?('test1').should be true
+  end
+
+end

data/spec/exchange_spec.rb

@@ -0,0 +1,117 @@
+# exchange_spec.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')
+
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib bunny]))
+
+describe Bunny::Exchange do
+	
+	before(:each) do
+    @b = Bunny.new
+		@b.start
+	end
+		
+	it "should raise an error if instantiated as non-existent type" do
+		lambda { @b.exchange('bogus_ex', :type => :bogus) }.should raise_error(Bunny::ProtocolError)
+	end
+	
+	it "should allow a default direct exchange to be instantiated by specifying :type" do
+		exch = @b.exchange('amq.direct', :type => :direct)
+		exch.should be_an_instance_of Bunny::Exchange
+		exch.name.should == 'amq.direct'
+		exch.type.should == :direct
+		@b.exchanges.has_key?('amq.direct').should be true
+	end
+	
+	it "should allow a default direct exchange to be instantiated without specifying :type" do
+		exch = @b.exchange('amq.direct')
+		exch.should be_an_instance_of Bunny::Exchange
+		exch.name.should == 'amq.direct'
+		exch.type.should == :direct
+		@b.exchanges.has_key?('amq.direct').should be true
+	end
+	
+	it "should allow a default fanout exchange to be instantiated without specifying :type" do
+		exch = @b.exchange('amq.fanout')
+		exch.should be_an_instance_of Bunny::Exchange
+		exch.name.should == 'amq.fanout'
+		exch.type.should == :fanout
+		@b.exchanges.has_key?('amq.fanout').should be true
+	end
+	
+	it "should allow a default topic exchange to be instantiated without specifying :type" do
+		exch = @b.exchange('amq.topic')
+		exch.should be_an_instance_of Bunny::Exchange
+		exch.name.should == 'amq.topic'
+		exch.type.should == :topic
+		@b.exchanges.has_key?('amq.topic').should be true
+	end
+	
+	# headers exchange not implemented in RabbitMQ yet. Uncomment if target broker/server supports it
+	#
+	#it "should allow a default headers exchange to be instantiated without specifying :type" do
+	#	exch = @b.exchange('amq.match')
+	#	exch.should be_an_instance_of Bunny::Exchange
+	#	exch.name.should == 'amq.match'
+	#	exch.type.should == :headers
+	#	@b.exchanges.has_key?('amq.match').should be true
+	#end
+	
+	it "should create an exchange as direct by default" do
+		exch = @b.exchange('direct_defaultex')
+		exch.should be_an_instance_of Bunny::Exchange
+		exch.name.should == 'direct_defaultex'
+		exch.type.should == :direct
+		@b.exchanges.has_key?('direct_defaultex').should be true
+	end
+	
+	it "should be able to be instantiated as a direct exchange" do
+		exch = @b.exchange('direct_exchange', :type => :direct)
+		exch.should be_an_instance_of Bunny::Exchange
+		exch.name.should == 'direct_exchange'
+		exch.type.should == :direct
+		@b.exchanges.has_key?('direct_exchange').should be true
+	end
+	
+	it "should be able to be instantiated as a topic exchange" do
+		exch = @b.exchange('topic_exchange', :type => :topic)
+		exch.should be_an_instance_of Bunny::Exchange
+		exch.name.should == 'topic_exchange'
+		exch.type.should == :topic
+		@b.exchanges.has_key?('topic_exchange').should be true
+	end
+	
+	it "should be able to be instantiated as a fanout exchange" do
+		exch = @b.exchange('fanout_exchange', :type => :fanout)
+		exch.should be_an_instance_of Bunny::Exchange
+		exch.name.should == 'fanout_exchange'
+		exch.type.should == :fanout
+		@b.exchanges.has_key?('fanout_exchange').should be true
+	end
+	
+	it "should ignore the :nowait option when instantiated" do
+		exch = @b.exchange('direct2_exchange', :nowait => true)
+	end
+	
+	it "should be able to publish a message" do
+		exch = @b.exchange('direct_exchange')
+		exch.publish('This is a published message')
+	end
+	
+	it "should be able to be deleted" do
+		exch = @b.exchange('direct_exchange')
+		res = exch.delete
+		res.should == :delete_ok
+		@b.exchanges.has_key?('direct_exchange').should be false
+	end
+	
+	it "should ignore the :nowait option when deleted" do
+		exch = @b.exchange('direct2_exchange')
+		exch.delete(:nowait => true)
+	end
+	
+end

data/spec/queue_spec.rb

@@ -0,0 +1,90 @@
+# queue_spec.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')
+
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib bunny]))
+
+describe Bunny::Queue do
+	
+	before(:each) do
+    @b = Bunny.new
+		@b.start
+	end
+	
+	it "should ignore the :nowait option when instantiated" do
+		q = @b.queue('test0', :nowait => true)
+	end
+	
+	it "should ignore the :nowait option when binding to an exchange" do
+		exch = @b.exchange('direct_exch')
+		q = @b.queue('test0')
+		q.bind(exch, :nowait => true).should == :bind_ok
+	end
+	
+	it "should be able to bind to an exchange" do
+		exch = @b.exchange('direct_exch')
+		q = @b.queue('test1')
+		q.bind(exch).should == :bind_ok
+	end
+	
+	it "should ignore the :nowait option when unbinding from an exchange" do
+		exch = @b.exchange('direct_exch')
+		q = @b.queue('test0')
+		q.unbind(exch, :nowait => true).should == :unbind_ok
+	end
+	
+	it "should be able to unbind from an exchange" do
+		exch = @b.exchange('direct_exch')
+		q = @b.queue('test1')
+		q.unbind(exch).should == :unbind_ok
+	end
+
+	it "should be able to publish a message" do
+		q = @b.queue('test1')
+		q.publish('This is a test message')
+		q.message_count.should == 1
+	end
+	
+	it "should be able to pop a message complete with header and delivery details" do
+		q = @b.queue('test1')
+		msg = q.pop(:header => true)
+		msg.should be_an_instance_of Hash
+		msg[:header].should be_an_instance_of Bunny::Protocol::Header
+		msg[:payload].should == 'This is a test message'
+		msg[:delivery_details].should be_an_instance_of Hash
+		q.message_count.should == 0
+	end
+
+	it "should be able to pop a message and just get the payload" do
+		q = @b.queue('test1')
+		q.publish('This is another test message')
+		msg = q.pop
+		msg.should == 'This is another test message'
+		q.message_count.should == 0
+	end
+	
+	it "should return an empty message when popping an empty queue" do
+		q = @b.queue('test1')
+		q.publish('This is another test message')
+		q.pop
+		msg = q.pop
+		msg.should == :queue_empty
+	end
+
+	it "should be able to be deleted" do
+		q = @b.queue('test1')
+		res = q.delete
+		res.should == :delete_ok
+		@b.queues.has_key?('test1').should be false
+	end
+	
+	it "should ignore the :nowait option when deleted" do
+		q = @b.queue('test0')
+		q.delete(:nowait => true)
+	end
+	
+end