gorgon 0.5.0.rc1 → 0.6.0.rc1

data/lib/gorgon_amq-protocol/lib/gorgon_amq/protocol/constants.rb

@@ -0,0 +1,22 @@
+module GorgonAMQ
+  module Protocol
+    TLS_PORT         = 5671
+    SSL_PORT         = 5671
+
+    # caching
+    EMPTY_STRING = "".freeze
+
+    PACK_INT8               = 'c'.freeze
+    PACK_CHAR               = 'C'.freeze
+    PACK_UINT16             = 'n'.freeze
+    PACK_UINT16_X2          = 'n2'.freeze
+    PACK_UINT32             = 'N'.freeze
+    PACK_UINT32_X2          = 'N2'.freeze
+    PACK_INT64              = 'q'.freeze
+    PACK_UCHAR_UINT32       = 'CN'.freeze
+    PACK_CHAR_UINT16_UINT32 = 'cnN'.freeze
+
+    PACK_32BIT_FLOAT        = 'f'.freeze
+    PACK_64BIT_FLOAT        = 'G'.freeze
+  end
+end

data/lib/gorgon_amq-protocol/lib/gorgon_amq/protocol/exceptions.rb

@@ -0,0 +1,60 @@
+module GorgonAMQ
+  module Protocol
+    class Error < StandardError
+      DEFAULT_MESSAGE = "AMQP error".freeze
+
+      def self.inherited(subclass)
+        @_subclasses ||= []
+        @_subclasses << subclass
+      end # self.inherited(subclazz)
+
+      def self.subclasses_with_values
+        @_subclasses.select{ |k| defined?(k::VALUE) }
+      end # self.subclasses_with_values
+
+      def self.[](code)
+        if result = subclasses_with_values.detect { |klass| klass::VALUE == code }
+          result
+        else
+          raise "No such exception class for code #{code}" unless result
+        end # if
+      end # self.[]
+
+      def initialize(message = self.class::DEFAULT_MESSAGE)
+        super(message)
+      end
+    end
+
+    class FrameTypeError < Protocol::Error
+      def initialize(types)
+        super("Must be one of #{types.inspect}")
+      end
+    end
+
+    class EmptyResponseError < Protocol::Error
+      DEFAULT_MESSAGE = "Empty response received from the server."
+
+      def initialize(message = self.class::DEFAULT_MESSAGE)
+        super(message)
+      end
+    end
+
+    class BadResponseError < Protocol::Error
+      def initialize(argument, expected, actual)
+        super("Argument #{argument} has to be #{expected.inspect}, was #{data.inspect}")
+      end
+    end
+
+    class SoftError < Protocol::Error
+      def self.inherited(subclass)
+        Error.inherited(subclass)
+      end # self.inherited(subclass)
+    end
+
+    class HardError < Protocol::Error
+      def self.inherited(subclass)
+        Error.inherited(subclass)
+      end # self.inherited(subclass)
+    end
+  end
+end

data/lib/gorgon_amq-protocol/lib/gorgon_amq/protocol/float_32bit.rb

@@ -0,0 +1,14 @@
+module GorgonAMQ
+  module Protocol
+    # Allows distinguishing between 32-bit and 64-bit floats in Ruby.
+    # Useful in cases when RabbitMQ plugins encode
+    # values as 32 bit numbers.
+    class Float32Bit
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+    end
+  end
+end

data/lib/gorgon_amq-protocol/lib/gorgon_amq/protocol/frame.rb

@@ -0,0 +1,210 @@
+# encoding: binary
+
+module GorgonAMQ
+  module Protocol
+    class Frame
+      TYPES = {:method => 1, :headers => 2, :body => 3, :heartbeat => 8}.freeze
+      TYPES_REVERSE = TYPES.invert.freeze
+      TYPES_OPTIONS = TYPES.keys.freeze
+      CHANNEL_RANGE = (0..65535).freeze
+      FINAL_OCTET   = "\xCE".freeze # 206
+
+      def self.encoded_payload(payload)
+        if payload.respond_to?(:force_encoding) && payload.encoding.name != 'BINARY'
+          # Only copy if we have to.
+          payload = payload.dup.force_encoding('BINARY')
+        end
+        payload
+      end
+
+      # The channel number is 0 for all frames which are global to the connection and 1-65535 for frames that refer to specific channels.
+      def self.encode_to_array(type, payload, channel)
+        raise RuntimeError.new("Channel has to be 0 or an integer in range 1..65535 but was #{channel.inspect}") unless CHANNEL_RANGE.include?(channel)
+        raise RuntimeError.new("Payload can't be nil") if payload.nil?
+        components = []
+        components << [find_type(type), channel, payload.bytesize].pack(PACK_CHAR_UINT16_UINT32)
+        components << encoded_payload(payload)
+        components << FINAL_OCTET
+        components
+      end
+
+      def self.encode(type, payload, channel)
+        encode_to_array(type, payload, channel).join
+      end
+
+      class << self
+        alias_method :__new__, :new unless method_defined?(:__new__) # because of reloading
+      end
+
+      def self.new(original_type, *args)
+        type_id = find_type(original_type)
+        klass = CLASSES[type_id]
+        klass.new(*args)
+      end
+
+      def self.find_type(type)
+        type_id = if Symbol === type then TYPES[type] else type end
+        raise FrameTypeError.new(TYPES_OPTIONS) if type == nil || !TYPES_REVERSE.has_key?(type_id)
+        type_id
+      end
+
+      def self.decode(*)
+        raise NotImplementedError.new <<-EOF
+You are supposed to redefine this method, because it's dependent on used IO adapter.
+
+This functionality is part of the https://github.com/ruby-amqp/amq-client library.
+        EOF
+      end
+
+      def self.decode_header(header)
+        raise EmptyResponseError if header == nil || header.empty?
+
+        type_id, channel, size = header.unpack(PACK_CHAR_UINT16_UINT32)
+        type = TYPES_REVERSE[type_id]
+        raise FrameTypeError.new(TYPES_OPTIONS) unless type
+        [type, channel, size]
+      end
+
+      def final?
+        true
+      end
+    end
+
+    class FrameSubclass < Frame
+      # Restore original new
+      class << self
+        alias_method :new, :__new__
+        undef_method :decode if method_defined?(:decode)
+      end
+
+      def self.id
+        @id
+      end
+
+      def self.encode(payload, channel)
+        super(@id, payload, channel)
+      end
+
+      attr_accessor :channel
+      attr_reader :payload
+      def initialize(payload, channel)
+        @payload, @channel = payload, channel
+      end
+
+      def size
+        @payload.bytesize
+      end
+
+      # TODO: remove once we are sure none of the clients
+      #       uses this method directly
+      # @api private
+      def encode_to_array
+        components = []
+        components << [self.class.id, @channel, @payload.bytesize].pack(PACK_CHAR_UINT16_UINT32)
+        components << self.class.encoded_payload(@payload)
+        components << FINAL_OCTET
+        components
+      end
+
+      def encode
+        s = [self.class.id, @channel, @payload.bytesize].pack(PACK_CHAR_UINT16_UINT32)
+        s << self.class.encoded_payload(@payload)
+        s << FINAL_OCTET
+        s
+      end
+    end
+
+    class MethodFrame < FrameSubclass
+      @id = 1
+
+      def method_class
+        @method_class ||= begin
+                            klass_id, method_id = self.payload.unpack(PACK_UINT16_X2)
+                            index               = klass_id << 16 | method_id
+                            GorgonAMQ::Protocol::METHODS[index]
+                          end
+      end
+
+      def final?
+        !self.method_class.has_content?
+      end # final?
+
+      def decode_payload
+        self.method_class.decode(@payload[4..-1])
+      end
+    end
+
+    class HeaderFrame < FrameSubclass
+      @id = 2
+
+      def final?
+        false
+      end
+
+      def body_size
+        decode_payload
+        @body_size
+      end
+
+      def weight
+        decode_payload
+        @weight
+      end
+
+      def klass_id
+        decode_payload
+        @klass_id
+      end
+
+      def properties
+        decode_payload
+        @properties
+      end
+
+      def decode_payload
+        @decoded_payload ||= begin
+                               @klass_id, @weight = @payload.unpack(PACK_UINT16_X2)
+                               # the total size of the content body, that is, the sum of the body sizes for the
+                               # following content body frames. Zero indicates that there are no content body frames.
+                               # So this is NOT related to this very header frame!
+                               @body_size         = GorgonAMQ::Hacks.unpack_uint64_big_endian(@payload[4..11]).first
+                               @data              = @payload[12..-1]
+                               @properties        = Basic.decode_properties(@data)
+                             end
+      end
+    end
+
+    class BodyFrame < FrameSubclass
+      @id = 3
+
+      def decode_payload
+        @payload
+      end
+
+      def final?
+        # we cannot know whether it is final or not so framing code in amq-client
+        # checks this over the entire frameset. MK.
+        false
+      end
+    end
+
+    class HeartbeatFrame < FrameSubclass
+      @id = 8
+
+      def final?
+        true
+      end # final?
+
+      def self.encode
+        super(Protocol::EMPTY_STRING, 0)
+      end
+    end
+
+    Frame::CLASSES = {
+      Frame::TYPES[:method] => MethodFrame,
+      Frame::TYPES[:headers] => HeaderFrame,
+      Frame::TYPES[:body] => BodyFrame,
+      Frame::TYPES[:heartbeat] => HeartbeatFrame
+    }
+  end
+end

data/lib/gorgon_amq-protocol/lib/gorgon_amq/protocol/table.rb

@@ -0,0 +1,142 @@
+# encoding: binary
+
+require "gorgon_amq/protocol/client"
+require "gorgon_amq/protocol/type_constants"
+require "gorgon_amq/protocol/table_value_encoder"
+require "gorgon_amq/protocol/table_value_decoder"
+
+module GorgonAMQ
+  module Protocol
+    class Table
+
+      #
+      # Behaviors
+      #
+
+      include TypeConstants
+
+
+      #
+      # API
+      #
+
+      class InvalidTableError < StandardError
+        def initialize(key, value)
+          super("Invalid table value on key #{key}: #{value.inspect} (#{value.class})")
+        end
+      end
+
+
+      def self.encode(table)
+        buffer = String.new
+
+        table ||= {}
+
+        table.each do |key, value|
+          key = key.to_s # it can be a symbol as well
+          buffer << key.bytesize.chr + key
+
+          case value
+          when Hash then
+            buffer << TYPE_HASH
+            buffer << self.encode(value)
+          else
+            buffer << TableValueEncoder.encode(value)
+          end
+        end
+
+        [buffer.bytesize].pack(PACK_UINT32) + buffer
+      end
+
+
+
+
+      def self.decode(data)
+        table        = Hash.new
+        table_length = data.unpack(PACK_UINT32).first
+
+        return table if table_length.zero?
+
+        offset       = 4
+        while offset <= table_length
+          key, offset  = decode_table_key(data, offset)
+          type, offset = TableValueDecoder.decode_value_type(data, offset)
+
+          table[key] = case type
+                       when TYPE_STRING
+                         v, offset = TableValueDecoder.decode_string(data, offset)
+                         v
+                       when TYPE_INTEGER
+                         v, offset = TableValueDecoder.decode_integer(data, offset)
+                         v
+                       when TYPE_DECIMAL
+                         v, offset = TableValueDecoder.decode_big_decimal(data, offset)
+                         v
+                       when TYPE_TIME
+                         v, offset = TableValueDecoder.decode_time(data, offset)
+                         v
+                       when TYPE_HASH
+                         v, offset = TableValueDecoder.decode_hash(data, offset)
+                         v
+                       when TYPE_BOOLEAN
+                         v, offset = TableValueDecoder.decode_boolean(data, offset)
+                         v
+                       when TYPE_SIGNED_8BIT  then
+                         v, offset = TableValueDecoder.decode_short_short(data, offset)
+                         v
+                       when TYPE_SIGNED_16BIT then
+                         v, offset = TableValueDecoder.decode_short(data, offset)
+                         v
+                       when TYPE_SIGNED_64BIT then
+                         v, offset = TableValueDecoder.decode_long(data, offset)
+                         v
+                       when TYPE_32BIT_FLOAT then
+                         v, offset = TableValueDecoder.decode_32bit_float(data, offset)
+                         v
+                       when TYPE_64BIT_FLOAT then
+                         v, offset = TableValueDecoder.decode_64bit_float(data, offset)
+                         v
+                       when TYPE_VOID
+                         nil
+                       when TYPE_ARRAY
+                         v, offset = TableValueDecoder.decode_array(data, offset)
+                         v
+                       else
+                         raise ArgumentError, "Not a valid type: #{type.inspect}\nData: #{data.inspect}\nUnprocessed data: #{data[offset..-1].inspect}\nOffset: #{offset}\nTotal size: #{table_length}\nProcessed data: #{table.inspect}"
+                       end
+        end
+
+        table
+      end # self.decode
+
+
+      def self.length(data)
+        data.unpack(PACK_UINT32).first
+      end
+
+
+      def self.hash_size(value)
+        acc = 0
+        value.each do |k, v|
+          acc += (1 + k.to_s.bytesize)
+          acc += TableValueEncoder.field_value_size(v)
+        end
+
+        acc
+      end # self.hash_size(value)
+
+
+      def self.decode_table_key(data, offset)
+        key_length = data.slice(offset, 1).unpack(PACK_CHAR).first
+        offset += 1
+        key = data.slice(offset, key_length)
+        offset += key_length
+
+        [key, offset]
+      end # self.decode_table_key(data, offset)
+
+
+
+    end # Table
+  end # Protocol
+end # AMQ