amq-protocol 0.0.1.pre

data/examples/01_basics.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require "socket"
+require_relative "../lib/amq/protocol.rb"
+
+server = TCPServer.new(5672)
+
+begin
+  socket = server.accept_nonblock
+rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
+  IO.select([server])
+  retry
+end
+# AMQ::Protocol::Connection::Start.encode

data/examples/02_eventmachine.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+require "eventmachine"
+require_relative "../lib/amq/protocol.rb"

data/irb.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "irb"
+require_relative "lib/amq/protocol.rb"
+
+include AMQ::Protocol
+
+IRB.start(__FILE__)

data/lib/amq/protocol.rb

@@ -0,0 +1,1473 @@
+# 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.
+
+require_relative "protocol/table.rb"
+require_relative "protocol/frame.rb"
+
+module AMQ
+  module Protocol
+    PROTOCOL_VERSION = "0.9.1"
+    PREAMBLE = "AMQP\x00\x00\x09\x01"
+    DEFAULT_PORT = 5672
+
+    # 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
+
+    class Connection < Class
+      @name = "connection"
+      @method = 10
+
+      class Start < Method
+        @name = "connection.start"
+        @method = 10
+        @index = 0x000A000A # 10, 10, 655370
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          version_major = data[offset...(offset + 1)].unpack("c").first
+          offset += 1
+          version_minor = data[offset...(offset + 1)].unpack("c").first
+          offset += 1
+          table_length = Table.length(data[offset..(offset + 4)])
+          server_properties = Table.decode(data[offset..table_length])
+          length = data[offset..(offset + 4)].unpack("N").first
+          offset += 4
+          mechanisms = data[offset..(offset + length)]
+          offset += length
+          length = data[offset..(offset + 4)].unpack("N").first
+          offset += 4
+          locales = data[offset..(offset + length)]
+          offset += length
+          self.new(version_major, version_minor, server_properties, mechanisms, locales)
+        end
+
+        attr_reader :version_major, :version_minor, :server_properties, :mechanisms, :locales
+        def initialize(version_major, version_minor, server_properties, mechanisms, locales)
+          @version_major = version_major
+          @version_minor = version_minor
+          @server_properties = server_properties
+          @mechanisms = mechanisms
+          @locales = locales
+        end
+      end
+
+      class StartOk < Method
+        @name = "connection.start-ok"
+        @method = 11
+        @index = 0x000A000B # 10, 11, 655371
+
+        # @return
+        # ["client_properties = nil", "mechanism = "PLAIN"", "response = nil", "locale = "en_US""]
+        def self.encode(client_properties, mechanism, response, locale)
+          pieces = []
+          pieces << [10, 11].pack("n2")
+          pieces << AMQ::Protocol::Table.encode(client_properties)
+          pieces << mechanism.bytesize.chr
+          pieces << mechanism
+          pieces << [response.bytesize].pack("N")
+          pieces << response
+          pieces << locale.bytesize.chr
+          pieces << locale
+          pieces.join("")
+        end
+      end
+
+      class Secure < Method
+        @name = "connection.secure"
+        @method = 20
+        @index = 0x000A0014 # 10, 20, 655380
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset..(offset + 4)].unpack("N").first
+          offset += 4
+          challenge = data[offset..(offset + length)]
+          offset += length
+          self.new(challenge)
+        end
+
+        attr_reader :challenge
+        def initialize(challenge)
+          @challenge = challenge
+        end
+      end
+
+      class SecureOk < Method
+        @name = "connection.secure-ok"
+        @method = 21
+        @index = 0x000A0015 # 10, 21, 655381
+
+        # @return
+        # ["response = nil"]
+        def self.encode(response)
+          pieces = []
+          pieces << [10, 21].pack("n2")
+          pieces << [response.bytesize].pack("N")
+          pieces << response
+          pieces.join("")
+        end
+      end
+
+      class Tune < Method
+        @name = "connection.tune"
+        @method = 30
+        @index = 0x000A001E # 10, 30, 655390
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          channel_max = data[offset..(offset + 2)].unpack("n").first
+          offset += 2
+          frame_max = data[offset..(offset + 4)].unpack("N").first
+          offset += 4
+          heartbeat = data[offset..(offset + 2)].unpack("n").first
+          offset += 2
+          self.new(channel_max, frame_max, heartbeat)
+        end
+
+        attr_reader :channel_max, :frame_max, :heartbeat
+        def initialize(channel_max, frame_max, heartbeat)
+          @channel_max = channel_max
+          @frame_max = frame_max
+          @heartbeat = heartbeat
+        end
+      end
+
+      class TuneOk < Method
+        @name = "connection.tune-ok"
+        @method = 31
+        @index = 0x000A001F # 10, 31, 655391
+
+        # @return
+        # ["channel_max = false", "frame_max = false", "heartbeat = false"]
+        def self.encode(channel_max, frame_max, heartbeat)
+          pieces = []
+          pieces << [10, 31].pack("n2")
+          pieces << [channel_max].pack("n")
+          pieces << [frame_max].pack("N")
+          pieces << [heartbeat].pack("n")
+          pieces.join("")
+        end
+      end
+
+      class Open < Method
+        @name = "connection.open"
+        @method = 40
+        @index = 0x000A0028 # 10, 40, 655400
+
+        # @return
+        # ["virtual_host = "/"", "capabilities = """, "insist = false"]
+        def self.encode(virtual_host, capabilities, insist)
+          pieces = []
+          pieces << [10, 40].pack("n2")
+          pieces << virtual_host.bytesize.chr
+          pieces << virtual_host
+          pieces << capabilities.bytesize.chr
+          pieces << capabilities
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if insist
+          pieces.join("")
+        end
+      end
+
+      class OpenOk < Method
+        @name = "connection.open-ok"
+        @method = 41
+        @index = 0x000A0029 # 10, 41, 655401
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          known_hosts = data[offset..(offset + length)]
+          offset += length
+          self.new(known_hosts)
+        end
+
+        attr_reader :known_hosts
+        def initialize(known_hosts)
+          @known_hosts = known_hosts
+        end
+      end
+
+      class Close < Method
+        @name = "connection.close"
+        @method = 50
+        @index = 0x000A0032 # 10, 50, 655410
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          reply_code = data[offset..(offset + 2)].unpack("n").first
+          offset += 2
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          reply_text = data[offset..(offset + length)]
+          offset += length
+          class_id = data[offset..(offset + 2)].unpack("n").first
+          offset += 2
+          method_id = data[offset..(offset + 2)].unpack("n").first
+          offset += 2
+          self.new(reply_code, reply_text, class_id, method_id)
+        end
+
+        attr_reader :reply_code, :reply_text, :class_id, :method_id
+        def initialize(reply_code, reply_text, class_id, method_id)
+          @reply_code = reply_code
+          @reply_text = reply_text
+          @class_id = class_id
+          @method_id = method_id
+        end
+
+        # @return
+        # ["reply_code = nil", "reply_text = """, "class_id = nil", "method_id = nil"]
+        def self.encode(reply_code, reply_text, class_id, method_id)
+          pieces = []
+          pieces << [10, 50].pack("n2")
+          pieces << [reply_code].pack("n")
+          pieces << reply_text.bytesize.chr
+          pieces << reply_text
+          pieces << [class_id].pack("n")
+          pieces << [method_id].pack("n")
+          pieces.join("")
+        end
+      end
+
+      class CloseOk < Method
+        @name = "connection.close-ok"
+        @method = 51
+        @index = 0x000A0033 # 10, 51, 655411
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        attr_reader
+        def initialize()
+        end
+
+        # @return
+        # []
+        def self.encode()
+          pieces = []
+          pieces << [10, 51].pack("n2")
+          pieces.join("")
+        end
+      end
+    end
+
+    class Channel < Class
+      @name = "channel"
+      @method = 20
+
+      class Open < Method
+        @name = "channel.open"
+        @method = 10
+        @index = 0x0014000A # 20, 10, 1310730
+
+        # @return
+        # ["out_of_band = """]
+        def self.encode(out_of_band)
+          pieces = []
+          pieces << [20, 10].pack("n2")
+          pieces << out_of_band.bytesize.chr
+          pieces << out_of_band
+          pieces.join("")
+        end
+      end
+
+      class OpenOk < Method
+        @name = "channel.open-ok"
+        @method = 11
+        @index = 0x0014000B # 20, 11, 1310731
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset..(offset + 4)].unpack("N").first
+          offset += 4
+          channel_id = data[offset..(offset + length)]
+          offset += length
+          self.new(channel_id)
+        end
+
+        attr_reader :channel_id
+        def initialize(channel_id)
+          @channel_id = channel_id
+        end
+      end
+
+      class Flow < Method
+        @name = "channel.flow"
+        @method = 20
+        @index = 0x00140014 # 20, 20, 1310740
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          bit_buffer = data[offset..(offset + 1)].unpack("c").first
+          offset += 1
+          active = (bit_buffer & (1 << 0)) != 0
+          self.new(active)
+        end
+
+        attr_reader :active
+        def initialize(active)
+          @active = active
+        end
+
+        # @return
+        # ["active = nil"]
+        def self.encode(active)
+          pieces = []
+          pieces << [20, 20].pack("n2")
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if active
+          pieces.join("")
+        end
+      end
+
+      class FlowOk < Method
+        @name = "channel.flow-ok"
+        @method = 21
+        @index = 0x00140015 # 20, 21, 1310741
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          bit_buffer = data[offset..(offset + 1)].unpack("c").first
+          offset += 1
+          active = (bit_buffer & (1 << 0)) != 0
+          self.new(active)
+        end
+
+        attr_reader :active
+        def initialize(active)
+          @active = active
+        end
+
+        # @return
+        # ["active = nil"]
+        def self.encode(active)
+          pieces = []
+          pieces << [20, 21].pack("n2")
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if active
+          pieces.join("")
+        end
+      end
+
+      class Close < Method
+        @name = "channel.close"
+        @method = 40
+        @index = 0x00140028 # 20, 40, 1310760
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          reply_code = data[offset..(offset + 2)].unpack("n").first
+          offset += 2
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          reply_text = data[offset..(offset + length)]
+          offset += length
+          class_id = data[offset..(offset + 2)].unpack("n").first
+          offset += 2
+          method_id = data[offset..(offset + 2)].unpack("n").first
+          offset += 2
+          self.new(reply_code, reply_text, class_id, method_id)
+        end
+
+        attr_reader :reply_code, :reply_text, :class_id, :method_id
+        def initialize(reply_code, reply_text, class_id, method_id)
+          @reply_code = reply_code
+          @reply_text = reply_text
+          @class_id = class_id
+          @method_id = method_id
+        end
+
+        # @return
+        # ["reply_code = nil", "reply_text = """, "class_id = nil", "method_id = nil"]
+        def self.encode(reply_code, reply_text, class_id, method_id)
+          pieces = []
+          pieces << [20, 40].pack("n2")
+          pieces << [reply_code].pack("n")
+          pieces << reply_text.bytesize.chr
+          pieces << reply_text
+          pieces << [class_id].pack("n")
+          pieces << [method_id].pack("n")
+          pieces.join("")
+        end
+      end
+
+      class CloseOk < Method
+        @name = "channel.close-ok"
+        @method = 41
+        @index = 0x00140029 # 20, 41, 1310761
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        attr_reader
+        def initialize()
+        end
+
+        # @return
+        # []
+        def self.encode()
+          pieces = []
+          pieces << [20, 41].pack("n2")
+          pieces.join("")
+        end
+      end
+    end
+
+    class Exchange < Class
+      @name = "exchange"
+      @method = 40
+
+      class Declare < Method
+        @name = "exchange.declare"
+        @method = 10
+        @index = 0x0028000A # 40, 10, 2621450
+
+        # @return
+        # ["ticket = false", "exchange = nil", "type = "direct"", "passive = false", "durable = false", "auto_delete = false", "internal = false", "nowait = false", "arguments = {}"]
+        def self.encode(ticket, exchange, type, passive, durable, auto_delete, internal, nowait, arguments)
+          pieces = []
+          pieces << [40, 10].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << exchange.bytesize.chr
+          pieces << exchange
+          pieces << type.bytesize.chr
+          pieces << type
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if passive
+          bit_buffer = bit_buffer | (1 << 1) if durable
+          bit_buffer = bit_buffer | (1 << 2) if auto_delete
+          bit_buffer = bit_buffer | (1 << 3) if internal
+          bit_buffer = bit_buffer | (1 << 4) if nowait
+          pieces << AMQ::Protocol::Table.encode(arguments)
+          pieces.join("")
+        end
+      end
+
+      class DeclareOk < Method
+        @name = "exchange.declare-ok"
+        @method = 11
+        @index = 0x0028000B # 40, 11, 2621451
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        attr_reader
+        def initialize()
+        end
+      end
+
+      class Delete < Method
+        @name = "exchange.delete"
+        @method = 20
+        @index = 0x00280014 # 40, 20, 2621460
+
+        # @return
+        # ["ticket = false", "exchange = nil", "if_unused = false", "nowait = false"]
+        def self.encode(ticket, exchange, if_unused, nowait)
+          pieces = []
+          pieces << [40, 20].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << exchange.bytesize.chr
+          pieces << exchange
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if if_unused
+          bit_buffer = bit_buffer | (1 << 1) if nowait
+          pieces.join("")
+        end
+      end
+
+      class DeleteOk < Method
+        @name = "exchange.delete-ok"
+        @method = 21
+        @index = 0x00280015 # 40, 21, 2621461
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        attr_reader
+        def initialize()
+        end
+      end
+
+      class Bind < Method
+        @name = "exchange.bind"
+        @method = 30
+        @index = 0x0028001E # 40, 30, 2621470
+
+        # @return
+        # ["ticket = false", "destination = nil", "source = nil", "routing_key = """, "nowait = false", "arguments = {}"]
+        def self.encode(ticket, destination, source, routing_key, nowait, arguments)
+          pieces = []
+          pieces << [40, 30].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << destination.bytesize.chr
+          pieces << destination
+          pieces << source.bytesize.chr
+          pieces << source
+          pieces << routing_key.bytesize.chr
+          pieces << routing_key
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          pieces << AMQ::Protocol::Table.encode(arguments)
+          pieces.join("")
+        end
+      end
+
+      class BindOk < Method
+        @name = "exchange.bind-ok"
+        @method = 31
+        @index = 0x0028001F # 40, 31, 2621471
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        attr_reader
+        def initialize()
+        end
+      end
+
+      class Unbind < Method
+        @name = "exchange.unbind"
+        @method = 40
+        @index = 0x00280028 # 40, 40, 2621480
+
+        # @return
+        # ["ticket = false", "destination = nil", "source = nil", "routing_key = """, "nowait = false", "arguments = {}"]
+        def self.encode(ticket, destination, source, routing_key, nowait, arguments)
+          pieces = []
+          pieces << [40, 40].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << destination.bytesize.chr
+          pieces << destination
+          pieces << source.bytesize.chr
+          pieces << source
+          pieces << routing_key.bytesize.chr
+          pieces << routing_key
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          pieces << AMQ::Protocol::Table.encode(arguments)
+          pieces.join("")
+        end
+      end
+
+      class UnbindOk < Method
+        @name = "exchange.unbind-ok"
+        @method = 51
+        @index = 0x00280033 # 40, 51, 2621491
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        attr_reader
+        def initialize()
+        end
+      end
+    end
+
+    class Queue < Class
+      @name = "queue"
+      @method = 50
+
+      class Declare < Method
+        @name = "queue.declare"
+        @method = 10
+        @index = 0x0032000A # 50, 10, 3276810
+
+        # @return
+        # ["ticket = false", "queue = """, "passive = false", "durable = false", "exclusive = false", "auto_delete = false", "nowait = false", "arguments = {}"]
+        def self.encode(ticket, queue, passive, durable, exclusive, auto_delete, nowait, arguments)
+          pieces = []
+          pieces << [50, 10].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << queue.bytesize.chr
+          pieces << queue
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if passive
+          bit_buffer = bit_buffer | (1 << 1) if durable
+          bit_buffer = bit_buffer | (1 << 2) if exclusive
+          bit_buffer = bit_buffer | (1 << 3) if auto_delete
+          bit_buffer = bit_buffer | (1 << 4) if nowait
+          pieces << AMQ::Protocol::Table.encode(arguments)
+          pieces.join("")
+        end
+      end
+
+      class DeclareOk < Method
+        @name = "queue.declare-ok"
+        @method = 11
+        @index = 0x0032000B # 50, 11, 3276811
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          queue = data[offset..(offset + length)]
+          offset += length
+          message_count = data[offset..(offset + 4)].unpack("N").first
+          offset += 4
+          consumer_count = data[offset..(offset + 4)].unpack("N").first
+          offset += 4
+          self.new(queue, message_count, consumer_count)
+        end
+
+        attr_reader :queue, :message_count, :consumer_count
+        def initialize(queue, message_count, consumer_count)
+          @queue = queue
+          @message_count = message_count
+          @consumer_count = consumer_count
+        end
+      end
+
+      class Bind < Method
+        @name = "queue.bind"
+        @method = 20
+        @index = 0x00320014 # 50, 20, 3276820
+
+        # @return
+        # ["ticket = false", "queue = nil", "exchange = nil", "routing_key = """, "nowait = false", "arguments = {}"]
+        def self.encode(ticket, queue, exchange, routing_key, nowait, arguments)
+          pieces = []
+          pieces << [50, 20].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << queue.bytesize.chr
+          pieces << queue
+          pieces << exchange.bytesize.chr
+          pieces << exchange
+          pieces << routing_key.bytesize.chr
+          pieces << routing_key
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          pieces << AMQ::Protocol::Table.encode(arguments)
+          pieces.join("")
+        end
+      end
+
+      class BindOk < Method
+        @name = "queue.bind-ok"
+        @method = 21
+        @index = 0x00320015 # 50, 21, 3276821
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        attr_reader
+        def initialize()
+        end
+      end
+
+      class Purge < Method
+        @name = "queue.purge"
+        @method = 30
+        @index = 0x0032001E # 50, 30, 3276830
+
+        # @return
+        # ["ticket = false", "queue = nil", "nowait = false"]
+        def self.encode(ticket, queue, nowait)
+          pieces = []
+          pieces << [50, 30].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << queue.bytesize.chr
+          pieces << queue
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          pieces.join("")
+        end
+      end
+
+      class PurgeOk < Method
+        @name = "queue.purge-ok"
+        @method = 31
+        @index = 0x0032001F # 50, 31, 3276831
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          message_count = data[offset..(offset + 4)].unpack("N").first
+          offset += 4
+          self.new(message_count)
+        end
+
+        attr_reader :message_count
+        def initialize(message_count)
+          @message_count = message_count
+        end
+      end
+
+      class Delete < Method
+        @name = "queue.delete"
+        @method = 40
+        @index = 0x00320028 # 50, 40, 3276840
+
+        # @return
+        # ["ticket = false", "queue = nil", "if_unused = false", "if_empty = false", "nowait = false"]
+        def self.encode(ticket, queue, if_unused, if_empty, nowait)
+          pieces = []
+          pieces << [50, 40].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << queue.bytesize.chr
+          pieces << queue
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if if_unused
+          bit_buffer = bit_buffer | (1 << 1) if if_empty
+          bit_buffer = bit_buffer | (1 << 2) if nowait
+          pieces.join("")
+        end
+      end
+
+      class DeleteOk < Method
+        @name = "queue.delete-ok"
+        @method = 41
+        @index = 0x00320029 # 50, 41, 3276841
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          message_count = data[offset..(offset + 4)].unpack("N").first
+          offset += 4
+          self.new(message_count)
+        end
+
+        attr_reader :message_count
+        def initialize(message_count)
+          @message_count = message_count
+        end
+      end
+
+      class Unbind < Method
+        @name = "queue.unbind"
+        @method = 50
+        @index = 0x00320032 # 50, 50, 3276850
+
+        # @return
+        # ["ticket = false", "queue = nil", "exchange = nil", "routing_key = """, "arguments = {}"]
+        def self.encode(ticket, queue, exchange, routing_key, arguments)
+          pieces = []
+          pieces << [50, 50].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << queue.bytesize.chr
+          pieces << queue
+          pieces << exchange.bytesize.chr
+          pieces << exchange
+          pieces << routing_key.bytesize.chr
+          pieces << routing_key
+          pieces << AMQ::Protocol::Table.encode(arguments)
+          pieces.join("")
+        end
+      end
+
+      class UnbindOk < Method
+        @name = "queue.unbind-ok"
+        @method = 51
+        @index = 0x00320033 # 50, 51, 3276851
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        attr_reader
+        def initialize()
+        end
+      end
+    end
+
+    class Basic < Class
+      @name = "basic"
+      @method = 60
+
+      PROPERTIES = [
+        :content_type, # shortstr
+        :content_encoding, # shortstr
+        :headers, # table
+        :delivery_mode, # octet
+        :priority, # octet
+        :correlation_id, # shortstr
+        :reply_to, # shortstr
+        :expiration, # shortstr
+        :message_id, # shortstr
+        :timestamp, # timestamp
+        :type, # shortstr
+        :user_id, # shortstr
+        :app_id, # shortstr
+        :cluster_id, # shortstr
+      ]
+
+      # 1 << 15
+      def self.encode_content_type(value)
+        pieces = []
+        pieces << result.bytesize.chr
+        pieces << result
+        [0, 0x8000, result]
+      end
+
+      # 1 << 14
+      def self.encode_content_encoding(value)
+        pieces = []
+        pieces << result.bytesize.chr
+        pieces << result
+        [1, 0x4000, result]
+      end
+
+      # 1 << 13
+      def self.encode_headers(value)
+        pieces = []
+        pieces << AMQ::Protocol::Table.encode(result)
+        [2, 0x2000, result]
+      end
+
+      # 1 << 12
+      def self.encode_delivery_mode(value)
+        pieces = []
+        pieces << [result].pack("B")
+        [3, 0x1000, result]
+      end
+
+      # 1 << 11
+      def self.encode_priority(value)
+        pieces = []
+        pieces << [result].pack("B")
+        [4, 0x0800, result]
+      end
+
+      # 1 << 10
+      def self.encode_correlation_id(value)
+        pieces = []
+        pieces << result.bytesize.chr
+        pieces << result
+        [5, 0x0400, result]
+      end
+
+      # 1 << 9
+      def self.encode_reply_to(value)
+        pieces = []
+        pieces << result.bytesize.chr
+        pieces << result
+        [6, 0x0200, result]
+      end
+
+      # 1 << 8
+      def self.encode_expiration(value)
+        pieces = []
+        pieces << result.bytesize.chr
+        pieces << result
+        [7, 0x0100, result]
+      end
+
+      # 1 << 7
+      def self.encode_message_id(value)
+        pieces = []
+        pieces << result.bytesize.chr
+        pieces << result
+        [8, 0x0080, result]
+      end
+
+      # 1 << 6
+      def self.encode_timestamp(value)
+        pieces = []
+        pieces << [result].pack(">Q")
+        [9, 0x0040, result]
+      end
+
+      # 1 << 5
+      def self.encode_type(value)
+        pieces = []
+        pieces << result.bytesize.chr
+        pieces << result
+        [10, 0x0020, result]
+      end
+
+      # 1 << 4
+      def self.encode_user_id(value)
+        pieces = []
+        pieces << result.bytesize.chr
+        pieces << result
+        [11, 0x0010, result]
+      end
+
+      # 1 << 3
+      def self.encode_app_id(value)
+        pieces = []
+        pieces << result.bytesize.chr
+        pieces << result
+        [12, 0x0008, result]
+      end
+
+      # 1 << 2
+      def self.encode_cluster_id(value)
+        pieces = []
+        pieces << result.bytesize.chr
+        pieces << result
+        [13, 0x0004, result]
+      end
+
+      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
+
+      class Qos < Method
+        @name = "basic.qos"
+        @method = 10
+        @index = 0x003C000A # 60, 10, 3932170
+
+        # @return
+        # ["prefetch_size = false", "prefetch_count = false", "global = false"]
+        def self.encode(prefetch_size, prefetch_count, global)
+          pieces = []
+          pieces << [60, 10].pack("n2")
+          pieces << [prefetch_size].pack("N")
+          pieces << [prefetch_count].pack("n")
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if global
+          pieces.join("")
+        end
+      end
+
+      class QosOk < Method
+        @name = "basic.qos-ok"
+        @method = 11
+        @index = 0x003C000B # 60, 11, 3932171
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        attr_reader
+        def initialize()
+        end
+      end
+
+      class Consume < Method
+        @name = "basic.consume"
+        @method = 20
+        @index = 0x003C0014 # 60, 20, 3932180
+
+        # @return
+        # ["ticket = false", "queue = nil", "consumer_tag = """, "no_local = false", "no_ack = false", "exclusive = false", "nowait = false", "arguments = {}"]
+        def self.encode(ticket, queue, consumer_tag, no_local, no_ack, exclusive, nowait, arguments)
+          pieces = []
+          pieces << [60, 20].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << queue.bytesize.chr
+          pieces << queue
+          pieces << consumer_tag.bytesize.chr
+          pieces << consumer_tag
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if no_local
+          bit_buffer = bit_buffer | (1 << 1) if no_ack
+          bit_buffer = bit_buffer | (1 << 2) if exclusive
+          bit_buffer = bit_buffer | (1 << 3) if nowait
+          pieces << AMQ::Protocol::Table.encode(arguments)
+          pieces.join("")
+        end
+      end
+
+      class ConsumeOk < Method
+        @name = "basic.consume-ok"
+        @method = 21
+        @index = 0x003C0015 # 60, 21, 3932181
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          consumer_tag = data[offset..(offset + length)]
+          offset += length
+          self.new(consumer_tag)
+        end
+
+        attr_reader :consumer_tag
+        def initialize(consumer_tag)
+          @consumer_tag = consumer_tag
+        end
+      end
+
+      class Cancel < Method
+        @name = "basic.cancel"
+        @method = 30
+        @index = 0x003C001E # 60, 30, 3932190
+
+        # @return
+        # ["consumer_tag = nil", "nowait = false"]
+        def self.encode(consumer_tag, nowait)
+          pieces = []
+          pieces << [60, 30].pack("n2")
+          pieces << consumer_tag.bytesize.chr
+          pieces << consumer_tag
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          pieces.join("")
+        end
+      end
+
+      class CancelOk < Method
+        @name = "basic.cancel-ok"
+        @method = 31
+        @index = 0x003C001F # 60, 31, 3932191
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          consumer_tag = data[offset..(offset + length)]
+          offset += length
+          self.new(consumer_tag)
+        end
+
+        attr_reader :consumer_tag
+        def initialize(consumer_tag)
+          @consumer_tag = consumer_tag
+        end
+      end
+
+      class Publish < Method
+        @name = "basic.publish"
+        @method = 40
+        @index = 0x003C0028 # 60, 40, 3932200
+
+        # @return
+        # ["ticket = false", "exchange = """, "routing_key = """, "mandatory = false", "immediate = false", "user_headers = nil", "payload = """, "frame_size = nil"]
+        def self.encode(ticket, exchange, routing_key, mandatory, immediate, user_headers, payload, frame_size)
+          pieces = []
+          pieces << [60, 40].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << exchange.bytesize.chr
+          pieces << exchange
+          pieces << routing_key.bytesize.chr
+          pieces << routing_key
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if mandatory
+          bit_buffer = bit_buffer | (1 << 1) if immediate
+          pieces.join("")
+        end
+      end
+
+      class Return < Method
+        @name = "basic.return"
+        @method = 50
+        @index = 0x003C0032 # 60, 50, 3932210
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          reply_code = data[offset..(offset + 2)].unpack("n").first
+          offset += 2
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          reply_text = data[offset..(offset + length)]
+          offset += length
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          exchange = data[offset..(offset + length)]
+          offset += length
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          routing_key = data[offset..(offset + length)]
+          offset += length
+          self.new(reply_code, reply_text, exchange, routing_key)
+        end
+
+        attr_reader :reply_code, :reply_text, :exchange, :routing_key
+        def initialize(reply_code, reply_text, exchange, routing_key)
+          @reply_code = reply_code
+          @reply_text = reply_text
+          @exchange = exchange
+          @routing_key = routing_key
+        end
+      end
+
+      class Deliver < Method
+        @name = "basic.deliver"
+        @method = 60
+        @index = 0x003C003C # 60, 60, 3932220
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          consumer_tag = data[offset..(offset + length)]
+          offset += length
+          delivery_tag = data[offset..(offset + 8)].unpack("N2").first
+          offset += 8
+          bit_buffer = data[offset..(offset + 1)].unpack("c").first
+          offset += 1
+          redelivered = (bit_buffer & (1 << 0)) != 0
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          exchange = data[offset..(offset + length)]
+          offset += length
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          routing_key = data[offset..(offset + length)]
+          offset += length
+          self.new(consumer_tag, delivery_tag, redelivered, exchange, routing_key)
+        end
+
+        attr_reader :consumer_tag, :delivery_tag, :redelivered, :exchange, :routing_key
+        def initialize(consumer_tag, delivery_tag, redelivered, exchange, routing_key)
+          @consumer_tag = consumer_tag
+          @delivery_tag = delivery_tag
+          @redelivered = redelivered
+          @exchange = exchange
+          @routing_key = routing_key
+        end
+      end
+
+      class Get < Method
+        @name = "basic.get"
+        @method = 70
+        @index = 0x003C0046 # 60, 70, 3932230
+
+        # @return
+        # ["ticket = false", "queue = nil", "no_ack = false"]
+        def self.encode(ticket, queue, no_ack)
+          pieces = []
+          pieces << [60, 70].pack("n2")
+          pieces << [ticket].pack("n")
+          pieces << queue.bytesize.chr
+          pieces << queue
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if no_ack
+          pieces.join("")
+        end
+      end
+
+      class GetOk < Method
+        @name = "basic.get-ok"
+        @method = 71
+        @index = 0x003C0047 # 60, 71, 3932231
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          delivery_tag = data[offset..(offset + 8)].unpack("N2").first
+          offset += 8
+          bit_buffer = data[offset..(offset + 1)].unpack("c").first
+          offset += 1
+          redelivered = (bit_buffer & (1 << 0)) != 0
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          exchange = data[offset..(offset + length)]
+          offset += length
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          routing_key = data[offset..(offset + length)]
+          offset += length
+          message_count = data[offset..(offset + 4)].unpack("N").first
+          offset += 4
+          self.new(delivery_tag, redelivered, exchange, routing_key, message_count)
+        end
+
+        attr_reader :delivery_tag, :redelivered, :exchange, :routing_key, :message_count
+        def initialize(delivery_tag, redelivered, exchange, routing_key, message_count)
+          @delivery_tag = delivery_tag
+          @redelivered = redelivered
+          @exchange = exchange
+          @routing_key = routing_key
+          @message_count = message_count
+        end
+      end
+
+      class GetEmpty < Method
+        @name = "basic.get-empty"
+        @method = 72
+        @index = 0x003C0048 # 60, 72, 3932232
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset..(offset + 1)].unpack("N")[0]
+          offset += 1
+          cluster_id = data[offset..(offset + length)]
+          offset += length
+          self.new(cluster_id)
+        end
+
+        attr_reader :cluster_id
+        def initialize(cluster_id)
+          @cluster_id = cluster_id
+        end
+      end
+
+      class Ack < Method
+        @name = "basic.ack"
+        @method = 80
+        @index = 0x003C0050 # 60, 80, 3932240
+
+        # @return
+        # ["delivery_tag = false", "multiple = false"]
+        def self.encode(delivery_tag, multiple)
+          pieces = []
+          pieces << [60, 80].pack("n2")
+          pieces << [delivery_tag].pack(">Q")
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if multiple
+          pieces.join("")
+        end
+      end
+
+      class Reject < Method
+        @name = "basic.reject"
+        @method = 90
+        @index = 0x003C005A # 60, 90, 3932250
+
+        # @return
+        # ["delivery_tag = nil", "requeue = true"]
+        def self.encode(delivery_tag, requeue)
+          pieces = []
+          pieces << [60, 90].pack("n2")
+          pieces << [delivery_tag].pack(">Q")
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if requeue
+          pieces.join("")
+        end
+      end
+
+      class RecoverAsync < Method
+        @name = "basic.recover-async"
+        @method = 100
+        @index = 0x003C0064 # 60, 100, 3932260
+
+        # @return
+        # ["requeue = false"]
+        def self.encode(requeue)
+          pieces = []
+          pieces << [60, 100].pack("n2")
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if requeue
+          pieces.join("")
+        end
+      end
+
+      class Recover < Method
+        @name = "basic.recover"
+        @method = 110
+        @index = 0x003C006E # 60, 110, 3932270
+
+        # @return
+        # ["requeue = false"]
+        def self.encode(requeue)
+          pieces = []
+          pieces << [60, 110].pack("n2")
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if requeue
+          pieces.join("")
+        end
+      end
+
+      class RecoverOk < Method
+        @name = "basic.recover-ok"
+        @method = 111
+        @index = 0x003C006F # 60, 111, 3932271
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        attr_reader
+        def initialize()
+        end
+      end
+    end
+
+    METHODS = begin
+      Method.methods.inject(Hash.new) do |hash, klass|
+        hash.merge!(klass.index => klass)
+      end
+    end
+  end
+end