gorgon 0.5.0.rc1 → 0.6.0.rc1

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

@@ -0,0 +1,190 @@
+# encoding: binary
+
+require "gorgon_amq/endianness"
+require "gorgon_amq/protocol/client"
+require "gorgon_amq/protocol/type_constants"
+require "gorgon_amq/protocol/table"
+require "gorgon_amq/protocol/float_32bit"
+
+module GorgonAMQ
+  module Protocol
+
+    class TableValueDecoder
+
+      #
+      # Behaviors
+      #
+
+      include TypeConstants
+
+
+      #
+      # API
+      #
+
+      def self.decode_array(data, initial_offset)
+        array_length = data.slice(initial_offset, 4).unpack(PACK_UINT32).first
+
+        ary    = Array.new
+        offset = initial_offset + 4
+
+        while offset <= (initial_offset + array_length)
+          type, offset = decode_value_type(data, offset)
+
+          i = case type
+              when TYPE_STRING
+                v, offset = decode_string(data, offset)
+                v
+              when TYPE_INTEGER
+                v, offset = decode_integer(data, offset)
+                v
+              when TYPE_DECIMAL
+                v, offset = decode_big_decimal(data, offset)
+                v
+              when TYPE_TIME
+                v, offset = decode_time(data, offset)
+                v
+              when TYPE_HASH
+                v, offset = decode_hash(data, offset)
+                v
+              when TYPE_BOOLEAN
+                v, offset = decode_boolean(data, offset)
+                v
+              when TYPE_SIGNED_8BIT then
+                v, offset = decode_short_short(data, offset)
+                v
+              when TYPE_SIGNED_16BIT then
+                v, offset = decode_short(data, offset)
+                v
+              when TYPE_SIGNED_64BIT then
+                v, offset = decode_long(data, offset)
+                v
+              when TYPE_32BIT_FLOAT then
+                v, offset = decode_32bit_float(data, offset)
+                v
+              when TYPE_64BIT_FLOAT then
+                v, offset = decode_64bit_float(data, offset)
+                v
+              when TYPE_VOID
+                nil
+              when TYPE_ARRAY
+                v, offset = TableValueDecoder.decode_array(data, offset)
+                v
+              else
+                raise ArgumentError.new("unsupported type in a table value: #{type.inspect}, do not know how to decode!")
+              end
+
+          ary << i
+        end
+
+
+        [ary, initial_offset + array_length + 4]
+      end # self.decode_array(data, initial_offset)
+
+
+      def self.decode_string(data, offset)
+        length = data.slice(offset, 4).unpack(PACK_UINT32).first
+        offset += 4
+        v = data.slice(offset, length)
+        offset += length
+
+        [v, offset]
+      end # self.decode_string(data, offset)
+
+
+      def self.decode_integer(data, offset)
+        v = data.slice(offset, 4).unpack(PACK_UINT32).first
+        offset += 4
+
+        [v, offset]
+      end # self.decode_integer(data, offset)
+
+
+      if GorgonAMQ::Endianness.big_endian?
+        def self.decode_long(data, offset)
+          v    = data.slice(offset, 8).unpack(PACK_INT64)
+
+          offset += 8
+          [v, offset]
+        end
+      else
+        def self.decode_long(data, offset)
+          slice = data.slice(offset, 8).bytes.to_a.reverse.map(&:chr).join
+          v     = slice.unpack(PACK_INT64).first
+
+          offset += 8
+          [v, offset]
+        end
+      end
+
+
+      def self.decode_big_decimal(data, offset)
+        decimals, raw = data.slice(offset, 5).unpack(PACK_UCHAR_UINT32)
+        offset += 5
+        v = BigDecimal.new(raw.to_s) * (BigDecimal.new(TEN) ** -decimals)
+
+        [v, offset]
+      end # self.decode_big_decimal(data, offset)
+
+
+      def self.decode_time(data, offset)
+        timestamp = data.slice(offset, 8).unpack(PACK_UINT32_X2).last
+        v = Time.at(timestamp)
+        offset += 8
+
+        [v, offset]
+      end # self.decode_time(data, offset)
+
+
+      def self.decode_boolean(data, offset)
+        integer = data.slice(offset, 2).unpack(PACK_CHAR).first # 0 or 1
+        offset += 1
+        [(integer == 1), offset]
+      end # self.decode_boolean(data, offset)
+
+
+      def self.decode_32bit_float(data, offset)
+        v = data.slice(offset, 4).unpack(PACK_32BIT_FLOAT).first
+        offset += 4
+
+        [v, offset]
+      end # self.decode_32bit_float(data, offset)
+
+
+      def self.decode_64bit_float(data, offset)
+        v = data.slice(offset, 8).unpack(PACK_64BIT_FLOAT).first
+        offset += 8
+
+        [v, offset]
+      end # self.decode_64bit_float(data, offset)
+
+
+      def self.decode_value_type(data, offset)
+        [data.slice(offset, 1), offset + 1]
+      end # self.decode_value_type(data, offset)
+
+
+
+      def self.decode_hash(data, offset)
+        length = data.slice(offset, 4).unpack(PACK_UINT32).first
+        v = Table.decode(data.slice(offset, length + 4))
+        offset += 4 + length
+
+        [v, offset]
+      end # self.decode_hash(data, offset)
+
+
+      def self.decode_short_short(data, offset)
+        v = data.slice(offset, 1).unpack(PACK_INT8).first
+        offset += 1
+        [v, offset]
+      end
+
+      def self.decode_short(data, offset)
+        v = GorgonAMQ::Hacks.unpack_int16_big_endian(data.slice(offset, 2)).first
+        offset += 2
+        [v, offset]
+      end
+    end # TableValueDecoder
+  end # Protocol
+end # AMQ

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

@@ -0,0 +1,123 @@
+# encoding: binary
+
+require "gorgon_amq/protocol/client"
+require "gorgon_amq/protocol/type_constants"
+require "gorgon_amq/protocol/table"
+require "date"
+
+require "gorgon_amq/protocol/float_32bit"
+
+module GorgonAMQ
+  module Protocol
+
+    class TableValueEncoder
+
+      #
+      # Behaviors
+      #
+
+      include TypeConstants
+
+      #
+      # API
+      #
+
+      def self.encode(value)
+        accumulator = String.new
+
+        case value
+        when String then
+          accumulator << TYPE_STRING
+          accumulator << [value.bytesize].pack(PACK_UINT32)
+          accumulator << value
+        when Symbol then
+          v = value.to_s
+          accumulator << TYPE_STRING
+          accumulator << [v.bytesize].pack(PACK_UINT32)
+          accumulator << v
+        when Integer then
+          accumulator << TYPE_INTEGER
+          accumulator << [value].pack(PACK_UINT32)
+        when GorgonAMQ::Protocol::Float32Bit then
+          accumulator << TYPE_32BIT_FLOAT
+          accumulator << [value.value].pack(PACK_32BIT_FLOAT)
+        when Float then
+          accumulator << TYPE_64BIT_FLOAT
+          accumulator << [value].pack(PACK_64BIT_FLOAT)
+        when true, false then
+          accumulator << TYPE_BOOLEAN
+          accumulator << (value ? BOOLEAN_TRUE : BOOLEAN_FALSE)
+        when Time then
+          accumulator << TYPE_TIME
+          accumulator << [value.to_i].pack(PACK_INT64).reverse # FIXME: there has to be a more efficient way
+        when nil then
+          accumulator << TYPE_VOID
+        when Array then
+          accumulator << TYPE_ARRAY
+          accumulator << [self.array_size(value)].pack(PACK_UINT32)
+
+          value.each { |v| accumulator << self.encode(v) }
+        when Hash then
+          accumulator << TYPE_HASH
+          accumulator << GorgonAMQ::Protocol::Table.encode(value)
+        else
+          # We don't want to require these libraries.
+          if defined?(BigDecimal) && value.is_a?(BigDecimal)
+            accumulator << TYPE_DECIMAL
+            if value.exponent < 0
+              decimals = -value.exponent
+              raw = (value * (decimals ** 10)).to_i
+              accumulator << [decimals + 1, raw].pack(PACK_UCHAR_UINT32) # somewhat like floating point
+            else
+              # per spec, the "decimals" octet is unsigned (!)
+              accumulator << [0, value.to_i].pack(PACK_UCHAR_UINT32)
+            end
+          else
+            raise ArgumentError.new("Unsupported value #{value.inspect} of type #{value.class.name}")
+          end # if
+        end # case
+
+        accumulator
+      end # self.encode(value)
+
+
+
+
+      def self.field_value_size(value)
+        # the type tag takes 1 byte
+        acc = 1
+
+        case value
+        when String then
+          acc += (value.bytesize + 4)
+        when Integer then
+          acc += 4
+        when Float then
+          acc += 8
+        when Time, DateTime then
+          acc += 8
+        when true, false then
+          acc += 1
+        when nil then
+          # nothing, type tag alone is enough
+        when Hash then
+          acc += (4 + Table.hash_size(value))
+        when Array then
+          acc += (4 + self.array_size(value))
+        end
+
+        acc
+      end # self.field_value_size(value)
+
+
+      def self.array_size(value)
+        acc = 0
+        value.each { |v| acc += self.field_value_size(v) }
+
+        acc
+      end # self.array_size(value)
+
+    end # TableValueEncoder
+
+  end # Protocol
+end # AMQ

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

@@ -0,0 +1,26 @@
+# encoding: binary
+
+module GorgonAMQ
+  module Protocol
+    module TypeConstants
+      TYPE_STRING       = 'S'.freeze
+      TYPE_INTEGER      = 'I'.freeze
+      TYPE_TIME         = 'T'.freeze
+      TYPE_DECIMAL      = 'D'.freeze
+      TYPE_HASH         = 'F'.freeze
+      TYPE_ARRAY        = 'A'.freeze
+      TYPE_SIGNED_8BIT  = 'b'.freeze
+      TYPE_64BIT_FLOAT  = 'd'.freeze
+      TYPE_32BIT_FLOAT  = 'f'.freeze
+      TYPE_SIGNED_64BIT = 'l'.freeze
+      TYPE_SIGNED_16BIT = 's'.freeze
+      TYPE_BOOLEAN      = 't'.freeze
+      TYPE_BYTE_ARRAY   = 'x'.freeze
+      TYPE_VOID         = 'V'.freeze
+      TEN               = '10'.freeze
+
+      BOOLEAN_TRUE  = "\x01".freeze
+      BOOLEAN_FALSE = "\x00".freeze
+    end # TypeConstants
+  end # Protocol
+end # AMQ

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

@@ -0,0 +1,5 @@
+module GorgonAMQ
+  module Protocol
+    VERSION = "1.8.0"
+  end # Protocol
+end # AMQ

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

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+require "gorgon_amq/protocol/client"
+require "gorgon_amq/uri"
+
+module GorgonAMQ
+    module Settings
+
+      # @private
+      AMQPS = "amqps".freeze
+
+      # Default connection settings used by AMQ clients
+      #
+      # @see GorgonAMQ::Client::Settings.configure
+      def self.default
+        @default ||= {
+          # server
+          :host  => "127.0.0.1",
+          :port  => GorgonAMQ::Protocol::DEFAULT_PORT,
+
+          # login
+          :user  => "guest",
+          :pass  => "guest",
+          :vhost => "/",
+
+          # ssl
+          :ssl => false,
+
+          :frame_max => (128 * 1024),
+          :heartbeat => 0
+        }
+      end
+
+
+      # Merges given configuration parameters with defaults and returns
+      # the result.
+      #
+      # @param [Hash] Configuration parameters to use.
+      #
+      # @option settings [String] :host ("127.0.0.1") Hostname AMQ broker runs on.
+      # @option settings [String] :port (5672) Port AMQ broker listens on.
+      # @option settings [String] :vhost ("/") Virtual host to use.
+      # @option settings [String] :user ("guest") Username to use for authentication.
+      # @option settings [String] :pass ("guest") Password to use for authentication.
+      # @option settings [String] :ssl (false) Should be use TLS (SSL) for connection?
+      # @option settings [String] :timeout (nil) Connection timeout.
+      # @option settings [String] :broker (nil) Broker name (use if you intend to use broker-specific features).
+      # @option settings [Fixnum] :frame_max (131072) Maximum frame size to use. If broker cannot support frames this large, broker's maximum value will be used instead.
+      #
+      # @return [Hash] Merged configuration parameters.
+      def self.configure(settings = nil)
+        case settings
+        when Hash then
+          if username = (settings.delete(:username) || settings.delete(:user))
+            settings[:user] ||= username
+          end
+
+          if password = (settings.delete(:password) || settings.delete(:pass))
+            settings[:pass] ||= password
+          end
+
+
+          self.default.merge(settings)
+        when String then
+          settings = self.parse_amqp_url(settings)
+          self.default.merge(settings)
+        when NilClass then
+          self.default
+        end
+      end
+
+      # Parses AMQP connection URI and returns its components as a hash.
+      #
+      # h2. vhost naming schemes
+      #
+      # It is convenient to be able to specify the AMQP connection
+      # parameters as a URI string, and various "amqp" URI schemes
+      # exist.  Unfortunately, there is no standard for these URIs, so
+      # while the schemes share the basic idea, they differ in some
+      # details.  This implementation aims to encourage URIs that work
+      # as widely as possible.
+      #
+      # The URI scheme should be "amqp", or "amqps" if SSL is required.
+      #
+      # The host, port, username and password are represented in the
+      # authority component of the URI in the same way as in http URIs.
+      #
+      # The vhost is obtained from the first segment of the path, with the
+      # leading slash removed.  The path should contain only a single
+      # segment (i.e, the only slash in it should be the leading one).
+      # If the vhost is to include slashes or other reserved URI
+      # characters, these should be percent-escaped.
+      #
+      # @example How vhost is parsed
+      #
+      #   GorgonAMQ::Settings.parse_amqp_url("amqp://dev.rabbitmq.com")            # => vhost is nil, so default (/) will be used
+      #   GorgonAMQ::Settings.parse_amqp_url("amqp://dev.rabbitmq.com/")           # => vhost is an empty string
+      #   GorgonAMQ::Settings.parse_amqp_url("amqp://dev.rabbitmq.com/%2Fvault")   # => vhost is /vault
+      #   GorgonAMQ::Settings.parse_amqp_url("amqp://dev.rabbitmq.com/production") # => vhost is production
+      #   GorgonAMQ::Settings.parse_amqp_url("amqp://dev.rabbitmq.com/a.b.c")      # => vhost is a.b.c
+      #   GorgonAMQ::Settings.parse_amqp_url("amqp://dev.rabbitmq.com/foo/bar")    # => ArgumentError
+      #
+      #
+      # @param [String] connection_string AMQP connection URI, à la JDBC connection string. For example: amqp://bus.megacorp.internal:5877.
+      # @return [Hash] Connection parameters (:username, :password, :vhost, :host, :port, :ssl)
+      #
+      # @raise [ArgumentError] When connection URI schema is not amqp or amqps, or the path contains multiple segments
+      #
+      # @api public
+      def self.parse_amqp_url(connection_string)
+        GorgonAMQ::URI.parse(connection_string)
+      end
+    end
+end