syntropy 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b63b4a2ba22db6a8edcb7fc01dbbc67ba36e7a6392bcb2d5cec18fbf03e961c9
-  data.tar.gz: 06b6347df280046f31da969514d9a844c3b6197f6e0a2cc73ddc804e0861a320
+  metadata.gz: 70dae64fe246aa0851a582ff914d647bcfc650755a237ef476a37de8fd0cc052
+  data.tar.gz: 9fde1a73c1136b316f4a5a42d7d0e359df76f4a7015146a5e4c0583eb22c9f76
 SHA512:
-  metadata.gz: 7c66c3ab9254e638dd0e0705680fb9d395ff87c539b2e55cc6005f5e70e7bb11d64b534c85e1ef06052ce194a70423b118872715c13e90b2e0c7082ecd2566fb
-  data.tar.gz: 9bb15db34ee78a8a6c8d2e4d87459368e85525d617ded497b78d1d693473f580877a9b177ee5181249a1e16d1c0352eb8d3afc670e3a211454ebaa828f86f107
+  metadata.gz: 2a5561fd30d062766fbb5e5df5ab80b1a6840b5a0bb29c2b1bc0e9a3a7872462face8a9e908d72f1a5426f5ad781b91adc079ca2412efbe95071b68f76c030d6
+  data.tar.gz: 22708dd2c98a250068613cbc1d54157ec5673100d2d4df2df216fa353085cbc13c696ae3903a527926c03c17ba746a145c1ff70f0aefddf7fd8996d60527d263

data/.github/workflows/test.yml

@@ -29,5 +29,5 @@ jobs:
         ruby-version: ${{matrix.ruby}}
         bundler-cache: true # 'bundle install' and cache
     - name: Run tests
-      # run: bundle exec ruby test/test_um.rb --name test_read_each_raising_2
-      run: bundle exec rake test
+      run: bundle exec ruby test/run.rb --verbose
+      # run: bundle exec rake test

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.30.0 2026-05-10
+
+- Refactor HTTP modules
+- Integrate Qeweney::Request
+
 # 0.29.0 2026-05-07
 
 - Use UM#file_watch for dev mode

data/README.md

@@ -48,8 +48,6 @@ Syntropy is based on:
 
 - [UringMachine](https://github.com/digital-fabric/uringmachine) - a lean mean
   [io_uring](https://unixism.net/loti/what_is_io_uring.html) machine for Ruby.
-- [Qeweney](https://github.com/digital-fabric/qeweney) a uniform interface for
-  working with HTTP requests and responses.
 - [Papercraft](https://github.com/digital-fabric/papercraft) HTML templating with plain Ruby.
 - [Extralite](https://github.com/digital-fabric/extralite) a fast and innovative
   SQLite wrapper for Ruby.

data/lib/syntropy/app.rb

@@ -3,12 +3,12 @@
 require 'json'
 require 'yaml'
 
-require 'qeweney'
 require 'papercraft'
 
 require 'syntropy/errors'
 require 'syntropy/module'
 require 'syntropy/routing_tree'
+require 'syntropy/mime_types'
 
 module Syntropy
   class App
@@ -59,14 +59,14 @@ module Syntropy
     # error message, and with the appropriate HTTP status code, according to the
     # type of error.
     #
-    # @param req [Qeweney::Request] HTTP request
+    # @param req [Syntropy::Request] HTTP request
     # @return [void]
     def call(req)
       path = req.path
       route = @router_proc.(path, req.route_params)
       if !route
         if (m = path.match(/^(.+)\/$/))
-          return req.redirect(m[1], Qeweney::Status::MOVED_PERMANENTLY)
+          return req.redirect(m[1], HTTP::MOVED_PERMANENTLY)
         else
           return handle_not_found(req)
         end
@@ -106,7 +106,7 @@ module Syntropy
     # Handles a not found error, taking into account hooks up the tree from the
     # request path.
     #
-    # @param req [Qeweney::Reqest] request
+    # @param req [Syntropy::Reqest] request
     # @return [void]
     def handle_not_found(req)
       closest_uptree_route = find_first_uptree_route(File.dirname(req.path))
@@ -188,7 +188,7 @@ module Syntropy
     # @return [Proc] route handler proc
     def static_route_proc(route)
       fn = route[:target][:fn]
-      headers = { 'Content-Type' => Qeweney::MimeTypes[File.extname(fn)] }
+      headers = { 'Content-Type' => MimeTypes[File.extname(fn)] }
 
       ->(req) {
         case req.method
@@ -204,7 +204,7 @@ module Syntropy
 
     # Serves a static file from the given target hash with cache validation.
     #
-    # @param req [Qeweney::Request] request
+    # @param req [Syntropy::Request] request
     # @param target [Hash] route target hash
     # @return [void]
     def serve_static_file(req, target)
@@ -253,7 +253,7 @@ module Syntropy
       target[:last_modified] = mtime
       target[:last_modified_date] = Time.at(mtime).httpdate
       target[:content] = buffer = String.new(capacity: size)
-      target[:mime_type] = Qeweney::MimeTypes[File.extname(target[:fn])]
+      target[:mime_type] = MimeTypes[File.extname(target[:fn])]
       len = 0
       while len < size
         len += @machine.read(fd, buffer, size, len)
@@ -498,7 +498,7 @@ module Syntropy
         @module_loader.invalidate_fn(fn)
         debounce_file_change
       }
-      
+
 
 
       # Syntropy.file_watch(@machine, @root_dir, period: period) do |event, fn|

data/lib/syntropy/errors.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require 'qeweney'
+require 'syntropy/http/status'
 
 module Syntropy
   # The base Syntropy error class
   class Error < StandardError
-    Status = Qeweney::Status
-
     # By default, the HTTP status for errors is 500 Internal Server Error.
-    DEFAULT_STATUS = Status::INTERNAL_SERVER_ERROR
+    DEFAULT_STATUS = HTTP::INTERNAL_SERVER_ERROR
 
     # Returns the HTTP status for the given exception.
     #
@@ -24,26 +22,26 @@ module Syntropy
     # @param err [Exception] error
     # @return [bool]
     def self.log_error?(err)
-      http_status(err) != Status::NOT_FOUND
+      http_status(err) != HTTP::NOT_FOUND
     end
 
     # Creates an error with status 404 Not Found.
     #
     # @param msg [String] error message
     # @return [Syntropy::Error]
-    def self.not_found(msg = 'Not found') = new(msg, Status::NOT_FOUND)
+    def self.not_found(msg = 'Not found') = new(msg, HTTP::NOT_FOUND)
 
     # Creates an error with status 405 Method Not Allowed.
     #
     # @param msg [String] error message
     # @return [Syntropy::Error]
-    def self.method_not_allowed(msg = 'Method not allowed') = new(msg, Status::METHOD_NOT_ALLOWED)
+    def self.method_not_allowed(msg = 'Method not allowed') = new(msg, HTTP::METHOD_NOT_ALLOWED)
 
     # Creates an error with status 418 I'm a teapot.
     #
     # @param msg [String] error message
     # @return [Syntropy::Error]
-    def self.teapot(msg = 'I\'m a teapot') = new(msg, Status::TEAPOT)
+    def self.teapot(msg = 'I\'m a teapot') = new(msg, HTTP::TEAPOT)
 
     attr_reader :http_status
 
@@ -61,26 +59,29 @@ module Syntropy
     #
     # @return [Integer, String] HTTP status
     def http_status
-      @http_status || Status::INTERNAL_SERVER_ERROR
+      @http_status || HTTP::INTERNAL_SERVER_ERROR
     end
   end
 
   # ValidationError is raised when a validation has failed.
   class ValidationError < Error
     def initialize(msg)
-      super(msg, Status::BAD_REQUEST)
+      super(msg, HTTP::BAD_REQUEST)
     end
   end
 
   class ProtocolError < Error
     def http_status
-      Qeweney::Status::BAD_REQUEST
+      HTTP::BAD_REQUEST
     end
   end
 
   class UnsupportedHTTPVersionError < ProtocolError
     def http_status
-      Qeweney::Status::HTTP_VERSION_NOT_SUPPORTED
+      HTTP::HTTP_VERSION_NOT_SUPPORTED
     end
   end
+
+  class BadRequestError < Error
+  end
 end

data/lib/syntropy/http/connection.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+require 'syntropy/errors'
+
+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 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 = 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']
+
+        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)
+        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 [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