amq-protocol 2.3.3 → 2.8.0

data/Rakefile

@@ -1,55 +0,0 @@
-require "bundler"
-Bundler.setup
-
-require "rake"
-require "rspec/core/rake_task"
-
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-require "amq/protocol/version"
-
-task :gem => :build
-task :build do
-  system "gem build amq-protocol.gemspec"
-end
-
-task :install => :build do
-  system "gem install amq-protocol-#{AMQ::Protocol::VERSION}.gem"
-end
-
-def extension
-  RUBY_PLATFORM =~ /darwin/ ? "bundle" : "so"
-end
-
-def compile!
-  puts "Compiling native extensions..."
-  Dir.chdir(Pathname(__FILE__).dirname + "ext/") do
-    `bundle exec ruby extconf.rb`
-    `make`
-    `cp client.#{extension} ../lib/amq/protocol/native/`
-  end
-end
-
-RSpec::Core::RakeTask.new("spec") do |spec|
-  spec.pattern = "spec/**/*_spec.rb"
-end
-
-RSpec::Core::RakeTask.new("clean_spec") do |spec|
-  spec.pattern = "spec/**/*_spec.rb"
-end
-
-task :compile do
-  compile!
-end
-
-task :clean do
-  puts "Cleaning out native extensions..."
-  begin
-    Dir.chdir(Pathname(__FILE__).dirname + "lib/amq-protocol/native") do
-      `rm client.#{extension}`
-    end
-  rescue Exception => e
-    puts e.message
-  end
-end
-
-task :default => [:compile, :spec, :clean, :clean_spec]

data/amq-protocol.gemspec

@@ -1,27 +0,0 @@
-#!/usr/bin/env gem build
-# encoding: utf-8
-
-require "base64"
-
-require File.expand_path("../lib/amq/protocol/version", __FILE__)
-
-Gem::Specification.new do |s|
-  s.name = "amq-protocol"
-  s.version = AMQ::Protocol::VERSION
-  s.authors = ["Jakub Stastny", "Michael S. Klishin", "Theo Hultberg", "Mark Abramov"]
-  s.homepage = "http://github.com/ruby-amqp/amq-protocol"
-  s.summary = "AMQP 0.9.1 encoding & decoding library."
-  s.description = <<-DESC
-  amq-protocol is an AMQP 0.9.1 serialization library for Ruby. It is not a
-  client: the library only handles serialization and deserialization.
-  DESC
-  s.email = ["michael.s.klishin@gmail.com"]
-  s.licenses    = ["MIT"]
-  s.required_ruby_version = Gem::Requirement.new(">= 2.2")
-
-  # files
-  s.files = `git ls-files`.split("\n").reject { |file| file =~ /^vendor\// }
-  s.require_paths = ["lib"]
-
-  s.extra_rdoc_files = ["README.md"] + Dir.glob("doc/*")
-end

data/benchmarks/int_allocator.rb

@@ -1,34 +0,0 @@
-$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-
-require 'amq/int_allocator'
-require "benchmark"
-
-allocator = AMQ::IntAllocator.new(1,65535)
-mutex = Mutex.new
-
-Benchmark.bm do |x|
-
-
-  x.report("allocate") do
-    allocator = AMQ::IntAllocator.new(1,65535)
-    1.upto(65534) do |i|
-      mutex.synchronize do
-        n = allocator.allocate
-        raise 'it be broke' unless n == i
-      end
-    end
-  end
-
-  x.report("allocate_with_release") do
-    allocator = AMQ::IntAllocator.new(1,65535)
-    1.upto(65534) do |i|
-      mutex.synchronize do
-        n = allocator.allocate
-        if i % 5 == 0
-          allocator.release(n)
-        end
-      end
-    end
-  end
-
-end

data/benchmarks/pure/body_framing_with_256k_payload.rb

@@ -1,28 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib"))
-
-require "amq/protocol/client"
-require "benchmark"
-
-FRAME_SIZE = 128 * 1024
-
-puts
-puts "-" * 80
-puts "Benchmarking on #{RUBY_DESCRIPTION}"
-
-n = 250_000
-
-# warm up the JIT, etc
-puts "Doing a warmup run..."
-15_000.times { AMQ::Protocol::Method.encode_body("a" * 256 * 1024, 1, FRAME_SIZE) }
-
-t  = Benchmark.realtime do
-  n.times { AMQ::Protocol::Method.encode_body("a" * 256 * 1024, 1, FRAME_SIZE) }
-end
-r  = (n.to_f/t.to_f)
-
-puts "AMQ::Protocol::Method.encode_body rate: #{(r / 1000).round(2)} KGHz"
-puts
-puts "-" * 80

data/benchmarks/pure/body_framing_with_2k_payload.rb

@@ -1,28 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib"))
-
-require "amq/protocol/client"
-require "benchmark"
-
-FRAME_SIZE = 128 * 1024
-
-puts
-puts "-" * 80
-puts "Benchmarking 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) }
-
-t  = Benchmark.realtime do
-  n.times { AMQ::Protocol::Method.encode_body("ab" * 1024, 1, FRAME_SIZE) }
-end
-r  = (n.to_f/t.to_f)
-
-puts "AMQ::Protocol::Method.encode_body rate: #{(r / 1000).round(2)} KGHz"
-puts
-puts "-" * 80

data/codegen/amqp_0.9.1_changes.json

@@ -1 +0,0 @@
-{"tx": {"select-ok": ["client"], "rollback": ["server"], "commit": ["server"], "rollback-ok": ["client"], "select": ["server"], "commit-ok": ["client"]}, "exchange": {"delete-ok": ["client"], "declare-ok": ["client"], "declare": ["server"], "delete": ["server"], "bind": ["server"], "bind-ok": ["client"], "unbind": ["server"], "unbind-ok": ["client"]}, "queue": {"unbind": ["server"], "unbind-ok": ["client"], "purge-ok": ["client"], "bind": ["server"], "purge": ["server"], "declare-ok": ["client"], "delete-ok": ["client"], "delete": ["server"], "declare": ["server"], "bind-ok": ["client"]}, "connection": {"secure": ["client"], "secure-ok": ["server"], "open-ok": ["client"], "close-ok": ["client", "server"], "start": ["client"], "tune": ["client"], "start-ok": ["server"], "close": ["client", "server"], "open": ["server"], "tune-ok": ["server"]}, "basic": {"qos": ["server"], "consume": ["server"], "reject": ["server"], "get": ["server"], "ack": ["client", "server"], "get-ok": ["client"], "consume-ok": ["client"], "deliver": ["client"], "recover-ok": ["client"], "publish": ["server"], "cancel": ["server", "client"], "recover-async": ["server"], "get-empty": ["client"], "qos-ok": ["client"], "return": ["client"], "recover": ["server"], "cancel-ok": ["client"]}, "channel": {"flow-ok": ["server", "client"], "flow": ["server", "client"], "open-ok": ["client"], "close-ok": ["client", "server"], "close": ["client", "server"], "open": ["server"]}}

data/codegen/codegen.py

@@ -1,151 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Documentation for Mako templates:
-# http://www.makotemplates.org/docs/syntax.html
-
-import os, sys, re
-
-sys.path.append(os.path.join("codegen", "rabbitmq-codegen"))
-
-from amqp_codegen import *
-try:
-    from mako.template import Template
-except ImportError:
-    print("Mako isn't installed. Please install mako via pip or similar.")
-    sys.exit(1)
-
-# main class
-class AmqpSpecObject(AmqpSpec):
-    IGNORED_CLASSES = ["access"]
-    IGNORED_FIELDS = {
-        'ticket': 0,
-        'capabilities': '',
-        'insist' : 0,
-        'out_of_band': '',
-        'known_hosts': '',
-    }
-
-    def __init__(self, path):
-        AmqpSpec.__init__(self, path)
-
-        def extend_field(field):
-            field.ruby_name = re.sub("[- ]", "_", field.name)
-            field.type = self.resolveDomain(field.domain)
-            field.ignored = bool(field.name in self.__class__.IGNORED_FIELDS) # I. e. deprecated
-
-        for klass in self.classes:
-            klass.ignored = bool(klass.name in self.__class__.IGNORED_CLASSES)
-
-            for field in klass.fields:
-                extend_field(field)
-
-            for method in klass.methods:
-                for field in method.arguments:
-                    extend_field(field)
-
-        self.classes = filter(lambda klass: not klass.ignored, self.classes)
-
-original_init = AmqpEntity.__init__
-def new_init(self, arg):
-    original_init(self, arg)
-    constant_name = ""
-    for chunk in self.name.split("-"):
-        constant_name += chunk.capitalize()
-    self.constant_name = constant_name
-AmqpEntity.__init__ = new_init
-
-# method.accepted_by("server")
-# method.accepted_by("client", "server")
-accepted_by_update = json.loads(open("codegen/amqp_0.9.1_changes.json").read())
-
-def accepted_by(self, *receivers):
-    def get_accepted_by(self):
-        try:
-            return accepted_by_update[self.klass.name][self.name]
-        except KeyError:
-            return ["server", "client"]
-
-    actual_receivers = get_accepted_by(self)
-    return all(map(lambda receiver: receiver in actual_receivers, receivers))
-
-AmqpMethod.accepted_by = accepted_by
-
-def convert_value_to_ruby(value):
-    values = {None: "nil", False: "false", True: "true", "": "EMPTY_STRING"}
-
-    try:
-        return values[value]
-    except:
-        return value.__repr__()
-
-def convert_to_ruby(field):
-    name = re.sub("-", "_", field.name) # TODO: use ruby_name
-    if name == "ticket":
-        return "%s = %s" % (name, field.defaultvalue) # we want to keep it as an int, not as a boolean
-    else:
-        return "%s = %s" % (name, convert_value_to_ruby(field.defaultvalue))
-
-def not_ignored_args(self):
-    if self.hasContent:
-        return ["payload", "user_headers"] + map(lambda argument: argument.ruby_name, filter(lambda argument: not argument.ignored, self.arguments)) + ["frame_size"]
-    else:
-        return map(lambda argument: argument.ruby_name, filter(lambda argument: not argument.ignored, self.arguments))
-
-AmqpMethod.not_ignored_args = not_ignored_args
-
-def ignored_args(self):
-    return filter(lambda argument: argument.ignored, self.arguments)
-
-AmqpMethod.ignored_args = ignored_args
-
-# helpers
-def to_ruby_name(name):
-    return re.sub("[- ]", "_", name)
-
-def to_ruby_class_name(name):
-    parts = re.split("[- ]", name)
-    ruby_class_name = ""
-    for part in parts:
-        ruby_class_name = ruby_class_name + part[0].upper() + part[1:].lower()
-    return ruby_class_name
-
-def params(self):
-    buffer = []
-    for f in self.arguments:
-        buffer.append(convert_to_ruby(f))
-    if self.hasContent:
-        buffer.append("user_headers = nil")
-        buffer.append("payload = \"\"")
-        buffer.append("frame_size = nil")
-    return buffer
-
-AmqpMethod.params = params
-
-def args(self):
-    return map(lambda item: item.split(" ")[0], self.params())
-
-AmqpMethod.args = args
-
-def binary(self):
-    method_id = self.klass.index << 16 | self.index
-    return "0x%08X # %i, %i, %i" % (method_id, self.klass.index, self.index, method_id)
-
-AmqpMethod.binary = binary
-
-# helpers
-def render(path, **context):
-    file = open(path)
-    template = Template(file.read())
-    return template.render(**context)
-
-def generateMain(type):
-    def main(json_spec_path):
-        spec = AmqpSpecObject(json_spec_path)
-        spec.type = type
-        print(render("codegen/protocol.rb.pytemplate", spec = spec))
-
-    return main
-
-if __name__ == "__main__":
-    do_main_dict({"client": generateMain("client")})

data/codegen/codegen_helpers.py

@@ -1,162 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import print_function
-
-def genSingleEncode(spec, cValue, unresolved_domain):
-    buffer = []
-    type = spec.resolveDomain(unresolved_domain)
-    if type == 'shortstr':
-        buffer.append("buffer << %s.to_s.bytesize.chr" % (cValue,))
-        buffer.append("buffer << %s.to_s" % (cValue,))
-    elif type == 'longstr':
-        buffer.append("buffer << [%s.to_s.bytesize].pack(PACK_UINT32)" % (cValue,))
-        buffer.append("buffer << %s.to_s" % (cValue,))
-    elif type == 'octet':
-        buffer.append("buffer << [%s].pack(PACK_CHAR)" % (cValue,))
-    elif type == 'short':
-        buffer.append("buffer << [%s].pack(PACK_UINT16)" % (cValue,))
-    elif type == 'long':
-        buffer.append("buffer << [%s].pack(PACK_UINT32)" % (cValue,))
-    elif type == 'longlong':
-        buffer.append("buffer << AMQ::Pack.pack_uint64_big_endian(%s)" % (cValue,))
-    elif type == 'timestamp':
-        buffer.append("buffer << AMQ::Pack.pack_uint64_big_endian(%s)" % (cValue,))
-    elif type == 'bit':
-        raise "Can't encode bit in genSingleEncode"
-    elif type == 'table':
-        buffer.append("buffer << AMQ::Protocol::Table.encode(%s)" % (cValue,))
-    else:
-        raise "Illegal domain in genSingleEncode: {0}".format(type)
-
-    return buffer
-
-def genSingleDecode(spec, field):
-    cLvalue = field.ruby_name
-    unresolved_domain = field.domain
-
-    if cLvalue == "known_hosts":
-        import sys
-        print(field, field.ignored, file = sys.stderr)
-
-    type = spec.resolveDomain(unresolved_domain)
-    buffer = []
-    if type == 'shortstr':
-        buffer.append("length = data[offset, 1].unpack(PACK_CHAR).first")
-        buffer.append("offset += 1")
-        buffer.append("%s = data[offset, length]" % (cLvalue,))
-        buffer.append("offset += length")
-    elif type == 'longstr':
-        buffer.append("length = data[offset, 4].unpack(PACK_UINT32).first")
-        buffer.append("offset += 4")
-        buffer.append("%s = data[offset, length]" % (cLvalue,))
-        buffer.append("offset += length")
-    elif type == 'octet':
-        buffer.append("%s = data[offset, 1].unpack(PACK_CHAR).first" % (cLvalue,))
-        buffer.append("offset += 1")
-    elif type == 'short':
-        buffer.append("%s = data[offset, 2].unpack(PACK_UINT16).first" % (cLvalue,))
-        buffer.append("offset += 2")
-    elif type == 'long':
-        buffer.append("%s = data[offset, 4].unpack(PACK_UINT32).first" % (cLvalue,))
-        buffer.append("offset += 4")
-    elif type == 'longlong':
-        buffer.append("%s = AMQ::Pack.unpack_uint64_big_endian(data[offset, 8]).first" % (cLvalue,))
-        buffer.append("offset += 8")
-    elif type == 'timestamp':
-        buffer.append("%s = data[offset, 8].unpack(PACK_UINT64_BE).first" % (cLvalue,))
-        buffer.append("offset += 8")
-    elif type == 'bit':
-        raise "Can't decode bit in genSingleDecode"
-    elif type == 'table':
-        buffer.append("table_length = Table.length(data[offset, 4])")
-        buffer.append("%s = Table.decode(data[offset, table_length + 4])" % (cLvalue,))
-        buffer.append("offset += table_length + 4")
-    else:
-        raise StandardError("Illegal domain '{0}' in genSingleDecode".format(type))
-
-    return buffer
-
-
-
-def genSingleSimpleDecode(spec, field):
-    cLvalue = field.ruby_name
-    unresolved_domain = field.domain
-
-    if cLvalue == "known_hosts":
-        import sys
-        print >> sys.stderr, field, field.ignored
-
-    type = spec.resolveDomain(unresolved_domain)
-    buffer = []
-    if type == 'shortstr':
-        buffer.append("data.to_s")
-    elif type == 'longstr':
-        buffer.append("data.to_s")
-    elif type == 'octet':
-        buffer.append("data.unpack(PACK_INT8).first")
-    elif type == 'short':
-        buffer.append("data.unpack(PACK_UINT16).first")
-    elif type == 'long':
-        buffer.append("data.unpack(PACK_UINT32).first")
-    elif type == 'longlong':
-        buffer.append("AMQ::Pack.unpack_uint64_big_endian(data).first")
-    elif type == 'timestamp':
-        buffer.append("Time.at(data.unpack(PACK_UINT64_BE).last)")
-    elif type == 'bit':
-        raise "Can't decode bit in genSingleDecode"
-    elif type == 'table':
-        buffer.append("Table.decode(data)")
-    else:
-        raise StandardError("Illegal domain '" + type + "' in genSingleSimpleDecode")
-
-    return buffer
-
-
-def genEncodeMethodDefinition(spec, m):
-    def finishBits():
-        if bit_index is not None:
-            buffer.append("buffer << [bit_buffer].pack(PACK_CHAR)")
-
-    bit_index = None
-    buffer = []
-
-    for f in m.arguments:
-        if spec.resolveDomain(f.domain) == 'bit':
-            if bit_index is None:
-                bit_index = 0
-                buffer.append("bit_buffer = 0")
-            if bit_index >= 8:
-                finishBits()
-                buffer.append("bit_buffer = 0")
-                bit_index = 0
-            buffer.append("bit_buffer = bit_buffer | (1 << %d) if %s" % (bit_index, f.ruby_name))
-            bit_index = bit_index + 1
-        else:
-            finishBits()
-            bit_index = None
-            buffer += genSingleEncode(spec, f.ruby_name, f.domain)
-
-    finishBits()
-    return buffer
-
-def genDecodeMethodDefinition(spec, m):
-    buffer = []
-    bitindex = None
-    for f in m.arguments:
-        if spec.resolveDomain(f.domain) == 'bit':
-            if bitindex is None:
-                bitindex = 0
-            if bitindex >= 8:
-                bitindex = 0
-            if bitindex == 0:
-                buffer.append("bit_buffer = data[offset, 1].unpack(PACK_CHAR).first")
-                buffer.append("offset += 1")
-                buffer.append("%s = (bit_buffer & (1 << %d)) != 0" % (f.ruby_name, bitindex))
-                #### TODO: ADD bitindex TO THE buffer
-            else:
-                buffer.append("%s = (bit_buffer & (1 << %d)) != 0" % (f.ruby_name, bitindex))
-            bitindex = bitindex + 1
-        else:
-            bitindex = None
-            buffer += genSingleDecode(spec, f)
-    return buffer