amq-protocol 0.0.1.pre → 0.5.0

data/lib/amq/protocol/frame.rb

@@ -2,44 +2,51 @@
 
 module AMQ
   module Protocol
+    SIMPLE_BYTE_PACK = 'c*'
     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) }
+      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
 
       # 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)
+      def self.encode(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?
-        [TYPES[type], channel, payload.bytesize].pack("cnN") + payload + FINAL_OCTET
+        [find_type(type), channel, payload.bytesize].pack(PACK_CHAR_UINT16_UINT32) + payload.bytes.to_a.pack(SIMPLE_BYTE_PACK) + FINAL_OCTET
       end
 
       class << self
-        alias_method :__new__, :new
+        alias_method :__new__, :new unless method_defined?(:__new__) # because of reloading
       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?
+        type_id = find_type(original_type)
+        klass = CLASSES[type_id]
         klass.new(*args)
       end
 
-      def self.decode(readable)
-        header = readable.read(7)
-        type_id, channel, size = header.unpack("cnN")
+      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
+        type_id, channel, size = header.unpack(PACK_CHAR_UINT16_UINT32)
         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)
+        raise FrameTypeError.new(TYPES_OPTIONS) unless type
+        [type, channel, size]
       end
     end
 
@@ -47,33 +54,47 @@ module AMQ
       # 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(channel, payload)
-        super(@id, channel, payload)
+      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
 
-      attr_reader :channel, :size, :payload
-      def initialize(channel, size, payload)
-        @channel, @size, @payload = channel, size, payload
+      def size
+        @payload.bytesize
+      end
+
+      def encode
+        [self.class.id, @channel, self.size].pack(PACK_CHAR_UINT16_UINT32) + @payload.bytes.to_a.pack(SIMPLE_BYTE_PACK) + FINAL_OCTET
       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]
+        @method_class ||= begin
+                            klass_id, method_id = self.payload.unpack(PACK_UINT16_X2)
+                            index               = klass_id << 16 | method_id
+                            AMQ::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
@@ -81,17 +102,69 @@ module AMQ
 
     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         = AMQ::Hacks.unpack_64_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
     end
-    
+
     class HeartbeatFrame < FrameSubclass
-      @id = 4
+      @id = 8
+
+      def final?
+        true
+      end # final?
+
+      def self.encode
+        super(Protocol::EMPTY_STRING, 0)
+      end
     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) }
+    Frame::CLASSES = {
+      Frame::TYPES[:method] => MethodFrame,
+      Frame::TYPES[:headers] => HeaderFrame,
+      Frame::TYPES[:body] => BodyFrame,
+      Frame::TYPES[:heartbeat] => HeartbeatFrame
+    }
   end
 end

data/lib/amq/protocol/table.rb

@@ -1,5 +1,10 @@
 # encoding: binary
 
+require "amq/protocol/client"
+
+# We will need to introduce concept of mappings, because
+# AMQP 0.9, 0.9.1 and RabbitMQ uses different letters for entities
+# http://dev.rabbitmq.com/wiki/Amqp091Errata#section_3
 module AMQ
   module Protocol
     class Table
@@ -9,80 +14,122 @@ module AMQ
         end
       end
 
+      TYPE_STRING = 'S'.freeze
+      TYPE_INTEGER = 'I'.freeze
+      TYPE_HASH = 'F'.freeze
+      TYPE_TIME = 'T'.freeze
+      TYPE_DECIMAL = 'D'.freeze
+      TYPE_BOOLEAN = 't'.freeze
+      TYPE_SIGNED_8BIT = 'b'.freeze
+      TYPE_SIGNED_16BIT = 's'.freeze
+      TYPE_SIGNED_64BIT = 'l'.freeze
+      TYPE_32BIT_FLOAT = 'f'.freeze
+      TYPE_64BIT_FLOAT = 'd'.freeze
+      TYPE_VOID = 'V'.freeze
+      TYPE_BYTE_ARRAY = 'x'.freeze
+      TEN = '10'.freeze
+
       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
+          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
+          when String then
+            buffer << TYPE_STRING
+            buffer << [value.bytesize].pack(PACK_UINT32)
+            buffer << value
+          when Integer then
+            buffer << TYPE_INTEGER
+            buffer << [value].pack(PACK_UINT32)
+          when TrueClass, FalseClass then
             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)
+            buffer << TYPE_INTEGER
+            buffer << [value].pack(PACK_UINT32)
+          when Hash then
+            buffer << TYPE_HASH # it will work as long as the encoding is ASCII-8BIT
+            buffer << self.encode(value)
+          when Time then
+            # TODO: encode timezone?
+            buffer << TYPE_TIME
+            buffer << [value.to_i].pack(PACK_INT64).reverse # Don't ask. It works.
           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")
+            if defined?(BigDecimal) && value.is_a?(BigDecimal)
+              buffer << TYPE_DECIMAL
+              if value.exponent < 0
+                decimals = -value.exponent
+                # p [value.exponent] # normalize
+                raw = (value * (decimals ** 10)).to_i
+                #pieces.append(struct.pack('>cBI', 'D', decimals, raw)) # byte integer
+                buffer << [decimals + 1, raw].pack(PACK_UCHAR_UINT32) # somewhat like floating point
+              else
+                # per spec, the "decimals" octet is unsigned (!)
+                buffer << [0, value.to_i].pack(PACK_UCHAR_UINT32)
+              end
             else
               raise InvalidTableError.new(key, value)
             end
           end
         end
 
-        [buffer.bytesize].pack(">N") + buffer
+        [buffer.bytesize].pack(PACK_UINT32) + buffer
       end
 
       def self.length(data)
-        data.unpack("N").first
+        data.unpack(PACK_UINT32).first
       end
 
       def self.decode(data)
         table = Hash.new
-        size = data.unpack("N").first
+        size = data.unpack(PACK_UINT32).first
         offset = 4
         while offset < size
-          key_length = data[offset].unpack("c").first
+          key_length = data.slice(offset, 1).unpack(PACK_CHAR).first
           offset += 1
-          key = data[offset...(offset += key_length)]
-          type = data[offset]
+          key = data.slice(offset, key_length)
+          offset += key_length
+          type = data.slice(offset, 1)
           offset += 1
           case type
-          when "S"
-            length = data[offset...(offset + 4)].unpack("N").first
+          when TYPE_STRING
+            length = data.slice(offset, 4).unpack(PACK_UINT32).first
             offset += 4
-            value = data[offset..(offset + length)]
+            value = data.slice(offset, length)
             offset += length
-          when "I"
-            value = data[offset...(offset + 4)].unpack("N").first
+          when TYPE_INTEGER
+            value = data.slice(offset, 4).unpack(PACK_UINT32).first
             offset += 4
-          when "D"
-            # TODO: decimal
-          when "T"
-            # TODO: timestamp
-          when "F"
-            value = self.decode(data[offset..-1])
+          when TYPE_DECIMAL
+            decimals, raw = data.slice(offset, 5).unpack(PACK_UCHAR_UINT32)
+            offset += 5
+            value = BigDecimal.new(raw.to_s) * (BigDecimal.new(TEN) ** -decimals)
+          when TYPE_TIME
+            # TODO: what is the first unpacked value??? Zone, maybe? It's 0, so it'd make sense.
+            timestamp = data.slice(offset, 8).unpack(PACK_UINT32_X2).last
+            value = Time.at(timestamp)
+            offset += 8
+          when TYPE_HASH
+            length = data.slice(offset, 4).unpack(PACK_UINT32).first
+            value = self.decode(data.slice(offset, length + 4))
+            offset += 4 + length
+          when TYPE_BOOLEAN
+            value  = data.slice(offset, 2)
+            integer = value.unpack(PACK_CHAR).first # 0 or 1
+            value = integer == 1
+            offset += 1
+          when TYPE_SIGNED_8BIT then raise NotImplementedError.new
+          when TYPE_SIGNED_16BIT then raise NotImplementedError.new
+          when TYPE_SIGNED_64BIT then raise NotImplementedError.new
+          when TYPE_32BIT_FLOAT then raise NotImplementedError.new
+          when TYPE_64BIT_FLOAT then raise NotImplementedError.new
+          when TYPE_VOID
+            value = nil
+          when TYPE_BYTE_ARRAY
           else
-            raise "Not a valid type: #{type.inspect}"
+            raise "Not a valid type: #{type.inspect}\nData: #{data.inspect}\nUnprocessed data: #{data[offset..-1].inspect}\nOffset: #{offset}\nTotal size: #{size}\nProcessed data: #{table.inspect}"
           end
           table[key] = value
         end

data/lib/amq/protocol/version.rb

@@ -0,0 +1,5 @@
+module AMQ
+  module Protocol
+    VERSION = "0.5.0".freeze
+  end # Protocol
+end # AMQ

data/post-processing.rb

@@ -9,6 +9,7 @@ buffer = ARGF.inject(String.new) do |buffer, line|
   # line filters
   line.gsub!(/\s*\n$/, "\n")
   line.gsub!("'", '"')
+  line.gsub!('u"', '"') if line =~ /^\s*# \[/
 
   buffer += line
 end

data/protocol.rb.pytemplate

@@ -3,44 +3,108 @@
 
 # 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 %>
+# IN THE ROOT DIRECTORY OF THE AMQ-PROTOCOL REPOSITORY.<% import codegen_helpers as helpers %><% import re, codegen %>
 
-require_relative "protocol/table.rb"
-require_relative "protocol/frame.rb"
+require "amq/protocol/table"
+require "amq/protocol/frame"
+require "amq/hacks"
 
 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}
+    PROTOCOL_VERSION = "${spec.major}.${spec.minor}.${spec.revision}".freeze
+    PREAMBLE         = "${'AMQP\\x00\\x%02x\\x%02x\\x%02x' % (spec.major, spec.minor, spec.revision)}".freeze
+    DEFAULT_PORT     = ${spec.port}
 
     # caching
     EMPTY_STRING = "".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
+
     # @version 0.0.1
     # @return [Array] Collection of subclasses of AMQ::Protocol::Class.
     def self.classes
-      Class.classes
+      Protocol::Class.classes
     end
 
     # @version 0.0.1
     # @return [Array] Collection of subclasses of AMQ::Protocol::Method.
     def self.methods
-      Method.methods
+      Protocol::Method.methods
     end
 
     class Error < StandardError
-      def initialize(message = "AMQP error")
+      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) # TODO: rewrite more effectively
+        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 ConnectionError < Error
+    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
+
+    % for tuple in spec.constants:
+    % if tuple[2] == "soft-error" or tuple[2] == "hard-error":
+    class ${codegen.to_ruby_class_name(tuple[0])} < ${codegen.to_ruby_class_name(tuple[2])}
+      VALUE = ${tuple[1]}
+    end
+
+    % endif
+    % endfor
+
     # We don't instantiate the following classes,
     # as we don't actually need any per-instance state.
     # Also, this is pretty low-level functionality,
@@ -57,10 +121,10 @@ module AMQ
     # all these methods would become global which would
     # be a bad, bad thing to do.
     class Class
-      @@classes = Array.new
+      @classes = Array.new
 
-      def self.method
-        @method
+      def self.method_id
+        @method_id
       end
 
       def self.name
@@ -68,20 +132,20 @@ module AMQ
       end
 
       def self.inherited(base)
-        if self == Class
-          @@classes << base
+        if self == Protocol::Class
+          @classes << base
         end
       end
 
       def self.classes
-        @@classes
+        @classes
       end
     end
 
     class Method
-      @@methods = Array.new
-      def self.method
-        @method
+      @methods = Array.new
+      def self.method_id
+        @method_id
       end
 
       def self.name
@@ -93,29 +157,30 @@ module AMQ
       end
 
       def self.inherited(base)
-        if self == Method
-          @@methods << base
+        if self == Protocol::Method
+          @methods << base
         end
       end
 
       def self.methods
-        @@methods
+        @methods
       end
 
-      def self.split_headers(user_headers, properties_set)
+      def self.split_headers(user_headers)
         properties, headers = {}, {}
-        user_headers.iteritems.each do |key, value|
-          if properties_set.has_key?(key)
+        user_headers.each do |key, value|
+          # key MUST be a symbol since symbols are not garbage-collected
+          if Basic::PROPERTIES.include?(key)
             properties[key] = value
           else
             headers[key] = value
           end
         end
 
-        return props, headers
+        return [properties, headers]
       end
 
-      def self.encode_body(body, frame_size)
+      def self.encode_body(body, channel, 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.
@@ -124,8 +189,9 @@ module AMQ
 
         Array.new.tap do |array|
           while body
-            payload, body = body[0..limit], body[limit..-1]
-            array << [0x03, payload]
+            payload, body = body[0, limit + 1], body[limit + 1, body.length - limit]
+            # array << [0x03, payload]
+            array << BodyFrame.new(payload, channel)
           end
         end
       end
@@ -145,9 +211,9 @@ module AMQ
     end
 
     % for klass in spec.classes :
-    class ${klass.constant_name} < Class
+    class ${klass.constant_name} < Protocol::Class
       @name = "${klass.name}"
-      @method = ${klass.index}
+      @method_id = ${klass.index}
 
       % if klass.fields: ## only the Basic class has fields (refered as properties in the JSON)
       PROPERTIES = [
@@ -159,21 +225,21 @@ module AMQ
       % 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):
+        buffer = ''
+        % for line in helpers.genSingleEncode(spec, "value", f.domain):
         ${line}
         % endfor
-        [${i}, ${"0x%04x" % ( 1 << (15-i),)}, result]
+        [${i}, ${"0x%04x" % ( 1 << (15-i),)}, buffer]
       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 #}
+      ## TODO: not only basic, resp. in fact it's only this class, but not necessarily in the future, rather check if properties are empty #}
+      % if klass.name == "basic" :
       def self.encode_properties(body_size, properties)
-        pieces = Array.new(14) { AMQ::Protocol::EMPTY_STRING }
-        flags = 0
+        pieces, flags = [], 0
 
         properties.each do |key, value|
           i, f, result = self.send(:"encode_#{key}", value)
@@ -181,42 +247,96 @@ module AMQ
           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
+        # result = [${klass.index}, 0, body_size, flags].pack('n2Qn')
+        result = [${klass.index}, 0].pack(PACK_UINT16_X2)
+        result += AMQ::Hacks.pack_64_big_endian(body_size)
+        result += [flags].pack(PACK_UINT16)
+        result + pieces.join(EMPTY_STRING)
+      end
+
+      # THIS DECODES ONLY FLAGS
+      DECODE_PROPERTIES = {
+        % for f in klass.fields:
+        ${"0x%04x" % ( 1 << (15 - klass.fields.index(f)),)} => :${f.ruby_name},
+        % endfor
+      }
+
+      DECODE_PROPERTIES_TYPE = {
+        % for f in klass.fields:
+        ${"0x%04x" % ( 1 << (15 - klass.fields.index(f)),)} => :${spec.resolveDomain(f.domain)},
+        % endfor
+      }
+
+      # Hash doesn't give any guarantees on keys order, we will do it in a
+      # straightforward way
+      DECODE_PROPERTIES_KEYS = [
+        % for f in klass.fields:
+        ${"0x%04x" % ( 1 << (15 - klass.fields.index(f)),)},
+        % endfor
+      ]
+
+      def self.decode_properties(data)
+        offset, data_length, properties = 0, data.bytesize, {}
+
+        compressed_index = data[offset, 2].unpack(PACK_UINT16)[0]
+        offset += 2
+        while data_length > offset
+          DECODE_PROPERTIES_KEYS.each do |key|
+            next unless compressed_index >= key
+            compressed_index -= key
+            name = DECODE_PROPERTIES[key] || raise(RuntimeError.new("No property found for index #{index.inspect}!"))
+            case DECODE_PROPERTIES_TYPE[key]
+            when :shortstr
+              size = data[offset, 1].unpack(PACK_CHAR)[0]
+              offset += 1
+              result = data[offset, size]
+            when :octet
+              size = 1
+              result = data[offset, size].unpack(PACK_CHAR).first
+            when :timestamp
+              size = 8
+              result = Time.at(data[offset, size].unpack(PACK_UINT32_X2).last)
+            when :table
+              size = 4 + data[offset, 4].unpack(PACK_UINT32)[0]
+              result = Table.decode(data[offset, size])
+            end
+            properties[name] = result
+            offset += size
+          end
+        end
+
+        properties
+      end
       % endif
 
-      % for method in klass.methods :
-      class ${method.constant_name} < Method
+      % for method in klass.methods:
+      class ${method.constant_name} < Protocol::Method
         @name = "${klass.name}.${method.name}"
-        @method = ${method.index}
+        @method_id = ${method.index}
         @index = ${method.binary()}
+        @packed_indexes = [${klass.index}, ${method.index}].pack(PACK_UINT16_X2).freeze
 
-        % if method.accepted_by("client") :
+        % if (spec.type == "client" and method.accepted_by("client")) or (spec.type == "server" and method.accepted_by("server")):
         # @return
         def self.decode(data)
           offset = 0
           % for line in helpers.genDecodeMethodDefinition(spec, method):
           ${line}
           % endfor
+          % if (method.klass.name == "connection" or method.klass.name == "channel") and method.name == "close":
+          if reply_code.eql?(200)
+            self.new(${', '.join([f.ruby_name for f in method.arguments])})
+          else
+            raise Error[reply_code].new(reply_text)
+          end
+          % else:
           self.new(${', '.join([f.ruby_name for f in method.arguments])})
+          % endif
         end
 
+        % if len(method.arguments) > 0:
         attr_reader ${', '.join([":" + f.ruby_name for f in method.arguments])}
+        % endif
         def initialize(${', '.join([f.ruby_name for f in method.arguments])})
           % for f in method.arguments:
           @${f.ruby_name} = ${f.ruby_name}
@@ -224,16 +344,50 @@ module AMQ
         end
         % endif
 
-        % if method.accepted_by("server"):
+        def self.has_content?
+          % if method.hasContent:
+          true
+          % else:
+          false
+          % endif
+        end
+
+        % if (spec.type == "client" and method.accepted_by("server")) or (spec.type == "server" and method.accepted_by("client")):
         # @return
         # ${method.params()}
-        def self.encode(${(", ").join(method.args())})
-          pieces = []
-          pieces << [${klass.index}, ${method.index}].pack("n2")
+        % if klass.name == "connection":
+        def self.encode(${(", ").join(method.not_ignored_args())})
+        % else:
+        def self.encode(${(", ").join(["channel"] + method.not_ignored_args())})
+        % endif
+          % for argument in method.ignored_args():
+          ${codegen.convert_to_ruby(argument)}
+          % endfor
+          % if klass.name == "connection":
+          channel = 0
+          % endif
+          buffer = ''
+          buffer << @packed_indexes
           % for line in helpers.genEncodeMethodDefinition(spec, method):
           ${line}
           % endfor
-          pieces.join("")
+          % if "payload" in method.args() or "user_headers" in method.args():
+          frames = [MethodFrame.new(buffer, channel)]
+          % if "user_headers" in method.args():
+          properties, headers = self.split_headers(user_headers)
+          # TODO: what shall I do with the headers?
+          if properties.nil? or properties.empty?
+            raise RuntimeError.new("Properties can not be empty!") # TODO: or can they?
+          end
+          properties_payload = Basic.encode_properties(payload.bytesize, properties)
+          frames << HeaderFrame.new(properties_payload, channel)
+          % endif
+          % if "payload" in method.args():
+          frames + self.encode_body(payload, channel, frame_size)
+          % endif
+          % else:
+          MethodFrame.new(buffer, channel)
+          % endif
         end
         % endif