stomp_parser 1.0.0

data/ext/stomp_parser/extconf.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "mkmf"
+
+$CFLAGS << " -O3"
+
+should_build = true
+should_build &&= have_header "ruby.h"
+should_build &&= defined?(RUBY_ENGINE) && %w[ruby rbx].include?(RUBY_ENGINE)
+
+if should_build
+  create_makefile("stomp_parser/c_parser")
+else
+  dummy_makefile(".")
+end

data/lib/stomp_parser.rb

@@ -0,0 +1,46 @@
+require "stomp_parser/version"
+require "stomp_parser/error"
+require "stomp_parser/frame"
+require "stomp_parser/ruby_parser"
+
+case RUBY_ENGINE
+when "ruby", "rbx"
+  require "stomp_parser/c_parser"
+when "jruby"
+  require "stomp_parser/java_parser"
+end
+
+module StompParser
+  Parser = if defined?(CParser)
+    CParser
+  elsif defined?(JavaParser)
+    JavaParser
+  else
+    RubyParser
+  end
+
+  @max_frame_size = 1024 * 10 # 10KB
+
+  class << self
+    attr_accessor :max_frame_size
+
+    # Create a parse error from a string chunk and an index.
+    #
+    # @api private
+    # @param [String] chunk
+    # @param [Integer] index
+    # @return [ParseError]
+    def build_parse_error(chunk, index)
+      ctx = 7
+      min = [0, index - ctx].max
+      len = ctx + 1 + ctx
+      context = chunk.byteslice(min, len).force_encoding("BINARY")
+
+      idx = index - min
+      chr = context[idx]
+      context[idx] = " -->#{chr}<-- "
+
+      ParseError.new("unexpected #{chr} in chunk (#{context.inspect})")
+    end
+  end
+end

data/lib/stomp_parser/error.rb

@@ -0,0 +1,18 @@
+module StompParser
+  class Error < StandardError
+  end
+
+  # Errors raised by the Parser.
+  class ParseError < Error
+  end
+
+  # Raised when the Parser has reached the
+  # limit for how large a Frame may be.
+  #
+  # Protects against malicious clients trying to
+  # fill the available memory by sending very large
+  # frames, for example by sending an unlimited
+  # amount of headers.
+  class FrameSizeExceeded < ParseError
+  end
+end

data/lib/stomp_parser/frame.rb

@@ -0,0 +1,133 @@
+module StompParser
+  class Frame
+    HEADER_TRANSLATIONS = {
+      '\\r' => "\r",
+      '\\n' => "\n",
+      '\\c' => ":",
+      '\\\\' => '\\',
+    }.freeze
+    HEADER_TRANSLATIONS_KEYS = Regexp.union(HEADER_TRANSLATIONS.keys).freeze
+    HEADER_REVERSE_TRANSLATIONS = HEADER_TRANSLATIONS.invert
+    HEADER_REVERSE_TRANSLATIONS_KEYS = Regexp.union(HEADER_REVERSE_TRANSLATIONS.keys).freeze
+    EMPTY = "".force_encoding("UTF-8").freeze
+
+    # @return [String]
+    attr_reader :command
+
+    # @return [Hash<String, String>]
+    attr_reader :headers
+
+    # @return [String]
+    attr_reader :body
+
+    # Construct a frame from a command, optional headers, and a body.
+    #
+    # @param [String] command
+    # @param [Hash<String, String>] headers
+    # @param [String] body
+    def initialize(command, headers = {}, body)
+      @command = command || EMPTY
+      @headers = headers
+      @body = body || EMPTY
+    end
+
+    # Content length of this frame, according to headers.
+    #
+    # @raise [ArgumentError] if content-length is not a valid integer
+    # @return [Integer, nil]
+    def content_length
+      if headers.has_key?("content-length")
+        begin
+          Integer(headers["content-length"])
+        rescue ArgumentError
+          raise Error, "invalid content length #{headers["content-length"].inspect}"
+        end
+      end
+    end
+
+    def content_type
+      headers["content-type"]
+    end
+
+    # @raise [ArgumentError] if encoding does not exist
+    # @return [Encoding] body encoding, according to headers.
+    def content_encoding
+      if content_type
+        mime_type, charset = content_type.to_s.split(";")
+        mime_type = mime_type.to_s
+        charset = charset.to_s[/\Acharset=(.*)/, 1].to_s
+
+        if charset.empty? and mime_type.to_s.start_with?("text/")
+          Encoding::UTF_8
+        elsif charset.empty?
+          Encoding::BINARY
+        else
+          Encoding.find(charset)
+        end
+      else
+        Encoding::BINARY
+      end
+    end
+
+    # Change the command of this frame.
+    #
+    # @param [String] command
+    def write_command(command)
+      @command = command
+    end
+
+    # Write a single header to this frame.
+    #
+    # @param [String] key
+    # @param [String] value
+    def write_header(key, value)
+      # @see http://stomp.github.io/stomp-specification-1.2.html#Repeated_Header_Entries
+      key = translate_header(key)
+      @headers[key] = translate_header(value) unless @headers.has_key?(key)
+    end
+
+    # Write the body to this frame.
+    #
+    # @param [String] body
+    def write_body(body)
+      @body = body.force_encoding(content_encoding)
+    end
+
+    # @return [String] a string-representation of this frame.
+    def to_str
+      frame = "".force_encoding("UTF-8")
+      frame << command << "\n"
+
+      outgoing_headers = headers.dup
+      outgoing_headers["content-length"] = body.bytesize
+      outgoing_headers.each do |key, value|
+        frame << serialize_header(key) << ":" << serialize_header(value) << "\n"
+      end
+      frame << "\n"
+
+      frame << body << "\x00"
+      frame
+    end
+    alias_method :to_s, :to_str
+
+    def [](key)
+      @headers[key]
+    end
+
+    def destination
+      self["destination"]
+    end
+
+    private
+
+    # @see http://stomp.github.io/stomp-specification-1.2.html#Value_Encoding
+    def translate_header(value)
+      value.gsub(HEADER_TRANSLATIONS_KEYS, HEADER_TRANSLATIONS).force_encoding(Encoding::UTF_8) unless value.empty?
+    end
+
+    # inverse of #translate_header
+    def serialize_header(value)
+      value.to_s.gsub(HEADER_REVERSE_TRANSLATIONS_KEYS, HEADER_REVERSE_TRANSLATIONS)
+    end
+  end
+end

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