syntropy 0.28.2 → 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/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/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