right_amqp 0.2.0

data/lib/right_amqp/amqp/frame.rb

@@ -0,0 +1,124 @@
+require File.expand_path('../spec', __FILE__)
+require File.expand_path('../buffer', __FILE__)
+require File.expand_path('../protocol', __FILE__)
+
+module AMQP
+  class Frame #:nodoc: all
+    def initialize payload = nil, channel = 0
+      @channel, @payload = channel, payload
+    end
+    attr_accessor :channel, :payload
+
+    def id
+      self.class::ID
+    end
+    
+    def to_binary
+      buf = Buffer.new
+      buf.write :octet, id
+      buf.write :short, channel
+      buf.write :longstr, payload
+      buf.write :octet, FOOTER
+      buf.rewind
+      buf
+    end
+
+    def to_s
+      to_binary.to_s
+    end
+
+    def == frame
+      [ :id, :channel, :payload ].inject(true) do |eql, field|
+        eql and __send__(field) == frame.__send__(field)
+      end
+    end
+    
+    class Invalid < StandardError; end
+    
+    class Method
+      def initialize payload = nil, channel = 0
+        super
+        unless @payload.is_a? Protocol::Class::Method or @payload.nil?
+          @payload = Protocol.parse(@payload)
+        end
+      end
+    end
+
+    class Header
+      def initialize payload = nil, channel = 0
+        super
+        unless @payload.is_a? Protocol::Header or @payload.nil?
+          @payload = Protocol::Header.new(@payload)
+        end
+      end
+    end
+
+    class Body; end
+
+    def self.parse buf
+      buf = Buffer.new(buf) unless buf.is_a? Buffer
+      buf.extract do
+        id, channel, payload, footer = buf.read(:octet, :short, :longstr, :octet)
+        Frame.types[id].new(payload, channel) if footer == FOOTER
+      end
+    end
+  end
+end
+
+if $0 =~ /bacon/ or $0 == __FILE__
+  require 'bacon'
+  include AMQP
+
+  describe Frame do
+    should 'handle basic frame types' do
+      Frame::Method.new.id.should == 1
+      Frame::Header.new.id.should == 2
+      Frame::Body.new.id.should == 3
+    end
+
+    should 'convert method frames to binary' do
+      meth = Protocol::Connection::Secure.new :challenge => 'secret'
+
+      frame = Frame::Method.new(meth)
+      frame.to_binary.should.be.kind_of? Buffer
+      frame.to_s.should == [ 1, 0, meth.to_s.length, meth.to_s, 206 ].pack('CnNa*C')
+    end
+
+    should 'convert binary to method frames' do
+      orig = Frame::Method.new Protocol::Connection::Secure.new(:challenge => 'secret')
+
+      copy = Frame.parse(orig.to_binary)
+      copy.should == orig
+    end
+
+    should 'ignore partial frames until ready' do
+      frame = Frame::Method.new Protocol::Connection::Secure.new(:challenge => 'secret')
+      data = frame.to_s
+
+      buf = Buffer.new
+      Frame.parse(buf).should == nil
+      
+      buf << data[0..5]
+      Frame.parse(buf).should == nil
+      
+      buf << data[6..-1]
+      Frame.parse(buf).should == frame
+      
+      Frame.parse(buf).should == nil
+    end
+
+    should 'convert header frames to binary' do
+      head = Protocol::Header.new(Protocol::Basic, :priority => 1)
+      
+      frame = Frame::Header.new(head)
+      frame.to_s.should == [ 2, 0, head.to_s.length, head.to_s, 206 ].pack('CnNa*C')
+    end
+
+    should 'convert binary to header frame' do
+      orig = Frame::Header.new Protocol::Header.new(Protocol::Basic, :priority => 1)
+      
+      copy = Frame.parse(orig.to_binary)
+      copy.should == orig
+    end
+  end
+end

data/lib/right_amqp/amqp/protocol.rb

@@ -0,0 +1,212 @@
+require File.expand_path('../spec', __FILE__)
+require File.expand_path('../buffer', __FILE__)
+
+module AMQP
+  module Protocol
+    #:stopdoc:
+    class Class::Method
+      def initialize *args
+        opts = args.pop if args.last.is_a? Hash
+        opts ||= {}
+        
+        @debug = 1 # XXX hack, p(obj) == '' if no instance vars are set
+        
+        if args.size == 1 and args.first.is_a? Buffer
+          buf = args.shift
+        else
+          buf = nil
+        end
+
+        self.class.arguments.each do |type, name|
+          val = buf ? buf.read(type) :
+                      args.shift || opts[name] || opts[name.to_s]
+          instance_variable_set("@#{name}", val)
+        end
+      end
+
+      def arguments
+        self.class.arguments.inject({}) do |hash, (type, name)|
+          hash.update name => instance_variable_get("@#{name}")
+        end
+      end
+
+      def to_binary
+        buf = Buffer.new
+        buf.write :short, self.class.section.id
+        buf.write :short, self.class.id
+
+        bits = []
+
+        self.class.arguments.each do |type, name|
+          val = instance_variable_get("@#{name}")
+          if type == :bit
+            bits << (val || false)
+          else
+            unless bits.empty?
+              buf.write :bit, bits
+              bits = []
+            end
+            buf.write type, val
+          end
+        end
+
+        buf.write :bit, bits unless bits.empty?
+        buf.rewind
+
+        buf
+      end
+      
+      def to_s
+        to_binary.to_s
+      end
+      
+      def to_frame channel = 0
+        Frame::Method.new(self, channel)
+      end
+    end
+
+    #:startdoc:
+    #
+    # Contains a properties hash that holds some potentially interesting 
+    # information.
+    # * :delivery_mode
+    # 1 equals transient.
+    # 2 equals persistent. Unconsumed persistent messages will survive
+    # a server restart when they are stored in a durable queue.
+    # * :redelivered
+    # True or False
+    # * :routing_key
+    # The routing string used for matching this message to this queue.
+    # * :priority
+    # An integer in the range of 0 to 9 inclusive.
+    # * :content_type
+    # Always "application/octet-stream" (byte stream)
+    # * :exchange
+    # The source exchange which published this message.
+    # * :message_count
+    # The number of unconsumed messages contained in the queue.
+    # * :delivery_tag
+    # A monotonically increasing integer. This number should not be trusted
+    # as a sequence number. There is no guarantee it won't get reset.
+    class Header
+      def initialize *args
+        opts = args.pop if args.last.is_a? Hash
+        opts ||= {}
+        
+        first = args.shift
+        
+        if first.is_a? ::Class and first.ancestors.include? Protocol::Class
+          @klass = first
+          @size = args.shift || 0
+          @weight = args.shift || 0
+          @properties = opts
+
+        elsif first.is_a? Buffer or first.is_a? String
+          buf = first
+          buf = Buffer.new(buf) unless buf.is_a? Buffer
+          
+          @klass = Protocol.classes[buf.read(:short)]
+          @weight = buf.read(:short)
+          @size = buf.read(:longlong)
+
+          props = buf.read(:properties, *klass.properties.map{|type,_| type })
+          @properties = Hash[*klass.properties.map{|_,name| name }.zip(props).reject{|k,v| v.nil? }.flatten]
+
+        else
+          raise ArgumentError, 'Invalid argument'
+        end
+        
+      end
+      attr_accessor :klass, :size, :weight, :properties
+      
+      def to_binary
+        buf = Buffer.new
+        buf.write :short, klass.id
+        buf.write :short, weight # XXX rabbitmq only supports weight == 0
+        buf.write :longlong, size
+        buf.write :properties, (klass.properties.map do |type, name|
+                                 [ type, properties[name] || properties[name.to_s] ]
+                               end)
+        buf.rewind
+        buf
+      end
+      
+      def to_s
+        to_binary.to_s
+      end
+
+      def to_frame channel = 0
+        Frame::Header.new(self, channel)
+      end
+
+      def == header
+        [ :klass, :size, :weight, :properties ].inject(true) do |eql, field|
+          eql and __send__(field) == header.__send__(field)
+        end
+      end
+
+      def method_missing meth, *args, &blk
+        @properties.has_key?(meth) || @klass.properties.find{|_,name| name == meth } ? @properties[meth] :
+                                                                                       super
+      end
+    end
+
+    def self.parse buf
+      buf = Buffer.new(buf) unless buf.is_a? Buffer
+      class_id, method_id = buf.read(:short, :short)
+      classes[class_id].methods[method_id].new(buf)
+    end
+    #:stopdoc:
+  end
+end
+
+if $0 =~ /bacon/ or $0 == __FILE__
+  require 'bacon'
+  include AMQP
+
+  describe Protocol do
+    should 'instantiate methods with arguments' do
+      meth = Protocol::Connection::StartOk.new nil, 'PLAIN', nil, 'en_US'
+      meth.locale.should == 'en_US'
+    end
+
+    should 'instantiate methods with named parameters' do
+      meth = Protocol::Connection::StartOk.new :locale => 'en_US',
+                                               :mechanism => 'PLAIN'
+      meth.locale.should == 'en_US'
+    end
+
+    should 'convert methods to binary' do
+      meth = Protocol::Connection::Secure.new :challenge => 'secret'
+      meth.to_binary.should.be.kind_of? Buffer
+
+      meth.to_s.should == [ 10, 20, 6, 'secret' ].pack('nnNa*')
+    end
+
+    should 'convert binary to method' do
+      orig = Protocol::Connection::Secure.new :challenge => 'secret'
+      copy = Protocol.parse orig.to_binary
+      orig.should == copy
+    end
+
+    should 'convert headers to binary' do
+      head = Protocol::Header.new Protocol::Basic,
+                                  size = 5,
+                                  weight = 0,
+                                  :content_type => 'text/json',
+                                  :delivery_mode => 1,
+                                  :priority => 1
+      head.to_s.should == [ 60, weight, 0, size, 0b1001_1000_0000_0000, 9, 'text/json', 1, 1 ].pack('nnNNnCa*CC')
+    end
+
+    should 'convert binary to header' do
+      orig = Protocol::Header.new Protocol::Basic,
+                                  size = 5,
+                                  weight = 0,
+                                  :content_type => 'text/json',
+                                  :delivery_mode => 1,
+                                  :priority => 1
+      Protocol::Header.new(orig.to_binary).should == orig
+    end
+  end
+end

data/lib/right_amqp/amqp/server.rb

@@ -0,0 +1,99 @@
+require File.expand_path('../frame', __FILE__)
+
+module AMQP
+  module Server
+    def post_init
+      @buf = ''
+      @channels = {}
+      @started = false
+    end
+
+    def receive_data data
+      @buf << data
+
+      unless @started
+        if @buf.size >= 8
+          if @buf.slice!(0,8) == "AMQP\001\001\b\000"
+            send Protocol::Connection::Start.new(
+              8,
+              0,
+              {
+                :information => 'Licensed under the Ruby license. See http://github.com/tmm1/amqp',
+                :copyright => 'Copyright (c) 2008-2009 Aman Gupta',
+                :platform => 'Ruby/EventMachine',
+                :version => '0.6.1',
+                :product => 'SquirrelMQ'
+              },
+              'PLAIN AMQPLAIN',
+              'en_US'
+            )
+          else
+            close_connection
+            return
+          end
+          @started = true
+        else
+          return
+        end
+      end
+
+      while frame = Frame.parse(@buf)
+        process_frame frame
+      end
+    end
+
+    def process_frame frame
+      channel = frame.channel
+
+      case method = frame.payload
+      when Protocol::Connection::StartOk
+        @user = method.response[:LOGIN]
+        @pass = method.response[:PASSWORD]
+        send Protocol::Connection::Tune.new(0, 131072, 0)
+
+      when Protocol::Connection::TuneOk
+        # mnnk
+
+      when Protocol::Connection::Open
+        @vhost = method.virtual_host
+        send Protocol::Connection::OpenOk.new('localhost')
+
+      when Protocol::Channel::Open
+        @channels[channel] = []
+        send Protocol::Channel::OpenOk.new, :channel => channel
+
+      when Protocol::Access::Request
+        send Protocol::Access::RequestOk.new(101)
+      end
+    end
+
+    def send data, opts = {}
+      channel = opts[:channel] ||= 0
+      data = data.to_frame(channel) unless data.is_a? Frame
+      data.channel = channel
+
+      log 'send', data
+      send_data data.to_s
+    end
+
+    def self.start host = 'localhost', port = 5672
+      EM.start_server host, port, self
+    end
+
+    private
+  
+    def log *args
+      require 'pp'
+      pp args
+      puts
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'rubygems'
+  require 'eventmachine'
+  EM.run{
+    AMQP::Server.start
+  }
+end

data/lib/right_amqp/amqp/spec.rb

@@ -0,0 +1,832 @@
+
+#:stopdoc:
+# this file was autogenerated on Mon Jan 23 15:55:36 -0800 2012
+# using amqp-0.8.json    (mtime: Mon Jan 23 15:30:40 -0800 2012)
+#
+# DO NOT EDIT! (edit protocol/codegen.rb instead, and run `rake codegen`)
+
+module AMQP
+  HEADER        = "AMQP".freeze
+  VERSION_MAJOR = 8
+  VERSION_MINOR = 0
+  PORT          = 5672
+
+  class Frame
+    def self.types
+      @types ||= {}
+    end
+
+    def self.Frame id
+      (@_base_frames ||= {})[id] ||= Class.new(Frame) do
+        class_eval %[
+          def self.inherited klass
+            klass.const_set(:ID, #{id})
+            Frame.types[#{id}] = klass
+          end
+        ]
+      end
+    end
+
+    class Method    < Frame( 1 ); end
+    class Header    < Frame( 2 ); end
+    class Body      < Frame( 3 ); end
+    class OobMethod < Frame( 4 ); end
+    class OobHeader < Frame( 5 ); end
+    class OobBody   < Frame( 6 ); end
+    class Trace     < Frame( 7 ); end
+    class Heartbeat < Frame( 8 ); end
+
+    FOOTER = 206
+  end
+
+  RESPONSES = {
+    200 => :REPLY_SUCCESS,
+    310 => :NOT_DELIVERED,
+    311 => :CONTENT_TOO_LARGE,
+    312 => :NO_ROUTE,
+    313 => :NO_CONSUMERS,
+    403 => :ACCESS_REFUSED,
+    404 => :NOT_FOUND,
+    405 => :RESOURCE_LOCKED,
+    406 => :PRECONDITION_FAILED,
+    320 => :CONNECTION_FORCED,
+    402 => :INVALID_PATH,
+  }
+
+  FIELDS = [
+    :bit,
+    :long,
+    :longlong,
+    :longstr,
+    :octet,
+    :short,
+    :shortstr,
+    :table,
+    :timestamp,
+  ]
+
+  module Protocol
+    class Class
+      class << self
+        FIELDS.each do |f|
+          class_eval %[
+            def #{f} name
+              properties << [ :#{f}, name ] unless properties.include?([:#{f}, name])
+              attr_accessor name
+            end
+          ]
+        end
+        
+        def properties() @properties ||= [] end
+
+        def id()   self::ID end
+        def name() self::NAME end
+      end
+
+      class Method
+        class << self
+          FIELDS.each do |f|
+            class_eval %[
+              def #{f} name
+                arguments << [ :#{f}, name ] unless arguments.include?([:#{f}, name])
+                attr_accessor name
+              end
+            ]
+          end
+          
+          def arguments() @arguments ||= [] end
+
+          def section() Protocol.const_get(self.to_s[/Protocol::(.+?)::/,1]) end
+          def id()      self::ID end
+          def name()    self::NAME end
+        end
+
+        def == b
+          self.class.arguments.inject(true) do |eql, (type, name)|
+            eql and __send__("#{name}") == b.__send__("#{name}")
+          end
+        end
+      end
+    
+      def self.methods() @methods ||= {} end
+    
+      def self.Method(id, name)
+        @_base_methods ||= {}
+        @_base_methods[id] ||= ::Class.new(Method) do
+          class_eval %[
+            def self.inherited klass
+              klass.const_set(:ID, #{id})
+              klass.const_set(:NAME, :#{name.to_s})
+              klass.section.methods[#{id}] = klass
+              klass.section.methods[klass::NAME] = klass
+            end
+          ]
+        end
+      end
+    end
+
+    def self.classes() @classes ||= {} end
+
+    def self.Class(id, name)
+      @_base_classes ||= {}
+      @_base_classes[id] ||= ::Class.new(Class) do
+        class_eval %[
+          def self.inherited klass
+            klass.const_set(:ID, #{id})
+            klass.const_set(:NAME, :#{name.to_s})
+            Protocol.classes[#{id}] = klass
+            Protocol.classes[klass::NAME] = klass
+          end
+        ]
+      end
+    end
+  end
+end
+  
+module AMQP
+  module Protocol
+    class Connection   < Class(  10, :connection   ); end
+    class Channel      < Class(  20, :channel      ); end
+    class Access       < Class(  30, :access       ); end
+    class Exchange     < Class(  40, :exchange     ); end
+    class Queue        < Class(  50, :queue        ); end
+    class Basic        < Class(  60, :basic        ); end
+    class File         < Class(  70, :file         ); end
+    class Stream       < Class(  80, :stream       ); end
+    class Tx           < Class(  90, :tx           ); end
+    class Dtx          < Class( 100, :dtx          ); end
+    class Tunnel       < Class( 110, :tunnel       ); end
+    class Test         < Class( 120, :test         ); end
+
+    class Connection
+
+      class Start        < Method(  10, :start          ); end
+      class StartOk      < Method(  11, :start_ok       ); end
+      class Secure       < Method(  20, :secure         ); end
+      class SecureOk     < Method(  21, :secure_ok      ); end
+      class Tune         < Method(  30, :tune           ); end
+      class TuneOk       < Method(  31, :tune_ok        ); end
+      class Open         < Method(  40, :open           ); end
+      class OpenOk       < Method(  41, :open_ok        ); end
+      class Redirect     < Method(  50, :redirect       ); end
+      class Close        < Method(  60, :close          ); end
+      class CloseOk      < Method(  61, :close_ok       ); end
+
+      class Start
+        octet      :version_major
+        octet      :version_minor
+        table      :server_properties
+        longstr    :mechanisms
+        longstr    :locales
+      end
+
+      class StartOk
+        table      :client_properties
+        shortstr   :mechanism
+        longstr    :response
+        shortstr   :locale
+      end
+
+      class Secure
+        longstr    :challenge
+      end
+
+      class SecureOk
+        longstr    :response
+      end
+
+      class Tune
+        short      :channel_max
+        long       :frame_max
+        short      :heartbeat
+      end
+
+      class TuneOk
+        short      :channel_max
+        long       :frame_max
+        short      :heartbeat
+      end
+
+      class Open
+        shortstr   :virtual_host
+        shortstr   :capabilities
+        bit        :insist
+      end
+
+      class OpenOk
+        shortstr   :known_hosts
+      end
+
+      class Redirect
+        shortstr   :host
+        shortstr   :known_hosts
+      end
+
+      class Close
+        short      :reply_code
+        shortstr   :reply_text
+        short      :class_id
+        short      :method_id
+      end
+
+      class CloseOk
+      end
+
+    end
+
+    class Channel
+
+      class Open         < Method(  10, :open           ); end
+      class OpenOk       < Method(  11, :open_ok        ); end
+      class Flow         < Method(  20, :flow           ); end
+      class FlowOk       < Method(  21, :flow_ok        ); end
+      class Alert        < Method(  30, :alert          ); end
+      class Close        < Method(  40, :close          ); end
+      class CloseOk      < Method(  41, :close_ok       ); end
+
+      class Open
+        shortstr   :out_of_band
+      end
+
+      class OpenOk
+      end
+
+      class Flow
+        bit        :active
+      end
+
+      class FlowOk
+        bit        :active
+      end
+
+      class Alert
+        short      :reply_code
+        shortstr   :reply_text
+        table      :details
+      end
+
+      class Close
+        short      :reply_code
+        shortstr   :reply_text
+        short      :class_id
+        short      :method_id
+      end
+
+      class CloseOk
+      end
+
+    end
+
+    class Access
+
+      class Request      < Method(  10, :request        ); end
+      class RequestOk    < Method(  11, :request_ok     ); end
+
+      class Request
+        shortstr   :realm
+        bit        :exclusive
+        bit        :passive
+        bit        :active
+        bit        :write
+        bit        :read
+      end
+
+      class RequestOk
+        short      :ticket
+      end
+
+    end
+
+    class Exchange
+
+      class Declare      < Method(  10, :declare        ); end
+      class DeclareOk    < Method(  11, :declare_ok     ); end
+      class Delete       < Method(  20, :delete         ); end
+      class DeleteOk     < Method(  21, :delete_ok      ); end
+
+      class Declare
+        short      :ticket
+        shortstr   :exchange
+        shortstr   :type
+        bit        :passive
+        bit        :durable
+        bit        :auto_delete
+        bit        :internal
+        bit        :nowait
+        table      :arguments
+      end
+
+      class DeclareOk
+      end
+
+      class Delete
+        short      :ticket
+        shortstr   :exchange
+        bit        :if_unused
+        bit        :nowait
+      end
+
+      class DeleteOk
+      end
+
+    end
+
+    class Queue
+
+      class Declare      < Method(  10, :declare        ); end
+      class DeclareOk    < Method(  11, :declare_ok     ); end
+      class Bind         < Method(  20, :bind           ); end
+      class BindOk       < Method(  21, :bind_ok        ); end
+      class Purge        < Method(  30, :purge          ); end
+      class PurgeOk      < Method(  31, :purge_ok       ); end
+      class Delete       < Method(  40, :delete         ); end
+      class DeleteOk     < Method(  41, :delete_ok      ); end
+      class Unbind       < Method(  50, :unbind         ); end
+      class UnbindOk     < Method(  51, :unbind_ok      ); end
+
+      class Declare
+        short      :ticket
+        shortstr   :queue
+        bit        :passive
+        bit        :durable
+        bit        :exclusive
+        bit        :auto_delete
+        bit        :nowait
+        table      :arguments
+      end
+
+      class DeclareOk
+        shortstr   :queue
+        long       :message_count
+        long       :consumer_count
+      end
+
+      class Bind
+        short      :ticket
+        shortstr   :queue
+        shortstr   :exchange
+        shortstr   :routing_key
+        bit        :nowait
+        table      :arguments
+      end
+
+      class BindOk
+      end
+
+      class Purge
+        short      :ticket
+        shortstr   :queue
+        bit        :nowait
+      end
+
+      class PurgeOk
+        long       :message_count
+      end
+
+      class Delete
+        short      :ticket
+        shortstr   :queue
+        bit        :if_unused
+        bit        :if_empty
+        bit        :nowait
+      end
+
+      class DeleteOk
+        long       :message_count
+      end
+
+      class Unbind
+        short      :ticket
+        shortstr   :queue
+        shortstr   :exchange
+        shortstr   :routing_key
+        table      :arguments
+      end
+
+      class UnbindOk
+      end
+
+    end
+
+    class Basic
+      shortstr   :content_type
+      shortstr   :content_encoding
+      table      :headers
+      octet      :delivery_mode
+      octet      :priority
+      shortstr   :correlation_id
+      shortstr   :reply_to
+      shortstr   :expiration
+      shortstr   :message_id
+      timestamp  :timestamp
+      shortstr   :type
+      shortstr   :user_id
+      shortstr   :app_id
+      shortstr   :cluster_id
+
+      class Qos          < Method(  10, :qos            ); end
+      class QosOk        < Method(  11, :qos_ok         ); end
+      class Consume      < Method(  20, :consume        ); end
+      class ConsumeOk    < Method(  21, :consume_ok     ); end
+      class Cancel       < Method(  30, :cancel         ); end
+      class CancelOk     < Method(  31, :cancel_ok      ); end
+      class Publish      < Method(  40, :publish        ); end
+      class Return       < Method(  50, :return         ); end
+      class Deliver      < Method(  60, :deliver        ); end
+      class Get          < Method(  70, :get            ); end
+      class GetOk        < Method(  71, :get_ok         ); end
+      class GetEmpty     < Method(  72, :get_empty      ); end
+      class Ack          < Method(  80, :ack            ); end
+      class Reject       < Method(  90, :reject         ); end
+      class Recover      < Method( 100, :recover        ); end
+
+      class Qos
+        long       :prefetch_size
+        short      :prefetch_count
+        bit        :global
+      end
+
+      class QosOk
+      end
+
+      class Consume
+        short      :ticket
+        shortstr   :queue
+        shortstr   :consumer_tag
+        bit        :no_local
+        bit        :no_ack
+        bit        :exclusive
+        bit        :nowait
+      end
+
+      class ConsumeOk
+        shortstr   :consumer_tag
+      end
+
+      class Cancel
+        shortstr   :consumer_tag
+        bit        :nowait
+      end
+
+      class CancelOk
+        shortstr   :consumer_tag
+      end
+
+      class Publish
+        short      :ticket
+        shortstr   :exchange
+        shortstr   :routing_key
+        bit        :mandatory
+        bit        :immediate
+      end
+
+      class Return
+        short      :reply_code
+        shortstr   :reply_text
+        shortstr   :exchange
+        shortstr   :routing_key
+      end
+
+      class Deliver
+        shortstr   :consumer_tag
+        longlong   :delivery_tag
+        bit        :redelivered
+        shortstr   :exchange
+        shortstr   :routing_key
+      end
+
+      class Get
+        short      :ticket
+        shortstr   :queue
+        bit        :no_ack
+      end
+
+      class GetOk
+        longlong   :delivery_tag
+        bit        :redelivered
+        shortstr   :exchange
+        shortstr   :routing_key
+        long       :message_count
+      end
+
+      class GetEmpty
+        shortstr   :cluster_id
+      end
+
+      class Ack
+        longlong   :delivery_tag
+        bit        :multiple
+      end
+
+      class Reject
+        longlong   :delivery_tag
+        bit        :requeue
+      end
+
+      class Recover
+        bit        :requeue
+      end
+
+    end
+
+    class File
+      shortstr   :content_type
+      shortstr   :content_encoding
+      table      :headers
+      octet      :priority
+      shortstr   :reply_to
+      shortstr   :message_id
+      shortstr   :filename
+      timestamp  :timestamp
+      shortstr   :cluster_id
+
+      class Qos          < Method(  10, :qos            ); end
+      class QosOk        < Method(  11, :qos_ok         ); end
+      class Consume      < Method(  20, :consume        ); end
+      class ConsumeOk    < Method(  21, :consume_ok     ); end
+      class Cancel       < Method(  30, :cancel         ); end
+      class CancelOk     < Method(  31, :cancel_ok      ); end
+      class Open         < Method(  40, :open           ); end
+      class OpenOk       < Method(  41, :open_ok        ); end
+      class Stage        < Method(  50, :stage          ); end
+      class Publish      < Method(  60, :publish        ); end
+      class Return       < Method(  70, :return         ); end
+      class Deliver      < Method(  80, :deliver        ); end
+      class Ack          < Method(  90, :ack            ); end
+      class Reject       < Method( 100, :reject         ); end
+
+      class Qos
+        long       :prefetch_size
+        short      :prefetch_count
+        bit        :global
+      end
+
+      class QosOk
+      end
+
+      class Consume
+        short      :ticket
+        shortstr   :queue
+        shortstr   :consumer_tag
+        bit        :no_local
+        bit        :no_ack
+        bit        :exclusive
+        bit        :nowait
+      end
+
+      class ConsumeOk
+        shortstr   :consumer_tag
+      end
+
+      class Cancel
+        shortstr   :consumer_tag
+        bit        :nowait
+      end
+
+      class CancelOk
+        shortstr   :consumer_tag
+      end
+
+      class Open
+        shortstr   :identifier
+        longlong   :content_size
+      end
+
+      class OpenOk
+        longlong   :staged_size
+      end
+
+      class Stage
+      end
+
+      class Publish
+        short      :ticket
+        shortstr   :exchange
+        shortstr   :routing_key
+        bit        :mandatory
+        bit        :immediate
+        shortstr   :identifier
+      end
+
+      class Return
+        short      :reply_code
+        shortstr   :reply_text
+        shortstr   :exchange
+        shortstr   :routing_key
+      end
+
+      class Deliver
+        shortstr   :consumer_tag
+        longlong   :delivery_tag
+        bit        :redelivered
+        shortstr   :exchange
+        shortstr   :routing_key
+        shortstr   :identifier
+      end
+
+      class Ack
+        longlong   :delivery_tag
+        bit        :multiple
+      end
+
+      class Reject
+        longlong   :delivery_tag
+        bit        :requeue
+      end
+
+    end
+
+    class Stream
+      shortstr   :content_type
+      shortstr   :content_encoding
+      table      :headers
+      octet      :priority
+      timestamp  :timestamp
+
+      class Qos          < Method(  10, :qos            ); end
+      class QosOk        < Method(  11, :qos_ok         ); end
+      class Consume      < Method(  20, :consume        ); end
+      class ConsumeOk    < Method(  21, :consume_ok     ); end
+      class Cancel       < Method(  30, :cancel         ); end
+      class CancelOk     < Method(  31, :cancel_ok      ); end
+      class Publish      < Method(  40, :publish        ); end
+      class Return       < Method(  50, :return         ); end
+      class Deliver      < Method(  60, :deliver        ); end
+
+      class Qos
+        long       :prefetch_size
+        short      :prefetch_count
+        long       :consume_rate
+        bit        :global
+      end
+
+      class QosOk
+      end
+
+      class Consume
+        short      :ticket
+        shortstr   :queue
+        shortstr   :consumer_tag
+        bit        :no_local
+        bit        :exclusive
+        bit        :nowait
+      end
+
+      class ConsumeOk
+        shortstr   :consumer_tag
+      end
+
+      class Cancel
+        shortstr   :consumer_tag
+        bit        :nowait
+      end
+
+      class CancelOk
+        shortstr   :consumer_tag
+      end
+
+      class Publish
+        short      :ticket
+        shortstr   :exchange
+        shortstr   :routing_key
+        bit        :mandatory
+        bit        :immediate
+      end
+
+      class Return
+        short      :reply_code
+        shortstr   :reply_text
+        shortstr   :exchange
+        shortstr   :routing_key
+      end
+
+      class Deliver
+        shortstr   :consumer_tag
+        longlong   :delivery_tag
+        shortstr   :exchange
+        shortstr   :queue
+      end
+
+    end
+
+    class Tx
+
+      class Select       < Method(  10, :select         ); end
+      class SelectOk     < Method(  11, :select_ok      ); end
+      class Commit       < Method(  20, :commit         ); end
+      class CommitOk     < Method(  21, :commit_ok      ); end
+      class Rollback     < Method(  30, :rollback       ); end
+      class RollbackOk   < Method(  31, :rollback_ok    ); end
+
+      class Select
+      end
+
+      class SelectOk
+      end
+
+      class Commit
+      end
+
+      class CommitOk
+      end
+
+      class Rollback
+      end
+
+      class RollbackOk
+      end
+
+    end
+
+    class Dtx
+
+      class Select       < Method(  10, :select         ); end
+      class SelectOk     < Method(  11, :select_ok      ); end
+      class Start        < Method(  20, :start          ); end
+      class StartOk      < Method(  21, :start_ok       ); end
+
+      class Select
+      end
+
+      class SelectOk
+      end
+
+      class Start
+        shortstr   :dtx_identifier
+      end
+
+      class StartOk
+      end
+
+    end
+
+    class Tunnel
+      table      :headers
+      shortstr   :proxy_name
+      shortstr   :data_name
+      octet      :durable
+      octet      :broadcast
+
+      class Request      < Method(  10, :request        ); end
+
+      class Request
+        table      :meta_data
+      end
+
+    end
+
+    class Test
+
+      class Integer      < Method(  10, :integer        ); end
+      class IntegerOk    < Method(  11, :integer_ok     ); end
+      class String       < Method(  20, :string         ); end
+      class StringOk     < Method(  21, :string_ok      ); end
+      class Table        < Method(  30, :table          ); end
+      class TableOk      < Method(  31, :table_ok       ); end
+      class Content      < Method(  40, :content        ); end
+      class ContentOk    < Method(  41, :content_ok     ); end
+
+      class Integer
+        octet      :integer_1
+        short      :integer_2
+        long       :integer_3
+        longlong   :integer_4
+        octet      :operation
+      end
+
+      class IntegerOk
+        longlong   :result
+      end
+
+      class String
+        shortstr   :string_1
+        longstr    :string_2
+        octet      :operation
+      end
+
+      class StringOk
+        longstr    :result
+      end
+
+      class Table
+        table      :table
+        octet      :integer_op
+        octet      :string_op
+      end
+
+      class TableOk
+        longlong   :integer_result
+        longstr    :string_result
+      end
+
+      class Content
+      end
+
+      class ContentOk
+        long       :content_checksum
+      end
+
+    end
+
+  end
+end