syntropy 0.28.2 → 0.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afaeaedff9f32e935a57dd4f4b10c3615f86da0dcac57bd73bc067bbd2d74e52
-  data.tar.gz: 22c6daed846a2b953cdbb3386196caa18336761e78e108dbeb8c08da161f5278
+  metadata.gz: b63b4a2ba22db6a8edcb7fc01dbbc67ba36e7a6392bcb2d5cec18fbf03e961c9
+  data.tar.gz: 06b6347df280046f31da969514d9a844c3b6197f6e0a2cc73ddc804e0861a320
 SHA512:
-  metadata.gz: 65e16a9fcad4eb182b042e84cb1ece66e3e20cb4c785d91ed821450033f276a5173837a485811b77dd9ae2234765a614bef99aaea3dbc4d934d1b96a44600e8b
-  data.tar.gz: 27563059f9c8d1afce71ee25be57450de7c19eaa4ab5ef540d9a4f9ea07830d7d79d1ce7c836e25a3bc47191fc4ec038120dc6ea178802736bdcdc3ad92132e6
+  metadata.gz: 7c66c3ab9254e638dd0e0705680fb9d395ff87c539b2e55cc6005f5e70e7bb11d64b534c85e1ef06052ce194a70423b118872715c13e90b2e0c7082ecd2566fb
+  data.tar.gz: 9bb15db34ee78a8a6c8d2e4d87459368e85525d617ded497b78d1d693473f580877a9b177ee5181249a1e16d1c0352eb8d3afc670e3a211454ebaa828f86f107

data/.ruby-version

@@ -0,0 +1 @@
+4.0.3

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.29.0 2026-05-07
+
+- Use UM#file_watch for dev mode
+- Integrate TP2 code
+- Update UringMachine
+
 # 0.28.2 2026-01-30
 
 - Update TP2, UringMachine

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.
-- [TP2](https://github.com/digital-fabric/tp2) - an io_uring-based web server for
-  concurrent Ruby apps.
 - [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.

data/bin/syntropy

@@ -84,11 +84,10 @@ env[:banner] = false
 
 # We set Syntropy.machine so we can reference it from anywhere
 env[:machine] = Syntropy.machine = UM.new
-env[:logger] = env[:logger] && TP2::Logger.new(env[:machine], **env)
+env[:logger] = env[:logger] && Syntropy::Logger.new(env[:machine], **env)
 
 require 'syntropy/version'
 require 'syntropy/dev_mode' if env[:dev_mode]
 
-env[:logger]&.info(message: "Running Syntropy version #{Syntropy::VERSION}")
 app = Syntropy::App.load(env)
-TP2.run(env) { app.call(it) }
+Syntropy.run(env) { app.call(it) }

data/cmd/setup/template/site/Dockerfile

@@ -29,4 +29,4 @@ COPY --from=gems --chown=app:app /usr/local/bundle /usr/local/bundle
 
 EXPOSE 1234
 
-CMD ["bundle", "exec", "tp2", "."]
+CMD ["bundle", "exec", "syntropy", "."]

data/lib/syntropy/app.rb

@@ -7,8 +7,6 @@ require 'qeweney'
 require 'papercraft'
 
 require 'syntropy/errors'
-require 'syntropy/file_watch'
-
 require 'syntropy/module'
 require 'syntropy/routing_tree'
 
@@ -474,9 +472,9 @@ module Syntropy
     # @return [void]
     def start
       @machine.spin do
-        # we do startup stuff asynchronously, in order to first let TP2 do its
-        # setup tasks
-        @machine.sleep 0.2
+        # we do startup stuff asynchronously, in order to first let Syntropy do
+        # its setup tasks.
+        @machine.sleep 0.1
         route_count = @routing_tree.static_map.size + @routing_tree.dynamic_map.size
         @logger&.info(
           message: "Serving from #{@root_dir} (#{route_count} routes found)"
@@ -493,11 +491,21 @@ module Syntropy
     def file_watcher_loop
       wf = @env[:watch_files]
       period = wf.is_a?(Numeric) ? wf : 0.1
-      Syntropy.file_watch(@machine, @root_dir, period: period) do |event, fn|
+
+      @machine.file_watch(@root_dir, UM::IN_CREATE | UM::IN_DELETE | UM::IN_CLOSE_WRITE) { |e|
+        fn = e[:fn]
         @logger&.info(message: 'File change detected', fn: fn)
         @module_loader.invalidate_fn(fn)
         debounce_file_change
-      end
+      }
+      
+
+
+      # Syntropy.file_watch(@machine, @root_dir, period: period) do |event, fn|
+      #   @logger&.info(message: 'File change detected', fn: fn)
+      #   @module_loader.invalidate_fn(fn)
+      #   debounce_file_change
+      # end
     rescue Exception => e
       p e
       p e.backtrace

data/lib/syntropy/connection.rb

@@ -0,0 +1,402 @@
+# 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/errors.rb

@@ -71,4 +71,16 @@ module Syntropy
       super(msg, Status::BAD_REQUEST)
     end
   end
+
+  class ProtocolError < Error
+    def http_status
+      Qeweney::Status::BAD_REQUEST
+    end
+  end
+
+  class UnsupportedHTTPVersionError < ProtocolError
+    def http_status
+      Qeweney::Status::HTTP_VERSION_NOT_SUPPORTED
+    end
+  end
 end

data/lib/syntropy/logger.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Syntropy
+  class Logger
+    def initialize(machine, fd = $stdout.fileno, **opts)
+      @machine = machine
+      @fd = fd
+      @opts = opts
+    end
+
+    def info(o)
+      call(:INFO, o)
+    end
+
+    def warn(o)
+      call(:WARN, o)
+    end
+
+    def error(o)
+      call(:ERROR, o)
+    end
+
+    private
+
+    # @param level <Symbol> log level
+    # @param o <Hash> hash
+    def call(level, o)
+      emit(make_entry(level, o))
+    rescue StandardError => e
+      puts 'Uncaught error while emitting log entry:'
+      p e: e
+      p e.backtrace
+      exit
+    end
+
+    def emit(entry)
+      @machine.write_async(@fd, "#{entry.to_json}\n")
+    end
+
+    def make_entry(level, o)
+      if o[:request]
+        make_request_entry(level, o)
+      elsif o[:error]
+        make_error_entry(level, o)
+      else
+        make_hash_entry(level, o)
+      end
+    end
+
+    def make_error_entry(level, o)
+      err = o[:error]
+      {
+        level: level.to_s,
+        ts: (t = Time.now; t.to_i),
+        ts_s: t.iso8601
+      }
+      .merge(o)
+      .merge(
+        error: "#{err.class}: #{err.message}",
+        backtrace: err.backtrace
+      )
+    end
+
+    def make_request_entry(level, o)
+      request = o[:request]
+      request_headers = request.headers
+      response_headers = o[:response_headers]
+      elapsed = request.adapter.monotonic_clock - request.start_stamp
+      {
+        level: level.to_s,
+        ts: (t = Time.now; t.to_i),
+        ts_s: t.iso8601,
+        message: o[:message] || 'HTTP request done',
+        client_ip: request.forwarded_for || '?',
+        http_method: request_headers[':method'].upcase,
+        user_agent: request_headers['user-agent'],
+        uri: full_uri(request_headers),
+        status: response_headers[':status'] || '200',
+        elapsed: elapsed
+      }
+    end
+
+    def make_hash_entry(level, hash)
+      {
+        level: level.to_s,
+        ts: (t = Time.now; t.to_i),
+        ts_s: t.iso8601
+      }
+      .merge(hash)
+    end
+
+    def full_uri(headers)
+      format(
+        '%<scheme>s://%<host>s%<path>s',
+        scheme: headers['x_forwarded_proto'] || 'http',
+        host:   headers['host'],
+        path:   headers[':path']
+      )
+    end
+  end
+end

data/lib/syntropy/request_extensions.rb

@@ -3,6 +3,32 @@
 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