amqp 0.7.5 → 0.8.0.beta1

data/lib/amqp/collection.rb

@@ -1,60 +0,0 @@
-# encoding: utf-8
-
-module AMQP
-  # AMQP::Collection is used to store named AMQ model entities (exchanges, queues)
-  class Collection < ::Array
-    class IncompatibleItemError < ArgumentError
-      def initialize(item)
-        super("Instance of #{item.class} doesn't respond to #name!")
-      end
-    end
-
-    def [](name)
-      self.find do |object|
-        object.name == name
-      end
-    end
-
-    # Collection#[]= doesn't really make any sense, as we can't
-    # redefine already existing Queues and Exchanges (we can declare
-    # them multiple times, but if the queue resp. exchange is already
-    # in the collection, it doesn't make sense to do so and we can't
-    # run declare twice in order to change options, because the AMQP
-    # broker closes the connection if we try to do so).
-
-    # Use Collection# << for adding items to the collection.
-    undef_method :[]=
-
-    def <<(item)
-      if (item.name rescue nil).nil? || !self[item.name]
-        self.add!(item)
-      end
-
-      # We can't just return the item, because in case the item isn't added
-      # to the collection, then it'd be different from self[item.name].
-      return self[item.name]
-    end
-
-    alias_method :__push__, :push
-    alias_method :push, :<<
-
-    def add!(item)
-      unless item.respond_to?(:name)
-        raise IncompatibleItemError.new(item)
-      end
-
-      __push__(item)
-      return item
-    end
-
-    def include?(name)
-      not self[name].nil?
-    end
-
-    def delete(name)
-      if self.include?(name)
-        self.delete_at(self.index(self[name]))
-      end
-    end
-  end
-end

data/lib/amqp/frame.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-
-require "amqp/spec"
-require "amqp/buffer"
-require "amqp/protocol"
-
-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

data/lib/amqp/protocol.rb

@@ -1,163 +0,0 @@
-# encoding: utf-8
-
-require "amqp/spec"
-require "amqp/buffer"
-
-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

data/lib/amqp/server.rb

@@ -1,101 +0,0 @@
-# encoding: utf-8
-
-require "amqp/frame"
-
-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/ruby-amqp/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/amqp/spec.rb

@@ -1,832 +0,0 @@
-
-#:stopdoc:
-# this file was autogenerated on 2011-07-25 08:34:44 +0100
-# using amqp-0.8.json    (mtime: 2011-07-25 08:30:58 +0100)
-#
-# 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.to_s 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.to_s 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