amq-protocol 0.0.1.pre → 0.5.0

data/examples/00_manual_test.rb

@@ -1,60 +1,139 @@
-# encoding: binary
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+# Usage:
+#   ./examples/00_manual_test.rb
+#   ./examples/00_manual_test.rb 5673
 
 require "socket"
-require_relative "../lib/amq/protocol.rb"
+require_relative "../lib/amq/protocol/client.rb"
 
 include AMQ::Protocol
 
-socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-sockaddr = Socket.pack_sockaddr_in((ARGV.first || 5672).to_i, "127.0.0.1") # NOTE: this doesn't work with "localhost", I don't know why.
+# Stolen from amq-client:
+class AMQ::Protocol::Frame
+  def self.decode(io)
+    header = io.read(7)
+    type, channel, size = self.decode_header(header)
+    data = io.read(size + 1)
+    payload, frame_end = data[0..-2], data[-1]
 
-begin
-  socket.connect(sockaddr)
-rescue Errno::ECONNREFUSED
-  abort "Don't forget to start an AMQP broker first!"
+    if frame_end != FINAL_OCTET
+      raise "Frame has to end with #{FINAL_OCTET.inspect}!"
+    end
+
+    self.new(type, payload, channel)
+  end
 end
 
-# helpers
-MethodFrame.encode(:method, 0, Connection::TuneOk.encode(0, 131072, 0))
+# NOTE: this doesn't work with "localhost", I don't know why:
+socket   = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+sockaddr = Socket.pack_sockaddr_in((ARGV.first || 5672).to_i, "127.0.0.1")
 
+# helpers
 def socket.encode(klass, *args)
   STDERR.puts "#{klass}.encode(#{args.inspect[1..-2]})"
-  klass.encode(*args).tap do |result|
-    STDERR.puts "=> #{result.inspect}"
-    STDERR.puts "MethodFrame.encode(:method, 0, #{result.inspect})"
-    STDERR.puts "=> #{MethodFrame.encode(:method, 0, result).inspect}\n\n"
-    self.write(MethodFrame.encode(:method, 0, result))
+  result = klass.encode(*args)
+  STDERR.puts "=> #{result}"
+  if result.is_a?(Frame)
+    self.write(result.encode)
+  else
+    data = result.inject("") do |buffer, frame|
+      self.write(frame.encode) ###
+      buffer += frame.encode
+    end
+    # self.write(data)
   end
 end
 
 def socket.decode
-  frame = MethodFrame.decode(self)
-  STDERR.puts "MethodFrame.decode(#{self.inspect})"
-  STDERR.puts "=> #{frame.inspect}\n\n"
+  frame = Frame.decode(self)
+  STDERR.puts "Frame.decode(#{self.inspect})"
+  STDERR.puts "=> #{frame.inspect}"
+  STDERR.puts "frame.decode_payload"
+  STDERR.puts "=> #{res = frame.decode_payload}\n\n"
+  return res
+end
+
+begin
+  socket.connect(sockaddr)
+rescue Errno::ECONNREFUSED
+  abort "Don't forget to start an AMQP broker first!"
 end
 
-# AMQP preamble
-puts "Sending AMQP preamble (#{AMQ::Protocol::PREAMBLE.inspect})\n\n"
-socket.write AMQ::Protocol::PREAMBLE
+begin
+  # AMQP preamble
+  puts "Sending AMQP preamble (#{AMQ::Protocol::PREAMBLE.inspect})\n\n"
+  socket.write AMQ::Protocol::PREAMBLE
+
+  # Connection.Start/Connection.Start-Ok
+  connection_start_response = socket.decode
+  socket.encode Connection::StartOk, {client: "AMQ Protocol"}, "PLAIN", "\0guest\0guest", "en_GB"
+
+  # Connection.Tune/Connection.Tune-Ok
+  connection_tune_response = socket.decode
+  channel_max = connection_tune_response.channel_max
+  frame_max   = connection_tune_response.frame_max
+  heartbeat   = connection_tune_response.heartbeat
+  socket.encode Connection::TuneOk, channel_max, frame_max, heartbeat
+  puts "Max agreed frame size: #{frame_max}"
+
+  # Connection.Open/Connection.Open-Ok
+  socket.encode Connection::Open, "/"
+  connection_open_ok_response = socket.decode
+
+  begin
+    # Channel.Open/Channel.Open-Ok
+    socket.encode Channel::Open, 1, ""
+    channel_open_ok_response = socket.decode
 
-# Start/Start-Ok
-socket.decode
-socket.encode Connection::StartOk, {client: "AMQ Protocol"}, "PLAIN", "guest\0guest\0", "en_GB"
+    begin
+      # Exchange.Declare/Exchange.Declare-Ok
+      socket.encode Exchange::Declare, 1, "tasks", "fanout", false, false, false, false, false, {}
+      exchange_declare_ok_response = socket.decode
 
-# Tune/Tune-Ok
-socket.decode
-socket.encode Connection::TuneOk, 0, 131072, 0
+      # Queue.Declare/Queue.Declare-Ok
+      socket.encode Queue::Declare, 1, "", false, false, false, false, false, {}
+      queue_declare_ok_response = socket.decode
 
-# Close
-# socket.encode Connection::Close
-# socket.decode
+      puts "Queue name: #{queue_declare_ok_response.queue.inspect}"
 
-socket.close
+      # Queue.Bind/Queue.Bind-Ok
+      socket.encode Queue::Bind, 1, queue_declare_ok_response.queue, "tasks", "", false, {}
+      queue_bind_ok_response = socket.decode
 
-__END__
-[CLIENT] conn#4 ch#0 -> {#method<connection.start-ok>(client-properties={product=AMQP, information=http://github.com/tmm1/amqp, platform=Ruby/EventMachine, version=0.6.7},mechanism=AMQPLAIN,response=LOGINSguesPASSWORDSguest,locale=en_US),null,""}
-[SERVER] conn#4 ch#0 <- {#method<connection.start>(version-major=8,version-minor=0,server properties={product=RabbitMQ, information=Licensed under the MPL.  See http://www.rabbitmq.com/, platform=Erlang/OTP, copyright=Copyright (C) 2007-2010 LShift Ltd., Cohesive Financial Technologies LLC., and Rabbit Technologies Ltd., version=2.1.0},mechanisms=PLAIN AMQPLAIN,locales=en_US),null,""}
-[SERVER] conn#4 ch#0 <- {#method<connection.tune>(channel-max=0,frame-max=131072,heartbeat=0),null,""}
-[CLIENT] conn#4 ch#0 -> {#method<connection.tune-ok>(channel-max=0,frame-max=131072,heartbeat=0),null,""}
-[CLIENT] conn#4 ch#0 -> {#method<connection.open>(virtual-host=/,capabilities=,insist=false),null,""}
-[SERVER] conn#4 ch#0 <- {#method<connection.open-ok>(known-hosts=),null,""}
+      # Basic.Consume
+      socket.encode Basic::Consume, 1, queue_declare_ok_response.queue, "", false, false, false, false, Hash.new
+
+      # Basic.Publish
+      socket.encode Basic::Publish, 1, "this is a payload", {content_type: "text/plain"}, "tasks", "", false, false, frame_max
+
+      # Basic.Consume-Ok
+      basic_consume_ok_response = socket.decode
+      puts "Consumed successfully, consumer tag: #{basic_consume_ok_response.consumer_tag}"
+
+      # Basic.Deliver
+      basic_deliver        = socket.decode
+      basic_deliver_header = socket.decode # header frame: {}
+      basic_deliver_body   = socket.decode # body frame: "this is a payload"
+      puts "[Received] headers: #{basic_deliver_header.inspect}, payload: #{basic_deliver_body.inspect}"
+    ensure
+      # Channel.Close/Channel.Close-Ok
+      socket.encode Channel::Close, 1, 200, "bye", 0, 0
+      channel_close_ok_response = socket.decode
+    end
+  ensure
+    # Connection.Close/Connection.Close-Ok
+    socket.encode Connection::Close, 200, "", 0, 0
+    close_ok_response = socket.decode
+  end
+rescue Exception => exception
+  STDERR.puts "\n\e[1;31m[#{exception.class}] #{exception.message}\e[0m"
+  exception.backtrace.each do |line|
+    line = "\e[0;36m#{line}\e[0m" if line.match(Regexp::quote(File.basename(__FILE__)))
+    STDERR.puts "  - " + line
+  end
+  exit 1 # Yes, this works with the ensure block, even though the rescue block run first. Magic.
+ensure
+  socket.close
+end

data/irb.rb

@@ -1,9 +1,81 @@
 #!/usr/bin/env ruby
-# encoding: utf-8
+# encoding: binary
+
+# This file is supposed to make inspecting AMQ protocol easier.
+
+# How does it work:
+# 1) This file is executed.
+# 2) We load irb, redefine where IRB looks for .irbrc and start IRB.
+# 3) IRB loads .irbrc, which we redefined, so it loads this file again.
+#    However now the second branch of "if __FILE__ == $0" gets executed,
+#    so it runs our custom code which loads the original .irbrc and then
+#    it redefines some IRB settings. In this case it add IRB hook which
+#    is executed after IRB is started.
+
+# Although it looks unnecessarily complicated, I can't see any easier
+# solution to this problem in case that you need to patch original settings.
+# Obviously in case you don't have the need, you'll be happy with simple:
+
+# require "irb"
+#
+# require_relative "lib/amq/protocol/client.rb"
+# include AMQ::Protocol
+#
+# IRB.start(__FILE__)
 
 require "irb"
-require_relative "lib/amq/protocol.rb"
 
-include AMQ::Protocol
+if __FILE__ == $0
+  puts "~ Using #{__FILE__} as an executable ..."
+
+
+  def IRB.rc_file_generators
+    yield Proc.new { |_| __FILE__ }
+  end
+
+  IRB.start(__FILE__)
+else
+  begin
+    irbrc = File.join(ENV["HOME"], ".irbrc")
+    puts "~ Using #{__FILE__} as a custom .irbrc .."
+    puts "~ Loading original #{irbrc} ..."
+    load irbrc
+
+    file = ENV["FILE"] || "client"
+    require_relative "lib/amq/protocol/#{file}.rb"
+    include AMQ::Protocol
+
+    begin
+      require "amq/client/io/string"
+
+      class AMQ::Protocol::Frame
+        def self.decode(string)
+          AMQ::Client::StringAdapter::Frame.decode(string)
+        end
+      end
+    rescue LoadError
+      warn "~ AMQ Client isn't available."
+    end
+
+    # "0123456789".chunks(1, 1, 2, 3)
+    # => ["0", "1", "23", "456"]
+    class String
+      def chunks(*parts)
+        offset = 0
+        parts.map do |number_of_characters|
+          self[offset..(offset + number_of_characters - 1)].tap do
+            offset += number_of_characters
+          end
+        end << self[offset..-1]
+      end
+    end
+
+    require "stringio"
 
-IRB.start(__FILE__)
+    def fd(data)
+      Frame.decode(StringIO.new(data))
+    end
+  rescue Exception => exception # it just discards all the exceptions!
+    abort exception.message + "\n  - " + exception.backtrace.join("\n  - ")
+  end
+end

data/lib/amq/hacks.rb

@@ -0,0 +1,33 @@
+# encoding: binary
+
+# Ruby doesn't support pack to/unpack from
+# 64bit string in network byte order.
+module AMQ
+  module Hacks
+    BIG_ENDIAN = ([1].pack("s") == "\x00\x01")
+    Q = "Q".freeze
+
+    if BIG_ENDIAN
+      def self.pack_64_big_endian(long_long)
+        [long_long].pack(Q)
+      end
+
+      def self.unpack_64_big_endian(data)
+        data.unpack(Q)
+      end
+    else
+      def self.pack_64_big_endian(long_long)
+        result = [long_long].pack(Q)
+        result.chars.to_a.reverse.join
+      end
+
+      def self.unpack_64_big_endian(data)
+        data = data.chars.to_a.reverse.join
+        data.unpack(Q)
+      end
+    end
+  end
+end
+
+# AMQ::Hacks.pack_64_big_endian(17)
+# AMQ::Hacks.unpack_64_big_endian("\x00\x00\x00\x00\x00\x00\x00\x11")

data/lib/amq/protocol.rb

@@ -1,1473 +1,4 @@
-# encoding: binary
+# -*- coding: utf-8 -*-
 
-# 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
+require "amq/protocol/version"
+require "amq/protocol/client"