gorgon 0.5.0.rc1 → 0.6.0.rc1

data/Gemfile.lock

@@ -1,10 +1,9 @@
 PATH
   remote: .
   specs:
-    gorgon (0.4.5)
+    gorgon (0.6.0.rc1)
       amqp (~> 0.9.7)
       awesome_print
-      bunny (= 0.8.0)
       colorize (~> 0.5.8)
       open4 (~> 1.3.0)
       ruby-progressbar (~> 1.0.1)
@@ -22,8 +21,7 @@ GEM
       amq-client (~> 0.9.12)
       amq-protocol (~> 1.2.0)
       eventmachine
-    awesome_print (1.2.0)
-    bunny (0.8.0)
+    awesome_print (1.1.0)
     colorize (0.5.8)
     diff-lcs (1.1.3)
     eventmachine (1.0.3)

data/gorgon.gemspec

@@ -32,5 +32,4 @@ Gem::Specification.new do |s|
   # This problem should be fixed
   s.add_runtime_dependency "yajl-ruby", '=1.1.0'
   s.add_runtime_dependency "uuidtools", '=2.1.3'
-  s.add_runtime_dependency "bunny", '=0.8.0'
 end

data/lib/gorgon/amqp_service.rb

@@ -1,4 +1,4 @@
-require 'bunny'
+require 'gorgon_bunny/lib/gorgon_bunny'
 require 'yajl'
 
 class AmqpQueueDecorator
@@ -8,8 +8,8 @@ class AmqpQueueDecorator
 
   def pop
     m = @queue.pop
-    p = m[:payload]
-    p == :queue_empty ? nil : p
+    payload = m[2]
+    return payload
   end
 end
 
@@ -30,10 +30,10 @@ class AmqpService
   end
 
   def start_worker file_queue_name, reply_exchange_name
-    Bunny.run @connection_config do |b|
+    GorgonBunny.run @connection_config do |b|
       queue = b.queue file_queue_name
       exchange = b.exchange reply_exchange_name
       yield AmqpQueueDecorator.new(queue), AmqpExchangeDecorator.new(exchange)
     end
   end
-end
+end

data/lib/gorgon/gem_command_handler.rb

@@ -1,6 +1,7 @@
 require "socket"
 require "yajl"
-require "bunny"
+
+require "gorgon_bunny/lib/gorgon_bunny"
 require 'open4'
 
 class GemCommandHandler

data/lib/gorgon/listener.rb

@@ -9,7 +9,7 @@ require "gorgon/crash_reporter"
 require "gorgon/gem_command_handler"
 
 require "yajl"
-require "bunny"
+require "gorgon_bunny/lib/gorgon_bunny"
 require "awesome_print"
 require "open4"
 require "tmpdir"
@@ -38,7 +38,7 @@ class Listener
   end
 
   def connect
-    @bunny = Bunny.new(connection_information)
+    @bunny = GorgonBunny.new(connection_information)
     @bunny.start
   end
 
@@ -50,10 +50,12 @@ class Listener
 
   def poll
     message = @job_queue.pop
-    return false if message[:payload] == :queue_empty
-    log "Received: #{message[:payload]}"
+    return false if message == [nil, nil, nil]
+    log "Received: #{message}"
 
-    handle_request message[:payload]
+    payload = message[2]
+
+    handle_request payload
 
     log "Waiting for more jobs..."
     return true

data/lib/gorgon/originator_protocol.rb

@@ -1,3 +1,4 @@
+
 require 'gorgon/job_definition'
 
 require 'amqp'

data/lib/gorgon/version.rb

@@ -1,3 +1,3 @@
 module Gorgon
-  VERSION = "0.5.0.rc1"
+  VERSION = "0.6.0.rc1"
 end

data/lib/gorgon/worker_manager.rb

@@ -56,7 +56,7 @@ class WorkerManager
   private
 
   def connect
-    @bunny = Bunny.new(@config[:connection])
+    @bunny = GorgonBunny.new(@config[:connection])
     @bunny.start
     @reply_exchange = @bunny.exchange(@job_definition.reply_exchange_name)
 
@@ -156,8 +156,11 @@ class WorkerManager
   def subscribe_to_originator_queue
 
     originator_watcher = proc do
+      payload = nil
       while true
-        if (payload = @originator_queue.pop[:payload]) != :queue_empty
+        response = @originator_queue.pop
+        if response != [nil, nil, nil]
+          payload = response[2]
           break
         end
         sleep 0.5

data/lib/gorgon_amq-protocol/.gitignore

@@ -0,0 +1,15 @@
+/*.gem
+/.rvmrc
+/.ruby-version
+tmp
+*.pyc
+/vendor/bundle
+/vendor/amq-*
+/coverage
+Gemfile.lock
+.rbx/*
+.Apple*
+.bundle/*
+bin/*
+*.bundle
+Makefile

data/lib/gorgon_amq-protocol/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "codegen/rabbitmq-codegen"]
+	path = codegen/rabbitmq-codegen
+	url = git://github.com/rabbitmq/rabbitmq-codegen.git

data/lib/gorgon_amq-protocol/.rspec

@@ -0,0 +1,3 @@
+--colour
+--format
+progress

data/lib/gorgon_amq-protocol/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+bundler_args: --without development
+script: "bundle exec rspec spec"
+rvm:
+  - 2.0
+  - 1.9.3
+  - jruby-19mode
+  - 1.9.2
+  - rbx-19mode
+  - ruby-head
+  - jruby-head
+  - 1.8.7
+  - rbx-18mode
+notifications:
+  recipients:
+    - michael@novemberain.com
+matrix:
+  allow_failures:
+    - rvm: ruby-head

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

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+module GorgonAMQ
+  # Very minimalistic, pure Ruby implementation of bit set. Inspired by java.util.BitSet,
+  # although significantly smaller in scope.
+  #
+  # Originally part of amqp gem. Extracted to make it possible for Bunny to use it.
+  class BitSet
+
+    #
+    # API
+    #
+
+    ADDRESS_BITS_PER_WORD = 6
+    BITS_PER_WORD         = (1 << ADDRESS_BITS_PER_WORD)
+    WORD_MASK             = 0xffffffffffffffff
+
+    # @param [Integer] Number of bits in the set
+    # @api public
+    def initialize(nbits)
+      @nbits = nbits
+
+      self.init_words(nbits)
+    end # initialize(nbits)
+
+    # Sets (flags) given bit. This method allows bits to be set more than once in a row, no exception will be raised.
+    #
+    # @param [Integer] A bit to set
+    # @api public
+    def set(i)
+      w = self.word_index(i)
+      @words[w] |= (1 << i)
+    end # set(i)
+
+    # Fetches flag value for given bit.
+    #
+    # @param [Integer] A bit to fetch
+    # @return [Boolean] true if given bit is set, false otherwise
+    # @api public
+    def get(i)
+      w = self.word_index(i)
+
+      (@words[w] & (1 << i)) != 0
+    end # get(i)
+    alias [] get
+
+    # Unsets (unflags) given bit. This method allows bits to be unset more than once in a row, no exception will be raised.
+    #
+    # @param [Integer] A bit to unset
+    # @api public
+    def unset(i)
+      w = self.word_index(i)
+      return if w.nil?
+
+      @words[w] &= ~(1 << i)
+    end # unset(i)
+
+    # Clears all bits in the set
+    # @api public
+    def clear
+      self.init_words(@nbits)
+    end # clear
+
+
+    #
+    # Implementation
+    #
+
+    protected
+
+    # @private
+    def init_words(nbits)
+      n      = word_index(nbits-1) + 1
+      @words = Array.new(n) { 1 }
+    end # init_words
+
+    # @private
+    def word_index(i)
+      i >> ADDRESS_BITS_PER_WORD
+    end # word_index(i)
+  end # BitSet
+end # AMQ

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

@@ -0,0 +1,15 @@
+module GorgonAMQ
+  module Endianness
+    BIG_ENDIAN = ([1].pack("s") == "\x00\x01")
+
+    def big_endian?
+      BIG_ENDIAN
+    end
+
+    def little_endian?
+      !BIG_ENDIAN
+    end
+
+    extend self
+  end
+end

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

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+require "gorgon_amq/bit_set"
+
+module GorgonAMQ
+  # Simple bitset-based integer allocator, heavily inspired by com.rabbitmq.utility.IntAllocator class
+  # in the RabbitMQ Java client.
+  #
+  # Unlike monotonically incrementing identifier, this allocator is suitable for very long running programs
+  # that aggressively allocate and release channels.
+  class IntAllocator
+
+    #
+    # API
+    #
+
+    # @return [Integer] Number of integers in the allocation range
+    attr_reader :number_of_bits
+    # @return [Integer] Upper boundary of the integer range available for allocation
+    attr_reader :hi
+    # @return [Integer] Lower boundary of the integer range available for allocation
+    attr_reader :lo
+
+    # @param [Integer] lo    Lower boundary of the integer range available for allocation
+    # @param [Integer] hi    Upper boundary of the integer range available for allocation
+    # @raise [ArgumentError] if upper boundary is not greater than the lower one
+    def initialize(lo, hi)
+      raise ArgumentError.new "upper boundary must be greater than the lower one (given: hi = #{hi}, lo = #{lo})" unless hi > lo
+
+      @hi = hi
+      @lo = lo
+
+      @number_of_bits = hi - lo
+      @range          = Range.new(1, @number_of_bits)
+      @free_set       = BitSet.new(@number_of_bits)
+    end # initialize(hi, lo)
+
+    # Attempts to allocate next available integer. If allocation succeeds, allocated value is returned.
+    # Otherwise, nil is returned.
+    #
+    # Current implementation of this method is O(n), where n is number of bits in the range available for
+    # allocation.
+    #
+    # @return [Integer] Allocated integer if allocation succeeded. nil otherwise.
+    def allocate
+      if n = find_unallocated_position
+        @free_set.set(n)
+
+        n
+      else
+        -1
+      end
+    end # allocate
+
+    # Releases previously allocated integer. If integer provided as argument was not previously allocated,
+    # this method has no effect.
+    #
+    # @return [NilClass] nil
+    def free(reservation)
+      @free_set.unset(reservation)
+    end # free(reservation)
+    alias release free
+
+    # @return [Boolean] true if provided argument was previously allocated, false otherwise
+    def allocated?(reservation)
+      @free_set.get(reservation)
+    end # allocated?(reservation)
+
+    # Releases the whole allocation range
+    def reset
+      @free_set.clear
+    end # reset
+
+
+
+    protected
+
+    # This implementation is significantly less efficient
+    # that what the RabbitMQ Java client has (based on java.lang.Long#nextSetBit and
+    # java.lang.Long.numberOfTrailingZeros, and thus binary search over bits).
+    # But for channel id generation, this is a good enough implementation.
+    #
+    # @private
+    def find_unallocated_position
+      r = nil
+      @range.each do |i|
+        if !@free_set.get(i)
+          r = i
+          break;
+        end
+      end
+
+      r
+    end # find_unallocated_position
+  end # IntAllocator
+end # AMQ

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

@@ -0,0 +1,53 @@
+# encoding: binary
+
+require 'gorgon_amq/endianness'
+
+module GorgonAMQ
+  # Implements pack to/unpack from 64bit string in network byte order
+  # compatible with Ruby 1.8+.
+  module Pack
+    UINT64 = "Q".freeze
+    INT16  = "c".freeze
+
+    if Endianness.big_endian?
+      def self.pack_uint64_big_endian(long_long)
+        [long_long].pack(UINT64)
+      end
+
+      def self.unpack_uint64_big_endian(data)
+        data.unpack(UINT64)
+      end
+
+      def self.pack_int16_big_endian(short)
+        [long_long].pack(INT16)
+      end
+
+      def self.unpack_int16_big_endian(data)
+        data.unpack(INT16)
+      end
+    else
+      def self.pack_uint64_big_endian(long_long)
+        result = [long_long].pack(UINT64)
+        result.bytes.to_a.reverse.map(&:chr).join
+      end
+
+      def self.unpack_uint64_big_endian(data)
+        data = data.bytes.to_a.reverse.map(&:chr).join
+        data.unpack(UINT64)
+      end
+
+      def self.pack_int16_big_endian(short)
+        result = [long_long].pack(INT16)
+        result.bytes.to_a.reverse.map(&:chr).join
+      end
+
+      def self.unpack_int16_big_endian(data)
+        data = data.bytes.to_a.reverse.map(&:chr).join
+        data.unpack(INT16)
+      end
+    end
+  end
+
+  # Backwards compatibility
+  Hacks = Pack
+end

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

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+require "gorgon_amq/protocol/version"
+require "gorgon_amq/protocol/client"

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

@@ -0,0 +1,2322 @@
+# encoding: binary
+
+# THIS IS AN AUTOGENERATED FILE, DO NOT MODIFY
+# IT DIRECTLY ! FOR CHANGES, PLEASE UPDATE FILES
+# IN THE ./codegen DIRECTORY OF THE AMQ-PROTOCOL REPOSITORY.
+
+require "gorgon_amq/pack"
+
+require "gorgon_amq/protocol/table"
+require "gorgon_amq/protocol/frame"
+
+require "gorgon_amq/protocol/constants"
+require "gorgon_amq/protocol/exceptions"
+
+module GorgonAMQ
+  module Protocol
+    PROTOCOL_VERSION = "0.9.1".freeze
+    PREAMBLE         = "AMQP\x00\x00\x09\x01".freeze
+    DEFAULT_PORT     = 5672
+
+    # @return [Array] Collection of subclasses of GorgonAMQ::Protocol::Class.
+    def self.classes
+      Protocol::Class.classes
+    end
+
+    # @return [Array] Collection of subclasses of GorgonAMQ::Protocol::Method.
+    def self.methods
+      Protocol::Method.methods
+    end
+
+    class ContentTooLarge < SoftError
+      VALUE = 311
+    end
+
+    class NoRoute < SoftError
+      VALUE = 312
+    end
+
+    class NoConsumers < SoftError
+      VALUE = 313
+    end
+
+    class AccessRefused < SoftError
+      VALUE = 403
+    end
+
+    class NotFound < SoftError
+      VALUE = 404
+    end
+
+    class ResourceLocked < SoftError
+      VALUE = 405
+    end
+
+    class PreconditionFailed < SoftError
+      VALUE = 406
+    end
+
+    class ConnectionForced < HardError
+      VALUE = 320
+    end
+
+    class InvalidPath < HardError
+      VALUE = 402
+    end
+
+    class FrameError < HardError
+      VALUE = 501
+    end
+
+    class SyntaxError < HardError
+      VALUE = 502
+    end
+
+    class CommandInvalid < HardError
+      VALUE = 503
+    end
+
+    class ChannelError < HardError
+      VALUE = 504
+    end
+
+    class UnexpectedFrame < HardError
+      VALUE = 505
+    end
+
+    class ResourceError < HardError
+      VALUE = 506
+    end
+
+    class NotAllowed < HardError
+      VALUE = 530
+    end
+
+    class NotImplemented < HardError
+      VALUE = 540
+    end
+
+    class InternalError < HardError
+      VALUE = 541
+    end
+
+
+    class Class
+      @classes = Array.new
+
+      def self.method_id
+        @method_id
+      end
+
+      def self.name
+        @name
+      end
+
+      def self.inherited(base)
+        if self == Protocol::Class
+          @classes << base
+        end
+      end
+
+      def self.classes
+        @classes
+      end
+    end
+
+    class Method
+      @methods = Array.new
+      def self.method_id
+        @method_id
+      end
+
+      def self.name
+        @name
+      end
+
+      def self.index
+        @index
+      end
+
+      def self.inherited(base)
+        if self == Protocol::Method
+          @methods << base
+        end
+      end
+
+      def self.methods
+        @methods
+      end
+
+      def self.split_headers(user_headers)
+        properties, headers = {}, {}
+        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 [properties, headers]
+      end
+
+      def self.encode_body(body, channel, frame_size)
+        return [] if body.empty?
+
+        # 8 = 1 + 2 + 4 + 1
+        # 1 byte of frame type
+        # 2 bytes of channel number
+        # 4 bytes of frame payload length
+        # 1 byte of payload trailer FRAME_END byte
+        limit        = frame_size - 8
+        return [BodyFrame.new(body, channel)] if body.bytesize < limit
+
+        # Otherwise String#slice on 1.9 will operate with code points,
+        # and we need bytes. MK.
+        body.force_encoding("ASCII-8BIT") if RUBY_VERSION.to_f >= 1.9
+
+        array = Array.new
+        while body && !body.empty?
+          payload, body = body[0, limit], body[limit, body.length - limit]
+          array << BodyFrame.new(payload, channel)
+        end
+
+        array
+      end
+
+      def self.instantiate(*args, &block)
+        self.new(*args, &block)
+      end
+    end
+
+    class Connection < Protocol::Class
+      @name = "connection"
+      @method_id = 10
+
+
+
+      class Start < Protocol::Method
+        @name = "connection.start"
+        @method_id = 10
+        @index = 0x000A000A # 10, 10, 655370
+        @packed_indexes = [10, 10].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          version_major = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          version_minor = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          table_length = Table.length(data[offset, 4])
+          server_properties = Table.decode(data[offset, table_length + 4])
+          offset += table_length + 4
+          length = data[offset, 4].unpack(PACK_UINT32).first
+          offset += 4
+          mechanisms = data[offset, length]
+          offset += length
+          length = data[offset, 4].unpack(PACK_UINT32).first
+          offset += 4
+          locales = data[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
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class StartOk < Protocol::Method
+        @name = "connection.start-ok"
+        @method_id = 11
+        @index = 0x000A000B # 10, 11, 655371
+        @packed_indexes = [10, 11].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'client_properties = nil', u"mechanism = u'PLAIN'", u'response = nil', u"locale = u'en_US'"]
+        def self.encode(client_properties, mechanism, response, locale)
+          channel = 0
+          buffer = @packed_indexes.dup
+          buffer << GorgonAMQ::Protocol::Table.encode(client_properties)
+          buffer << mechanism.to_s.bytesize.chr
+          buffer << mechanism.to_s
+          buffer << [response.to_s.bytesize].pack(PACK_UINT32)
+          buffer << response.to_s
+          buffer << locale.to_s.bytesize.chr
+          buffer << locale.to_s
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class Secure < Protocol::Method
+        @name = "connection.secure"
+        @method_id = 20
+        @index = 0x000A0014 # 10, 20, 655380
+        @packed_indexes = [10, 20].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset, 4].unpack(PACK_UINT32).first
+          offset += 4
+          challenge = data[offset, length]
+          offset += length
+          self.new(challenge)
+        end
+
+        attr_reader :challenge
+        def initialize(challenge)
+          @challenge = challenge
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class SecureOk < Protocol::Method
+        @name = "connection.secure-ok"
+        @method_id = 21
+        @index = 0x000A0015 # 10, 21, 655381
+        @packed_indexes = [10, 21].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'response = nil']
+        def self.encode(response)
+          channel = 0
+          buffer = @packed_indexes.dup
+          buffer << [response.to_s.bytesize].pack(PACK_UINT32)
+          buffer << response.to_s
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class Tune < Protocol::Method
+        @name = "connection.tune"
+        @method_id = 30
+        @index = 0x000A001E # 10, 30, 655390
+        @packed_indexes = [10, 30].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          channel_max = data[offset, 2].unpack(PACK_UINT16).first
+          offset += 2
+          frame_max = data[offset, 4].unpack(PACK_UINT32).first
+          offset += 4
+          heartbeat = data[offset, 2].unpack(PACK_UINT16).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
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class TuneOk < Protocol::Method
+        @name = "connection.tune-ok"
+        @method_id = 31
+        @index = 0x000A001F # 10, 31, 655391
+        @packed_indexes = [10, 31].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'channel_max = false', u'frame_max = false', u'heartbeat = false']
+        def self.encode(channel_max, frame_max, heartbeat)
+          channel = 0
+          buffer = @packed_indexes.dup
+          buffer << [channel_max].pack(PACK_UINT16)
+          buffer << [frame_max].pack(PACK_UINT32)
+          buffer << [heartbeat].pack(PACK_UINT16)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class Open < Protocol::Method
+        @name = "connection.open"
+        @method_id = 40
+        @index = 0x000A0028 # 10, 40, 655400
+        @packed_indexes = [10, 40].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u"virtual_host = u'/'", u'capabilities = EMPTY_STRING', u'insist = false']
+        def self.encode(virtual_host)
+          capabilities = EMPTY_STRING
+          insist = false
+          channel = 0
+          buffer = @packed_indexes.dup
+          buffer << virtual_host.to_s.bytesize.chr
+          buffer << virtual_host.to_s
+          buffer << capabilities.to_s.bytesize.chr
+          buffer << capabilities.to_s
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if insist
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class OpenOk < Protocol::Method
+        @name = "connection.open-ok"
+        @method_id = 41
+        @index = 0x000A0029 # 10, 41, 655401
+        @packed_indexes = [10, 41].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          known_hosts = data[offset, length]
+          offset += length
+          self.new(known_hosts)
+        end
+
+        attr_reader :known_hosts
+        def initialize(known_hosts)
+          @known_hosts = known_hosts
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Close < Protocol::Method
+        @name = "connection.close"
+        @method_id = 50
+        @index = 0x000A0032 # 10, 50, 655410
+        @packed_indexes = [10, 50].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          reply_code = data[offset, 2].unpack(PACK_UINT16).first
+          offset += 2
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          reply_text = data[offset, length]
+          offset += length
+          class_id = data[offset, 2].unpack(PACK_UINT16).first
+          offset += 2
+          method_id = data[offset, 2].unpack(PACK_UINT16).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
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'reply_code = nil', u'reply_text = EMPTY_STRING', u'class_id = nil', u'method_id = nil']
+        def self.encode(reply_code, reply_text, class_id, method_id)
+          channel = 0
+          buffer = @packed_indexes.dup
+          buffer << [reply_code].pack(PACK_UINT16)
+          buffer << reply_text.to_s.bytesize.chr
+          buffer << reply_text.to_s
+          buffer << [class_id].pack(PACK_UINT16)
+          buffer << [method_id].pack(PACK_UINT16)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class CloseOk < Protocol::Method
+        @name = "connection.close-ok"
+        @method_id = 51
+        @index = 0x000A0033 # 10, 51, 655411
+        @packed_indexes = [10, 51].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # []
+        def self.encode()
+          channel = 0
+          buffer = @packed_indexes.dup
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class Blocked < Protocol::Method
+        @name = "connection.blocked"
+        @method_id = 60
+        @index = 0x000A003C # 10, 60, 655420
+        @packed_indexes = [10, 60].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          reason = data[offset, length]
+          offset += length
+          self.new(reason)
+        end
+
+        attr_reader :reason
+        def initialize(reason)
+          @reason = reason
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'reason = EMPTY_STRING']
+        def self.encode(reason)
+          channel = 0
+          buffer = @packed_indexes.dup
+          buffer << reason.to_s.bytesize.chr
+          buffer << reason.to_s
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class Unblocked < Protocol::Method
+        @name = "connection.unblocked"
+        @method_id = 61
+        @index = 0x000A003D # 10, 61, 655421
+        @packed_indexes = [10, 61].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # []
+        def self.encode()
+          channel = 0
+          buffer = @packed_indexes.dup
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+    end
+
+    class Channel < Protocol::Class
+      @name = "channel"
+      @method_id = 20
+
+
+
+      class Open < Protocol::Method
+        @name = "channel.open"
+        @method_id = 10
+        @index = 0x0014000A # 20, 10, 1310730
+        @packed_indexes = [20, 10].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'out_of_band = EMPTY_STRING']
+        def self.encode(channel, out_of_band)
+          buffer = @packed_indexes.dup
+          buffer << out_of_band.to_s.bytesize.chr
+          buffer << out_of_band.to_s
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class OpenOk < Protocol::Method
+        @name = "channel.open-ok"
+        @method_id = 11
+        @index = 0x0014000B # 20, 11, 1310731
+        @packed_indexes = [20, 11].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset, 4].unpack(PACK_UINT32).first
+          offset += 4
+          channel_id = data[offset, length]
+          offset += length
+          self.new(channel_id)
+        end
+
+        attr_reader :channel_id
+        def initialize(channel_id)
+          @channel_id = channel_id
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Flow < Protocol::Method
+        @name = "channel.flow"
+        @method_id = 20
+        @index = 0x00140014 # 20, 20, 1310740
+        @packed_indexes = [20, 20].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          active = (bit_buffer & (1 << 0)) != 0
+          self.new(active)
+        end
+
+        attr_reader :active
+        def initialize(active)
+          @active = active
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'active = nil']
+        def self.encode(channel, active)
+          buffer = @packed_indexes.dup
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if active
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class FlowOk < Protocol::Method
+        @name = "channel.flow-ok"
+        @method_id = 21
+        @index = 0x00140015 # 20, 21, 1310741
+        @packed_indexes = [20, 21].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          active = (bit_buffer & (1 << 0)) != 0
+          self.new(active)
+        end
+
+        attr_reader :active
+        def initialize(active)
+          @active = active
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'active = nil']
+        def self.encode(channel, active)
+          buffer = @packed_indexes.dup
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if active
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class Close < Protocol::Method
+        @name = "channel.close"
+        @method_id = 40
+        @index = 0x00140028 # 20, 40, 1310760
+        @packed_indexes = [20, 40].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          reply_code = data[offset, 2].unpack(PACK_UINT16).first
+          offset += 2
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          reply_text = data[offset, length]
+          offset += length
+          class_id = data[offset, 2].unpack(PACK_UINT16).first
+          offset += 2
+          method_id = data[offset, 2].unpack(PACK_UINT16).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
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'reply_code = nil', u'reply_text = EMPTY_STRING', u'class_id = nil', u'method_id = nil']
+        def self.encode(channel, reply_code, reply_text, class_id, method_id)
+          buffer = @packed_indexes.dup
+          buffer << [reply_code].pack(PACK_UINT16)
+          buffer << reply_text.to_s.bytesize.chr
+          buffer << reply_text.to_s
+          buffer << [class_id].pack(PACK_UINT16)
+          buffer << [method_id].pack(PACK_UINT16)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class CloseOk < Protocol::Method
+        @name = "channel.close-ok"
+        @method_id = 41
+        @index = 0x00140029 # 20, 41, 1310761
+        @packed_indexes = [20, 41].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # []
+        def self.encode(channel)
+          buffer = @packed_indexes.dup
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+    end
+
+    class Exchange < Protocol::Class
+      @name = "exchange"
+      @method_id = 40
+
+
+
+      class Declare < Protocol::Method
+        @name = "exchange.declare"
+        @method_id = 10
+        @index = 0x0028000A # 40, 10, 2621450
+        @packed_indexes = [40, 10].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'exchange = nil', u"type = u'direct'", u'passive = false', u'durable = false', u'auto_delete = false', u'internal = false', u'nowait = false', u'arguments = {}']
+        def self.encode(channel, exchange, type, passive, durable, auto_delete, internal, nowait, arguments)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << exchange.to_s.bytesize.chr
+          buffer << exchange.to_s
+          buffer << type.to_s.bytesize.chr
+          buffer << type.to_s
+          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
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          buffer << GorgonAMQ::Protocol::Table.encode(arguments)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class DeclareOk < Protocol::Method
+        @name = "exchange.declare-ok"
+        @method_id = 11
+        @index = 0x0028000B # 40, 11, 2621451
+        @packed_indexes = [40, 11].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Delete < Protocol::Method
+        @name = "exchange.delete"
+        @method_id = 20
+        @index = 0x00280014 # 40, 20, 2621460
+        @packed_indexes = [40, 20].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'exchange = nil', u'if_unused = false', u'nowait = false']
+        def self.encode(channel, exchange, if_unused, nowait)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << exchange.to_s.bytesize.chr
+          buffer << exchange.to_s
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if if_unused
+          bit_buffer = bit_buffer | (1 << 1) if nowait
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class DeleteOk < Protocol::Method
+        @name = "exchange.delete-ok"
+        @method_id = 21
+        @index = 0x00280015 # 40, 21, 2621461
+        @packed_indexes = [40, 21].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Bind < Protocol::Method
+        @name = "exchange.bind"
+        @method_id = 30
+        @index = 0x0028001E # 40, 30, 2621470
+        @packed_indexes = [40, 30].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'destination = nil', u'source = nil', u'routing_key = EMPTY_STRING', u'nowait = false', u'arguments = {}']
+        def self.encode(channel, destination, source, routing_key, nowait, arguments)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << destination.to_s.bytesize.chr
+          buffer << destination.to_s
+          buffer << source.to_s.bytesize.chr
+          buffer << source.to_s
+          buffer << routing_key.to_s.bytesize.chr
+          buffer << routing_key.to_s
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          buffer << GorgonAMQ::Protocol::Table.encode(arguments)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class BindOk < Protocol::Method
+        @name = "exchange.bind-ok"
+        @method_id = 31
+        @index = 0x0028001F # 40, 31, 2621471
+        @packed_indexes = [40, 31].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Unbind < Protocol::Method
+        @name = "exchange.unbind"
+        @method_id = 40
+        @index = 0x00280028 # 40, 40, 2621480
+        @packed_indexes = [40, 40].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'destination = nil', u'source = nil', u'routing_key = EMPTY_STRING', u'nowait = false', u'arguments = {}']
+        def self.encode(channel, destination, source, routing_key, nowait, arguments)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << destination.to_s.bytesize.chr
+          buffer << destination.to_s
+          buffer << source.to_s.bytesize.chr
+          buffer << source.to_s
+          buffer << routing_key.to_s.bytesize.chr
+          buffer << routing_key.to_s
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          buffer << GorgonAMQ::Protocol::Table.encode(arguments)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class UnbindOk < Protocol::Method
+        @name = "exchange.unbind-ok"
+        @method_id = 51
+        @index = 0x00280033 # 40, 51, 2621491
+        @packed_indexes = [40, 51].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+    end
+
+    class Queue < Protocol::Class
+      @name = "queue"
+      @method_id = 50
+
+
+
+      class Declare < Protocol::Method
+        @name = "queue.declare"
+        @method_id = 10
+        @index = 0x0032000A # 50, 10, 3276810
+        @packed_indexes = [50, 10].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'queue = EMPTY_STRING', u'passive = false', u'durable = false', u'exclusive = false', u'auto_delete = false', u'nowait = false', u'arguments = {}']
+        def self.encode(channel, queue, passive, durable, exclusive, auto_delete, nowait, arguments)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << queue.to_s.bytesize.chr
+          buffer << queue.to_s
+          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
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          buffer << GorgonAMQ::Protocol::Table.encode(arguments)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class DeclareOk < Protocol::Method
+        @name = "queue.declare-ok"
+        @method_id = 11
+        @index = 0x0032000B # 50, 11, 3276811
+        @packed_indexes = [50, 11].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          queue = data[offset, length]
+          offset += length
+          message_count = data[offset, 4].unpack(PACK_UINT32).first
+          offset += 4
+          consumer_count = data[offset, 4].unpack(PACK_UINT32).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
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Bind < Protocol::Method
+        @name = "queue.bind"
+        @method_id = 20
+        @index = 0x00320014 # 50, 20, 3276820
+        @packed_indexes = [50, 20].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'queue = EMPTY_STRING', u'exchange = nil', u'routing_key = EMPTY_STRING', u'nowait = false', u'arguments = {}']
+        def self.encode(channel, queue, exchange, routing_key, nowait, arguments)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << queue.to_s.bytesize.chr
+          buffer << queue.to_s
+          buffer << exchange.to_s.bytesize.chr
+          buffer << exchange.to_s
+          buffer << routing_key.to_s.bytesize.chr
+          buffer << routing_key.to_s
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          buffer << GorgonAMQ::Protocol::Table.encode(arguments)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class BindOk < Protocol::Method
+        @name = "queue.bind-ok"
+        @method_id = 21
+        @index = 0x00320015 # 50, 21, 3276821
+        @packed_indexes = [50, 21].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Purge < Protocol::Method
+        @name = "queue.purge"
+        @method_id = 30
+        @index = 0x0032001E # 50, 30, 3276830
+        @packed_indexes = [50, 30].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'queue = EMPTY_STRING', u'nowait = false']
+        def self.encode(channel, queue, nowait)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << queue.to_s.bytesize.chr
+          buffer << queue.to_s
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class PurgeOk < Protocol::Method
+        @name = "queue.purge-ok"
+        @method_id = 31
+        @index = 0x0032001F # 50, 31, 3276831
+        @packed_indexes = [50, 31].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          message_count = data[offset, 4].unpack(PACK_UINT32).first
+          offset += 4
+          self.new(message_count)
+        end
+
+        attr_reader :message_count
+        def initialize(message_count)
+          @message_count = message_count
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Delete < Protocol::Method
+        @name = "queue.delete"
+        @method_id = 40
+        @index = 0x00320028 # 50, 40, 3276840
+        @packed_indexes = [50, 40].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'queue = EMPTY_STRING', u'if_unused = false', u'if_empty = false', u'nowait = false']
+        def self.encode(channel, queue, if_unused, if_empty, nowait)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << queue.to_s.bytesize.chr
+          buffer << queue.to_s
+          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
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class DeleteOk < Protocol::Method
+        @name = "queue.delete-ok"
+        @method_id = 41
+        @index = 0x00320029 # 50, 41, 3276841
+        @packed_indexes = [50, 41].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          message_count = data[offset, 4].unpack(PACK_UINT32).first
+          offset += 4
+          self.new(message_count)
+        end
+
+        attr_reader :message_count
+        def initialize(message_count)
+          @message_count = message_count
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Unbind < Protocol::Method
+        @name = "queue.unbind"
+        @method_id = 50
+        @index = 0x00320032 # 50, 50, 3276850
+        @packed_indexes = [50, 50].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'queue = EMPTY_STRING', u'exchange = nil', u'routing_key = EMPTY_STRING', u'arguments = {}']
+        def self.encode(channel, queue, exchange, routing_key, arguments)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << queue.to_s.bytesize.chr
+          buffer << queue.to_s
+          buffer << exchange.to_s.bytesize.chr
+          buffer << exchange.to_s
+          buffer << routing_key.to_s.bytesize.chr
+          buffer << routing_key.to_s
+          buffer << GorgonAMQ::Protocol::Table.encode(arguments)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class UnbindOk < Protocol::Method
+        @name = "queue.unbind-ok"
+        @method_id = 51
+        @index = 0x00320033 # 50, 51, 3276851
+        @packed_indexes = [50, 51].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+    end
+
+    class Basic < Protocol::Class
+      @name = "basic"
+      @method_id = 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)
+        buffer = ''
+        buffer << value.to_s.bytesize.chr
+        buffer << value.to_s
+        [0, 0x8000, buffer]
+      end
+
+      # 1 << 14
+      def self.encode_content_encoding(value)
+        buffer = ''
+        buffer << value.to_s.bytesize.chr
+        buffer << value.to_s
+        [1, 0x4000, buffer]
+      end
+
+      # 1 << 13
+      def self.encode_headers(value)
+        buffer = ''
+        buffer << GorgonAMQ::Protocol::Table.encode(value)
+        [2, 0x2000, buffer]
+      end
+
+      # 1 << 12
+      def self.encode_delivery_mode(value)
+        buffer = ''
+        buffer << [value].pack(PACK_CHAR)
+        [3, 0x1000, buffer]
+      end
+
+      # 1 << 11
+      def self.encode_priority(value)
+        buffer = ''
+        buffer << [value].pack(PACK_CHAR)
+        [4, 0x0800, buffer]
+      end
+
+      # 1 << 10
+      def self.encode_correlation_id(value)
+        buffer = ''
+        buffer << value.to_s.bytesize.chr
+        buffer << value.to_s
+        [5, 0x0400, buffer]
+      end
+
+      # 1 << 9
+      def self.encode_reply_to(value)
+        buffer = ''
+        buffer << value.to_s.bytesize.chr
+        buffer << value.to_s
+        [6, 0x0200, buffer]
+      end
+
+      # 1 << 8
+      def self.encode_expiration(value)
+        buffer = ''
+        buffer << value.to_s.bytesize.chr
+        buffer << value.to_s
+        [7, 0x0100, buffer]
+      end
+
+      # 1 << 7
+      def self.encode_message_id(value)
+        buffer = ''
+        buffer << value.to_s.bytesize.chr
+        buffer << value.to_s
+        [8, 0x0080, buffer]
+      end
+
+      # 1 << 6
+      def self.encode_timestamp(value)
+        buffer = ''
+        buffer << GorgonAMQ::Pack.pack_uint64_big_endian(value)
+        [9, 0x0040, buffer]
+      end
+
+      # 1 << 5
+      def self.encode_type(value)
+        buffer = ''
+        buffer << value.to_s.bytesize.chr
+        buffer << value.to_s
+        [10, 0x0020, buffer]
+      end
+
+      # 1 << 4
+      def self.encode_user_id(value)
+        buffer = ''
+        buffer << value.to_s.bytesize.chr
+        buffer << value.to_s
+        [11, 0x0010, buffer]
+      end
+
+      # 1 << 3
+      def self.encode_app_id(value)
+        buffer = ''
+        buffer << value.to_s.bytesize.chr
+        buffer << value.to_s
+        [12, 0x0008, buffer]
+      end
+
+      # 1 << 2
+      def self.encode_cluster_id(value)
+        buffer = ''
+        buffer << value.to_s.bytesize.chr
+        buffer << value.to_s
+        [13, 0x0004, buffer]
+      end
+
+
+
+      def self.encode_properties(body_size, properties)
+        pieces, flags = [], 0
+
+        properties.reject {|key, value| value.nil?}.each do |key, value|
+          i, f, result = self.__send__(:"encode_#{key}", value)
+          flags |= f
+          pieces[i] = result
+        end
+
+        # result = [60, 0, body_size, flags].pack('n2Qn')
+        result = [60, 0].pack(PACK_UINT16_X2)
+        result += GorgonAMQ::Pack.pack_uint64_big_endian(body_size)
+        result += [flags].pack(PACK_UINT16)
+        result + pieces.join(EMPTY_STRING)
+      end
+
+      # THIS DECODES ONLY FLAGS
+      DECODE_PROPERTIES = {
+        0x8000 => :content_type,
+        0x4000 => :content_encoding,
+        0x2000 => :headers,
+        0x1000 => :delivery_mode,
+        0x0800 => :priority,
+        0x0400 => :correlation_id,
+        0x0200 => :reply_to,
+        0x0100 => :expiration,
+        0x0080 => :message_id,
+        0x0040 => :timestamp,
+        0x0020 => :type,
+        0x0010 => :user_id,
+        0x0008 => :app_id,
+        0x0004 => :cluster_id,
+      }
+
+      DECODE_PROPERTIES_TYPE = {
+        0x8000 => :shortstr,
+        0x4000 => :shortstr,
+        0x2000 => :table,
+        0x1000 => :octet,
+        0x0800 => :octet,
+        0x0400 => :shortstr,
+        0x0200 => :shortstr,
+        0x0100 => :shortstr,
+        0x0080 => :shortstr,
+        0x0040 => :timestamp,
+        0x0020 => :shortstr,
+        0x0010 => :shortstr,
+        0x0008 => :shortstr,
+        0x0004 => :shortstr,
+      }
+
+      # Hash doesn't give any guarantees on keys order, we will do it in a
+      # straightforward way
+      DECODE_PROPERTIES_KEYS = [
+        0x8000,
+        0x4000,
+        0x2000,
+        0x1000,
+        0x0800,
+        0x0400,
+        0x0200,
+        0x0100,
+        0x0080,
+        0x0040,
+        0x0020,
+        0x0010,
+        0x0008,
+        0x0004,
+      ]
+
+      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
+
+      class Qos < Protocol::Method
+        @name = "basic.qos"
+        @method_id = 10
+        @index = 0x003C000A # 60, 10, 3932170
+        @packed_indexes = [60, 10].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'prefetch_size = false', u'prefetch_count = false', u'global = false']
+        def self.encode(channel, prefetch_size, prefetch_count, global)
+          buffer = @packed_indexes.dup
+          buffer << [prefetch_size].pack(PACK_UINT32)
+          buffer << [prefetch_count].pack(PACK_UINT16)
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if global
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class QosOk < Protocol::Method
+        @name = "basic.qos-ok"
+        @method_id = 11
+        @index = 0x003C000B # 60, 11, 3932171
+        @packed_indexes = [60, 11].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Consume < Protocol::Method
+        @name = "basic.consume"
+        @method_id = 20
+        @index = 0x003C0014 # 60, 20, 3932180
+        @packed_indexes = [60, 20].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'queue = EMPTY_STRING', u'consumer_tag = EMPTY_STRING', u'no_local = false', u'no_ack = false', u'exclusive = false', u'nowait = false', u'arguments = {}']
+        def self.encode(channel, queue, consumer_tag, no_local, no_ack, exclusive, nowait, arguments)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << queue.to_s.bytesize.chr
+          buffer << queue.to_s
+          buffer << consumer_tag.to_s.bytesize.chr
+          buffer << consumer_tag.to_s
+          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
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          buffer << GorgonAMQ::Protocol::Table.encode(arguments)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class ConsumeOk < Protocol::Method
+        @name = "basic.consume-ok"
+        @method_id = 21
+        @index = 0x003C0015 # 60, 21, 3932181
+        @packed_indexes = [60, 21].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          consumer_tag = data[offset, length]
+          offset += length
+          self.new(consumer_tag)
+        end
+
+        attr_reader :consumer_tag
+        def initialize(consumer_tag)
+          @consumer_tag = consumer_tag
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Cancel < Protocol::Method
+        @name = "basic.cancel"
+        @method_id = 30
+        @index = 0x003C001E # 60, 30, 3932190
+        @packed_indexes = [60, 30].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          consumer_tag = data[offset, length]
+          offset += length
+          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          nowait = (bit_buffer & (1 << 0)) != 0
+          self.new(consumer_tag, nowait)
+        end
+
+        attr_reader :consumer_tag, :nowait
+        def initialize(consumer_tag, nowait)
+          @consumer_tag = consumer_tag
+          @nowait = nowait
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'consumer_tag = nil', u'nowait = false']
+        def self.encode(channel, consumer_tag, nowait)
+          buffer = @packed_indexes.dup
+          buffer << consumer_tag.to_s.bytesize.chr
+          buffer << consumer_tag.to_s
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class CancelOk < Protocol::Method
+        @name = "basic.cancel-ok"
+        @method_id = 31
+        @index = 0x003C001F # 60, 31, 3932191
+        @packed_indexes = [60, 31].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          consumer_tag = data[offset, length]
+          offset += length
+          self.new(consumer_tag)
+        end
+
+        attr_reader :consumer_tag
+        def initialize(consumer_tag)
+          @consumer_tag = consumer_tag
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Publish < Protocol::Method
+        @name = "basic.publish"
+        @method_id = 40
+        @index = 0x003C0028 # 60, 40, 3932200
+        @packed_indexes = [60, 40].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          true
+        end
+
+        # @return
+        # [u'ticket = 0', u'exchange = EMPTY_STRING', u'routing_key = EMPTY_STRING', u'mandatory = false', u'immediate = false', 'user_headers = nil', 'payload = ""', 'frame_size = nil']
+        def self.encode(channel, payload, user_headers, exchange, routing_key, mandatory, immediate, frame_size)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << exchange.to_s.bytesize.chr
+          buffer << exchange.to_s
+          buffer << routing_key.to_s.bytesize.chr
+          buffer << routing_key.to_s
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if mandatory
+          bit_buffer = bit_buffer | (1 << 1) if immediate
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          frames = [MethodFrame.new(buffer, channel)]
+          properties, headers = self.split_headers(user_headers)
+          if properties.nil? or properties.empty?
+            raise RuntimeError.new("Properties can not be empty!")
+          end
+          properties_payload = Basic.encode_properties(payload.bytesize, properties)
+          frames << HeaderFrame.new(properties_payload, channel)
+          frames += self.encode_body(payload, channel, frame_size)
+          frames
+        end
+
+      end
+
+      class Return < Protocol::Method
+        @name = "basic.return"
+        @method_id = 50
+        @index = 0x003C0032 # 60, 50, 3932210
+        @packed_indexes = [60, 50].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          reply_code = data[offset, 2].unpack(PACK_UINT16).first
+          offset += 2
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          reply_text = data[offset, length]
+          offset += length
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          exchange = data[offset, length]
+          offset += length
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          routing_key = data[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
+
+        def self.has_content?
+          true
+        end
+
+
+      end
+
+      class Deliver < Protocol::Method
+        @name = "basic.deliver"
+        @method_id = 60
+        @index = 0x003C003C # 60, 60, 3932220
+        @packed_indexes = [60, 60].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          consumer_tag = data[offset, length]
+          offset += length
+          delivery_tag = GorgonAMQ::Pack.unpack_uint64_big_endian(data[offset, 8]).first
+          offset += 8
+          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          redelivered = (bit_buffer & (1 << 0)) != 0
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          exchange = data[offset, length]
+          offset += length
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          routing_key = data[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
+
+        def self.has_content?
+          true
+        end
+
+
+      end
+
+      class Get < Protocol::Method
+        @name = "basic.get"
+        @method_id = 70
+        @index = 0x003C0046 # 60, 70, 3932230
+        @packed_indexes = [60, 70].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'ticket = 0', u'queue = EMPTY_STRING', u'no_ack = false']
+        def self.encode(channel, queue, no_ack)
+          ticket = 0
+          buffer = @packed_indexes.dup
+          buffer << [ticket].pack(PACK_UINT16)
+          buffer << queue.to_s.bytesize.chr
+          buffer << queue.to_s
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if no_ack
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class GetOk < Protocol::Method
+        @name = "basic.get-ok"
+        @method_id = 71
+        @index = 0x003C0047 # 60, 71, 3932231
+        @packed_indexes = [60, 71].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          delivery_tag = GorgonAMQ::Pack.unpack_uint64_big_endian(data[offset, 8]).first
+          offset += 8
+          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          redelivered = (bit_buffer & (1 << 0)) != 0
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          exchange = data[offset, length]
+          offset += length
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          routing_key = data[offset, length]
+          offset += length
+          message_count = data[offset, 4].unpack(PACK_UINT32).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
+
+        def self.has_content?
+          true
+        end
+
+
+      end
+
+      class GetEmpty < Protocol::Method
+        @name = "basic.get-empty"
+        @method_id = 72
+        @index = 0x003C0048 # 60, 72, 3932232
+        @packed_indexes = [60, 72].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          length = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          cluster_id = data[offset, length]
+          offset += length
+          self.new(cluster_id)
+        end
+
+        attr_reader :cluster_id
+        def initialize(cluster_id)
+          @cluster_id = cluster_id
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Ack < Protocol::Method
+        @name = "basic.ack"
+        @method_id = 80
+        @index = 0x003C0050 # 60, 80, 3932240
+        @packed_indexes = [60, 80].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          delivery_tag = GorgonAMQ::Pack.unpack_uint64_big_endian(data[offset, 8]).first
+          offset += 8
+          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          multiple = (bit_buffer & (1 << 0)) != 0
+          self.new(delivery_tag, multiple)
+        end
+
+        attr_reader :delivery_tag, :multiple
+        def initialize(delivery_tag, multiple)
+          @delivery_tag = delivery_tag
+          @multiple = multiple
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'delivery_tag = false', u'multiple = false']
+        def self.encode(channel, delivery_tag, multiple)
+          buffer = @packed_indexes.dup
+          buffer << GorgonAMQ::Pack.pack_uint64_big_endian(delivery_tag)
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if multiple
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class Reject < Protocol::Method
+        @name = "basic.reject"
+        @method_id = 90
+        @index = 0x003C005A # 60, 90, 3932250
+        @packed_indexes = [60, 90].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'delivery_tag = nil', u'requeue = true']
+        def self.encode(channel, delivery_tag, requeue)
+          buffer = @packed_indexes.dup
+          buffer << GorgonAMQ::Pack.pack_uint64_big_endian(delivery_tag)
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if requeue
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class RecoverAsync < Protocol::Method
+        @name = "basic.recover-async"
+        @method_id = 100
+        @index = 0x003C0064 # 60, 100, 3932260
+        @packed_indexes = [60, 100].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'requeue = false']
+        def self.encode(channel, requeue)
+          buffer = @packed_indexes.dup
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if requeue
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class Recover < Protocol::Method
+        @name = "basic.recover"
+        @method_id = 110
+        @index = 0x003C006E # 60, 110, 3932270
+        @packed_indexes = [60, 110].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'requeue = false']
+        def self.encode(channel, requeue)
+          buffer = @packed_indexes.dup
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if requeue
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class RecoverOk < Protocol::Method
+        @name = "basic.recover-ok"
+        @method_id = 111
+        @index = 0x003C006F # 60, 111, 3932271
+        @packed_indexes = [60, 111].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Nack < Protocol::Method
+        @name = "basic.nack"
+        @method_id = 120
+        @index = 0x003C0078 # 60, 120, 3932280
+        @packed_indexes = [60, 120].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          delivery_tag = GorgonAMQ::Pack.unpack_uint64_big_endian(data[offset, 8]).first
+          offset += 8
+          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          multiple = (bit_buffer & (1 << 0)) != 0
+          requeue = (bit_buffer & (1 << 1)) != 0
+          self.new(delivery_tag, multiple, requeue)
+        end
+
+        attr_reader :delivery_tag, :multiple, :requeue
+        def initialize(delivery_tag, multiple, requeue)
+          @delivery_tag = delivery_tag
+          @multiple = multiple
+          @requeue = requeue
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'delivery_tag = false', u'multiple = false', u'requeue = true']
+        def self.encode(channel, delivery_tag, multiple, requeue)
+          buffer = @packed_indexes.dup
+          buffer << GorgonAMQ::Pack.pack_uint64_big_endian(delivery_tag)
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if multiple
+          bit_buffer = bit_buffer | (1 << 1) if requeue
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+    end
+
+    class Tx < Protocol::Class
+      @name = "tx"
+      @method_id = 90
+
+
+
+      class Select < Protocol::Method
+        @name = "tx.select"
+        @method_id = 10
+        @index = 0x005A000A # 90, 10, 5898250
+        @packed_indexes = [90, 10].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # []
+        def self.encode(channel)
+          buffer = @packed_indexes.dup
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class SelectOk < Protocol::Method
+        @name = "tx.select-ok"
+        @method_id = 11
+        @index = 0x005A000B # 90, 11, 5898251
+        @packed_indexes = [90, 11].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Commit < Protocol::Method
+        @name = "tx.commit"
+        @method_id = 20
+        @index = 0x005A0014 # 90, 20, 5898260
+        @packed_indexes = [90, 20].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # []
+        def self.encode(channel)
+          buffer = @packed_indexes.dup
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class CommitOk < Protocol::Method
+        @name = "tx.commit-ok"
+        @method_id = 21
+        @index = 0x005A0015 # 90, 21, 5898261
+        @packed_indexes = [90, 21].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+      class Rollback < Protocol::Method
+        @name = "tx.rollback"
+        @method_id = 30
+        @index = 0x005A001E # 90, 30, 5898270
+        @packed_indexes = [90, 30].pack(PACK_UINT16_X2).freeze
+
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # []
+        def self.encode(channel)
+          buffer = @packed_indexes.dup
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class RollbackOk < Protocol::Method
+        @name = "tx.rollback-ok"
+        @method_id = 31
+        @index = 0x005A001F # 90, 31, 5898271
+        @packed_indexes = [90, 31].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+
+      end
+
+    end
+
+    class Confirm < Protocol::Class
+      @name = "confirm"
+      @method_id = 85
+
+
+
+      class Select < Protocol::Method
+        @name = "confirm.select"
+        @method_id = 10
+        @index = 0x0055000A # 85, 10, 5570570
+        @packed_indexes = [85, 10].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
+          offset += 1
+          nowait = (bit_buffer & (1 << 0)) != 0
+          self.new(nowait)
+        end
+
+        attr_reader :nowait
+        def initialize(nowait)
+          @nowait = nowait
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # [u'nowait = false']
+        def self.encode(channel, nowait)
+          buffer = @packed_indexes.dup
+          bit_buffer = 0
+          bit_buffer = bit_buffer | (1 << 0) if nowait
+          buffer << [bit_buffer].pack(PACK_CHAR)
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+      class SelectOk < Protocol::Method
+        @name = "confirm.select-ok"
+        @method_id = 11
+        @index = 0x0055000B # 85, 11, 5570571
+        @packed_indexes = [85, 11].pack(PACK_UINT16_X2).freeze
+
+        # @return
+        def self.decode(data)
+          offset = 0
+          self.new()
+        end
+
+        def initialize()
+        end
+
+        def self.has_content?
+          false
+        end
+
+        # @return
+        # []
+        def self.encode(channel)
+          buffer = @packed_indexes.dup
+          MethodFrame.new(buffer, channel)
+        end
+
+      end
+
+    end
+
+
+    METHODS = begin
+      Method.methods.inject(Hash.new) do |hash, klass|
+        hash.merge!(klass.index => klass)
+      end
+    end
+  end
+end
+