syntropy 0.29.0 → 0.31.0

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
@@ -35,6 +35,7 @@ module Syntropy
     end
 
     attr_reader :module_loader, :routing_tree, :root_dir, :mount_path, :env
+    attr_accessor :test_mode
 
     def initialize(**env)
       @machine = env[:machine]
@@ -59,14 +60,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 +107,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 +189,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 +205,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 +254,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)
@@ -321,7 +322,7 @@ module Syntropy
           }
           body {
             markdown md
-            auto_refresh_watch! if @env[:dev_mode]
+            auto_refresh! if @env[:dev_mode]
           }
         }
       }
@@ -450,18 +451,28 @@ module Syntropy
     end
 
     RAW_DEFAULT_ERROR_HANDLER = ->(req, err) {
+      status = Syntropy::Error.http_status(err)
+
       msg = err.message
       msg = nil if msg.empty? || (req.method == 'head')
-      req.respond(msg, ':status' => Syntropy::Error.http_status(err)) rescue nil
+      req.respond(msg, ':status' => status) rescue nil
     }
 
-    def default_error_handler
+    TEST_MODE_DEFAULT_ERROR_HANDLER = ->(req, err) {
+      status = Syntropy::Error.http_status(err)
+      raise if status == HTTP::INTERNAL_SERVER_ERROR
+
+      msg = err.message
+      msg = nil if msg.empty? || (req.method == 'head')
+      req.respond(msg, ':status' => status) rescue nil
+    }
 
+    def default_error_handler
       @default_error_handler ||= begin
         if @builtin_applet
           @builtin_applet.module_loader.load('/default_error_handler')
         else
-          RAW_DEFAULT_ERROR_HANDLER
+          @test_mode ? TEST_MODE_DEFAULT_ERROR_HANDLER : RAW_DEFAULT_ERROR_HANDLER
         end
       end
     end
@@ -498,7 +509,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/applets/builtin/default_error_handler.rb

@@ -23,7 +23,7 @@ ErrorPage = ->(error:, status:, backtrace:) {
           }
         end
       }
-      auto_refresh_watch!
+      auto_refresh!
     }
   }
 }
@@ -32,7 +32,7 @@ def transform_backtrace(backtrace)
   backtrace.map do
     if (m = it.match(/^(.+:\d+):/))
       location = m[1]
-      { entry: it, url: "vscode://file/#{location}" }
+      { entry: it, url: "zed://file/#{location}" }
     else
       { entry: it, url: nil }
     end
@@ -43,7 +43,7 @@ def error_response_html(req, error)
   status = Syntropy::Error.http_status(error)
   backtrace = transform_backtrace(error.backtrace)
   html = Papercraft.html(ErrorPage, error:, status:, backtrace:)
-  req.html_response(html, ':status' => status)
+  req.respond_html(html, ':status' => status)
 end
 
 def error_response_raw(req, error)

data/lib/syntropy/applets/builtin/req.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 export ->(req) {
-  req.json_response({
+  req.respond_json({
     headers: req.headers
   })
 }

data/lib/syntropy/dev_mode.rb

@@ -4,7 +4,7 @@ TAG_DEBUG_PROC = ->(level, fn, line, col) {
   {
     'data-syntropy-level' => level,
     'data-syntropy-fn'    => fn,
-    'data-syntropy-loc'   => "vscode://file/#{fn}:#{line}:#{col}"
+    'data-syntropy-loc'   => "zed://file/#{fn}:#{line}:#{col}"
   }
 }
 

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,35 @@ 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
+
+  class InvalidRequestContentTypeError < Error
+    def http_status
+      HTTP::UNSUPPORTED_MEDIA_TYPE
     end
   end
 end

data/lib/syntropy/http/client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'syntropy/http/client_connection'
+require 'uri'
+
+module Syntropy
+  module HTTP
+    class Client
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def get(url, **headers, &)
+        uri = URI.parse(url)
+        headers = headers.merge(
+          ':method' => 'GET',
+          ':path' => uri.request_uri
+        )
+        req(uri, **headers, &)
+      end
+
+      private
+
+      # @param uri [URI]
+      def req(uri, **headers)
+        connection = make_connection(uri.scheme, uri.host, uri.port)
+        response_headers = connection.req(**headers)
+        if block_given?
+          yield(response_headers, connection)
+        else
+          [response_headers, connection.get_response_body(response_headers)]
+        end
+      end
+
+      def make_connection(_scheme, host, port)
+        ip = (host =~ /^\d+\.\d+\.\d+\.\d+$/) ? host : @machine.resolve(host)[0]
+
+        fd = @machine.tcp_connect(ip, port)
+        Syntropy::HTTP::ClientConnection.new(@machine, fd)
+      end
+    end
+  end
+end

data/lib/syntropy/http/client_connection.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'syntropy/errors'
+require 'syntropy/http/io_extensions'
+
+module Syntropy
+  module HTTP
+    class ClientConnection
+      attr_reader :fd, :response_headers, :logger
+
+      def initialize(machine, fd, io_mode: :socket)
+        @machine = machine
+        @fd = fd
+        @io = machine.io(fd, io_mode)
+      end
+
+      def req(body: nil, **headers)
+        if body
+          headers = headers.merge(
+            'Content-Length' => body.bytesize
+          )
+        end
+        @io.http_write_request_headers(**headers)
+        if body
+          @io.write(body)
+        end
+
+        @io.http_read_response_headers
+      end
+
+      def get_response_body(headers)
+        @io.http_read_body(headers)
+      end
+    end
+  end
+end

data/lib/syntropy/http/io_extensions.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'syntropy/errors'
+
+module Syntropy
+  module HTTP
+    module ProtocolMethods
+      RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+HTTP\/([019\.]{1,3})/i
+      RE_RESPONSE_LINE = /^HTTP\/1\.1\s+(\d{3})(\s+.+)?$/i
+      RE_HEADER_LINE = /^([a-z0-9-]+):\s+(.+)/i
+
+      MAX_REQUEST_LINE_LEN = 1 << 14 # 16KB
+      MAX_RESPONSE_LINE_LEN = 1 << 8 # 256
+      MAX_HEADER_LINE_LEN = 1 << 10 # 1KB
+      MAX_CHUNK_SIZE_LEN = 16
+
+      # @return [Hash] headers
+      def http_read_request_headers
+        line = 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'
+
+        headers = {
+          ':method'   => m[1].downcase,
+          ':path'     => m[2],
+          ':protocol' => 'http/1.1'
+        }
+
+        loop do
+          line = 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 http_read_response_headers
+        line = read_line(MAX_RESPONSE_LINE_LEN)
+        return nil if !line
+
+        m = line.match(RE_RESPONSE_LINE)
+        raise ProtocolError, 'Invalid response line' if !m
+
+        headers = {
+          ':status'   => m[1].to_i
+        }
+
+        loop do
+          line = 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
+
+          k = m[1].downcase
+          if (h = headers[k])
+            (h = headers[k] = [h]) if !h.is_a?(Array)
+            h << m[2]
+          else
+            headers[k] = m[2]
+          end
+        end
+
+        headers
+      end
+
+      def http_read_body(headers)
+        content_length = headers['content-length']
+        if content_length
+          chunk = read(content_length.to_i)
+          return chunk
+        end
+
+        chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
+        if chunked_encoding
+          buf = +''
+          while (chunk = http_read_cte_chunk(nil))
+            buf << chunk
+          end
+          return buf
+        end
+
+        nil
+      end
+
+      def http_read_body_chunk(headers)
+        content_length = headers['content-length']
+        if content_length
+          chunk = read(content_length.to_i)
+          return chunk
+        end
+
+        chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
+        return http_read_cte_chunk(nil) if chunked_encoding
+
+        nil
+      end
+
+      def http_write_request_headers(headers)
+        method = headers[':method'] || (raise BadRequestError)
+        path = headers[':path'] || (raise BadRequestError)
+
+        lines = ["#{method} #{path} HTTP/1.1\r\n"]
+        headers.each do |k, v|
+          next if k =~ /^\:/
+
+          if v.is_a?(Array)
+            v.each { lines << "#{k}: #{it}\r\n" }
+          else
+            lines << "#{k}: #{v}\r\n"
+          end
+        end
+        lines << "\r\n"
+        write(*lines)
+      end
+
+      private
+
+      def http_read_cte_chunk(buffer)
+        chunk_size_str = read_line(MAX_CHUNK_SIZE_LEN)
+        return nil if !chunk_size_str
+
+        chunk_size = chunk_size_str.to_i(16)
+        if chunk_size == 0
+          read_line(0)
+          return nil
+        end
+
+        chunk = read(chunk_size)
+        read_line(0)
+
+        buffer ? (buffer << chunk) : chunk
+      end
+    end
+  end
+end
+
+UringMachine::IO.include(Syntropy::HTTP::ProtocolMethods)

data/lib/syntropy/http/server.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'syntropy/http/server_connection'
+
+module Syntropy
+  module HTTP
+    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_connection(it) }
+      rescue UM::Terminate
+        @machine.shutdown(listen_fd, UM::SHUT_RD)
+      end
+
+      def start_connection(fd)
+        conn = ServerConnection.new(@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
+end