syntropy 0.29.0 → 0.31.0

data/lib/syntropy/http/server_connection.rb

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+require 'syntropy/errors'
+require 'syntropy/http/io_extensions'
+
+module Syntropy
+  module HTTP
+    # 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 ServerConnection
+      attr_reader :fd, :response_headers, :logger
+
+      def initialize(machine, fd, env, io_mode: :socket, &app)
+        @machine = machine
+        @fd = fd
+        @env = env
+        @logger = env[:logger]
+        @io = machine.io(fd, io_mode)
+        @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 = Syntropy::Request.new(headers, self)
+
+        @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 [Syntropy::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' => 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']
+
+        body = @io.http_read_body(headers)
+        headers[':body-done-reading'] = true if body
+        body
+      end
+
+      def get_body_chunk(req)
+        headers = req.headers
+        return nil if headers[':body-done-reading']
+
+        chunk = @io.http_read_body_chunk(headers)
+        headers[':body-done-reading'] = true if !chunk
+        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 [Syntropy::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 [Syntropy::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 [Syntropy::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 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 ? OK : 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
+end

data/lib/syntropy/http/status.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Syntropy
+  module HTTP
+    # translated from https://golang.org/pkg/net/http/#pkg-constants
+    # https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+
+    CONTINUE                        = 100 # RFC 7231, 6.2.1
+    SWITCHING_PROTOCOLS             = 101 # RFC 7231, 6.2.2
+    PROCESSING                      = 102 # RFC 2518, 10.1
+    EARLY_HINTS                     = 103 # RFC 8297
+
+    OK                              = 200 # RFC 7231, 6.3.1
+    CREATED                         = 201 # RFC 7231, 6.3.2
+    ACCEPTED                        = 202 # RFC 7231, 6.3.3
+    NON_AUTHORITATIVE_INFO          = 203 # RFC 7231, 6.3.4
+    NO_CONTENT                      = 204 # RFC 7231, 6.3.5
+    RESET_CONTENT                   = 205 # RFC 7231, 6.3.6
+    PARTIAL_CONTENT                 = 206 # RFC 7233, 4.1
+    MULTI_STATUS                    = 207 # RFC 4918, 11.1
+    ALREADY_REPORTED                = 208 # RFC 5842, 7.1
+    IM_USED                         = 226 # RFC 3229, 10.4.1
+
+    MULTIPLE_CHOICES                = 300 # RFC 7231, 6.4.1
+    MOVED_PERMANENTLY               = 301 # RFC 7231, 6.4.2
+    FOUND                           = 302 # RFC 7231, 6.4.3
+    SEE_OTHER                       = 303 # RFC 7231, 6.4.4
+    NOT_MODIFIED                    = 304 # RFC 7232, 4.1
+    USE_PROXY                       = 305 # RFC 7231, 6.4.5
+
+    TEMPORARY_REDIRECT              = 307 # RFC 7231, 6.4.7
+    PERMANENT_REDIRECT              = 308 # RFC 7538, 3
+
+    BAD_REQUEST                     = 400 # RFC 7231, 6.5.1
+    UNAUTHORIZED                    = 401 # RFC 7235, 3.1
+    PAYMENT_REQUIRED                = 402 # RFC 7231, 6.5.2
+    FORBIDDEN                       = 403 # RFC 7231, 6.5.3
+    NOT_FOUND                       = 404 # RFC 7231, 6.5.4
+    METHOD_NOT_ALLOWED              = 405 # RFC 7231, 6.5.5
+    NOT_ACCEPTABLE                  = 406 # RFC 7231, 6.5.6
+    PROXY_AUTH_REQUIRED             = 407 # RFC 7235, 3.2
+    REQUEST_TIMEOUT                 = 408 # RFC 7231, 6.5.7
+    CONFLICT                        = 409 # RFC 7231, 6.5.8
+    GONE                            = 410 # RFC 7231, 6.5.9
+    LENGTH_REQUIRED                 = 411 # RFC 7231, 6.5.10
+    PRECONDITION_FAILED             = 412 # RFC 7232, 4.2
+    REQUEST_ENTITY_TOO_LARGE        = 413 # RFC 7231, 6.5.11
+    REQUEST_URI_TOO_LONG            = 414 # RFC 7231, 6.5.12
+    UNSUPPORTED_MEDIA_TYPE          = 415 # RFC 7231, 6.5.13
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416 # RFC 7233, 4.4
+    EXPECTATION_FAILED              = 417 # RFC 7231, 6.5.14
+    TEAPOT                          = 418 # RFC 7168, 2.3.3
+    MISDIRECTED_REQUEST             = 421 # RFC 7540, 9.1.2
+    UNPROCESSABLE_ENTITY            = 422 # RFC 4918, 11.2
+    LOCKED                          = 423 # RFC 4918, 11.3
+    FAILED_DEPENDENCY               = 424 # RFC 4918, 11.4
+    TOO_EARLY                       = 425 # RFC 8470, 5.2.
+    UPGRADE_REQUIRED                = 426 # RFC 7231, 6.5.15
+    PRECONDITION_REQUIRED           = 428 # RFC 6585, 3
+    TOO_MANY_REQUESTS               = 429 # RFC 6585, 4
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431 # RFC 6585, 5
+    UNAVAILABLE_FOR_LEGAL_REASONS   = 451 # RFC 7725, 3
+
+    INTERNAL_SERVER_ERROR           = 500 # RFC 7231, 6.6.1
+    NOT_IMPLEMENTED                 = 501 # RFC 7231, 6.6.2
+    BAD_GATEWAY                     = 502 # RFC 7231, 6.6.3
+    SERVICE_UNAVAILABLE             = 503 # RFC 7231, 6.6.4
+    GATEWAY_TIMEOUT                 = 504 # RFC 7231, 6.6.5
+    HTTP_VERSION_NOT_SUPPORTED      = 505 # RFC 7231, 6.6.6
+    VARIANT_ALSO_NEGOTIATES         = 506 # RFC 2295, 8.1
+    INSUFFICIENT_STORAGE            = 507 # RFC 4918, 11.5
+    LOOP_DETECTED                   = 508 # RFC 5842, 7.2
+    NOT_EXTENDED                    = 510 # RFC 2774, 7
+    NETWORK_AUTHENTICATION_REQUIRED = 511 # RFC 6585, 6
+  end
+end

data/lib/syntropy/http.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'syntropy/http/status'
+require 'syntropy/http/client_connection'
+require 'syntropy/http/client'
+require 'syntropy/http/server_connection'
+require 'syntropy/http/server'

data/lib/syntropy/json_api.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'qeweney'
 require 'syntropy/errors'
 require 'json'
 
@@ -31,7 +30,7 @@ module Syntropy
       else
         raise Syntropy::Error.method_not_allowed
       end
-      [{ status: 'OK', response: response }, Qeweney::Status::OK]
+      [{ status: 'OK', response: response }, HTTP::OK]
     rescue => e
       if !e.is_a?(Syntropy::Error)
         p e
@@ -55,10 +54,8 @@ module Syntropy
       raise err
     end
 
-    INTERNAL_SERVER_ERROR = Qeweney::Status::INTERNAL_SERVER_ERROR
-
     def __error_response__(err)
-      http_status = err.respond_to?(:http_status) ? err.http_status : INTERNAL_SERVER_ERROR
+      http_status = err.respond_to?(:http_status) ? err.http_status : HTTP::INTERNAL_SERVER_ERROR
       error_name = err.class.name.split('::').last
       [{ status: error_name, message: err.message }, http_status]
     end

data/lib/syntropy/logger.rb

@@ -67,7 +67,7 @@ module Syntropy
       request = o[:request]
       request_headers = request.headers
       response_headers = o[:response_headers]
-      elapsed = request.adapter.monotonic_clock - request.start_stamp
+      elapsed = monotonic_clock - request.start_stamp
       {
         level: level.to_s,
         ts: (t = Time.now; t.to_i),
@@ -82,6 +82,10 @@ module Syntropy
       }
     end
 
+    def monotonic_clock
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
+
     def make_hash_entry(level, hash)
       {
         level: level.to_s,

data/lib/syntropy/mime_types.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Syntropy
+  # File extension to MIME type mapping
+  module MimeTypes
+    TYPES = {
+      'html'  => 'text/html',
+      'css'   => 'text/css',
+      'js'    => 'application/javascript',
+      'txt'   => 'text/plain',
+      'text'  => 'text/plain',
+      'gif'   => 'image/gif',
+      'jpg'   => 'image/jpeg',
+      'jpeg'  => 'image/jpeg',
+      'png'   => 'image/png',
+      'ico'   => 'image/x-icon',
+      'svg'   => 'image/svg+xml',
+      'pdf'   => 'application/pdf',
+      'json'  => 'application/json',
+    }.freeze
+
+    EXT_REGEXP = /\.?([^\.]+)$/.freeze
+
+    def self.[](ref)
+      case ref
+      when Symbol
+        TYPES[ref.to_s]
+      when EXT_REGEXP
+        TYPES[Regexp.last_match(1)]
+      when ''
+        nil
+      else
+        raise "Invalid argument #{ref.inspect}"
+      end
+    end
+  end
+end

data/lib/syntropy/papercraft_extensions.rb

@@ -3,7 +3,7 @@
 require 'papercraft'
 
 Papercraft.extension(
-  'auto_refresh_watch!': ->(loc = '/.syntropy') {
+  'auto_refresh!': ->(loc = '/.syntropy') {
     if $syntropy_dev_mode
       script(src: File.join(loc, 'auto_refresh/watch.js'), type: 'module')
     end

data/lib/syntropy/request/mock_adapter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Syntropy
+  class MockAdapter
+    attr_reader :response_body, :response_headers, :calls
+
+    def get_body_chunk(_req)
+      @request_body_chunks.shift
+    end
+
+    def get_body(_req)
+      body = @request_body_chunks.join('')
+      @request_body_chunks.clear
+      body
+    end
+
+    def complete?(_req)
+      @request_body_chunks.empty?
+    end
+
+    def initialize(request_body)
+      case request_body
+      when Array
+        @request_body_chunks = request_body
+      when nil
+        @request_body_chunks = []
+      else
+        @request_body_chunks = [request_body]
+      end
+      @calls = []
+    end
+
+    def set_response_headers(headers)
+      @response_headers = headers
+    end
+
+    def respond(req, body, headers)
+      headers = @response_headers.merge(headers) if @response_headers
+      @calls << [:respond, req, body, headers]
+      @response_body = body
+      @response_headers = headers
+    end
+
+    def status
+      raise 'No response' if !response_headers
+
+      response_headers[':status'] || HTTP::OK
+    end
+
+    def method_missing(sym, *args)
+      calls << [sym, *args]
+    end
+
+    def self.mock(headers = {}, request_body = nil)
+      headers[':method'] ||= ''
+      headers[':path'] ||= ''
+      Request.new(headers, new(request_body))
+    end
+  end
+end