bunny 0.7.13 → 0.8.0

data/lib/qrack/qrack09.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-$: << File.expand_path(File.dirname(__FILE__))
-
-require 'protocol/spec09'
-require 'protocol/protocol09'
-
-require 'transport/buffer09'
-require 'transport/frame09'
-
-require 'qrack/client'
-require 'qrack/channel'
-require 'qrack/queue'
-require 'bunny/consumer'
-require 'qrack/errors'
-
-module Qrack
-  include Protocol09
-  include Transport09
-end

data/lib/qrack/transport/buffer09.rb

@@ -1,305 +0,0 @@
-# encoding: utf-8
-
-if [].map.respond_to? :with_index
-  class Array #:nodoc:
-    def enum_with_index
-      each.with_index
-    end
-  end
-else
-  require 'enumerator'
-end
-
-module Qrack
-  module Transport09 #:nodoc: all
-    class Buffer
-
-      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.bytesize
-      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)
-                         when 65 # 'A'
-                           table.read(:array)
-                         when 108 # 'l'
-                           table.read(:longlong)
-                         when 116 # 't'
-                           table.read(:octet) == 1
-                         end
-            end
-
-            t
-          when :bit
-            if (@bits ||= []).empty?
-              val = read(:octet)
-              @bits = (0..7).map{|i| (val & (1 << i)) != 0 }
-            end
-
-            @bits.shift
-          when :array
-            a = Array.new
-
-            array = Buffer.new(read(:longstr))
-            until array.empty?
-              type = array.read(:octet)
-              a << case type
-                   when 70 # 'F'
-                     array.read(:table)
-                   end
-            end
-
-            a
-          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.bytesize, data], 'Ca*')
-        when :longstr
-          if data.is_a? Hash
-            write(:table, data)
-          else
-            data = (data || '').to_s
-            _write([data.bytesize, 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 Integer
-                               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.bytesize
-                               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)
-                             when TrueClass
-                               table.write(:octet, 116) # 't'
-                               table.write(:octet, 1)
-                             when FalseClass
-                               table.write(:octet, 116) # 't'
-                               table.write(:octet, 0)
-                             else
-                               raise Qrack::InvalidTypeError, "Cannot write table field for the type of #{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.bytesize
-      end
-    end
-  end
-end

data/lib/qrack/transport/frame09.rb

@@ -1,97 +0,0 @@
-
-# encoding: utf-8
-
-
-#:stopdoc:
-# this file was autogenerated on 2011-07-21 07:07:06 +0100
-#
-# DO NOT EDIT! (edit ext/qparser.rb and config.yml instead, and run 'ruby qparser.rb')
-
-module Qrack
-  module Transport09
-    class Frame
-
-      FOOTER = 206
-      ID = 0
-
-      @types = {
-                 1 => 'Method',
-                 2 => 'Header',
-                 3 => 'Body',
-                 8 => 'Heartbeat',
-               }
-
-      attr_accessor :channel, :payload
-
-      def initialize payload = nil, channel = 0
-        @channel, @payload = channel, payload
-      end
-
-      def id
-        self.class::ID
-      end
-
-      def to_binary
-        buf = Transport09::Buffer.new
-        buf.write :octet, id
-        buf.write :short, channel
-        buf.write :longstr, payload
-        buf.write :octet, 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
-
-      def self.parse buf
-        buf = Transport09::Buffer.new(buf) unless buf.is_a? Transport09::Buffer
-        buf.extract do
-          id, channel, payload, footer = buf.read(:octet, :short, :longstr, :octet)
-          Qrack::Transport09.const_get(@types[id]).new(payload, channel) if footer == FOOTER
-        end
-      end
-
-    end
-
-    class Method < Frame
-
-      ID = 1
-
-      def initialize payload = nil, channel = 0
-        super
-        unless @payload.is_a? Protocol09::Class::Method or @payload.nil?
-          @payload = Protocol09.parse(@payload)
-        end
-      end
-    end
-
-    class Header < Frame
-
-      ID = 2
-
-      def initialize payload = nil, channel = 0
-        super
-        unless @payload.is_a? Protocol09::Header or @payload.nil?
-          @payload = Protocol09::Header.new(@payload)
-        end
-      end
-    end
-
-    class Body < Frame
-      ID = 3
-    end
-
-    class Heartbeat < Frame
-      ID = 8
-    end
-
-  end
-end

data/spec/spec_08/bunny_spec.rb

@@ -1,75 +0,0 @@
-# encoding: utf-8
-
-# 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_relative "../spec_helper"
-
-describe Bunny do
-
-  before(:each) do
-    @b = Bunny.new
-    @b.start
-  end
-
-  after(:each) do
-    begin
-      @b.stop
-    rescue Exception
-    ensure
-      @b = nil
-    end
-  end
-
-  it "should connect to an AMQP server" do
-    @b.status.should == :connected
-  end
-
-  it "should be able to create and open a new channel" do
-    c = @b.create_channel
-    c.number.should == 2
-    c.should be_an_instance_of(Bunny::Channel)
-    @b.channels.size.should == 3
-    c.open.should == :open_ok
-    @b.channel.number.should == 2
-  end
-
-  it "should be able to switch between channels" do
-    @b.channel.number.should == 1
-    @b.switch_channel(0)
-    @b.channel.number.should == 0
-  end
-
-  it "should raise an error if trying to switch to a non-existent channel" do
-    lambda { @b.switch_channel(5)}.should raise_error(RuntimeError)
-  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
-
-  it "should be able to set QoS" do
-    @b.qos.should == :qos_ok
-  end
-
-  it "should be able to set QoS (with global:true)" do
-    @b.qos(:global => true).should == :qos_ok
-  end
-
-end
-

data/spec/spec_08/connection_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-# connection_spec.rb
-
-require_relative "../spec_helper"
-
-describe Bunny do
-
-  it "should raise an error if the wrong user name or password is used" do
-    b = Bunny.new(:spec => "0.8", :user => 'wrong')
-    lambda { b.start}.should raise_error(Bunny::ProtocolError)
-  end
-
-  it "should be able to open a TCPSocket with a timeout" do
-    b = Bunny.new(:spec => "0.8")
-    connect_timeout = 5
-    lambda {
-      Bunny::Timer::timeout(connect_timeout, Qrack::ConnectionTimeout) do
-        TCPSocket.new(b.host, b.port)
-      end
-    }.should_not raise_error(Exception)
-  end
-
-end

data/spec/spec_08/exchange_spec.rb

@@ -1,175 +0,0 @@
-# encoding: utf-8
-
-# 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_relative "../spec_helper"
-
-describe 'Exchange' do
-
-  before(:each) do
-    @b = Bunny.new
-    @b.start
-  end
-
-  after(:each) do
-    begin
-      @b.stop
-    rescue Exception
-    ensure
-      @b = nil
-    end
-  end
-
-  it "should raise an error if instantiated as non-existent type" do
-    lambda { @b.exchange('bogus_ex', :type => :bogus) }.should raise_error(Bunny::ForcedConnectionCloseError)
-    @b.status.should == :not_connected
-  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
-
-  it "should allow a default headers (amq.match) 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 allow a default headers (amq.headers) exchange to be instantiated without specifying :type" do
-    exch = @b.exchange('amq.headers')
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'amq.headers'
-    exch.type.should == :headers
-    @b.exchanges.has_key?('amq.headers').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 be able to be instantiated as a headers exchange" do
-    exch = @b.exchange('headers_exchange', :type => :headers)
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'headers_exchange'
-    exch.type.should == :headers
-    @b.exchanges.has_key?('headers_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 not modify the passed options hash when publishing a message" do
-    exch = @b.exchange('direct_exchange')
-    opts = {:key => 'a', :persistent => true}
-    exch.publish('', opts)
-    opts.should == {:key => 'a', :persistent => true}
-  end
-
-  it "should be able to publish a message with headers containing integer values" do
-    exch = @b.exchange('direct_exchange')
-    exch.publish('This is a published message', :headers => {:a => 1})
-  end
-
-  it "should be able to return an undeliverable message" do
-    exch = @b.exchange('return_exch')
-    exch.publish('This message should be undeliverable', :mandatory => true)
-    ret_msg = @b.returned_message
-    ret_msg.should be_an_instance_of(Hash)
-    ret_msg[:payload].should == 'This message should be undeliverable'
-  end
-
-  it "should be able to handle connection close on trying to publish with immediate=true" do
-    exch = @b.exchange('return_exch')
-    exch.publish('This message should force a connection close', :immediate => true)
-    lambda { @b.returned_message }.should raise_error(Bunny::ForcedConnectionCloseError)
-  end
-
-  it "should not close the connection when trying to delete a non existent exchange" do
-    exch = @b.exchange('direct_exchange')
-    exch.delete(:exchange => 'bogus_ex').should == :delete_ok
-    @b.channel.active.should == true
-  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