tp2 0.19.1 → 0.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11150b296eb03a7cc91e71c55a4f4738977aa423525e6c51f47467deec175f89
-  data.tar.gz: f4fc0cb3407f322c1f3dc20f5b5c0ec4f6e68b32a32e5eb1079b5db0aeebe38d
+  metadata.gz: 3ecde63feddaaf920da1342c895b9ee40045dc56088d1b5668bd96cd98a26d84
+  data.tar.gz: bd79ac1a84bdfb208a1e5f19c72c9023ecf2a3c41b33977d8082c18fa8b40925
 SHA512:
-  metadata.gz: 2b12e3db4d8d746b8914038824590ed6ff07dcdd9d72857d7c37e96558e78e483fd179fe333472f089a3b8f3134fd56ce1dd35a9a8d43ffda65a7723dc2bc1e4
-  data.tar.gz: 72391f14fe4dfc227edff22e49441759cdf038f5676947a169dbe924543bb29e9439f5688aae0e6b04d5c49b21618d098b08337e63035140c614a2d85bfae718
+  metadata.gz: e6a0a68e0693206db0ad721c058e28365a105135d0fdb34b10c7ae059b82d4cb90701cc2c84546a66359533f28ba1e90f382293d27670894d2ab6aeaf30964d9
+  data.tar.gz: ae6baf0c99d571ffbce56db855c68ed571569747d695e74034b4a3cecf5a47e4ffdd0816c07d45eb4b19ac4b389e42eb976409ae39b801feea4aa3be2efd200a

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.19.2 2025-11-03
+
+- Update UringMachine
+
 # 0.19.1 2025-10-27
 
 - Update UringMachine

data/TODO.md

@@ -1,23 +1,7 @@
 ## Immediate
 
-- [v] Remove support for HTTP/0.9, HTTP/1.0
-  - [v] Reply with 505 HTTP version not supported:
-
-    ```
-    < GET / HTTP/0.9
-
-    > HTTP/1.1 505
-    > Connection: close
-    ```
-
-- [v] Use chunked transfer encoding exclusively
-- [ ] Cache rendered headers
-  - [ ] Look at sketch in ~/Desktop/docs/
-
-- [v] Add options for:
-  - [v] Date header
-  - [v] Server header
-
+- [ ] Reimplement HTTP parsing, performance could be much improved. See
+      `examples/perf_parser.rb` and also: https://github.com/puma/puma/pull/3660
 - [ ] Change signal handling to use self-pipe
 
 ##

data/examples/perf_parser.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  gem 'uringmachine'
+  gem 'benchmark'
+  gem 'benchmark-ips', '>= 2.14.0'
+end
+
+require 'uringmachine'
+require 'benchmark/ips'
+
+require 'strscan'
+
+class TP2Parser
+  def initialize(machine, fd)
+    @machine = machine
+    @fd = fd
+    @stream = UM::Stream.new(machine, fd)
+  end
+
+  def run
+    parse_headers
+  end
+
+  RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+http\/([019\.]{1,3})/i
+  RE_HEADER_LINE = /^([a-z0-9-]+):\s+(.+)/i
+  MAX_REQUEST_LINE_LEN = 1 << 14 # 16KB
+  MAX_HEADER_LINE_LEN = 1 << 10 # 1KB
+  MAX_CHUNK_SIZE_LEN = 16
+
+  def parse_headers
+    buf = String.new(capacity: 4096)
+    headers = get_request_line(buf)
+    return nil if !headers
+    
+    loop do
+      line = @stream.get_line(buf, MAX_HEADER_LINE_LEN)
+      break if line.nil? || line.empty?
+      m = line.match(RE_HEADER_LINE)
+      raise ProtocolError, "Invalid header: #{line[0..2047].inspect}" if !m
+      headers[m[1].downcase] = m[2]
+    end
+    
+    headers
+  end
+
+  def get_request_line(buf)
+    line = @stream.get_line(buf, MAX_REQUEST_LINE_LEN)
+    return nil if !line
+
+    m = line.match(RE_REQUEST_LINE)
+    raise ProtocolError, 'Invalid request line' if !m
+
+    http_version = m[3]
+    raise UnsupportedHTTPVersionError, 'HTTP version not supported' if http_version != '1.1'
+    
+    {
+      ':method'   => m[1].downcase,
+      ':path'     => m[2],
+      ':protocol' => 'http/1.1'
+    }
+  end
+end
+
+class PumaHttpParser
+  STEPS = [
+    :http_method,
+    :target,
+    :version,
+    :headers,
+    :body
+  ]
+
+  # Step delimeters
+  SPACE = /\s/
+  RETURN_OR_NEWLINE = /[\r\n]/
+
+  SSL = "Invalid HTTP format, parsing fails. Are you trying to open an SSL connection to a non-SSL Puma?"
+
+  METHODS = %r{#{'GET|POST|HEAD|PUT|DELETE'}\b}
+  WS = /\s+/
+  def http_method(req)
+    req["REQUEST_METHOD"] = (@scanner.scan(METHODS) || raise_error!("Invalid HTTP format, parsing fails. Are you trying to open an SSL connection to a non-SSL Puma?")).strip
+    @scanner.skip(WS)
+    @step += 1
+  end
+
+  # URL components
+  URI = /[^\s#]+/ # Match everything up until whitespace or a hash
+  SCHEME = %r{\Ahttps?://}
+  PARTS = /\A(?<path>[^?#]*)(\?(?<params>[^#]*))?/
+  NWS = /\S*/ # not white space
+  FRAGMENT_DELIMETER = /#/
+  UNPRINTABLE_CHARACTERS = %r{[^ -~]} # find a character that's not between " " (space) and "~" (tilde)
+  def target(req)
+    uri = @scanner.scan(URI)
+    req["REQUEST_URI"] = uri
+    raise_error!("HTTP element REQUEST_URI is longer than the (1024 * 12) allowed length (was #{uri.length})") if uri.length > 1024 * 12
+    unless uri.match? SCHEME
+      parts = PARTS
+        .match(uri)
+        .named_captures
+      path = parts["path"]
+      if path.match? UNPRINTABLE_CHARACTERS
+        raise_error!(SSL)
+      else
+        req["REQUEST_PATH"] = path
+        raise_error!("HTTP element REQUEST_PATH is longer than the (8192) allowed length (was #{path.length})") if path.length > 8192
+      end
+      params = parts["params"] || ""
+      if params.match? UNPRINTABLE_CHARACTERS
+        raise_error!(SSL)
+      else
+        req["QUERY_STRING"] = params
+        raise_error!("HTTP element QUERY_STRING is longer than the (1024 * 10) allowed length (was #{params.length})") if params.length > 1024 * 10
+      end
+      if @scanner.skip(FRAGMENT_DELIMETER)
+        req["FRAGMENT"] = @scanner.scan(NWS)
+        raise_error!("HTTP element FRAGMENT is longer than the 1024 allowed length (was #{req["FRAGMENT"].length})") if req["FRAGMENT"].length > 1024
+      end
+    end
+    @scanner.scan(WS)
+    @step += 1
+  end
+
+  HTTP_VERSION = %r{(HTTP/1\.[01])}
+  RETURN_NEWLINE = %r{\r\n}
+  NEWLINE = %r{\n}
+  def version(req)
+    req["SERVER_PROTOCOL"] = @scanner.scan(HTTP_VERSION) || raise_error!(SSL)
+    @scanner.skip(RETURN_NEWLINE) || raise_error!
+    @delimeter = RETURN_OR_NEWLINE
+    @step += 1
+  end
+
+  HEADER = %r{[^\r\n]+\r\n}
+  HEADER_FORMAT = /\A([^:]+):\s*([^\r\n]+)/
+  DIGITS = /\A\d+\z/
+  TRAILING_WS = /\s*$/
+  def headers(req)
+    while header = @scanner.scan(HEADER)
+      @headers_count += 1
+      raise_error! if @headers_count > 1024 # TODO Use a  better number
+      @headers_total_length += header.length
+      raise_error!("HTTP element HEADER is longer than the (1024 * (80 + 32)) allowed length (was 114930)") if @headers_total_length > 1024 * (80 + 32) # TODO Need to figure out how to calculate 114930 better.
+      raise_error! unless HEADER_FORMAT.match(header)
+      key = $1
+      value = $2
+      raise_error!("HTTP element FIELD_NAME is longer than the 256 allowed length (was #{key.length})") if key.length > 256
+      raise_error!("HTTP element FIELD_VALUE is longer than the 80 * 1024 allowed length (was #{value.length})") if value.length > 80 * 1024
+      raise_error! if value.match?(NEWLINE)
+      key = key.upcase.tr("_-", ",_")
+      key = "HTTP_#{key}" unless ["CONTENT_LENGTH", "CONTENT_TYPE"].include?(key)
+      value = value.rstrip
+      if req.has_key?(key)
+        req[key] << ", #{value}"
+      else
+        req[key] = value
+      end
+    end
+    if @scanner.skip(RETURN_NEWLINE)
+      @step += 1
+      @finished = true
+    end
+    raise_error!(SSL) if @scanner.exist?(/[^\r]\n/) # catch bad headers that are missing a return.
+    raise_error!(SSL) if @scanner.exist?(/\r[^\n]/) # catch bad headers that are missing a newline.
+  end
+
+  def execute(req, data, start)
+    unless @scanner
+      reset
+      @scanner = StringScanner.new(data)
+    end
+
+    send(STEPS[@step], req) while !@finished && @scanner.exist?(@delimeter)
+
+    if @step == 0
+      raise_error!("Invalid HTTP format, parsing fails. Are you trying to open an SSL connection to a non-SSL Puma?")
+    end
+
+    nread
+  end
+
+  def body
+    @body ||= @scanner.rest.tap { @scanner.terminate } # Using terminate feels hacky to me. Is there something better?
+  end
+
+  def nread
+    @scanner&.pos || 0
+  end
+
+  def reset
+    @step = 0
+    @finished = false
+    @delimeter = SPACE
+    @error = false
+    @scanner = nil
+    @body = nil
+    @headers_count = 0
+    @headers_total_length = 0
+  end
+
+  def finished?
+    @finished
+  end
+
+  def raise_error!(message = nil)
+    @error = true
+    raise HttpParserError.new(message)
+  end
+
+  def error?
+    @error
+  end
+end
+
+
+
+
+REQ = "GET /foo/bar HTTP/1.1\r\nHost: foobar.com\r\nAccept: blah blah\r\n\r\n"
+
+@machine = UM.new
+
+def run_tp2
+  r, w = UM.pipe
+  parser = TP2Parser.new(@machine, r)
+  @machine.write(w, REQ)
+  @machine.close_async(w)
+
+  parser.run
+end
+
+p run_tp2
+
+def run_puma_pure_ruby
+  parser = PumaHttpParser.new
+  req = {}
+  r, w = UM.pipe
+  @machine.write(w, REQ)
+  @machine.close_async(w)
+  data = +''
+  @machine.read(r, data, 8192)
+  parser.execute(req, data, 0)
+  req
+end
+
+p run_puma_pure_ruby
+
+Benchmark.ips do |x|
+  x.config(:time => 10, :warmup => 3)
+
+  x.report("tp2") { run_tp2 }
+  x.report("puma") { run_puma_pure_ruby }
+
+  x.compare!(order: :baseline)
+end

data/lib/tp2/version.rb

@@ -1,3 +1,3 @@
 module TP2
-  VERSION = '0.19.1'
+  VERSION = '0.19.2'
 end

data/tp2.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 3.4'
   s.executables   = ['tp2']
 
-  s.add_dependency 'uringmachine',    '~> 0.19'
+  s.add_dependency 'uringmachine',    '~> 0.19.1'
   s.add_dependency 'qeweney',         '~> 0.23'
   s.add_dependency 'rack',            '~> 3.1.15'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tp2
 version: !ruby/object:Gem::Version
-  version: 0.19.1
+  version: 0.19.2
 platform: ruby
 authors:
 - Sharon Rosner
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: 0.19.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: 0.19.1
 - !ruby/object:Gem::Dependency
   name: qeweney
   requirement: !ruby/object:Gem::Requirement
@@ -68,6 +68,7 @@ files:
 - TODO.md
 - bin/tp2
 - examples/app.rb
+- examples/perf_parser.rb
 - examples/rack.ru
 - examples/simple.rb
 - lib/tp2.rb