syntropy 0.29.0 → 0.31.0

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/request_extensions.rb

@@ -1,308 +0,0 @@
-# frozen_string_literal: true
-
-require 'qeweney'
-require 'json'
-
-class Qeweney::Request
-  attr_accessor :start_stamp
-
-  def respond_with_static_file(path, etag, last_modified, opts)
-    cache_headers = (etag || last_modified) ? {
-      'etag' => etag,
-      'last-modified' => last_modified
-    } : {}
-
-    adapter.respond_with_static_file(self, path, opts, cache_headers)
-  end
-
-  def set_response_headers(headers)
-    adapter.set_response_headers(headers)
-  end
-
-  def set_cookie(*)
-    adapter.set_cookie(*)
-  end
-
-  def upgrade(protocol, custom_headers = nil, &block)
-    super(protocol, custom_headers)
-    adapter.with_stream(&block)
-  end
-end
-
-module Syntropy
-  # Extensions for the Qeweney::Request class
-  module RequestExtensions
-    attr_reader :route_params
-    attr_accessor :route
-
-    # Initializes request with additional fields
-    def initialize(headers, adapter)
-      @headers  = headers
-      @adapter  = adapter
-      @route = nil
-      @route_params = {}
-      @ctx = nil
-    end
-
-    # Sets up mock request additional fields
-    def setup_mock_request
-      @route = nil
-      @route_params = {}
-      @ctx = nil
-    end
-
-    # Returns the request context
-    def ctx
-      @ctx ||= {}
-    end
-
-    # Checks the request's HTTP method against the given accepted values. If not
-    # included in the accepted values, raises an exception. Otherwise, returns
-    # the request's HTTP method.
-    #
-    # @param accepted [Array<String>] list of accepted HTTP methods
-    # @return [String] request's HTTP method
-    def validate_http_method(*accepted)
-      return method if accepted.include?(method)
-
-      raise Syntropy::Error.method_not_allowed
-    end
-
-    # Responds according to the given map. The given map defines the responses
-    # for each method. The value for each method is either an array containing
-    # the body and header values to use as response, or a proc returning such an
-    # array. For example:
-    #
-    #     req.respond_by_http_method(
-    #       'head'  => [nil, headers],
-    #       'get'   => -> { [IO.read(fn), headers] }
-    #     )
-    #
-    # If the request's method is not included in the given map, an exception is
-    # raised.
-    #
-    # @param map [Hash] hash mapping HTTP methods to responses
-    # @return [void]
-    def respond_by_http_method(map)
-      value = map[self.method]
-      raise Syntropy::Error.method_not_allowed if !value
-
-      value = value.() if value.is_a?(Proc)
-      (body, headers) = value
-      respond(body, headers)
-    end
-
-    # Responds to GET requests with the given body and headers. Otherwise raises
-    # an exception.
-    #
-    # @param body [String, nil] response body
-    # @param headers [Hash] response headers
-    # @return [void]
-    def respond_on_get(body, headers = {})
-      case self.method
-      when 'head'
-        respond(nil, headers)
-      when 'get'
-        respond(body, headers)
-      else
-        raise Syntropy::Error.method_not_allowed
-      end
-    end
-
-    # Responds to POST requests with the given body and headers. Otherwise
-    # raises an exception.
-    #
-    # @param body [String, nil] response body
-    # @param headers [Hash] response headers
-    # @return [void]
-    def respond_on_post(body, headers = {})
-      case self.method
-      when 'head'
-        respond(nil, headers)
-      when 'post'
-        respond(body, headers)
-      else
-      raise Syntropy::Error.method_not_allowed
-      end
-    end
-
-    # Validates and optionally converts request parameter value for the given
-    # parameter name against the given clauses. If no clauses are given,
-    # verifies the parameter value is not nil. A clause can be a class, such as
-    # String, Integer, etc, in which case the value is converted into the
-    # corresponding value. A clause can also be a range, for verifying the value
-    # is within the range. A clause can also be an array of two or more clauses,
-    # at least one of which should match the value. If the validation fails, an
-    # exception is raised. Example:
-    #
-    #     height = req.validate_param(:height, Integer, 1..100)
-    #
-    # @param name [Symbol] parameter name
-    # @clauses [Array] one or more validation clauses
-    # @return [any] validated parameter value
-    def validate_param(name, *clauses)
-      validate(query[name], *clauses)
-    end
-
-    # Validates and optionally converts a value against the given clauses. If no
-    # clauses are given, verifies the parameter value is not nil. A clause can
-    # be a class, such as String, Integer, etc, in which case the value is
-    # converted into the corresponding value. A clause can also be a range, for
-    # verifying the value is within the range. A clause can also be an array of
-    # two or more clauses, at least one of which should match the value. If the
-    # validation fails, an exception is raised.
-    #
-    # @param value [any] value
-    # @clauses [Array] one or more validation clauses
-    # @return [any] validated value
-    def validate(value, *clauses)
-      raise Syntropy::ValidationError, 'Validation error' if clauses.empty? && !value
-
-      clauses.each do |c|
-        valid = param_is_valid?(value, c)
-        raise(Syntropy::ValidationError, 'Validation error') if !valid
-
-        value = param_convert(value, c)
-      end
-      value
-    end
-
-    # Validates request cache information. If the request cache information
-    # matches the given etag or last_modified values, responds with a 304 Not
-    # Modified status. Otherwise, yields to the given block for a normal
-    # response, and sets cache control headers according to the given arguments.
-    #
-    # @param cache_control [String] value for Cache-Control header
-    # @param etag [String, nil] Etag header value
-    # @param last_modified [String, nil] Last-Modified header value
-    # @return [void]
-    def validate_cache(cache_control: 'public', etag: nil, last_modified: nil)
-      validated = false
-      if (client_etag = headers['if-none-match'])
-        validated = true if client_etag == etag
-      end
-      if (client_mtime = headers['if-modified-since'])
-        validated = true if client_mtime == last_modified
-      end
-      if validated
-        respond(nil, ':status' => Qeweney::Status::NOT_MODIFIED)
-      else
-        cache_headers = {
-          'Cache-Control' => cache_control
-        }
-        cache_headers['Etag'] = etag if etag
-        cache_headers['Last-Modified'] = last_modified if last_modified
-        set_response_headers(cache_headers)
-        yield
-      end
-    end
-
-    # Reads the request body and returns form data.
-    #
-    # @return [Hash] form data
-    def get_form_data
-      body = read
-      if !body || body.empty?
-        raise Syntropy::Error.new('Missing form data', Qeweney::Status::BAD_REQUEST)
-      end
-
-      Qeweney::Request.parse_form_data(body, headers)
-    rescue Qeweney::BadRequestError
-      raise Syntropy::Error.new('Invalid form data', Qeweney::Status::BAD_REQUEST)
-    end
-
-    def html_response(html, **headers)
-      respond(
-        html,
-        'Content-Type' => 'text/html; charset=utf-8',
-        **headers
-      )
-    end
-
-    def json_response(obj, **headers)
-      respond(
-        JSON.dump(obj),
-        'Content-Type' => 'application/json; charset=utf-8',
-        **headers
-      )
-    end
-
-    def json_pretty_response(obj, **headers)
-      respond(
-        JSON.pretty_generate(obj),
-        'Content-Type' => 'application/json; charset=utf-8',
-        **headers
-      )
-    end
-
-    def browser?
-      user_agent = headers['user-agent']
-      user_agent && user_agent =~ /^Mozilla\//
-    end
-
-    # Returns true if the accept header includes the given MIME type
-    #
-    # @param mime_type [String] MIME type
-    # @return [bool]
-    def accept?(mime_type)
-      accept = headers['accept']
-      return nil if !accept
-
-      @accept_parts ||= parse_accept_parts(accept)
-      @accept_parts.include?(mime_type)
-    end
-
-    private
-
-    def parse_accept_parts(accept)
-      accept.split(',').map { it.match(/^\s*([^\s;]+)/)[1] }
-    end
-
-    BOOL_REGEXP = /^(t|f|true|false|on|off|1|0|yes|no)$/
-    BOOL_TRUE_REGEXP = /^(t|true|on|1|yes)$/
-    INTEGER_REGEXP = /^[+-]?[0-9]+$/
-    FLOAT_REGEXP = /^[+-]?[0-9]+(\.[0-9]+)?$/
-
-    # Returns true the given value matches the given condition.
-    #
-    # @param value [any] value
-    # @param cond [any] condition
-    # @return [bool]
-    def param_is_valid?(value, cond)
-      return cond.any? { |c| param_is_valid?(value, c) } if cond.is_a?(Array)
-
-      if value
-        if cond == :bool
-          return value =~ BOOL_REGEXP
-        elsif cond == Integer
-          return value =~ INTEGER_REGEXP
-        elsif cond == Float
-          return value =~ FLOAT_REGEXP
-        end
-      end
-
-      cond === value
-    end
-
-    # Converts the given value according to the given class.
-    #
-    # @param value [any] value
-    # @param klass [Class] class
-    # @return [any] converted value
-    def param_convert(value, klass)
-      if klass == :bool
-        value =~ BOOL_TRUE_REGEXP ? true : false
-      elsif klass == Integer
-        value.to_i
-      elsif klass == Float
-        value.to_f
-      elsif klass == Symbol
-        value.to_sym
-      else
-        value
-      end
-    end
-  end
-end
-
-Qeweney::Request.include(Syntropy::RequestExtensions)