uma 0.1.0

data/lib/uma/http.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module Uma
+  module HTTP
+    class Error < StandardError; end
+    class ParseError < Error; end
+    class ResponseError < Error; end
+
+    class RackIO
+      def initialize(env, stream)
+        @env = env
+        @stream = stream
+        @machine = stream.machine
+        @fd = stream.fd
+      end
+
+      def gets
+        @stream.get_line(nil, 0)
+      end
+
+      def read(len, buf = +'')
+        @stream.get_string(buf, -30)
+      end
+
+      def each(&)
+        if @env['HTTP_TRANSFER_ENCODING'] == 'chunked'
+          read_chunks(&)
+        elsif (v = @env['CONTENT_LENGTH'])
+          len = v.to_i
+          yield @stream.get_string(+'', len)
+        end
+      end
+
+      def read_chunks
+        buf = +''
+        while true
+          line = @stream.get_line(buf, 8)
+          len = line.to_i(16)
+          break if len == 0
+
+          chunk = @stream.get_string(nil, len)
+          yield chunk
+          @stream.skip(2)
+        end
+      end
+
+      def close
+        @machine.close(@fd)
+      end
+
+      def puts(str)
+        write("#{str}\n")
+      end
+
+      def write(*bufs)
+        @machine.writev(@fd, *bufs)
+      end
+      alias_method :<<, :write
+    end
+
+    class ChunkedIO
+      def initialize(machine, fd, stream)
+        @machine = machine
+        @fd = fd
+        @stream = stream
+        @first_write = true
+      end
+
+      def read(len, buf = +'')
+        stream.get_string(buf, len)
+        buf
+      end
+
+      def write(*chunks)
+        bufs = []
+        chunks.each do
+          bufs << (@first_write ? "#{it.bytesize.to_s(16)}\r\n" : "\r\n#{it.bytesize.to_s(16)}\r\n")
+          bufs << it
+          @first_write = false
+        end
+        @machine.sendv(@fd, *bufs)
+      end
+      alias_method :<<, :write
+
+      def flush
+      end
+
+      def close_read
+        @machine.shutdown(@fd, UM::SHUT_RD)
+      end
+
+      def close_write
+        @machine.shutdown(@fd, UM::SHUT_WR)
+      end
+
+      def close
+        return if @closed
+
+        @closed = true
+        chunked_ending = @first_write ? "0\r\n\r\n" : "\r\n0\r\n\r\n"
+        @machine.sendv(@fd, chunked_ending)
+      end
+
+      def closed?
+        @closed
+      end
+    end
+
+    extend self
+
+    def http_connection(machine, config, fd)
+      stream = UM::Stream.new(machine, fd)
+      while true
+        break if !process_request(machine, config, fd, stream)
+      end
+    end
+
+    def process_request(machine, config, fd, stream)
+      env = get_request_env(config, stream)
+      return false if !env
+
+      rack_response = config[:app].(env)
+      if !env['uma.hijacked?']
+        send_rack_response(machine, env, fd, rack_response)
+        should_process_next_request?(env)
+      else
+        false
+      end
+    rescue => e
+      if (h = config[:error_handler])
+        h.(e)
+      else
+        send_error_response(machine, fd, e)
+      end
+    end
+
+    def get_request_env(config, stream)
+      env = {
+        'rack.url_scheme' => 'http',
+        'SCRIPT_NAME'   => '',
+        'SERVER_NAME'   => 'localhost',
+        'rack.hijack?'  => true,
+        'rack.hijack'   => -> {
+          env['uma.hijacked?'] = true
+          env['rack.hijack'] = env['rack.input'] || RackIO.new(env, stream)
+        },
+        'rack.errors'   => config[:error_stream]
+      }
+      buf = +''
+      ret = stream.get_line(buf, 4096)
+      return if !ret
+
+      parse_request_line(env, buf)
+      while true
+        ret = stream.get_line(buf, 4096)
+        raise ParseError, "Unexpected EOF" if !ret
+        break if buf.empty?
+
+        parse_header(env, buf)
+      end
+
+      if env['CONTENT_LENGTH'] || env['HTTP_TRANSFER_ENCODING'] == 'chunked'
+        env['rack.input'] = RackIO.new(env, stream)
+      end
+      env
+    end
+
+    RE_REQUEST_LINE = /^([a-z]+)\s+([^\s\?]+)(?:\?([^\s]+))?\s+(http\/[019\.]{1,3})/i
+
+    def parse_request_line(env, line)
+      m = line.match(RE_REQUEST_LINE)
+      raise ParseError, 'Invalid request line' if !m
+
+      env['REQUEST_METHOD']   = m[1].upcase
+      env['PATH_INFO']        = m[2]
+      env['QUERY_STRING']     = m[3] || ''
+      env['SERVER_PROTOCOL']  = m[4]
+    end
+
+    RE_HEADER_LINE = /^([a-z0-9-]+):\s+(.+)/i
+
+    def parse_header(env, line)
+      m = line.match(RE_HEADER_LINE)
+      raise ParseError, 'Invalid header' if !m
+
+      key = "HTTP_#{m[1].upcase.tr('-', '_')}"
+      value = m[2]
+      case key
+      when 'HTTP_CONTENT_TYPE'
+        env['CONTENT_TYPE'] = value
+      when 'HTTP_CONTENT_LENGTH'
+        env['CONTENT_LENGTH'] = value
+      when 'HTTP_HOST'
+        env['SERVER_NAME'] = value
+        env[key] = value
+      else
+        env[key] = value
+      end
+    end
+
+    CHUNK_END = "\r\n0\r\n\r\n"
+
+    def send_rack_response(machine, env, fd, response)
+      status, headers, body = response
+      hijack = headers['rack.hijack']
+
+      empty_body = body.nil? || body == '' || (body.is_a?(Array) && body.empty?)
+
+      if !hijack
+        chunked = nil
+        headers['content-length'] = '0' if empty_body
+        chunked = !headers['content-length']
+        headers['transfer-encoding'] = 'chunked' if chunked
+      end
+
+      buf_status = "HTTP/1.1 #{status}\r\n"
+      buf_headers = format_headers(headers)
+
+      if hijack
+        machine.sendv(fd, buf_status, buf_headers)
+        hijack.(env['rack.hijack'].())
+      elsif body && !empty_body
+        if chunked
+          send_body_chunked(machine, env, fd, buf_status, buf_headers, body)
+        else
+          if body.is_a?(Array)
+            machine.sendv(fd, buf_status, buf_headers, *body)
+          else
+            machine.sendv(fd, buf_status, buf_headers, body)
+          end
+        end
+      else
+        machine.sendv(fd, buf_status, buf_headers)
+      end
+    end
+
+    def send_body_chunked(machine, env, fd, buf_status, buf_headers, body)
+      case body
+      when String
+        buf_chunk_header = "#{body.bytesize.to_s(16)}\r\n"
+        machine.sendv(
+          fd,
+          buf_status,
+          buf_headers,
+          buf_chunk_header,
+          body,
+          CHUNK_END
+        )
+      when Array
+        bufs = [buf_status, buf_headers]
+        first = true
+        body.each {
+          bufs << (first ? "#{it.bytesize.to_s(16)}\r\n" : "\r\n#{it.bytesize.to_s(16)}\r\n")
+          first = false
+          bufs << it
+        }
+        bufs << CHUNK_END
+        machine.sendv(fd, *bufs)
+      else
+        if body.respond_to?(:each)
+          first = true
+          body.each do
+            chunk_header = first ? "#{it.bytesize.to_s(16)}\r\n" : "\r\n#{it.bytesize.to_s(16)}\r\n"
+            if first
+              machine.sendv(fd, buf_status, buf_headers, chunk_header, it)
+              first = false
+            else
+              machine.sendv(fd, chunk_header, it)
+            end
+          end
+          machine.sendv(fd, first ? "0\r\n\r\n" : "\r\n0\r\n\r\n")
+        elsif body.respond_to?(:call)
+          machine.sendv(fd, buf_status, buf_headers)
+          chunked_stream = ChunkedIO.new(machine, fd, env['uma.stream'])
+          body.call(chunked_stream)
+        else
+          raise ResponseError, "Invalid response body: #{body.inspect}"
+        end
+
+        chunked_stream.close if chunked_stream
+        body.close if body.respond_to?(:close)
+      end
+    end
+
+    def format_headers(headers)
+      buf = +''
+      headers.each do |k, v|
+        next if k =~ /^rack\./
+
+        case v
+        when String
+          buf << "#{k}: #{v}\r\n"
+        when Array
+          v.each { buf << "#{k}: #{it}\r\n" }
+        else
+          raise ResponseError, "Invalid header value #{v.inspect}"
+        end
+      end
+      buf << "\r\n"
+      buf
+    end
+
+    def should_process_next_request?(env)
+      # TODO: look at env
+      true
+    end
+  end
+end

data/lib/uma/server.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'uringmachine/fiber_scheduler'
+
+module Uma
+
+  class Server
+    def initialize(env)
+      @env = env
+    end
+
+    def start
+      @machine = UM.new
+      @stop_queue = UM::Queue.new
+
+      @config = ServerControl.server_config(@env)
+      @threads = @config[:thread_count].times.map {
+        ServerControl.start_worker_thread(@config, @stop_queue)
+      }
+
+      ServerControl.await_process_termination(@machine)
+
+      stop
+    end
+
+    def stop
+      return if !@threads
+
+      @config[:thread_count].times { @machine.push(@stop_queue, :stop) }
+      @threads.each(&:join)
+      @threads = nil
+    end
+  end
+
+  module ServerControl
+    extend self
+
+    def server_config(env)
+      {
+        thread_count: 2,
+        bind_entries: env[:bind] ? bind_entries(env[:bind]) : [],
+        connection_proc: env[:connection_proc],
+        error_stream: env[:error_stream]
+      }
+    end
+
+    def bind_entries(bind_value)
+      case bind_value
+      when Array
+        bind_value.map { parse_bind_spec(it) }
+      when String
+        [parse_bind_spec(bind_value)]
+      else
+        raise ArgumentError, "invalid bind value"
+      end
+    end
+
+    BIND_SPEC_RE = /^(.+)\:(\d+)$/.freeze
+
+    def parse_bind_spec(spec)
+      if (m = spec.match(BIND_SPEC_RE))
+        [m[1], m[2].to_i]
+      else
+        raise ArgumentError, "Invalid bind spec"
+      end
+    end
+
+    def start_worker_thread(config, stop_queue)
+      Thread.new do
+        machine = UM.new
+        scheduler = UM::FiberScheduler.new(machine)
+        Fiber.set_scheduler(scheduler)
+
+        worker_thread(machine, config, stop_queue)
+      end
+    end
+
+    def worker_thread(machine, config, stop_queue)
+      connection_fibers = Set.new
+      accept_fibers = start_acceptors(machine, config, connection_fibers)
+
+      machine.shift(stop_queue)
+
+      worker_thread_graceful_stop(machine, accept_fibers, connection_fibers)
+    end
+
+    # @return [Set<Fiber>] a set of accept fibers
+    def start_acceptors(machine, config, connection_fibers)
+      set = Set.new
+      return set if !config[:bind_entries] || config[:bind_entries].empty?
+
+      config[:bind_entries].each do
+        host, port = it
+        set << machine.spin do
+          fd = prepare_listening_socket(machine, host, port)
+          machine.accept_each(fd) { |fd|
+            start_connection(machine, config, connection_fibers, fd)
+          }
+        rescue UM::Terminate
+        ensure
+          machine.close(fd)
+        end
+      end
+      set
+    end
+
+    def prepare_listening_socket(machine, host, port)
+      fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+      machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEPORT, true)
+      machine.bind(fd, host, port)
+      machine.listen(fd, UM::SOMAXCONN)
+      fd
+    end
+
+    # @return [Fiber]
+    def start_connection(machine, config, connection_fibers, fd)
+      f = machine.spin do
+        connection_fibers << f
+        config[:connection_proc]&.(machine, fd)
+      ensure
+        machine.close(fd) rescue nil
+        connection_fibers.delete(f)
+      end
+    end
+
+    def worker_thread_graceful_stop(machine, accept_fibers, connection_fibers)
+      # stop accepting connections
+      machine.terminate(accept_fibers)
+      machine.await_fibers(accept_fibers)
+
+      machine.terminate(connection_fibers)
+
+      # graceful stop with a timeout of 10 seconds
+      machine.timeout(10, UM::Terminate) do
+        machine.await_fibers(connection_fibers)
+      rescue UM::Terminate
+        alive = connection_fibers.reject(&:done?)
+        machine.terminate(alive)
+        machine.await_fibers(alive)
+      end
+    end
+
+    def await_process_termination(machine)
+      sig_queue = UM::Queue.new
+
+      old_term_handler = trap('SIGTERM') {
+        machine.push(sig_queue, :term)
+        trap('SIGTERM', old_term_handler)
+      }
+      old_int_handler = trap('SIGINT')  {
+        machine.push(sig_queue, :int)
+        trap('SIGINT', old_int_handler)
+      }
+
+      machine.shift(sig_queue)
+    end
+  end
+end

data/lib/uma/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Uma
+  VERSION = '0.1.0'
+end

data/lib/uma.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'uringmachine'

data/test/apps/bad_syntax.ru

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+def t

data/test/apps/config.ru

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+run ->(env) { [200, {}, 'Hello from config.ru'] }

data/test/apps/roda1.ru

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "roda"
+require "irb"
+
+# Demo app copied from Roda website:
+# https://roda.jeremyevans.net/
+class App < Roda
+  route do |r|
+    # GET / request
+    r.root do
+      r.redirect "/hello"
+    end
+
+    # /hello branch
+    r.on "hello" do
+      # Set variable for all routes in /hello branch
+      @greeting = 'Hello'
+
+      # GET /hello/world request
+      r.get "world" do
+        "#{@greeting} world!"
+      end
+
+      # /hello request
+      r.is do
+        # GET /hello request
+        r.get do
+          "#{@greeting}!"
+        end
+
+        # POST /hello request
+        r.post do
+          r.redirect
+        end
+      end
+    end
+  end
+end
+
+run App.freeze.app

data/test/apps/simple.ru

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+run ->(env) { [200, {}, 'simple'] }

data/test/helper.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require_relative './coverage' if ENV['COVERAGE']
+require 'uma'
+require 'minitest/autorun'
+require 'securerandom'
+
+STDOUT.sync = true
+STDERR.sync = true
+
+module ::Kernel
+  def debug(**h)
+    k, v = h.first
+    h.delete(k)
+
+    rest = h.inject(+'') { |s, (k, v)| s << "  #{k}: #{v.inspect}\n" }
+    STDOUT.orig_write("#{k}=>#{v} #{caller[0]}\n#{rest}")
+  end
+
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.first.is_a?(String)
+      if args.size > 1
+        format("%s: %p\n", args.shift, args)
+      else
+        format("%s\n", args.first)
+      end
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+
+  def monotonic_clock
+    ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+  end
+end
+
+module Minitest::Assertions
+  # def setup
+  #   sleep 0.0001
+  # end
+
+  def assert_in_range exp_range, act
+    msg = message(msg) { "Expected #{mu_pp(act)} to be in range #{mu_pp(exp_range)}" }
+    assert exp_range.include?(act), msg
+  end
+end
+
+class UMBaseTest < Minitest::Test
+  # pull in UM constants
+  UM.constants.each do |c|
+    v = UM.const_get(c)
+    const_set(c, v) if v.is_a?(Integer)
+  end
+
+  attr_accessor :machine
+
+  def setup
+    @machine = UM.new
+    @machine.test_mode = true
+  end
+
+  def teardown
+    return if !@machine
+
+    if ENV['UM_METRICS']
+      pp machine.metrics
+    end
+
+    pending_fibers = @machine.pending_fibers
+    raise "leaked fibers: #{pending_fibers}" if pending_fibers.size > 0
+
+    GC.start
+  end
+
+  def scheduler_calls_tally
+    @scheduler.calls.map { it[:sym] }.tally
+  end
+
+  @@port ||= 10001 + SecureRandom.rand(50000)
+
+  def random_port
+    @@port_assign_mutex ||= Mutex.new
+    @@port_assign_mutex.synchronize do
+      @@port += 1
+    end
+  end
+
+  def make_tmp_file_tree(dir, spec)
+    FileUtils.mkdir(dir) rescue nil
+    spec.each do |k, v|
+      fn = File.join(dir, k.to_s)
+      case v
+      when String
+        IO.write(fn, v)
+      when Hash
+        FileUtils.mkdir(fn) rescue nil
+        make_tmp_file_tree(fn, v)
+      end
+    end
+    dir
+  end
+end

data/test/run.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob("#{__dir__}/test_*.rb").each do |path|
+  require(path)
+end

data/test/test_app.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'uma/app'
+
+class AppTest < UMBaseTest
+  App = Uma::App
+
+  def test_app
+    fn = File.join(__dir__, 'apps/simple.ru')
+    app = App.new(fn)
+
+    assert_kind_of App, app
+    assert_equal [200, {}, 'simple'], app.to_proc.({})
+  end
+
+  def test_app_bad_filename
+    fn = File.join(__dir__, 'apps/simple2.ru')
+    assert_raises(Uma::Error) { App.new(fn) }
+  end
+
+  def test_app_invalid_syntax
+    fn = File.join(__dir__, 'apps/bad_syntax.ru')
+    assert_raises(Uma::Error) { App.new(fn) }
+  end
+end