stomp_parser 1.0.0-universal-java

data/lib/stomp_parser/ruby_parser.rb.rl

@@ -0,0 +1,155 @@
+%%{
+  machine frame;
+
+  getkey (chunk.getbyte(p) ^ 128) - 128;
+
+  action mark {
+    mark = p
+  }
+  action mark_key {
+    mark_key = chunk.byteslice(mark, p - mark)
+    mark = nil
+  }
+  action mark_frame {
+    mark_frame = Frame.new(nil, nil)
+    mark_frame_size = 0
+  }
+  action check_frame_size {
+    mark_frame_size += 1
+    raise FrameSizeExceeded if mark_frame_size > max_frame_size
+  }
+
+  action write_command {
+    mark_frame.write_command(chunk.byteslice(mark, p - mark))
+    mark = nil
+  }
+
+  action write_header {
+    mark_frame.write_header(mark_key, chunk.byteslice(mark, p - mark))
+    mark_key = mark = nil
+  }
+
+  action write_body {
+    mark_frame.write_body(chunk.byteslice(mark, p - mark))
+    mark = nil
+  }
+
+  action finish_headers {
+    mark_content_length = mark_frame.content_length
+  }
+
+  action consume_null {
+    (p - mark) < mark_content_length if mark_content_length
+  }
+
+  action consume_octet {
+    if mark_content_length
+      (p - mark) < mark_content_length
+    else
+      true
+    end
+  }
+
+  action finish_frame {
+    yield mark_frame
+    mark_frame = nil
+  }
+
+  include frame_common "parser_common.rl";
+}%%
+
+module StompParser
+  class RubyParser
+    class State
+      def initialize
+        @cs = RubyParser.start
+        @chunk = nil
+        @mark = nil
+        @mark_key = nil
+        @mark_frame = nil
+        @mark_frame_size = nil
+        @mark_content_length = nil
+      end
+
+      # You want documentation? HAHA.
+      attr_accessor :chunk
+      attr_accessor :cs
+      attr_accessor :mark
+      attr_accessor :mark_key
+      attr_accessor :mark_frame
+      attr_accessor :mark_frame_size
+      attr_accessor :mark_content_length
+    end
+
+    # this manipulates the singleton class of our context,
+    # so we do not want to run this code very often or we
+    # bust our ruby method caching
+    %% write data noprefix;
+
+    # Parse a chunk of Stomp-formatted data into a Frame.
+    #
+    # @param [String] chunk
+    # @param [State] state previous parser state, or nil for initial state
+    # @param [Integer] max_frame_size
+    # @yield [frame] yields each frame as it is parsed
+    # @yieldparam frame [Frame]
+    def self._parse(chunk, state, max_frame_size)
+      chunk.force_encoding(Encoding::BINARY)
+
+      if state.chunk
+        p = state.chunk.bytesize
+        chunk = state.chunk << chunk
+      else
+        p = 0
+      end
+
+      pe = chunk.bytesize # special
+
+      cs = state.cs
+      mark = state.mark
+      mark_key = state.mark_key
+      mark_frame = state.mark_frame
+      mark_frame_size = state.mark_frame_size
+      mark_content_length = state.mark_content_length
+
+      %% write exec;
+
+      if mark
+        state.chunk = chunk
+      else
+        state.chunk = nil
+      end
+
+      state.cs = cs
+      state.mark = mark
+      state.mark_key = mark_key
+      state.mark_frame = mark_frame
+      state.mark_frame_size = mark_frame_size
+      state.mark_content_length = mark_content_length
+
+      if cs == RubyParser.error
+        StompParser.build_parse_error(chunk, p)
+      else
+        nil
+      end
+    end
+
+    def initialize(max_frame_size = StompParser.max_frame_size)
+      @state = State.new
+      @max_frame_size = Integer(max_frame_size)
+    end
+
+    # Parse a chunk.
+    #
+    # @param [String] chunk
+    # @yield [frame]
+    # @yieldparam [Frame] frame
+    def parse(chunk)
+      @error ||= self.class._parse(chunk, @state, @max_frame_size) do |frame|
+        yield frame
+      end
+
+      raise @error if @error
+    end
+  end
+end

data/lib/stomp_parser/version.rb

@@ -0,0 +1,3 @@
+module StompParser
+  VERSION = "1.0.0"
+end

data/parser_common.rl

@@ -0,0 +1,25 @@
+%%{
+  machine frame_common;
+
+  NULL = "\0";
+  EOL = "\r"? . "\n";
+  OCTET = any;
+
+  client_commands = "SEND" | "SUBSCRIBE" | "UNSUBSCRIBE" | "BEGIN" | "COMMIT" | "ABORT" | "ACK" | "NACK" | "DISCONNECT" | "CONNECT" | "STOMP";
+  server_commands = "CONNECTED" | "MESSAGE" | "RECEIPT" | "ERROR";
+  command = (client_commands | server_commands) > mark % write_command . EOL;
+
+  HEADER_ESCAPE = "\\" . ("\\" | "n" | "r" | "c");
+  HEADER_OCTET = HEADER_ESCAPE | (OCTET - "\r" - "\n" - "\\" - ":");
+  header_key = HEADER_OCTET+ > mark % mark_key;
+  header_value = HEADER_OCTET* > mark;
+  header = header_key . ":" . header_value;
+  headers = (header % write_header . EOL)* % finish_headers . EOL;
+
+  consume_body = (NULL when consume_null | ^NULL when consume_octet)*;
+  body = consume_body >from(mark) % write_body <: NULL;
+
+  frame = ((command > mark_frame) :> headers :> (body @ finish_frame)) $ check_frame_size;
+
+  stream := (EOL | frame)*;
+}%%

data/spec/bench_helper.rb

@@ -0,0 +1,67 @@
+require "bundler/setup"
+require "stomp_parser"
+require "benchmark/ips"
+
+class Benchpress
+  attr_reader :options
+
+  def initialize(options, &body)
+    @options = options
+    instance_exec(self, &body)
+  end
+
+  def name
+    "#{options[:file]}:#{options[:line]} #{options[:desc]}"
+  end
+
+  def setup(&block)
+    @setup = block
+  end
+
+  def code(&block)
+    @code = block
+  end
+
+  def assert(&block)
+    @assert = block
+  end
+
+  def run_initial
+    instance_exec(&@setup) if @setup
+    result = run
+    result = instance_exec(result, &@assert) if @assert
+    unless result
+      raise "#{name} code returns #{result.inspect}"
+    end
+  end
+
+  def run
+    instance_exec(&@code)
+  end
+
+  def to_proc
+    lambda { run }
+  end
+end
+
+def describe(description, &body)
+  file, line, _ = caller[0].split(':')
+  options = {
+    desc: description,
+    file: File.basename(file),
+    line: line,
+  }
+
+  $__benchmarks__ << Benchpress.new(options, &body)
+end
+
+$__benchmarks__ = []
+
+at_exit do
+  reports = Benchmark.ips(time = 2) do |x|
+    $__benchmarks__.each do |bench|
+      5.times { bench.run_initial }
+      x.report(bench.name, &bench)
+    end
+  end
+end

data/spec/benchmarks/message_bench.rb

@@ -0,0 +1,50 @@
+require_relative "../bench_helper"
+
+describe "Frame#to_str minimal" do |bench|
+  bench.setup do
+    @frame = StompParser::Frame.new("CONNECT", nil)
+  end
+
+  bench.code { @frame.to_str }
+
+  bench.assert do |frame_str|
+    frame_str == "CONNECT\ncontent-length:0\n\n\x00"
+  end
+end
+
+describe "Frame#to_str with header" do |bench|
+  bench.setup do
+    @frame = StompParser::Frame.new("CONNECT", { "heart-beat" => "0,0" }, nil)
+  end
+
+  bench.code { @frame.to_str }
+
+  bench.assert do |frame_str|
+    frame_str == "CONNECT\nheart-beat:0,0\ncontent-length:0\n\n\x00"
+  end
+end
+
+describe "Frame#to_str with headers and small body" do |bench|
+  bench.setup do
+    @frame = StompParser::Frame.new("CONNECT", { "some" => "header" }, "body")
+  end
+
+  bench.code { @frame.to_str }
+
+  bench.assert do |frame_str|
+    frame_str == "CONNECT\nsome:header\ncontent-length:4\n\nbody\x00"
+  end
+end
+
+describe "Frame#to_str with headers and large body" do |bench|
+  bench.setup do
+    large_binary = "b\x00" * 2 # make room for headers
+    @frame = StompParser::Frame.new("CONNECT", { "some" => "header" }, large_binary)
+  end
+
+  bench.code { @frame.to_str }
+
+  bench.assert do |frame_str|
+    frame_str == "CONNECT\nsome:header\ncontent-length:#{@frame.body.bytesize}\n\n#{@frame.body}\x00"
+  end
+end

data/spec/benchmarks/parser_bench.rb

@@ -0,0 +1,43 @@
+require_relative "../bench_helper"
+
+def parse_one(parser, data)
+  frame = nil
+  parser.parse(data) { |m| frame = m }
+  frame
+end
+
+%w[CParser JavaParser RubyParser].each do |parser|
+  parser = begin
+    StompParser.const_get(parser)
+  rescue NameError
+    next
+  end
+
+  describe "#{parser}: minimal" do |bench|
+    bench.setup do
+      @parser = parser.new
+      @frame = "CONNECT\n\n\x00"
+    end
+
+    bench.code { parse_one(@parser, @frame) }
+  end
+
+  describe "#{parser}: headers and small body" do |bench|
+    bench.setup do
+      @parser = parser.new
+      @frame = "CONNECT\ncontent-length:4\n\nbody\x00"
+    end
+
+    bench.code { parse_one(@parser, @frame) }
+  end
+
+  describe "#{parser}: headers and large body" do |bench|
+    bench.setup do
+      @parser = parser.new
+      large_body = ("b" * (StompParser.max_frame_size - 50)) # make room for headers
+      @frame = "CONNECT\ncontent-length:#{large_body.bytesize}\n\n#{large_body}\x00"
+    end
+
+    bench.code { parse_one(@parser, @frame) }
+  end
+end

data/spec/profile.rb

@@ -0,0 +1,27 @@
+require "bundler/setup"
+require "stomp_parser"
+require "perftools"
+
+parser = StompParser::Parser.new
+body_size = (1024 * 99) / 2
+large_binary = "b\x00" * body_size # make room for headers
+data = <<-MESSAGE
+CONNECT
+content-length:#{large_binary.bytesize}
+
+#{large_binary}\x00
+MESSAGE
+stream = data + data + data + data
+
+profile_output = File.expand_path("./profile/parser.profile", File.dirname(__FILE__))
+PerfTools::CpuProfiler.start(profile_output) do
+  i = 100
+  loop do
+    parser.parse(data) do |frame|
+      # no op
+    end
+
+    i -= 1
+    break if i <= 0
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "bundler/setup"
+require "stomp_parser"
+require "pry"
+require "timeout"
+
+require "support/shared_parser_examples"

data/spec/stomp_parser/c_parser_spec.rb

@@ -0,0 +1,5 @@
+if defined?(StompParser::CParser)
+  describe StompParser::CParser do
+    it_behaves_like "a stomp_parser parser"
+  end
+end

data/spec/stomp_parser/java_parser_spec.rb

@@ -0,0 +1,5 @@
+if defined?(StompParser::JavaParser)
+  describe StompParser::JavaParser do
+    it_behaves_like "a stomp_parser parser"
+  end
+end

data/spec/stomp_parser/message_spec.rb

@@ -0,0 +1,50 @@
+describe StompParser::Frame do
+  describe "#content_length" do
+    it "returns content length if available" do
+      frame = StompParser::Frame.new("CONNECT", { "content-length" => "1337" }, nil)
+      frame.content_length.should eq 1337
+    end
+
+    it "returns nil if no content length defined" do
+      frame = StompParser::Frame.new("CONNECT", nil)
+      frame.content_length.should be_nil
+    end
+
+    it "raises an error if invalid content length defined" do
+      frame = StompParser::Frame.new("CONNECT", { "content-length" => "LAWL" }, nil)
+      expect { frame.content_length }.to raise_error(StompParser::Error, /invalid content length "LAWL"/)
+    end
+  end
+
+  describe "#to_str" do
+    specify "frame with command only" do
+      frame = StompParser::Frame.new("CONNECT", nil)
+      frame.to_str.should eq "CONNECT\ncontent-length:0\n\n\x00"
+    end
+
+    specify "frame with with headers" do
+      frame = StompParser::Frame.new("CONNECT", { "moo" => "cow", "boo" => "hoo" }, nil)
+      frame.to_str.should eq "CONNECT\nmoo:cow\nboo:hoo\ncontent-length:0\n\n\x00"
+    end
+
+    specify "frame with with body" do
+      frame = StompParser::Frame.new("CONNECT", "this is a body")
+      frame.to_str.should eq "CONNECT\ncontent-length:14\n\nthis is a body\x00"
+    end
+
+    specify "frame with escapeable characters in headers" do
+      frame = StompParser::Frame.new("CONNECT", { "k\\\n\r:" => "v\\\n\r:" }, nil)
+      frame.to_str.should eq "CONNECT\nk\\\\\\n\\r\\c:v\\\\\\n\\r\\c\ncontent-length:0\n\n\x00"
+    end
+
+    specify "frame with binary body" do
+      frame = StompParser::Frame.new("CONNECT", "\x00ab\x00")
+      frame.to_str.should eq "CONNECT\ncontent-length:4\n\n\x00ab\x00\x00"
+    end
+
+    specify "overrides user-specified content-length" do
+      frame = StompParser::Frame.new("CONNECT", { "content-length" => "10" }, "\x00ab\x00")
+      frame.to_str.should eq "CONNECT\ncontent-length:4\n\n\x00ab\x00\x00"
+    end
+  end
+end