right_speed 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a21c10b045dfb5591600c16d61a7fa9d09771db4960e0d3c3021b90c8fbdc48c
+  data.tar.gz: a71b06cde0b6b1028aabdab601673d827040824db08d6fce181c9c9816669d74
+SHA512:
+  metadata.gz: 490fb8ff447db76d7cdc16980d547de1b078d9648afe9534804a638abb708d63f572b84a64489707fedad4dfd29caf046b96456b390064ada334a7b14953b556
+  data.tar.gz: 52e3d420c923a0593f463aeff793911000bce92b8855723f02fa7ffc4e3da3744779d264e29f5ee0b4e46f5a63e5570a39c33f4c79d8c1cd3c2f4e718c6315bf

data/.github/workflows/main.yml

@@ -0,0 +1,35 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0.2
+    - name: Run the default task
+      run: |
+        gem install bundler
+        bundle install
+        bundle exec rake
+    - name: Run the actual server
+      run: |
+        bundle exec ruby bin/right_speed -c snippets/test.ru &
+        sleep 5
+        output=$(curl -s http://127.0.0.1:8080/)
+        kill %1
+        echo "Output: $output"
+        test "$output" = "Yaaay"
+    - name: Run rackup
+      # Using production not to use middlewares for development (lint, etc)
+      run: |
+        bundle exec rackup snippets/test.ru -s right_speed -E production -O Host=127.0.0.1 -O Port=8081 &
+        sleep 5
+        output=$(curl -s http://127.0.0.1:8081/)
+        kill %1
+        echo "Output: $output"
+        test "$output" = "Yaaay"

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in right_speed.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "test-unit", "~> 3.0"
+
+# The updated libraries for ractor-safety
+gem "http_parser.rb", git: 'https://github.com/tmm1/http_parser.rb.git'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Satoshi Moris Tagomori
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+# RightSpeed
+
+RightSpeed is **an experimental application server** to host Rack applications, on Ractor workers, to test/verify that your application is Ractor-safe/Ractor-ready or not.
+Ractor is an experimental feature of Ruby 3.0, thus **this application server is also not for production environments**.
+
+Currently, RightSpeed supports the very limited set of Rack protocol specifications. Unsupported features are, for example:
+
+* Writing logs into files
+* Daemonizing processes
+* Reloading applications without downtime
+* Handling session objects (using `rack.session`)
+* Handling multipart contents flexisbly (using `rack.multipart.buffer_size` nor `rack.multipart.tempfile_factory`)
+* [Hijacking](https://github.com/rack/rack/blob/master/SPEC.rdoc#label-Hijacking)
+
+## Changelog
+
+* v0.1.0:
+  * The first release just before RubyKaigi Takeout 2021
+
+## Usage
+
+Use the latest Ruby 3.x release!
+
+Install `right_speed` by `gem` command (`gem i right_speed`), then use it directly:
+
+```
+$ right_speed -c config.ru -p 8080 --workers 8
+
+# See right_speed --help for full options:
+$ right_speed --help
+Usage: right_speed [options]
+
+OPTIONS
+  --config, -c PATH     The path of the rackup configuration file (default: config.ru)
+  --port, -p PORT       The port number to listen (default: 8080)
+  --backlog NUM         The number of backlog
+  --workers NUM         The number of Ractors (default: CPU cores)
+  --worker-type TYPE    The type of workers, available options are read/accept (default: read)
+  --help                Show this message
+```
+
+Or, use `rackup` with `-s right_speed`:
+
+```
+$ rackup config.ru -s right_speed -p 8080 -O Workers=8
+```
+
+The default number of worker Ractors is the number of CPU cores.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tagomoris/right_speed.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/bin/right_speed

@@ -0,0 +1,106 @@
+#!ruby
+# frozen_string_literal: true
+
+require_relative "../lib/right_speed/env"
+require_relative "../lib/right_speed/server"
+require "getoptlong"
+
+module RightSpeed
+  module Command
+    Options = Struct.new(
+      :rackup, :port, :backlog,
+      :workers, :worker_type,
+      keyword_init: true,
+    )
+
+    COMMAND_OPTIONS = [
+      ['--config', '-c', GetoptLong::REQUIRED_ARGUMENT],
+      ['--port', '-p', GetoptLong::REQUIRED_ARGUMENT],
+      ['--backlog', GetoptLong::REQUIRED_ARGUMENT],
+      ['--workers', GetoptLong::REQUIRED_ARGUMENT],
+      ['--worker-type', GetoptLong::REQUIRED_ARGUMENT],
+      ['--help', GetoptLong::NO_ARGUMENT],
+    ]
+
+    DEFAULT_RACKUP_PATH = 'config.ru'
+    DEFAULT_PORT = Server::DEFAULT_PORT
+    DEFAULT_WORKERS = Env.processors
+    DEFAULT_WORKER_TYPE = Server::DEFAULT_WORKER_TYPE
+    DEFAULT_LISTENER_TYPE = Server::DEFAULT_LISTENER_TYPE
+
+    AVAILABLE_WORKER_TYPES = Server::AVAILABLE_WORKER_TYPES.map(:to_s).join('/')
+    AVAILABLE_LISTENER_TYPES = Server::AVAILABLE_LISTENER_TYPES.map(:to_s).join('/')
+
+    def self.show_help(error: false, error_message: nil)
+      STDERR.puts(error_message, "\n") if error_message
+      STDERR.puts <<~EOS
+        Usage: right_speed [options]
+
+        OPTIONS
+          --config, -c PATH     The path of the rackup configuration file (default: #{DEFAULT_RACKUP_PATH})
+          --port, -p PORT       The port number to listen (default: #{DEFAULT_PORT})
+          --backlog NUM         The number of backlog
+          --workers NUM         The number of Ractors (default: CPU cores, #{DEFAULT_WORKERS})
+          --worker-type TYPE    The type of workers (available: #{AVAILABLE_WORKER_TYPES}, default: #{DEFAULT_WORKER_TYPE})
+          --help                Show this message
+      EOS
+      exit(error ? 1 : 0)
+    end
+
+    def self.integer_value(value, name)
+      Integer(value)
+    rescue
+      show_help(error: true, error_message: "#{name} should be an Integer: #{value}")
+    end
+
+    def self.parse_command_line_options
+      optparse = GetoptLong.new
+      optparse.set_options(*COMMAND_OPTIONS)
+      options = Options.new(
+        rackup: DEFAULT_RACKUP_PATH,
+        port: DEFAULT_PORT,
+        backlog: nil,
+        workers: DEFAULT_WORKERS,
+        worker_type: DEFAULT_WORKER_TYPE,
+      )
+      worker_type = :read
+      optparse.each_option do |name, value|
+        case name
+        when '--config'
+          options.rackup = value
+        when '--port'
+          options.port = integer_value(value, "Port number")
+        when '--backlog'
+          options.backlog = integer_value(value, "Backlog")
+        when '--workers'
+          options.workers = integer_value(value, "Workers")
+        when '--worker-type'
+          options.worker_type = value.to_sym
+        when '--help'
+          show_help
+        else
+          show_help(error: true, error_messsage: "Unknown option: #{name}")
+        end
+      end
+      options
+    end
+
+    def self.start
+      options = parse_command_line_options
+      server = begin
+                 RightSpeed::Server.new(
+                   port: options.port,
+                   app: options.rackup,
+                   backlog: options.backlog,
+                   workers: options.workers,
+                   worker_type: options.worker_type,
+                 )
+               rescue => e
+                 show_help(error: true, error_message: "Failed to launch the server, " + e.message)
+               end
+      server.run
+    end
+  end
+end
+
+RightSpeed::Command.start

data/lib/rack/handler/right_speed.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "right_speed/server"
+
+module Rack
+  module Handler
+    class RightSpeed
+      def self.run(app, **options)
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? '127.0.0.1' : '0.0.0.0'
+
+        host = options.delete(:Host) || default_host
+        port = options.delete(:Port) || 8080
+        workers = options.delete(:Workers) || ::RightSpeed::Env.processors
+        server = ::RightSpeed::Server.new(app: app, host: host, port: port, workers: workers)
+
+        yield server if block_given?
+
+        server.run
+      end
+
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? '127.0.0.1' : '0.0.0.0'
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+          "Workers=NUM" => "Number of workers (default: #{::RightSpeed::Env.processors})",
+        }
+      end
+    end
+
+    register :right_speed, ::Rack::Handler::RightSpeed
+  end
+end

data/lib/right_speed/connection_closer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "logger"
+
+module RightSpeed
+  class ConnectionCloser
+    def run(workers)
+      @ractor = Ractor.new(workers) do |workers|
+        logger = RightSpeed.logger
+        while workers.size > 0
+          r, conn = Ractor.select(*workers, move: true)
+          if conn == :closing
+            workers.delete(r)
+            next
+          end
+          begin
+            conn.close
+          rescue => e
+            logger.debug { "Error while closing a connection #{conn}, #{e.class}:#{e.message}" }
+          end
+        end
+      rescue => e
+        logger.error { "Unexpected error, #{e.class}:#{e.message}" }
+      end
+    end
+  end
+end

data/lib/right_speed/const.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "version"
+
+module RightSpeed
+  SOFTWARE_NAME = "RightSpeed #{VERSION} (#{RUBY_ENGINE} #{RUBY_VERSION}p#{RUBY_PATCHLEVEL} [#{RUBY_PLATFORM}])".freeze
+  RACK_VERSION = Rack::VERSION.freeze
+end

data/lib/right_speed/env.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require "concurrent"
+
+module RightSpeed
+  module Env
+    def self.processors
+      Concurrent.processor_count
+    end
+  end
+end

data/lib/right_speed/handler.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+require "logger"
+require "stringio"
+require "http/parser"
+require "rack"
+
+require "pp"
+
+require_relative "./const"
+
+module RightSpeed
+  class Handler
+    def initialize(app)
+      @app = app
+    end
+
+    def session(conn)
+      Session.new(self, conn)
+    end
+
+    def process(session, client, request)
+      # https://github.com/rack/rack/blob/master/SPEC.rdoc
+      env = {
+        # TODO: replace the keys using constants: https://github.com/rack/rack/blob/master/lib/rack.rb
+        'HTTP_VERSION' => request.http_version,
+        'PATH_INFO' => request.path_info,
+        'QUERY_STRING' => request.query_string || "",
+        'REMOTE_ADDR' => client.addr,
+        'REQUEST_METHOD' => request.http_method,
+        'REQUEST_PATH' => request.path_info,
+        'REQUEST_URI' => request.request_uri,
+        'SCRIPT_NAME' => "",
+        'SERVER_NAME' => client.server_addr,
+        'SERVER_PORT' => client.server_port.to_s,
+        'SERVER_PROTOCOL' => request.http_version,
+        'SERVER_SOFTWARE' => RightSpeed::SOFTWARE_NAME,
+        **request.headers_in_env_style,
+        ### Rack specific keys
+        'rack.version' => RightSpeed::RACK_VERSION,
+        'rack.url_scheme' => 'http', # http or https, depending on the request URL.
+        'rack.input' => request.body, # The input stream.
+        'rack.errors' => $stderr, # The error stream.
+        'rack.multithread' => true,
+        'rack.multiprocess' => false,
+        'rack.run_once' => false,
+        'rack.hijack?' => false, # https://github.com/rack/rack/blob/master/SPEC.rdoc#label-Hijacking
+        ### Optional Rack keys
+        ## 'rack.session'
+        # A hash like interface for storing request session data.
+        # The store must implement:
+        #   store(key, value) (aliased as []=); fetch(key, default = nil) (aliased as []);
+        #   delete(key); clear; to_hash (returning unfrozen Hash instance);
+        'rack.logger' => session.logger,
+        # A common object interface for logging messages.
+        # The object must implement:
+        #   info(message, &block),debug(message, &block),warn(message, &block),error(message, &block),fatal(message, &block)
+        ## 'rack.multipart.buffer_size'
+        # An Integer hint to the multipart parser as to what chunk size to use for reads and writes.
+        ## 'rack.multipart.tempfile_factory'
+        # An object responding to #call with two arguments, the filename and content_type given for the multipart form field,
+        # and returning an IO-like object that responds to #<< and optionally #rewind. This factory will be used to instantiate
+        # the tempfile for each multipart form file upload field, rather than the default class of Tempfile.
+      }
+      status, headers, body = @app.call(env)
+      Response.new(http_version: request.http_version, status_code: status, headers: headers, body: body)
+    end
+
+    class Client
+      attr_reader :addr, :port, :server_addr, :server_port
+
+      def initialize(conn)
+        _, @port, _, @addr = conn.peeraddr
+        _, @server_port, _, @server_addr = conn.addr
+        if @server_addr == "::1"
+          @server_addr = "localhost"
+        end
+      end
+    end
+
+    class Request
+      attr_reader :http_method, :http_version, :request_url, :headers, :body, :path_info, :query_string
+
+      def initialize(client:, http_method:, http_version:, request_url:, headers:, body:)
+        @client = client
+        @http_method = http_method
+        @http_version = "HTTP/" + http_version.map(&:to_s).join(".")
+        @request_url = request_url
+        @headers = headers
+        @body = StringIO.new(body)
+
+        @path_info, @query_string = request_url.split('?')
+      end
+
+      def request_uri
+        "http://#{@client.server_addr}:#{@client.server_port}#{request_url}"
+      end
+
+      def headers_in_env_style
+        headers = {}
+        @headers.each do |key, value|
+          headers["HTTP_" + key.gsub("-", "_").upcase] = value
+        end
+        headers
+      end
+    end
+
+    class Response
+      STATUS_MESSAGE_MAP = {
+        200 => "OK",
+      }.freeze
+
+      attr_reader :body
+
+      def initialize(http_version:, status_code:, headers:, body:)
+        @http_version = http_version
+        @status_code = status_code
+        @status_message = STATUS_MESSAGE_MAP.fetch(status_code, "Unknown")
+        @headers = headers
+        @body = body
+      end
+
+      def status
+        "#{@http_version} #{@status_code} #{@status_message}\r\n"
+      end
+
+      def headers
+        @headers.map{|key, value| "#{key}: #{value}\r\n" }.join + "\r\n"
+      end
+    end
+
+    class Session
+      READ_CHUNK_LENGTH = 1024
+
+      attr_reader :logger
+
+      def initialize(handler, conn)
+        @logger = RightSpeed.logger
+        @handler = handler
+        @conn = conn
+        @client = Client.new(conn)
+
+        # https://github.com/tmm1/http_parser.rb
+        @parser = Http::Parser.new(self, default_header_value_type: :mixed)
+        @reading = true
+        @method = nil
+        @url = nil
+        @headers = nil
+        @body = String.new
+      end
+
+      # TODO: implement handling of "Connection" and "Keep-Alive"
+      # https://developer.mozilla.org/ja/docs/Web/HTTP/Headers/Connection
+      # https://developer.mozilla.org/ja/docs/Web/HTTP/Headers/Keep-Alive
+
+      def process
+        while @reading && !@conn.eof?
+          @parser << @conn.readpartial(READ_CHUNK_LENGTH)
+        end
+      end
+
+      def on_headers_complete(headers)
+        @headers = headers
+        @method = @parser.http_method
+        @url = @parser.request_url
+      end
+
+      def on_body(chunk)
+        @body << chunk
+      end
+
+      def on_message_complete
+        # @logger.debug {
+        #   "complete to read the request, headers:#{@headers}, body:#{@body}"
+        # }
+        request = Request.new(
+          client: @client, http_method: @method, http_version: @parser.http_version,
+          request_url: @url, headers: @headers, body: @body
+        )
+        response = @handler.process(self, @client, request)
+        send_response(response)
+        @reading = false
+      end
+
+      def send_response(response)
+        @conn.write response.status
+        @conn.write response.headers
+        response.body.each do |part|
+          @conn.write part
+        end
+      end
+    end
+  end
+end

data/lib/right_speed/listener.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "logger"
+
+module RightSpeed
+  module Listener
+    def self.setup(listener_type:, host:, port:, backlog: nil)
+      case listener_type
+      when :roundrobin
+        RoundRobinListener.new(host, port, backlog)
+      else
+        SimpleListener.new(host, port, backlog)
+      end
+    end
+
+    class SimpleListener
+      attr_reader :sock
+
+      def initialize(host, port, backlog)
+        @host = host
+        @port = port
+        @backlog = backlog
+        @sock = nil
+      end
+
+      def run(_processor)
+        @running = true
+        @sock = TCPServer.open(@host, @port)
+        @sock.listen(@backlog) if @backlog
+        @sock
+      end
+
+      def wait
+        # do nothing
+      end
+
+      def stop
+        @running = false
+        if @sock
+          @sock.close rescue nil
+        end
+      end
+    end
+
+    class RoundRobinListener < SimpleListener
+      def run(processor)
+        @running = true
+        @ractor = Ractor.new(@host, @port, @backlog, processor) do |host, port, backlog, processor|
+          logger = RightSpeed.logger
+          sock = TCPServer.open(host, port)
+          sock.listen(backlog) if backlog
+          logger.info { "listening #{host}:#{port}" }
+          while conn = sock.accept
+            processor.process(conn)
+          end
+        end
+      end
+
+      def wait
+        @ractor.take
+      end
+
+      def stop
+        @running = false
+        @ractor = nil # TODO: terminate the Ractor if possible
+      end
+    end
+  end
+end

data/lib/right_speed/logger.rb

@@ -0,0 +1,9 @@
+module RightSpeed
+  def self.logger
+    return Ractor.current[:logger] if Ractor.current[:logger]
+    logger = Logger.new($stderr)
+    logger.formatter = lambda {|severity, datetime, progname, msg| "[#{datetime}] #{severity} #{msg}\n" }
+    Ractor.current[:logger] = logger
+    logger
+  end
+end

data/lib/right_speed/processor.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'rack/builder'
+
+require_relative 'worker/accepter'
+require_relative 'worker/reader'
+require_relative 'connection_closer'
+
+module RightSpeed
+  module Processor
+    def self.setup(app:, worker_type:, workers:)
+      app = if app.respond_to?(:call)
+              app
+            elsif app.is_a?(String) # rackup config path
+              build_app(app)
+            else
+              raise "Unexpected app #{app}"
+            end
+      handler = Ractor.make_shareable(Handler.new(app))
+      case worker_type
+      when :read
+        ReadProcessor.new(workers, handler)
+      when :accept
+        AcceptProcessor.new(workers, handler)
+      else
+        raise "Unknown worker type #{worker_type}"
+      end
+    end
+
+    def self.build_app(ru)
+      app = Rack::Builder.parse_file(ru)
+      if app.respond_to?(:call)
+        app
+      elsif app.is_a?(Array) && app[0].respond_to?(:call)
+        # Rack::Builder returns [app, options] but options will be deprecated
+        app[0]
+      else
+        raise "Failed to build Rack app from #{ru}: #{app}"
+      end
+    end
+
+    class Base
+      def initialize(workers, handler)
+        raise "BUG: use implementation class"
+      end
+
+      def configure(listener:)
+        raise "BUG: not implemented"
+      end
+
+      def run
+        raise "BUG: not implemented"
+      end
+
+      def process(conn)
+        raise "BUG: not implemented"
+      end
+
+      def wait
+        raise "BUG: not implemented"
+        # ractors.each{|r| r.take}
+        # finalizer.close rescue nil
+      end
+    end
+
+    class ReadProcessor < Base
+      def initialize(workers, handler)
+        @worker_num = workers
+        @handler = handler
+        @workers = workers.times.map{|i| Worker::Reader.new(id: i, handler: @handler)}
+        @closer = ConnectionCloser.new
+        @counter = 0
+      end
+
+      def configure(listener:)
+        @listener = listener
+      end
+
+      def run
+        @workers.each{|w| w.run}
+        @closer.run(@workers.map{|w| w.ractor})
+        @listener.run(self)
+      end
+
+      def process(conn)
+        current, @counter = @counter, @counter + 1
+        @workers[current % @worker_num].process(conn)
+      end
+
+      def wait
+        @workers.each{|w| w.wait}
+      end
+    end
+
+    class AcceptProcessor < Base
+      def initialize(workers, handler)
+        @worker_num = workers
+        @handler = handler
+        @workers = workers.times.map{|i| Worker::Accepter.new(id: i, handler: @handler) }
+      end
+
+      def configure(listener:)
+        @listener = listener
+        @workers.each do |w|
+          w.configure(listener.sock)
+        end
+      end
+
+      def run
+        @workers.each do |w|
+          w.run
+        end
+        # TODO: connection closer
+      end
+
+      def wait
+        @workers.each{|w| w.wait}
+      end
+    end
+  end
+end

data/lib/right_speed/ractor_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "uri"
+require "rack"
+
+module RightSpeed
+  module RactorHelper
+    def self.uri_hook
+      # Use 3.1.0-dev!
+    end
+
+    def self.rack_hook
+      ip_filter = Ractor.make_shareable(Rack::Request.ip_filter)
+      overwrite_method(Rack::Request::Helpers, :trusted_proxy?) do |ip|
+        ip_filter.call(ip)
+      end
+      overwrite_method(Rack::Request::Helpers, :query_parser, Rack::Utils.default_query_parser)
+      overwrite_const(Rack::ShowExceptions, :TEMPLATE, Rack::ShowExceptions::TEMPLATE)
+      freeze_all_constants(::Rack)
+    end
+
+    def self.freeze_all_constants(mojule, touch_list=[])
+      touch_list << mojule
+      mojule.constants.each do |const_name|
+        const = begin
+                  mojule.const_get(const_name)
+                rescue LoadError
+                  # ignore unloadable modules (autoload, probably)
+                  nil
+                end
+        next unless const
+        if const.is_a?(Module) && !touch_list.include?(const)
+          # not freeze Module/Class because we're going to do monkey patching...
+          freeze_all_constants(const, touch_list)
+        else
+          const.freeze
+        end
+      end
+    end
+
+    def self.overwrite_method(mojule, name, value=nil, &block)
+      if block_given?
+        mojule.define_method(name, Ractor.make_shareable(block))
+      else
+        v = Ractor.make_shareable(value)
+        mojule.define_method(name, Ractor.make_shareable(->(){ v }))
+      end
+    end
+
+    def self.overwrite_const(mojule, name, value)
+      v = Ractor.make_shareable(value)
+      mojule.const_set(name, value)
+    end
+  end
+end

data/lib/right_speed/server.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "socket"
+require "logger"
+require "webrick"
+
+require_relative "processor"
+require_relative "listener"
+require_relative "env"
+require_relative "ractor_helper"
+
+module RightSpeed
+  CONFIG_HOOK_KEY = 'right_speed_config_hooks'
+
+  class Server
+    DEFAULT_HOST = "127.0.0.1"
+    DEFAULT_PORT = 8080
+    DEFAULT_WORKER_TYPE = :read
+    DEFAULT_WORKERS = Env.processors
+    DEFAULT_SCHEDULER_TYPE = :roundrobin
+
+    AVAILABLE_WORKER_TYPES = [:read, :accept]
+    AVAILABLE_LISTENER_TYPES = [:roundrobin, :fair]
+
+    attr_reader :config_hooks
+
+    def initialize(
+          app:,
+          host: DEFAULT_HOST,
+          port: DEFAULT_PORT,
+          workers: DEFAULT_WORKERS,
+          worker_type: DEFAULT_WORKER_TYPE,
+          scheduler_type: DEFAULT_SCHEDULER_TYPE,
+          backlog: nil
+        )
+      @host = host
+      @port = port
+      @app = app
+      @workers = workers
+      @worker_type = worker_type
+      @listener_type = case @worker_type
+                       when :read then scheduler_type
+                       else :listen
+                       end
+      @backlog = backlog
+      @config_hooks = []
+      @logger = nil
+    end
+
+    def run
+      logger = RightSpeed.logger
+      logger.info { "Start running with #{@workers} workers" }
+
+      hooks = @config_hooks + (Ractor.current[RightSpeed::CONFIG_HOOK_KEY] || [])
+      hooks.each do |hook|
+        if hook.respond_to?(:call)
+          hook.call
+        end
+      end
+
+      RactorHelper.uri_hook
+      RactorHelper.rack_hook
+
+      begin
+        processor = Processor.setup(app: @app, worker_type: @worker_type, workers: @workers)
+        listener = Listener.setup(listener_type: @listener_type, host: @host, port: @port, backlog: nil)
+        processor.configure(listener: listener)
+        processor.run
+        listener.wait
+        processor.wait
+      ensure
+        listener.stop rescue nil
+        processor.stop rescue nil
+      end
+    end
+  end
+end

data/lib/right_speed/version.rb

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

data/lib/right_speed/worker/accepter.rb

@@ -0,0 +1,30 @@
+require_relative 'base'
+
+module RightSpeed
+  module Worker
+    class Accepter < Base
+      def configure(sock)
+        @sock = sock
+      end
+
+      def run
+        @ractor = Ractor.new(@id, @sock) do |id, sock|
+          while conn = sock.accept
+            begin
+              data = conn.read
+              # TODO: process it
+              logger.info "[read|#{id}] Data: #{data}"
+              conn.write "200 OK"
+            ensure
+              conn.close rescue nil
+            end
+          end
+        end
+      end
+
+      def wait
+        @ractor.take
+      end
+    end
+  end
+end

data/lib/right_speed/worker/base.rb

@@ -0,0 +1,22 @@
+require_relative "../logger"
+require_relative "../handler"
+
+module RightSpeed
+  module Worker
+    class Base
+      def initialize(id:, handler:)
+        @id = id
+        @handler = handler
+        @ractor = nil
+      end
+
+      def ractor
+        @ractor
+      end
+
+      def stop
+        @ractor # TODO: terminate if possible
+      end
+    end
+  end
+end

data/lib/right_speed/worker/reader.rb

@@ -0,0 +1,34 @@
+require_relative "base"
+require_relative "../logger"
+
+module RightSpeed
+  module Worker
+    class Reader < Base
+      def run
+        @ractor = Ractor.new(@id, @handler) do |id, handler|
+          logger = RightSpeed.logger
+          while conn = Ractor.receive
+            begin
+              handler.session(conn).process
+              # TODO: keep-alive?
+              Ractor.yield(conn, move: true) # to yield closing connections to ConnectionCloser
+            rescue => e
+              logger.error { "Unexpected error: #{e.message}\n" + e.backtrace.map{"\t#{_1}\n"}.join }
+              # TODO: print backtrace in better way
+            end
+          end
+          logger.info { "Worker#{id}: Finishing the Ractor" }
+          Ractor.yield(:closing) # to tell the outgoing path will be closed when stopping
+        end
+      end
+
+      def process(conn)
+        @ractor.send(conn, move: true)
+      end
+
+      def wait
+        @ractor.take
+      end
+    end
+  end
+end

data/lib/right_speed.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "right_speed/version"
+
+module RightSpeed
+end
+
+require_relative "right_speed/server"

data/right_speed.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "lib/right_speed/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "right_speed"
+  spec.version       = RightSpeed::VERSION
+  spec.authors       = ["Satoshi Moris Tagomori"]
+  spec.email         = ["tagomoris@gmail.com"]
+
+  spec.summary       = "HTTP server implementation using Ractor"
+  spec.description   = "HTTP server, which provides traffic under the support of Ractor"
+  spec.homepage      = "https://github.com/tagomoris/right_speed"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.2")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features|snippets)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{\Abin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "webrick", "~> 1.7"
+  spec.add_runtime_dependency "rack", "~> 2.2"
+  spec.add_runtime_dependency "concurrent-ruby", "~> 1.1"
+  spec.add_runtime_dependency "http_parser.rb", "~> 0.8"
+
+  spec.add_development_dependency "test-unit"
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: right_speed
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Satoshi Moris Tagomori
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: HTTP server, which provides traffic under the support of Ractor
+email:
+- tagomoris@gmail.com
+executables:
+- right_speed
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/right_speed
+- lib/rack/handler/right_speed.rb
+- lib/right_speed.rb
+- lib/right_speed/connection_closer.rb
+- lib/right_speed/const.rb
+- lib/right_speed/env.rb
+- lib/right_speed/handler.rb
+- lib/right_speed/listener.rb
+- lib/right_speed/logger.rb
+- lib/right_speed/processor.rb
+- lib/right_speed/ractor_helper.rb
+- lib/right_speed/server.rb
+- lib/right_speed/version.rb
+- lib/right_speed/worker/accepter.rb
+- lib/right_speed/worker/base.rb
+- lib/right_speed/worker/reader.rb
+- right_speed.gemspec
+homepage: https://github.com/tagomoris/right_speed
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tagomoris/right_speed
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.0.dev
+signing_key:
+specification_version: 4
+summary: HTTP server implementation using Ractor
+test_files: []