amq-protocol 2.3.3 → 2.8.0

data/codegen/protocol.rb.pytemplate

@@ -1,320 +0,0 @@
-# encoding: utf-8
-# encoding: binary
-# frozen_string_literal: true
-
-# THIS IS AN AUTOGENERATED FILE, DO NOT MODIFY
-# IT DIRECTLY ! FOR CHANGES, PLEASE UPDATE FILES
-# IN THE ./codegen DIRECTORY OF THE AMQ-PROTOCOL REPOSITORY.<% import codegen_helpers as helpers %><% import re, os, codegen %>
-
-require "amq/pack"
-
-require "amq/protocol/table"
-require "amq/protocol/frame"
-
-require "amq/protocol/constants"
-require "amq/protocol/exceptions"
-
-module AMQ
-  module Protocol
-    PROTOCOL_VERSION = "${spec.major}.${spec.minor}.${spec.revision}".freeze
-    PREAMBLE         = "${'AMQP\\x00\\x%02x\\x%02x\\x%02x' % (spec.major, spec.minor, spec.revision)}".freeze
-    DEFAULT_PORT     = ${spec.port}
-
-    # @return [Array] Collection of subclasses of AMQ::Protocol::Class.
-    def self.classes
-      Protocol::Class.classes
-    end
-
-    # @return [Array] Collection of subclasses of AMQ::Protocol::Method.
-    def self.methods
-      Protocol::Method.methods
-    end
-
-    % for tuple in spec.constants:
-    % if tuple[2] == "soft-error" or tuple[2] == "hard-error":
-    class ${codegen.to_ruby_class_name(tuple[0])} < ${codegen.to_ruby_class_name(tuple[2])}
-      VALUE = ${tuple[1]}
-    end
-
-    % endif
-    % endfor
-
-    class Class
-      @classes = Array.new
-
-      def self.method_id
-        @method_id
-      end
-
-      def self.name
-        @name
-      end
-
-      def self.inherited(base)
-        if self == Protocol::Class
-          @classes << base
-        end
-      end
-
-      def self.classes
-        @classes
-      end
-    end
-
-    class Method
-      @methods = Array.new
-      def self.method_id
-        @method_id
-      end
-
-      def self.name
-        @name
-      end
-
-      def self.index
-        @index
-      end
-
-      def self.inherited(base)
-        if self == Protocol::Method
-          @methods << base
-        end
-      end
-
-      def self.methods
-        @methods
-      end
-
-      def self.split_headers(user_headers)
-        properties, headers = {}, {}
-        user_headers.each do |key, value|
-          # key MUST be a symbol since symbols are not garbage-collected
-          if Basic::PROPERTIES.include?(key)
-            properties[key] = value
-          else
-            headers[key] = value
-          end
-        end
-
-        return [properties, headers]
-      end
-
-      def self.encode_body(body, channel, frame_size)
-        return [] if body.empty?
-
-        # 8 = 1 + 2 + 4 + 1
-        # 1 byte of frame type
-        # 2 bytes of channel number
-        # 4 bytes of frame payload length
-        # 1 byte of payload trailer FRAME_END byte
-        limit        = frame_size - 8
-        return [BodyFrame.new(body, channel)] if body.bytesize < limit
-
-        # Otherwise String#slice on 1.9 will operate with code points,
-        # and we need bytes. MK.
-        body.force_encoding("ASCII-8BIT") if RUBY_VERSION.to_f >= 1.9
-
-        array = Array.new
-        while body && !body.empty?
-          payload, body = body[0, limit], body[limit, body.length - limit]
-          array << BodyFrame.new(payload, channel)
-        end
-
-        array
-      end
-
-      def self.instantiate(*args, &block)
-        self.new(*args, &block)
-      end
-    end
-
-    % for klass in spec.classes :
-    class ${klass.constant_name} < Protocol::Class
-      @name = "${klass.name}"
-      @method_id = ${klass.index}
-
-      % if klass.fields: ## only the Basic class has fields (refered as properties in the JSON)
-      PROPERTIES = [
-      % for field in klass.fields:
-        :${field.ruby_name}, # ${spec.resolveDomain(field.domain)}
-        % endfor
-      ]
-
-      % for f in klass.fields:
-      # <% i = klass.fields.index(f) %>1 << ${15 - i}
-      def self.encode_${f.ruby_name}(value)
-        buffer = +''
-        % for line in helpers.genSingleEncode(spec, "value", f.domain):
-        ${line}
-        % endfor
-        [${i}, ${"0x%04x" % ( 1 << (15-i),)}, buffer]
-      end
-
-      % endfor
-
-      % endif
-
-      % if klass.name == "basic" :
-      def self.encode_properties(body_size, properties)
-        pieces, flags = [], 0
-
-        properties.reject {|key, value| value.nil?}.each do |key, value|
-          i, f, result = self.__send__(:"encode_#{key}", value)
-          flags |= f
-          pieces[i] = result
-        end
-
-        # result = [${klass.index}, 0, body_size, flags].pack('n2Qn')
-        result = [${klass.index}, 0].pack(PACK_UINT16_X2)
-        result += AMQ::Pack.pack_uint64_big_endian(body_size)
-        result += [flags].pack(PACK_UINT16)
-        pieces_joined = pieces.join(EMPTY_STRING)
-        result.force_encoding(pieces_joined.encoding) + pieces_joined
-      end
-
-      # THIS DECODES ONLY FLAGS
-      DECODE_PROPERTIES = {
-        % for f in klass.fields:
-        ${"0x%04x" % ( 1 << (15 - klass.fields.index(f)),)} => :${f.ruby_name},
-        % endfor
-      }
-
-      DECODE_PROPERTIES_TYPE = {
-        % for f in klass.fields:
-        ${"0x%04x" % ( 1 << (15 - klass.fields.index(f)),)} => :${spec.resolveDomain(f.domain)},
-        % endfor
-      }
-
-      # Hash doesn't give any guarantees on keys order, we will do it in a
-      # straightforward way
-      DECODE_PROPERTIES_KEYS = [
-        % for f in klass.fields:
-        ${"0x%04x" % ( 1 << (15 - klass.fields.index(f)),)},
-        % endfor
-      ]
-
-      def self.decode_properties(data)
-        offset, data_length, properties = 0, data.bytesize, {}
-
-        compressed_index = data[offset, 2].unpack(PACK_UINT16)[0]
-        offset += 2
-        while data_length > offset
-          DECODE_PROPERTIES_KEYS.each do |key|
-            next unless compressed_index >= key
-            compressed_index -= key
-            name = DECODE_PROPERTIES[key] || raise(RuntimeError.new("No property found for index #{index.inspect}!"))
-            case DECODE_PROPERTIES_TYPE[key]
-            when :shortstr
-              size = data[offset, 1].unpack(PACK_CHAR)[0]
-              offset += 1
-              result = data[offset, size]
-            when :octet
-              size = 1
-              result = data[offset, size].unpack(PACK_CHAR).first
-            when :timestamp
-              size = 8
-              result = Time.at(data[offset, size].unpack(PACK_UINT64_BE).last)
-            when :table
-              size = 4 + data[offset, 4].unpack(PACK_UINT32)[0]
-              result = Table.decode(data[offset, size])
-            end
-            properties[name] = result
-            offset += size
-          end
-        end
-
-        properties
-      end
-      % endif
-
-      % for method in klass.methods:
-      class ${method.constant_name} < Protocol::Method
-        @name = "${klass.name}.${method.name}"
-        @method_id = ${method.index}
-        @index = ${method.binary()}
-        @packed_indexes = [${klass.index}, ${method.index}].pack(PACK_UINT16_X2).freeze
-
-        % if (spec.type == "client" and method.accepted_by("client")) or (spec.type == "server" and method.accepted_by("server") or spec.type == "all"):
-        # @return
-        def self.decode(data)
-          offset = offset = 0 # self-assigning offset to eliminate "assigned but unused variable" warning even if offset is not used in this method
-          % for line in helpers.genDecodeMethodDefinition(spec, method):
-          ${line}
-          % endfor
-          % if (method.klass.name == "connection" or method.klass.name == "channel") and method.name == "close":
-          self.new(${', '.join([f.ruby_name for f in method.arguments])})
-          % else:
-          self.new(${', '.join([f.ruby_name for f in method.arguments])})
-          % endif
-        end
-
-        % if len(method.arguments) > 0:
-        attr_reader ${', '.join([":" + f.ruby_name for f in method.arguments])}
-        % endif
-        def initialize(${', '.join([f.ruby_name for f in method.arguments])})
-          % for f in method.arguments:
-          @${f.ruby_name} = ${f.ruby_name}
-          % endfor
-        end
-        % endif
-
-        def self.has_content?
-          % if method.hasContent:
-          true
-          % else:
-          false
-          % endif
-        end
-
-        % if (spec.type == "client" and method.accepted_by("server")) or (spec.type == "server" and method.accepted_by("client")) or spec.type == "all":
-        # @return
-        # ${method.params()}
-        % if klass.name == "connection":
-        def self.encode(${(", ").join(method.not_ignored_args())})
-        % else:
-        def self.encode(${(", ").join(["channel"] + method.not_ignored_args())})
-        % endif
-          % for argument in method.ignored_args():
-          ${codegen.convert_to_ruby(argument)}
-          % endfor
-          % if klass.name == "connection":
-          channel = 0
-          % endif
-          buffer = @packed_indexes.dup
-          % for line in helpers.genEncodeMethodDefinition(spec, method):
-          ${line}
-          % endfor
-          % if "payload" in method.args() or "user_headers" in method.args():
-          frames = [MethodFrame.new(buffer, channel)]
-          % if "user_headers" in method.args():
-          properties, _headers = self.split_headers(user_headers)
-          if properties.nil? or properties.empty?
-            raise RuntimeError.new("Properties can not be empty!")
-          end
-          properties_payload = Basic.encode_properties(payload.bytesize, properties)
-          frames << HeaderFrame.new(properties_payload, channel)
-          % endif
-          % if "payload" in method.args():
-          frames += self.encode_body(payload, channel, frame_size)
-          frames
-          % endif
-          % else:
-          MethodFrame.new(buffer, channel)
-          % endif
-        end
-        % endif
-
-      end
-
-      % endfor
-    end
-
-    % endfor
-
-    METHODS = begin
-      Method.methods.inject(Hash.new) do |hash, klass|
-        hash.merge!(klass.index => klass)
-      end
-    end
-  end
-end

data/generate.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-# rabbitmq-codegen is Python 3 compatible and so is
-# the code in this repo but Mako still fails with 3.6 as of May 2017 :( MK.
-python = ENV.fetch("PYTHON", "python2")
-
-def sh(*args)
-  system(*args)
-end
-
-extensions = []
-
-spec = "codegen/rabbitmq-codegen/amqp-rabbitmq-0.9.1.json"
-unless File.exist?(spec)
-  sh "git submodule update --init"
-end
-
-path = "lib/amq/protocol/client.rb"
-puts "Running '#{python} ./codegen/codegen.py client #{spec} #{extensions.join(' ')} #{path}'"
-sh "#{python} ./codegen/codegen.py client #{spec} #{extensions.join(' ')} #{path}"
-if File.file?(path)
-  sh "ruby -c #{path}"
-end

data/profiling/README.md

@@ -1,9 +0,0 @@
-# Profiling Scripts
-
-This directory contains profiling scripts. Currently they use [stackprof](https://github.com/tmm1/stackprof) which
-requires Ruby 2.1+ (preview2 or later).
-
-## Running the Profiler
-
-    ruby profiling/stackprof/body_framing_with_2k_payload.rb
-    stackprof profiling/dumps/body_framing_with_2k_payload.dump --text

data/profiling/stackprof/body_framing_with_2k_payload.rb

@@ -1,33 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib"))
-
-require "amq/protocol/client"
-
-FRAME_SIZE = 128 * 1024
-
-puts
-puts "-" * 80
-puts "Profiling on #{RUBY_DESCRIPTION}"
-
-n = 250_000
-
-# warm up the JIT, etc
-puts "Doing a warmup run..."
-15_000.times { AMQ::Protocol::Method.encode_body("ab" * 1024, 1, FRAME_SIZE) }
-
-require 'stackprof'
-
-# preallocate
-ary = Array.new(n) { "ab" * 1024 }
-
-puts "Doing main run..."
-result = StackProf.run(mode: :wall) do
-  n.times { |i| AMQ::Protocol::Method.encode_body(ary[i], 1, FRAME_SIZE) }
-end
-
-File.open('./profiling/dumps/body_framing_with_2k_payload.dump', "w+") do |f|
-  f.write Marshal.dump(result)
-end
-

data/spec/amq/bit_set_spec.rb

@@ -1,227 +0,0 @@
-require "amq/bit_set"
-
-# extracted from amqp gem. MK.
-RSpec.describe AMQ::BitSet do
-
-  #
-  # Environment
-  #
-
-  let(:nbits) { (1 << 16) - 1 }
-
-
-  #
-  # Examples
-  #
-
-  describe "#new" do
-    it "has no bits set at the start" do
-      bs = AMQ::BitSet.new(128)
-      0.upto(127) do |i|
-        expect(bs[i]).to be_falsey
-      end
-    end # it
-  end # describe
-
-  describe "#word_index" do
-    subject do
-      described_class.new(nbits)
-    end
-    it "returns 0 when the word is between 0 and 63" do
-      expect(subject.word_index(0)).to eq(0)
-      expect(subject.word_index(63)).to eq(0)
-    end # it
-    it "returns 1 when the word is between 64 and 127" do
-      expect(subject.word_index(64)).to be(1)
-      expect(subject.word_index(127)).to be(1)
-    end # it
-    it "returns 2 when the word is between 128 and another number" do
-      expect(subject.word_index(128)).to be(2)
-    end # it
-  end # describe
-
-  describe "#get, #[]" do
-    describe "when bit at given position is set" do
-      subject do
-        o = described_class.new(nbits)
-        o.set(3)
-        o
-      end
-
-      it "returns true" do
-        expect(subject.get(3)).to be_truthy
-      end # it
-    end # describe
-
-    describe "when bit at given position is off" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "returns false" do
-        expect(subject.get(5)).to be_falsey
-      end # it
-    end # describe
-
-    describe "when index out of range" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "should raise IndexError for negative index" do
-        expect { subject.get(-1) }.to raise_error(IndexError)
-      end # it
-      it "should raise IndexError for index >= number of bits" do
-        expect { subject.get(nbits) }.to raise_error(IndexError)
-      end # it
-    end # describe
-  end # describe
-
-
-  describe "#set" do
-    describe "when bit at given position is set" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "has no effect" do
-        subject.set(3)
-        expect(subject.get(3)).to be_truthy
-        subject.set(3)
-        expect(subject[3]).to be_truthy
-      end # it
-    end # describe
-
-    describe "when bit at given position is off" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "sets that bit" do
-        subject.set(3)
-        expect(subject.get(3)).to be_truthy
-
-        subject.set(33)
-        expect(subject.get(33)).to be_truthy
-
-        subject.set(3387)
-        expect(subject.get(3387)).to be_truthy
-      end # it
-    end # describe
-
-    describe "when index out of range" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "should raise IndexError for negative index" do
-        expect { subject.set(-1) }.to raise_error(IndexError)
-      end # it
-      it "should raise IndexError for index >= number of bits" do
-        expect { subject.set(nbits) }.to raise_error(IndexError)
-      end # it
-    end # describe
-  end # describe
-
-
-  describe "#unset" do
-    describe "when bit at a given position is set" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "unsets that bit" do
-        subject.set(3)
-        expect(subject.get(3)).to be_truthy
-        subject.unset(3)
-        expect(subject.get(3)).to be_falsey
-      end # it
-    end # describe
-
-
-    describe "when bit at a given position is off" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "has no effect" do
-        expect(subject.get(3)).to be_falsey
-        subject.unset(3)
-        expect(subject.get(3)).to be_falsey
-      end # it
-    end # describe
-
-    describe "when index out of range" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "should raise IndexError for negative index" do
-        expect { subject.unset(-1) }.to raise_error(IndexError)
-      end # it
-      it "should raise IndexError for index >= number of bits" do
-        expect { subject.unset(nbits) }.to raise_error(IndexError)
-      end # it
-    end # describe
-  end # describe
-
-
-
-  describe "#clear" do
-    subject do
-      described_class.new(nbits)
-    end
-
-    it "clears all bits" do
-      subject.set(3)
-      expect(subject.get(3)).to be_truthy
-
-      subject.set(7668)
-      expect(subject.get(7668)).to be_truthy
-
-      subject.clear
-
-      expect(subject.get(3)).to be_falsey
-      expect(subject.get(7668)).to be_falsey
-    end # it
-  end # describe
-
-  describe "#number_of_trailing_ones" do
-    it "calculates them" do
-      expect(described_class.number_of_trailing_ones(0)).to eq(0)
-      expect(described_class.number_of_trailing_ones(1)).to eq(1)
-      expect(described_class.number_of_trailing_ones(2)).to eq(0)
-      expect(described_class.number_of_trailing_ones(3)).to eq(2)
-      expect(described_class.number_of_trailing_ones(4)).to eq(0)
-    end # it
-  end # describe
-
-  describe '#next_clear_bit' do
-    subject do
-      described_class.new(255)
-    end
-    it "returns sequential values when none have been returned" do
-      expect(subject.next_clear_bit).to eq(0)
-      subject.set(0)
-      expect(subject.next_clear_bit).to eq(1)
-      subject.set(1)
-      expect(subject.next_clear_bit).to eq(2)
-      subject.unset(1)
-      expect(subject.next_clear_bit).to eq(1)
-    end # it
-
-    it "returns the same number as long as nothing is set" do
-      expect(subject.next_clear_bit).to eq(0)
-      expect(subject.next_clear_bit).to eq(0)
-    end # it
-
-    it "handles more than 128 bits" do
-      0.upto(254) do |i|
-        subject.set(i)
-        expect(subject.next_clear_bit).to eq(i + 1)
-      end
-      subject.unset(254)
-      expect(subject.get(254)).to be_falsey
-    end # it
-  end # describe
-end