sidekick-client 0.1.0

data/lib/ext/bunny-0.6.0/lib/qrack/qrack08.rb

@@ -0,0 +1,23 @@
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'protocol/spec08'
+require 'protocol/protocol08'
+
+require 'transport/buffer08'
+require 'transport/frame08'
+
+require 'qrack/client'
+require 'qrack/channel'
+require 'qrack/queue'
+require 'qrack/subscription'
+
+module Qrack
+	
+	include Protocol
+	include Transport
+	
+	# Errors
+	class BufferOverflowError < StandardError; end
+  class InvalidTypeError < StandardError; end
+
+end

data/lib/ext/bunny-0.6.0/lib/qrack/qrack09.rb

@@ -0,0 +1,23 @@
+$: << 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 'qrack/subscription'
+
+module Qrack
+	
+	include Protocol09
+	include Transport09
+	
+	# Errors
+	class BufferOverflowError < StandardError; end
+  class InvalidTypeError < StandardError; end
+
+end

data/lib/ext/bunny-0.6.0/lib/qrack/queue.rb

@@ -0,0 +1,53 @@
+module Qrack
+	
+	# Queue ancestor class
+	class Queue
+		
+		attr_reader :name, :client
+	  attr_accessor :delivery_tag, :subscription
+	
+=begin rdoc
+
+=== DESCRIPTION:
+
+Returns consumer count from Queue#status.
+
+=end
+
+	  def consumer_count
+	    s = status
+			s[:consumer_count]
+	  end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+Returns message count from Queue#status.
+
+=end
+
+	  def message_count
+	    s = status
+			s[:message_count]
+	  end
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+Publishes a message to the queue via the default nameless '' direct exchange.
+
+==== RETURNS:
+
+nil
+
+=end
+
+	  def publish(data, opts = {})
+	    exchange.publish(data, opts)
+	  end
+		
+	end
+	
+end

data/lib/ext/bunny-0.6.0/lib/qrack/subscription.rb

@@ -0,0 +1,102 @@
+module Qrack
+	# Subscription ancestor class
+	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
+			
+			# Give queue reference to this subscription
+			@queue.subscription = self
+			
+			# 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
+
+			# Start subscription loop
+			loop do
+			
+				begin
+					method = client.next_method(:timeout => timeout)
+				rescue Qrack::ClientTimeout
+					queue.unsubscribe()
+					break
+				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
+
+			  # 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
+					msg += client.next_payload
+				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?
+
+				# Exit loop if message_max condition met
+				if (!message_max.nil? and message_count == message_max)
+					# Stop consuming messages
+					queue.unsubscribe()				
+					# 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/ext/bunny-0.6.0/lib/qrack/transport/buffer08.rb

@@ -0,0 +1,276 @@
+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.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