syntropy 0.29.0 → 0.30.0

data/lib/syntropy/http/server.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'syntropy/http/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_client_connection(it) }
+      rescue UM::Terminate
+        # terminated
+      end
+
+      def start_client_connection(fd)
+        conn = Connection.new(self, @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

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,5 @@
+# frozen_string_literal: true
+
+require 'syntropy/http/status'
+require 'syntropy/http/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/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/request/mock_adapter.rb

@@ -0,0 +1,58 @@
+# 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
+      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

data/lib/syntropy/request/request_info.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'escape_utils'
+
+module Syntropy
+  module RequestInfoMethods
+    def host
+      @headers['host'] || @headers[':authority']
+    end
+    alias_method :authority, :host
+
+    def connection
+      @headers['connection']
+    end
+
+    def upgrade_protocol
+      connection == 'upgrade' && @headers['upgrade']&.downcase
+    end
+
+    def websocket_version
+      headers['sec-websocket-version'].to_i
+    end
+
+    def protocol
+      @protocol ||= @adapter.protocol
+    end
+
+    def method
+      @method ||= @headers[':method'].downcase
+    end
+
+    def scheme
+      @scheme ||= @headers[':scheme']
+    end
+
+    # Rewrites the request path by replacing the given src with the given
+    # replacement.
+    #
+    # @param src [String, Regexp] src pattern
+    # @param replacement [String] replacement
+    # @return [Syntropy::Request] self
+    def rewrite!(src, replacement)
+      @headers[':path'] = @headers[':path']
+        .gsub(src, replacement)
+        .gsub('//', '/')
+      @path = nil
+      @uri = nil
+      @full_uri = nil
+      self
+    end
+
+    def uri
+      @uri ||= URI.parse(@headers[':path'] || '')
+    end
+
+    def full_uri
+      @full_uri = "#{scheme}://#{host}#{uri}"
+    end
+
+    def path
+      @path ||= uri.path
+    end
+
+    def query_string
+      @query_string ||= uri.query
+    end
+
+    def query
+      return @query if @query
+
+      @query = (q = uri.query) ? parse_query(q) : {}
+    end
+
+    QUERY_KV_REGEXP = /([^=]+)(?:=(.*))?/
+
+    def parse_query(query)
+      query.split('&').each_with_object({}) do |kv, h|
+        k, v = kv.match(QUERY_KV_REGEXP)[1..2]
+        h[k.to_sym] = v ? URI.decode_www_form_component(v) : true
+      end
+    end
+
+    def request_id
+      @headers['x-request-id']
+    end
+
+    def forwarded_for
+      @headers['x-forwarded-for']
+    end
+
+    # TODO: should return encodings in client's order of preference (and take
+    # into account q weights)
+    def accept_encoding
+      encoding = @headers['accept-encoding']
+      return [] unless encoding
+
+      encoding.split(',').map { |i| i.strip }
+    end
+
+    def cookies
+      @cookies ||= parse_cookies(headers['cookie'])
+    end
+
+    COOKIE_RE = /^([^=]+)=(.*)$/.freeze
+    SEMICOLON = ';'
+
+    def parse_cookies(cookies)
+      return {} unless cookies
+
+      cookies.split(SEMICOLON).each_with_object({}) do |c, h|
+        raise BadRequestError, 'Invalid cookie format' unless c.strip =~ COOKIE_RE
+
+        key, value = Regexp.last_match[1..2]
+        h[key] = EscapeUtils.unescape_uri(value)
+      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', HTTP::BAD_REQUEST)
+      end
+
+      Syntropy::Request.parse_form_data(body, headers)
+    rescue Syntropy::BadRequestError
+      raise Syntropy::Error.new('Invalid form data', HTTP::BAD_REQUEST)
+    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
+  end
+
+  module RequestInfoClassMethods
+    def parse_form_data(body, headers)
+      case (content_type = headers['content-type'])
+      when /^multipart\/form\-data; boundary=([^\s]+)/
+        boundary = "--#{Regexp.last_match(1)}"
+        parse_multipart_form_data(body, boundary)
+      when /^application\/x-www-form-urlencoded/
+        parse_urlencoded_form_data(body)
+      else
+        raise BadRequestError, "Unsupported form data content type: #{content_type}"
+      end
+    end
+
+    def parse_multipart_form_data(body, boundary)
+      parts = body.split(boundary)
+      raise BadRequestError, 'Invalid form data' if parts.size < 2
+      parts.each_with_object({}) do |p, h|
+        next if p.empty? || p == "--\r\n"
+
+        # remove post-boundary \r\n
+        p.slice!(0, 2)
+        parse_multipart_form_data_part(p, h)
+      end
+    end
+
+    def parse_multipart_form_data_part(part, hash)
+      body, headers = parse_multipart_form_data_part_headers(part)
+      disposition = headers['content-disposition'] || ''
+
+      name = (disposition =~ /name="([^"]+)"/) ? Regexp.last_match(1) : nil
+      filename = (disposition =~ /filename="([^"]+)"/) ? Regexp.last_match(1) : nil
+
+      if filename
+        hash[name] = { filename: filename, content_type: headers['content-type'], data: body }
+      else
+        hash[name] = body
+      end
+    end
+
+    def parse_multipart_form_data_part_headers(part)
+      headers = {}
+      while true
+        idx = part.index("\r\n")
+        break unless idx
+
+        header = part[0, idx]
+        part.slice!(0, idx + 2)
+        break if header.empty?
+
+        next unless header =~ /^([^\:]+)\:\s?(.+)$/
+
+        headers[Regexp.last_match(1).downcase] = Regexp.last_match(2)
+      end
+      # remove trailing \r\n
+      part.slice!(part.size - 2, 2)
+      [part, headers]
+    end
+
+    PARAMETER_RE = /^([^=]+)(?:=(.*))?$/.freeze
+    MAX_PARAMETER_NAME_SIZE = 256
+    MAX_PARAMETER_VALUE_SIZE = 2**20 # 1MB
+
+    def parse_urlencoded_form_data(body)
+      return {} unless body
+
+      body.force_encoding(Encoding::UTF_8) unless body.encoding == Encoding::UTF_8
+      body.split('&').each_with_object({}) do |i, m|
+        raise BadRequestError, 'Invalid parameter format' unless i =~ PARAMETER_RE
+
+        k = Regexp.last_match(1)
+        raise BadRequestError, 'Invalid parameter size' if k.size > MAX_PARAMETER_NAME_SIZE
+
+        v = Regexp.last_match(2)
+        raise BadRequestError, 'Invalid parameter size' if v && v.size > MAX_PARAMETER_VALUE_SIZE
+
+        m[EscapeUtils.unescape_uri(k)] = v ? EscapeUtils.unescape_uri(v) : true
+      end
+    end
+  end
+end