syntropy 0.29.0 → 0.30.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: syntropy
 version: !ruby/object:Gem::Version
-  version: 0.29.0
+  version: 0.30.0
 platform: ruby
 authors:
 - Sharon Rosner
@@ -38,47 +38,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.2.0
 - !ruby/object:Gem::Dependency
-  name: qeweney
+  name: uringmachine
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.24'
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.24'
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
-  name: uringmachine
+  name: cgi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: listen
+  name: escape_utils
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 3.9.0
+        version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 3.9.0
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -196,18 +196,25 @@ files:
 - lib/syntropy/applets/builtin/json_api.js
 - lib/syntropy/applets/builtin/ping.rb
 - lib/syntropy/applets/builtin/req.rb
-- lib/syntropy/connection.rb
 - lib/syntropy/connection_pool.rb
 - lib/syntropy/dev_mode.rb
 - lib/syntropy/errors.rb
+- lib/syntropy/http.rb
+- lib/syntropy/http/connection.rb
+- lib/syntropy/http/server.rb
+- lib/syntropy/http/status.rb
 - lib/syntropy/json_api.rb
 - lib/syntropy/logger.rb
 - lib/syntropy/markdown.rb
+- lib/syntropy/mime_types.rb
 - lib/syntropy/module.rb
 - lib/syntropy/papercraft_extensions.rb
-- lib/syntropy/request_extensions.rb
+- lib/syntropy/request.rb
+- lib/syntropy/request/mock_adapter.rb
+- lib/syntropy/request/request_info.rb
+- lib/syntropy/request/response.rb
+- lib/syntropy/request/validation.rb
 - lib/syntropy/routing_tree.rb
-- lib/syntropy/server.rb
 - lib/syntropy/side_run.rb
 - lib/syntropy/utils.rb
 - lib/syntropy/version.rb
@@ -252,8 +259,11 @@ files:
 - test/test_connection_pool.rb
 - test/test_errors.rb
 - test/test_json_api.rb
+- test/test_mock_adapter.rb
 - test/test_module.rb
 - test/test_request_extensions.rb
+- test/test_request_info.rb
+- test/test_response.rb
 - test/test_routing_tree.rb
 - test/test_server.rb
 - test/test_side_run.rb

data/lib/syntropy/connection.rb

@@ -1,402 +0,0 @@
-# frozen_string_literal: true
-
-require 'qeweney'
-require 'stringio'
-require 'syntropy/errors'
-require 'syntropy/request_extensions'
-
-module Syntropy
-  # Implements an HTTP/1.1 connection received by the Syntropy server. This
-  # implementation rejects incoming HTTP/0.9 or HTTP/1.0 requests. The response
-  # body is sent exclusively using chunked transfer encoding. Request bodies are
-  # accepted using either fixed length (Content-Length header) or chunked
-  # transfer encoding.
-  class Connection
-    attr_reader :fd, :response_headers, :logger
-
-    def initialize(server, machine, fd, env, &app)
-      @server = server
-      @machine = machine
-      @fd = fd
-      @env = env
-      @logger = env[:logger]
-      @io = machine.io(fd, :socket)
-      @app = app
-
-      @done = nil
-      @response_headers = nil
-    end
-
-    def run
-      loop do
-        @done = nil
-        @response_headers = nil
-        persist = serve_request
-        break if !persist
-      end
-    rescue UM::Terminate
-      # server is terminated, do nothing
-    rescue StandardError => e
-      @logger&.error(
-        message:  'Uncaught error while running connection',
-        error:    e
-      )
-    ensure
-      @machine.close_async(@fd)
-    end
-
-    # Processes an incoming request by parsing the headers, creating a request
-    # object and handing it off to the app handler. Returns true if the
-    # connection should be persisted.
-    def serve_request
-      @closed = nil
-      headers = parse_headers
-      return false if !headers
-
-      request = Qeweney::Request.new(headers, self)
-
-      request.start_stamp = monotonic_clock
-      @app.call(request)
-      persist_connection?(headers)
-    rescue StandardError => e
-      handle_error(request, e)
-      false
-    end
-
-    # Handles an error encountered while serving a request by logging the error
-    # and optionally sending an error response with the relevant HTTP status
-    # code. For I/O errors, no response is sent.
-    #
-    # @param request [Qeweney::Request] HTTP request
-    # @param err [Exception] error
-    # @return [void]
-    def handle_error(request, err)
-      case err
-      when SystemCallError
-        log_error(err, 'I/O error')
-        false
-      when ProtocolError
-        log_error(err, err.message)
-        respond(request, err.message, ':status' => err.http_status)
-      else
-        log_error(err, 'Internal error')
-        return if !request || @done
-
-        respond(request, 'Internal server error', ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
-      end
-    end
-
-    # Logs the given err and given message.
-    #
-    # @param err [Exception] error
-    # @param message [String] error message
-    # @return [void]
-    def log_error(err, message)
-      @logger&.error(message: "#{message}, closing connection", error: err)
-    end
-
-    def get_body(req)
-      headers = req.headers
-      return nil if headers[':body-done-reading']
-
-      content_length = headers['content-length']
-      if content_length
-
-        chunk = @io.read(content_length.to_i)
-        headers[':body-done-reading'] = true
-        return chunk
-      end
-
-      chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
-      if chunked_encoding
-        buf = +''
-        while (chunk = read_chunk(headers, nil))
-          buf << chunk
-        end
-        headers[':body-done-reading'] = true
-        return buf
-      end
-
-      nil
-    end
-
-    def get_body_chunk(req, _buffered_only = false)
-      headers = req.headers
-      content_length = headers['content-length']
-      if content_length
-        return nil if headers[':body-done-reading']
-
-        chunk = @io.read(content_length.to_i)
-        headers[':body-done-reading'] = true
-        return chunk
-      end
-
-      chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
-      return read_chunk(headers, nil) if chunked_encoding
-
-      return nil if headers[':body-done-reading']
-
-      # if content-length is not specified, we read to EOF, up to max 1MB size
-      chunk = read(1 << 20, nil, false)
-      headers[':body-done-reading'] = true
-      chunk
-    end
-
-    def complete?(req)
-      req.headers[':body-done-reading']
-    end
-
-    # response API
-
-    # Sets response headers before sending any response. This method is used to
-    # add headers such as Set-Cookie or cache control headers to a response
-    # before actually responding, specifically in middleware hooks.
-    #
-    # @param headers [Hash] response headers
-    # @return [void]
-    def set_response_headers(headers)
-      @response_headers ? @response_headers.merge!(headers) : @response_headers = headers
-    end
-
-    def set_cookie(*cookies)
-      existing_cookies = @response_headers && @response_headers['Set-Cookie']
-      if existing_cookies
-        @response_headers['Set-Cookie'] = existing_cookies + cookies
-      else
-        set_response_headers('Set-Cookie' => cookies)
-      end
-    end
-
-    SEND_FLAGS = UM::MSG_NOSIGNAL | UM::MSG_WAITALL
-
-    EMPTY_CHUNK = "0\r\n\r\n"
-    EMPTY_CHUNK_LEN = EMPTY_CHUNK.bytesize
-
-    CHUNKED_ENCODING_POSTLUDE = "\r\n#{EMPTY_CHUNK}"
-
-    # Sends response including headers and body. Waits for the request to complete
-    # if not yet completed. The body is sent using chunked transfer encoding.
-    # @param request [Qeweney::Request] HTTP request
-    # @param body [String] response body
-    # @param headers
-    def respond(request, body, headers)
-      headers = @response_headers.merge(headers) if @response_headers
-
-      formatted_headers = format_headers(headers, body)
-      @response_headers = headers
-      request&.tx_incr(formatted_headers.bytesize + (body ? body.bytesize : 0))
-      if body
-        chunk_prelude = "#{body.bytesize.to_s(16)}\r\n"
-        @machine.sendv(@fd, formatted_headers, chunk_prelude, body, CHUNKED_ENCODING_POSTLUDE)
-      else
-        @machine.send(@fd, formatted_headers, formatted_headers.bytesize, SEND_FLAGS)
-      end
-      @logger&.info(request: request, response_headers: headers) if request
-      @done = true
-    end
-
-    # Sends response headers. If empty_response is truthy, the response status
-    # code will default to 204, otherwise to 200.
-    # @param request [Qeweney::Request] HTTP request
-    # @param headers [Hash] response headers
-    # @param empty_response [boolean] whether a response body will be sent
-    # @return [void]
-    def send_headers(request, headers, empty_response: false)
-      formatted_headers = format_headers(headers, !empty_response)
-      request.tx_incr(formatted_headers.bytesize)
-      @machine.send(@fd, formatted_headers, formatted_headers.bytesize, SEND_FLAGS)
-      @response_headers = headers
-    end
-
-    # Sends a response body chunk. If no headers were sent, default headers are
-    # sent using #send_headers. if the done option is true(thy), an empty chunk
-    # will be sent to signal response completion to the client.
-    # @param request [Qeweney::Request] HTTP request
-    # @param chunk [String] response body chunk
-    # @param done [boolean] whether the response is completed
-    # @return [void]
-    def send_chunk(request, chunk, done: false)
-      data = +''
-      data << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n" if chunk
-      data << EMPTY_CHUNK if done
-      return if data.empty?
-
-      request.tx_incr(data.bytesize)
-      @machine.send(@fd, data, data.bytesize, SEND_FLAGS)
-      return if @done || !done
-
-      @logger&.info(request: request, response_headers: @response_headers)
-      @done = true
-    end
-
-    # Finishes the response to the current request. If no headers were sent,
-    # default headers are sent using #send_headers.
-    # @return [void]
-    def finish(request)
-      request.tx_incr(EMPTY_CHUNK_LEN)
-      @machine.send(@fd, EMPTY_CHUNK, EMPTY_CHUNK_LEN, SEND_FLAGS)
-      return if @done
-
-      @logger&.info(request, request, response_headers: @response_headers)
-      @done = true
-    end
-
-    def respond_with_static_file(req, path, env, cache_headers)
-      fd = @machine.open(path, UM::O_RDONLY)
-      env ||= {}
-      if env[:headers]
-        env[:headers].merge!(cache_headers)
-      else
-        env[:headers] = cache_headers
-      end
-
-      maxlen = env[:max_len] || 65_536
-      buf = String.new(capacity: maxlen)
-      headers_sent = nil
-      loop do
-        res = @machine.read(fd, buf, maxlen, 0)
-        if res < maxlen && !headers_sent
-          return respond(req, buf, env[:headers])
-        elsif res == 0
-          return finish(req)
-        end
-
-        if !headers_sent
-          send_headers(req, env[:headers])
-          headers_sent = true
-        end
-        done = res < maxlen
-        send_chunk(req, buf, done: done)
-        return if done
-      end
-    end
-
-    def close
-      return if @closed
-
-      @closed = true
-      @machine.shutdown(@fd, UM::SHUT_WR)
-      @machine.close_async(@fd)
-    end
-
-    def monotonic_clock
-      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-    end
-
-    def with_stream
-      yield @io, @fd
-    end
-
-    private
-
-    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 persist_connection?(headers)
-      connection = headers['connection']&.downcase
-      return connection != 'close'
-    end
-
-    def parse_headers
-      headers = get_request_line(MAX_REQUEST_LINE_LEN)
-      return nil if !headers
-
-      loop do
-        line = @io.read_line(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 = @io.read_line(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
-
-    def read_chunk(headers, buffer)
-      chunk_size_str = @io.read_line(MAX_CHUNK_SIZE_LEN)
-      return nil if !chunk_size_str
-
-      chunk_size = chunk_size_str.to_i(16)
-      if chunk_size == 0
-        headers[':body-done-reading'] = true
-        @io.read_line(0)
-        return nil
-      end
-
-      chunk = @io.read(chunk_size)
-      @io.read_line(0)
-
-      buffer ? (buffer << chunk) : chunk
-    end
-
-    INTERNAL_HEADER_REGEXP = /^:/
-
-    # Formats response headers into an array. If empty_response is true(thy),
-    # the response status code will default to 204, otherwise to 200.
-    # @param headers [Hash] response headers
-    # @param body [boolean] whether a response body will be sent
-    # @return [String] formatted response headers
-    def format_headers(headers, body)
-      status = headers[':status'] || (body ? Qeweney::Status::OK : Qeweney::Status::NO_CONTENT)
-      lines = format_status_line(body, status)
-      lines << @env[:server_headers] if @env[:server_headers]
-      headers.each do |k, v|
-        next if k =~ INTERNAL_HEADER_REGEXP
-
-        collect_header_lines(lines, k, v)
-      end
-      lines << "\r\n"
-      lines
-    end
-
-    def format_status_line(body, status)
-      if !body
-        empty_status_line(status)
-      else
-        with_body_status_line(status, body)
-      end
-    end
-
-    def empty_status_line(status)
-      if status == 204
-        +"HTTP/1.1 #{status}\r\n"
-      else
-        +"HTTP/1.1 #{status}\r\nContent-Length: 0\r\n"
-      end
-    end
-
-    def with_body_status_line(status, body)
-      +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
-    end
-
-    def collect_header_lines(lines, key, value)
-      if value.is_a?(Array)
-        value.inject(lines) { |_, item| lines << "#{key}: #{item}\r\n" }
-      else
-        lines << "#{key}: #{value}\r\n"
-      end
-    end
-  end
-end

data/lib/syntropy/server.rb

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-require 'syntropy/connection'
-require 'syntropy/request_extensions'
-
-module Syntropy
-  class Server
-    PENDING_REQUESTS_GRACE_PERIOD = 0.1
-    PENDING_REQUESTS_TIMEOUT_PERIOD = 5
-
-    def self.syntropy_app(_machine, env)
-      if env[:app_location]
-        env[:logger]&.info(message: 'Loading web app', location: env[:app_location])
-        require env[:app_location]
-
-        env.merge!(Syntropy.config)
-      end
-      env[:app]
-    end
-
-    def self.static_app(env); end
-
-    def initialize(machine, env, &app)
-      @machine = machine
-      @env = env
-      @app = app || app_from_env
-      @server_fds = []
-      @accept_fibers = []
-    end
-
-    def app_from_env
-      case @env[:app_type]
-      when nil, :syntropy
-        Server.syntropy_app(@machine, @env)
-      when :static
-        Server.static_app(@env)
-      else
-        raise "Invalid app type #{@env[:app_type].inspect}"
-      end
-    end
-
-    def run
-      setup
-      @machine.await(@accept_fibers)
-    rescue UM::Terminate
-      graceful_shutdown
-    end
-
-    def stop!
-      graceful_shutdown
-    end
-
-    private
-
-    def setup
-      bind_info = get_bind_entries
-      bind_info.each do |(host, port)|
-        fd = setup_server_socket(host, port)
-        @server_fds << fd
-        @accept_fibers << @machine.spin { accept_incoming(fd) }
-      end
-      bind_string = bind_info.map { it.join(':') }.join(', ')
-      @env[:logger]&.info(message: "Listening on #{bind_string}")
-      setup_server_extensions
-
-      # map fibers
-      @connection_fibers = Set.new
-    end
-
-    def get_bind_entries
-      bind = @env[:bind]
-      case bind
-      when Array
-        bind.map { bind_info(it) }
-      when String
-        [bind_info(bind)]
-      else
-        # default
-        [['0.0.0.0', 1234]]
-      end
-    end
-
-    def bind_info(bind_string)
-      parts = bind_string.split(':')
-      [parts[0], parts[1].to_i]
-    end
-
-    def setup_server_socket(host, port)
-      fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-      @machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
-      @machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEPORT, true)
-      @machine.bind(fd, host, port)
-      @machine.listen(fd, UM::SOMAXCONN)
-      fd
-    end
-
-    def setup_server_extensions
-      extensions = @env[:server_extensions]
-      return if !extensions
-
-      server_name = extensions[:name]
-      if extensions[:date]
-        @date_header_fiber = @machine.spin {
-          @machine.periodically(1) { update_server_headers(server_name) }
-        }
-        update_server_headers(server_name)
-      elsif server_name
-        @env[:server_headers] = "Server: #{server_name}\r\n"
-      end
-    end
-
-    def update_server_headers(server_name)
-      @env[:server_date] = Time.now
-      if server_name
-        @env[:server_headers] = "Server: #{server_name}\r\nDate: #{@env[:server_date].httpdate}\r\n"
-      else
-        @env[:server_headers] = "Date: #{Time.now.httpdate}\r\n"
-      end
-    end
-
-    def accept_incoming(listen_fd)
-      @machine.accept_each(listen_fd) { start_client_connection(it) }
-    rescue UM::Terminate
-      # terminated
-    end
-
-    def start_client_connection(fd)
-      conn = Connection.new(self, @machine, fd, @env, &@app)
-      f = @machine.spin(conn) do
-        it.run
-      ensure
-        @connection_fibers.delete(f)
-      end
-      @connection_fibers << f
-    end
-
-    def close_all_server_fds
-      @server_fds.each { @machine.close_async(it) }
-    end
-
-    STOP = UM::Terminate.new
-
-    def stop_accept_fibers
-      @accept_fibers.each { @machine.schedule(it, STOP) if !it.done? }
-      @machine.await(@accept_fibers)
-    end
-
-    def graceful_shutdown
-      @env[:logger]&.info(message: 'Shutting down gracefully...')
-
-      # stop listening
-      close_all_server_fds
-      stop_accept_fibers
-      @machine.snooze
-
-      return if @connection_fibers.empty?
-
-      # sleep for a bit, let requests finish
-      @machine.sleep(PENDING_REQUESTS_GRACE_PERIOD)
-      return if @connection_fibers.empty?
-
-      # terminate pending fibers
-      pending = @connection_fibers.to_a
-      pending.each { @machine.schedule(it, STOP) }
-
-      @machine.timeout(PENDING_REQUESTS_TIMEOUT_PERIOD, UM::Terminate) do
-        @machine.await(@connection_fibers)
-      rescue UM::Terminate
-        # timeout on waiting for adapters to finish running, do nothing
-      end
-    end
-  end
-end