bunny 0.8.0 → 0.9.0.pre1

data/lib/qrack/qrack.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-$: << File.expand_path(File.dirname(__FILE__))
-
-require 'protocol/spec'
-require 'protocol/protocol'
-
-require 'transport/buffer'
-require 'transport/frame'
-
-require 'qrack/client'
-require 'qrack/channel'
-require 'qrack/queue'
-require 'bunny/consumer'
-require 'qrack/errors'
-
-module Qrack
-  include Protocol
-  include Transport
-end

data/lib/qrack/queue.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-module Qrack
-
-  # Queue ancestor class
-  class Queue
-
-    # @return [AMQ::Client::Consumer] Default consumer (registered with {Queue#subscribe}).
-    attr_accessor :default_consumer
-
-    attr_reader :name, :client
-
-    attr_accessor :delivery_tag
-
-
-    # Returns consumer count from {Queue#status}.
-    def consumer_count
-      s = status
-      s[:consumer_count]
-    end
-
-    # Returns message count from {Queue#status}.
-    def message_count
-      s = status
-      s[:message_count]
-    end
-
-    # Publishes a message to the queue via the default nameless '' direct exchange.
-
-    # @return [NilClass] nil
-    # @deprecated
-    # @note This method will be removed before 0.8 release.
-    def publish(data, opts = {})
-      Bunny.deprecation_warning("Qrack::Queue#publish", "0.8", "Use direct_exchange = bunny.exchange(''); direct_exchange.publish('message', key: queue.name) if you want to publish directly to one given queue. For more informations see https://github.com/ruby-amqp/bunny/issues/15 and for more theoretical explanation check http://bit.ly/nOF1CK")
-      exchange.publish(data, opts)
-    end
-
-  end
-
-end

data/lib/qrack/subscription.rb

@@ -1,152 +0,0 @@
-# encoding: utf-8
-
-#################################################
-# WARNING: THIS CLASS IS DEPRECATED, DO NOT     #
-# USE IT DIRECTLY! USE BUNNY::CONSUMER INSTEAD! #
-#################################################
-
-module Qrack
-  # Subscription ancestor class
-  # @deprecated
-  class Subscription
-
-    attr_accessor :consumer_tag, :delivery_tag, :message_max, :timeout, :ack, :exclusive
-    attr_reader :client, :queue, :message_count
-
-    def initialize(client, queue, opts = {})
-      @client = client
-      @queue = queue
-
-      # Get timeout value
-      @timeout = opts[:timeout] || nil
-
-      # Get maximum amount of messages to process
-      @message_max = opts[:message_max] || nil
-
-      # If a consumer tag is not passed in the server will generate one
-      @consumer_tag = opts[:consumer_tag] || nil
-
-      # Ignore the :nowait option if passed, otherwise program will hang waiting for a
-      # response from the server causing an error.
-      opts.delete(:nowait)
-
-      # Do we want to have to provide an acknowledgement?
-      @ack = opts[:ack] || nil
-
-      # Does this consumer want exclusive use of the queue?
-      @exclusive = opts[:exclusive] || false
-
-      # Initialize message counter
-      @message_count = 0
-
-      # Store cancellator
-      @cancellator = opts[:cancellator]
-
-      # Store options
-      @opts = opts
-    end
-
-    def start(&blk)
-      # Do not process any messages if zero message_max
-      if message_max == 0
-        return
-      end
-
-      # Notify server about new consumer
-      setup_consumer
-
-      # We need to keep track of three possible subscription states
-      # :subscribed, :pending, and :unsubscribed
-      # 'pending' occurs because of network latency, where we tried to unsubscribe but were already given a message
-      subscribe_state = :subscribed
-
-      # Start subscription loop
-      loop do
-
-        begin
-          method = client.next_method(:timeout => timeout, :cancellator => @cancellator)
-        rescue Qrack::FrameTimeout
-          begin
-            queue.unsubscribe
-            subscribe_state = :unsubscribed
-
-            break
-          rescue Bunny::ProtocolError
-            # Unsubscribe failed because we actually got a message, so we're in a weird state.
-            # We have to keep processing the message or else it may be lost...
-            # ...and there is also a CancelOk method floating around that we need to consume from the socket
-
-            method = client.last_method
-            subscribe_state = :pending
-          end
-        end
-
-        # Increment message counter
-        @message_count += 1
-
-        # get delivery tag to use for acknowledge
-        queue.delivery_tag = method.delivery_tag if @ack
-        header = client.next_payload
-
-        # The unsubscribe ok may be sprinked into the payload
-        if subscribe_state == :pending and header.is_a?(Qrack::Protocol::Basic::CancelOk)
-          # We popped off the CancelOk, so we don't have to keep looking for it
-          subscribe_state = :unsubscribed
-
-          # Get the actual header now
-          header = client.next_payload
-        end
-
-        # If maximum frame size is smaller than message payload body then message
-        # will have a message header and several message bodies
-        msg = ''
-        while msg.length < header.size
-          message = client.next_payload
-
-          # The unsubscribe ok may be sprinked into the payload
-          if subscribe_state == :pending and message.is_a?(Qrack::Protocol::Basic::CancelOk)
-            # We popped off the CancelOk, so we don't have to keep looking for it
-            subscribe_state = :unsubscribed
-            next
-          end
-
-          msg << message
-        end
-
-        # If block present, pass the message info to the block for processing
-        blk.call({:header => header, :payload => msg, :delivery_details => method.arguments}) if !blk.nil?
-
-        # Unsubscribe if we've encountered the maximum number of messages
-        if subscribe_state == :subscribed and !message_max.nil? and message_count == message_max
-          queue.unsubscribe
-          subscribe_state = :unsubscribed
-        end
-
-        # Exit the loop if we've unsubscribed
-        if subscribe_state != :subscribed
-          # We still haven't found the CancelOk, so it's the next method
-          if subscribe_state == :pending
-            method = client.next_method
-            client.check_response(method, Qrack::Protocol::Basic::CancelOk, "Error unsubscribing from queue #{queue.name}, got #{method.class}")
-
-            subscribe_state = :unsubscribed
-          end
-
-          # Acknowledge receipt of the final message
-          queue.ack() if @ack
-
-          # Quit the loop
-          break
-        end
-
-        # Have to do the ack here because the ack triggers the release of messages from the server
-        # if you are using Client#qos prefetch and you will get extra messages sent through before
-        # the unsubscribe takes effect to stop messages being sent to this consumer unless the ack is
-        # deferred.
-        queue.ack() if @ack
-      end
-    end
-
-  end
-
-end

data/lib/qrack/transport/buffer.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 Transport #: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)
-                         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 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.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)
-                             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_ready?(timeout, cancellator)
-        if @data.is_a?(Qrack::Client)
-          @data.read_ready?(timeout, cancellator)
-        else
-          true
-        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