amq-protocol 0.0.1.pre

data/lib/amq/protocol/frame.rb

@@ -0,0 +1,97 @@
+# encoding: binary
+
+module AMQ
+  module Protocol
+    class Frame
+      TYPES         = {method: 1, header: 2, body: 3, heartbeat: 4}
+      TYPES_REVERSE = TYPES.inject({}) { |hash, pair| hash.merge!(pair[1] => pair[0]) }
+      TYPES_OPTIONS = TYPES.keys
+      CHANNEL_RANGE = (0..65535)
+      FINAL_OCTET   = "\xCE" # 206
+
+      TYPES.default_proc = lambda { |hash, key| key if (1..4).include?(key) }
+
+      # 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(type, channel, payload)
+        raise ConnectionError.new(TYPES_OPTIONS) unless TYPES_OPTIONS.include?(type) or (type = TYPES[type])
+        raise RuntimeError.new("Channel has to be 0 or an integer in range 1..65535") unless CHANNEL_RANGE.include?(channel)
+        raise RuntimeError.new("Payload can't be nil") if payload.nil?
+        [TYPES[type], channel, payload.bytesize].pack("cnN") + payload + FINAL_OCTET
+      end
+
+      class << self
+        alias_method :__new__, :new
+      end
+
+      def self.new(original_type, *args)
+        type  = TYPES[original_type]
+        klass = CLASSES[type]
+        raise "Type can be an integer in range 1..4 or #{TYPES_OPTIONS.inspect}, was #{original_type.inspect}" if klass.nil?
+        klass.new(*args)
+      end
+
+      def self.decode(readable)
+        header = readable.read(7)
+        type_id, channel, size = header.unpack("cnN")
+        type = TYPES_REVERSE[type_id]
+        data = readable.read(size + 1)
+        payload, frame_end = data[0..-2], data[-1]
+        raise RuntimeError.new("Frame doesn't end with #{FINAL_OCTET} as it must, which means the size is miscalculated.") unless frame_end == FINAL_OCTET
+        # raise RuntimeError.new("invalid size: is #{payload.bytesize}, expected #{size}") if @payload.bytesize != size # We obviously can't test that, because we used read(size), so it's pointless.
+        raise ConnectionError.new(TYPES_OPTIONS) unless TYPES_OPTIONS.include?(type)
+        self.new(type, channel, size, payload)
+      end
+    end
+
+    class FrameSubclass < Frame
+      # Restore original new
+      class << self
+        alias_method :new, :__new__
+      end
+
+      def self.id
+        @id
+      end
+
+      def self.encode(channel, payload)
+        super(@id, channel, payload)
+      end
+
+      attr_reader :channel, :size, :payload
+      def initialize(channel, size, payload)
+        @channel, @size, @payload = channel, size, payload
+      end
+    end
+
+    # Example:
+    # MethodFrame.encode(:method, 0, Connection::TuneOk.encode(0, 131072, 0))
+    class MethodFrame < FrameSubclass
+      @id = 1
+
+      def method_class
+        klass_id, method_id = self.payload.unpack("n2")
+        index = klass_id << 16 | method_id
+        AMQ::Protocol::METHODS[index]
+      end
+
+      def decode_payload
+        self.method_class.decode(@payload[4..-1])
+      end
+    end
+
+    class HeaderFrame < FrameSubclass
+      @id = 2
+    end
+
+    class BodyFrame < FrameSubclass
+      @id = 3
+    end
+    
+    class HeartbeatFrame < FrameSubclass
+      @id = 4
+    end
+
+    Frame::CLASSES = {method: MethodFrame, header: HeaderFrame, body: BodyFrame, heartbeat: HeaderFrame}
+    Frame::CLASSES.default_proc = lambda { |hash, key| hash[Frame::TYPES_REVERSE[key]] if (1..4).include?(key) }
+  end
+end

data/lib/amq/protocol/table.rb

@@ -0,0 +1,94 @@
+# encoding: binary
+
+module AMQ
+  module Protocol
+    class Table
+      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 String
+            buffer += ["S".ord, value.bytesize].pack(">cN")
+            buffer += value
+          when Integer
+            buffer += ["I".ord, value].pack(">cN")
+          when TrueClass, FalseClass
+            value = value ? 1 : 0
+            buffer += ["I".ord, value].pack(">cN")
+          when Hash
+            buffer += "F" # it will work as long as the encoding is ASCII-8BIT
+            buffer += self.encode(value)
+          else
+            # We don't want to require these libraries.
+            if const_defined?(:BigDecimal) && value.is_a?(BigDecimal)
+              # TODO
+              # value = value.normalize()
+              # if value._exp < 0:
+              #     decimals = -value._exp
+              #     raw = int(value * (decimal.Decimal(10) ** decimals))
+              #     pieces.append(struct.pack('>cBI', 'D', decimals, raw))
+              # else:
+              #     # per spec, the "decimals" octet is unsigned (!)
+              #     pieces.append(struct.pack('>cBI', 'D', 0, int(value)))
+            elsif const_defined?(:DateTime) && value.is_a?(DateTime)
+              # TODO
+              # buffer += ["T", calendar.timegm(value.utctimetuple())].pack(">cQ")
+            else
+              raise InvalidTableError.new(key, value)
+            end
+          end
+        end
+
+        [buffer.bytesize].pack(">N") + buffer
+      end
+
+      def self.length(data)
+        data.unpack("N").first
+      end
+
+      def self.decode(data)
+        table = Hash.new
+        size = data.unpack("N").first
+        offset = 4
+        while offset < size
+          key_length = data[offset].unpack("c").first
+          offset += 1
+          key = data[offset...(offset += key_length)]
+          type = data[offset]
+          offset += 1
+          case type
+          when "S"
+            length = data[offset...(offset + 4)].unpack("N").first
+            offset += 4
+            value = data[offset..(offset + length)]
+            offset += length
+          when "I"
+            value = data[offset...(offset + 4)].unpack("N").first
+            offset += 4
+          when "D"
+            # TODO: decimal
+          when "T"
+            # TODO: timestamp
+          when "F"
+            value = self.decode(data[offset..-1])
+          else
+            raise "Not a valid type: #{type.inspect}"
+          end
+          table[key] = value
+        end
+
+        table
+      end
+    end
+  end
+end

data/post-processing.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby -i
+# encoding: utf-8
+
+# helpers
+def pass; end
+
+# main
+buffer = ARGF.inject(String.new) do |buffer, line|
+  # line filters
+  line.gsub!(/\s*\n$/, "\n")
+  line.gsub!("'", '"')
+
+  buffer += line
+end
+
+# buffer filters
+buffer.gsub!(/\n{2,}/m, "\n\n")
+pass while buffer.gsub!(/(\n( *)  end)\n{2,}(\2end)/m, "\\1\n\\3")
+
+# Make sure there's only one \n at the end
+pass while buffer.chomp!
+buffer += "\n"
+
+puts buffer

data/protocol.rb.pytemplate

@@ -0,0 +1,253 @@
+# encoding: utf-8
+# encoding: binary
+
+# THIS IS AN AUTOGENERATED FILE, DO NOT MODIFY
+# IT DIRECTLY ! FOR CHANGES, PLEASE UPDATE CODEGEN.PY
+# IN THE ROOT DIRECTORY OF THE AMQP-PROTOCOL REPOSITORY.<% import codegen_helpers as helpers %>
+
+require_relative "protocol/table.rb"
+require_relative "protocol/frame.rb"
+
+module AMQ
+  module Protocol
+    PROTOCOL_VERSION = "${spec.major}.${spec.minor}.${spec.revision}"
+    PREAMBLE = "${'AMQP\\x00\\x%02x\\x%02x\\x%02x' % (spec.major, spec.minor, spec.revision)}"
+    DEFAULT_PORT = ${spec.port}
+
+    # caching
+    EMPTY_STRING = "".freeze
+
+    # @version 0.0.1
+    # @return [Array] Collection of subclasses of AMQ::Protocol::Class.
+    def self.classes
+      Class.classes
+    end
+
+    # @version 0.0.1
+    # @return [Array] Collection of subclasses of AMQ::Protocol::Method.
+    def self.methods
+      Method.methods
+    end
+
+    class Error < StandardError
+      def initialize(message = "AMQP error")
+        super(message)
+      end
+    end
+
+    class ConnectionError < Error
+      def initialize(types)
+        super("Must be one of #{types.inspect}")
+      end
+    end
+
+    # We don't instantiate the following classes,
+    # as we don't actually need any per-instance state.
+    # Also, this is pretty low-level functionality,
+    # hence it should have a reasonable performance.
+    # As everyone knows, garbage collector in MRI performs
+    # really badly, which is another good reason for
+    # not creating any objects, but only use class as
+    # a struct. Creating classes is quite expensive though,
+    # but here the inheritance comes handy and mainly
+    # as we can't simply make a reference to a function,
+    # we can't use a hash or an object. I've been also
+    # considering to have just a bunch of methods, but
+    # here's the problem, that after we'd require this file,
+    # all these methods would become global which would
+    # be a bad, bad thing to do.
+    class Class
+      @@classes = Array.new
+
+      def self.method
+        @method
+      end
+
+      def self.name
+        @name
+      end
+
+      def self.inherited(base)
+        if self == Class
+          @@classes << base
+        end
+      end
+
+      def self.classes
+        @@classes
+      end
+    end
+
+    class Method
+      @@methods = Array.new
+      def self.method
+        @method
+      end
+
+      def self.name
+        @name
+      end
+
+      def self.index
+        @index
+      end
+
+      def self.inherited(base)
+        if self == Method
+          @@methods << base
+        end
+      end
+
+      def self.methods
+        @@methods
+      end
+
+      def self.split_headers(user_headers, properties_set)
+        properties, headers = {}, {}
+        user_headers.iteritems.each do |key, value|
+          if properties_set.has_key?(key)
+            properties[key] = value
+          else
+            headers[key] = value
+          end
+        end
+
+        return props, headers
+      end
+
+      def self.encode_body(body, frame_size)
+        # Spec is broken: Our errata says that it does define
+        # something, but it just doesn't relate do method and
+        # properties frames. Which makes it, well, suboptimal.
+        # https://dev.rabbitmq.com/wiki/Amqp091Errata#section_11
+        limit = frame_size - 7 - 1
+
+        Array.new.tap do |array|
+          while body
+            payload, body = body[0..limit], body[limit..-1]
+            array << [0x03, payload]
+          end
+        end
+      end
+
+      # We can return different:
+      # - instantiate given subclass of Method
+      # - create an OpenStruct object
+      # - create a hash
+      # - yield params into the block rather than just return
+      # @api plugin
+      def self.instantiate(*args, &block)
+        self.new(*args, &block)
+        # or OpenStruct.new(args.first)
+        # or args.first
+        # or block.call(*args)
+      end
+    end
+
+    % for klass in spec.classes :
+    class ${klass.constant_name} < Class
+      @name = "${klass.name}"
+      @method = ${klass.index}
+
+      % if klass.fields: ## only the Basic class has fields (refered as properties in the JSON)
+      PROPERTIES = [
+      % for field in klass.fields:
+        :${field.ruby_name}, # ${spec.resolveDomain(field.domain)}
+        % endfor
+      ]
+
+      % for f in klass.fields:
+      # <% i = klass.fields.index(f) %>1 << ${15 - i}
+      def self.encode_${f.ruby_name}(value)
+        pieces = []
+        % for line in helpers.genSingleEncode(spec, "result", f.domain):
+        ${line}
+        % endfor
+        [${i}, ${"0x%04x" % ( 1 << (15-i),)}, result]
+      end
+
+      % endfor
+
+      % endif
+
+      % if klass.name == "basic" : ## TODO: not only basic, resp. in fact it's only this class, but not necessarily in the future, rather check if properties are empty #}
+      def self.encode_properties(body_size, properties)
+        pieces = Array.new(14) { AMQ::Protocol::EMPTY_STRING }
+        flags = 0
+
+        properties.each do |key, value|
+          i, f, result = self.send(:"encode_#{key}", value)
+          flags |= f
+          pieces[i] = result
+        end
+
+        result = [CLASS_BASIC, 0, body_size, flags].pack("!HHQH")
+        [0x02, result, pieces.join("")].join("")
+      end
+
+      #def self.decode_properties
+      #  print "def %s(data, offset):" % (c.decode,)
+      #  print "    props = {}"
+      #  print "    flags, = struct.unpack_from('!H', data, offset)"
+      #  print "    offset += 2"
+      #  print "    assert (flags & 0x01) == 0"
+      #  for i, f in enumerate(c.fields):
+      #      print "    if (flags & 0x%04x): # 1 << %i" % (1 << (15-i), 15-i)
+      #      fields = codegen_helpers.UnpackWrapper()
+      #      fields.add(f.n, f.t)
+      #      fields.do_print(" "*8, "props['%s']")
+      #  print "    return props, offset"
+      #end
+      % endif
+
+      % for method in klass.methods :
+      class ${method.constant_name} < Method
+        @name = "${klass.name}.${method.name}"
+        @method = ${method.index}
+        @index = ${method.binary()}
+
+        % if method.accepted_by("client") :
+        # @return
+        def self.decode(data)
+          offset = 0
+          % for line in helpers.genDecodeMethodDefinition(spec, method):
+          ${line}
+          % endfor
+          self.new(${', '.join([f.ruby_name for f in method.arguments])})
+        end
+
+        attr_reader ${', '.join([":" + f.ruby_name for f in method.arguments])}
+        def initialize(${', '.join([f.ruby_name for f in method.arguments])})
+          % for f in method.arguments:
+          @${f.ruby_name} = ${f.ruby_name}
+          % endfor
+        end
+        % endif
+
+        % if method.accepted_by("server"):
+        # @return
+        # ${method.params()}
+        def self.encode(${(", ").join(method.args())})
+          pieces = []
+          pieces << [${klass.index}, ${method.index}].pack("n2")
+          % for line in helpers.genEncodeMethodDefinition(spec, method):
+          ${line}
+          % endfor
+          pieces.join("")
+        end
+        % endif
+
+      end
+
+      % endfor
+    end
+
+    % endfor
+
+    METHODS = begin
+      Method.methods.inject(Hash.new) do |hash, klass|
+        hash.merge!(klass.index => klass)
+      end
+    end
+  end
+end