itsi 0.1.9 → 0.1.12

data/gems/server/README.md

@@ -1,3 +1,7 @@
+---
+type: docs
+---
+
 # ItsiServer
 
 TODO: Delete this and the text below, and describe your gem

data/gems/server/_index.md

@@ -0,0 +1,6 @@
+---
+title: Itsi Server
+type: docs
+---
+
+## Foo

data/gems/server/exe/itsi

@@ -1,51 +1,44 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
+require "itsi/server"
 require "optparse"
 
-# Default options used when starting Osprey from the CLI using `osprey`
-DEFAULT_OPTIONS = {
-  # Number of workers
-  workers: 1,
-  # Number of threads per worker
-  threads: 1,
-  # Graceful shutdown timeout
-  shutdown_timeout: 5,
-  # Binds
-  binds: ["http://0.0.0.0:3000"],
-  # Preload
-  preload: true,
-  # Rackup file
-  rackup_file: "config.ru",
-  # Scheduler class
-  scheduler_class: nil,
-  # Whether to stream the body or not
-  stream_body: false
-}
-
-options = DEFAULT_OPTIONS.to_a.select(&:last).to_h
-
-# Define the option parser
+Itsi::Server::Config.save_argv!
+
+options = {}
+
 OptionParser.new do |opts|
   opts.banner = "Usage: itsi [options]"
 
-  opts.on("-w", "--workers WORKERS", Integer, "Number of workers (default: #{options[:workers]})") do |w|
+  opts.on("-C", "--config CONFIG_FILE", String, "Itsi Configuration file to use (default: Itsi.rb)") do |config_file|
+    options[:config_file] = config_file
+  end
+
+  opts.on("-w", "--workers WORKERS", Integer, "Number of workers (default: #{Etc.nprocessors})") do |w|
     options[:workers] = w
   end
 
-  opts.on("-t", "--threads THREADS", Integer, "Number of threads (default: #{options[:threads]})") do |t|
+  opts.on("-t", "--threads THREADS", Integer, "Number of threads (default: 1)") do |t|
     options[:threads] = t
   end
 
-  opts.on("-r", "--rackup_file FILE", String, "Rackup file to use (default: #{options[:rackup_file]})") do |rf|
+  opts.on("-mtr", "--multithreaded-reactor true/false", String,
+          "Use a multithreaded reactor (default: true)") do |mtr|
+    options[:multithreaded_reactor] = mtr.to_s == "true"
+  end
+
+  opts.on("-r", "--rackup_file FILE", String, "Rackup file to use (default: config.ru)") do |rf|
     options[:rackup_file] = rf
   end
 
   opts.on("--worker-memory-limit MEMORY_LIMIT", Integer,
-          "Memory limit for each worker (default: #{options[:worker_memory_limit] || 'None'}). If this limit is breached the worker is gracefully restarted") do |ml|
+          "Memory limit for each worker (default: None). If this limit is breached the worker is gracefully restarted") do |ml|
     options[:worker_memory_limit] = ml
   end
 
-  opts.on("-f", "--fiber_scheduler [CLASS_NAME]", [String], "Scheduler class to use (default: nil). Provide blank or true to use Itsi::Scheduler, or a classname to use an alternative scheduler") do |scheduler_class|
+  opts.on("-f", "--fiber_scheduler [CLASS_NAME]", [String],
+          "Scheduler class to use (default: nil). Provide blank or true to use Itsi::Scheduler, or a classname to use an alternative scheduler") do |scheduler_class|
     if scheduler_class.nil? || scheduler_class == "true"
       options[:scheduler_class] = "Itsi::Scheduler"
     elsif scheduler_class == "false"
@@ -65,15 +58,16 @@ OptionParser.new do |opts|
     end
   end
 
-
-  opts.on("-b", "--bind BIND", String, "Bind address (default: #{options[:binds].join(", ")}). You can specify this flag multiple times to bind to multiple addresses.") do |bind|
-    options[:binds].pop if options[:binds].first.frozen?
+  opts.on("-b", "--bind BIND", String,
+          "Bind address (default: http://0.0.0.0:3000). You can specify this flag multiple times to bind to multiple addresses.") do |bind|
+    options[:binds] ||= []
     options[:binds] << bind
   end
 
   opts.on("-c", "--cert_path CERT_PATH", String,
           "Path to the SSL certificate file (must follow a --bind option). You can specify this flag multiple times.") do |cp|
     raise OptionParser::InvalidOption, "--cert_path must follow a --bind" if options[:binds].empty?
+
     require "uri"
 
     # Modify the last bind entry to add/update the cert query parameter
@@ -84,8 +78,10 @@ OptionParser.new do |opts|
     options[:binds][-1] = "#{uri.host}?#{query_string}"
   end
 
-  opts.on("-k", "--key_path KEY_PATH", String, "Path to the SSL key file (must follow a --bind option). You can specify this flag multiple times.") do |kp|
+  opts.on("-k", "--key_path KEY_PATH", String,
+          "Path to the SSL key file (must follow a --bind option). You can specify this flag multiple times.") do |kp|
     raise OptionParser::InvalidOption, "--key_path must follow a --bind" if options[:binds].empty?
+
     require "uri"
 
     # Modify the last bind entry to add/update the key query parameter
@@ -113,32 +109,25 @@ OptionParser.new do |opts|
     puts opts
     exit
   end
-end.parse!
 
-# Rack app loader, invoked per worker.
-# This is a no-op if preloading is enabled (we just return the preloaded app).
-preloader = \
-  if options[:preload]
-    require "rack"
-
-    app = Array(Rack::Builder.parse_file(options[:rackup_file])).first
-    require_relative "../lib/itsi/server/scheduler_mode" if options[:scheduler_class]
-    app.method(:itself).to_proc
-  else
-    lambda do
-      require "rack"
-
-      app = Array(Rack::Builder.parse_file(options[:rackup_file])).first
-      require_relative "../lib/itsi/server/scheduler_mode" if options[:scheduler_class]
-      app
-    end
+  opts.on("--reexec PARAMS", String, "Reexec the server with the given parameters") do |params|
+    options[:reexec] = params
   end
 
-# Make sure Itsi is loaded, if not already loaded by the rack_app above.
-# Start the Itsi server
-require "itsi/server"
+  opts.on("--listeners LISTENERS", String, "Listeners for reexec") do |listeners|
+    options[:listeners] = listeners
+  end
+end.parse!
+
 
-Itsi::Server.new(
-  app: preloader,
-  **options.except(:preload, :rackup_file)
-).start
+case (command = ARGV.pop)
+when "init"
+  Itsi::Server::Config.write_default
+  exit(0)
+when "reload", "restart", "down", "up", "add_worker", "remove_worker", "status"
+  Itsi::Server.send(command)
+when nil, "start", "serve"
+  Itsi::Server.start(options)
+else
+  puts "Invalid command #{command}"
+end

data/gems/server/itsi-server.gemspec

@@ -27,7 +27,9 @@ Gem::Specification.new do |spec|
       (f == gemspec) ||
         f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
     end
-  end
+  end + Dir["../../crates/**/*.{toml,rs,lock}"].map do |ext_file|
+    "ext/#{ext_file[%r{.*crates/(.*?)$}, 1]}"
+  end.compact
 
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
@@ -38,7 +40,6 @@ Gem::Specification.new do |spec|
   # spec.add_dependency "example-gem", "~> 1.0"
   spec.add_dependency "rack", ">= 1.6"
   spec.add_dependency "rb_sys", "~> 0.9.91"
-
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
 end

data/gems/server/lib/itsi/{request.rb → http_request.rb}

@@ -4,9 +4,23 @@ require "stringio"
 require "socket"
 
 module Itsi
-  class Request
+  class HttpRequest
     attr_accessor :hijacked
 
+    EMPTY_IO = StringIO.new("").freeze
+    RACK_HEADER_MAP = StandardHeaders::ALL.map do |header|
+      rack_form = if header == "content-type"
+                    "CONTENT_TYPE"
+                  elsif header == "content-length"
+                    "CONTENT_LENGTH"
+                  else
+                    "HTTP_#{header.upcase.gsub(/-/, "_")}"
+                  end
+      [header, rack_form]
+    end.to_h.tap do |hm|
+      hm.default_proc = proc { |hsh, key| "HTTP_#{key.upcase.gsub(/-/, "_")}" }
+    end
+
     def to_rack_env
       path = self.path
       host = self.host
@@ -21,8 +35,8 @@ module Itsi
         "REMOTE_ADDR" => remote_addr,
         "SERVER_PORT" => port.to_s,
         "SERVER_NAME" => host,
-        "HTTP_HOST" => host,
         "SERVER_PROTOCOL" => version,
+        "HTTP_HOST" => host,
         "HTTP_VERSION" => version,
         "itsi.request" => self,
         "itsi.response" => response,
@@ -36,17 +50,26 @@ module Itsi
         "rack.hijack?" => true,
         "rack.multipart.buffer_size" => 16_384,
         "rack.hijack" => build_hijack_proc
-      }.tap { |r| headers.each { |(k, v)| r[k] = v } }
+      }.tap do |r|
+        headers.each do |(k, v)|
+          r[RACK_HEADER_MAP[k]] = v
+        end
+      end
+    end
+
+    def respond(_body = nil, _status = 200, _header = nil, status: _status, headers: _header, body: _body,
+                hijack: false, &blk)
+      response.respond(status: status, headers: headers, body: body, hijack: hijack, &blk)
     end
 
     def build_hijack_proc
       lambda do
         self.hijacked = true
         UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
+          server_sock.autoclose = false
           response.hijack(server_sock.fileno)
           server_sock.sync = true
           app_sock.sync = true
-          app_sock.instance_variable_set("@server_sock", server_sock)
           app_sock
         end
       end
@@ -54,8 +77,9 @@ module Itsi
 
     def build_input_io
       case body
-      when Array then File.open(body.first, "rb")
+      when nil then StringIO.new("")
       when String then StringIO.new(body)
+      when Array then File.open(body.first, "rb")
       else body
       end
     end

data/gems/server/lib/itsi/http_response.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require 'forwardable'
+require "stringio"
+require "socket"
+
+module Itsi
+
+  class HttpResponse
+
+    def respond _body=nil, _status=200, _header=nil, status: _status, headers: _header, body: _body, hijack: false, &blk
+      self.status = status
+
+      if headers
+        headers.each do |key, value|
+          if value.is_a?(Array)
+            value.each { |v| add_header(key, v) }
+          else
+            add_header(key, value)
+          end
+        end
+      end
+
+      if body
+        # Common case. Write a single string body.
+        send_and_close(body)
+      elsif block_given?
+
+        # If you call respond with a block, you get a handle to a stream that you can write to.
+        yield self
+
+        # If you hijack the connection, you are responsible for closing it.
+        # Otherwise, the response will be closed automatically.
+        self.close unless hijack
+      else
+        self.close
+      end
+    end
+  end
+end

data/gems/server/lib/itsi/server/Itsi.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# This is the default Itsi configuration file, installed when you run `itsi init`
+# It contains a sane starting point for configuring your Itsi server.
+# You can use this file in both development and production environments.
+# Most of the options in this file can be overridden by command line options.
+# Check out itsi -h to learn more about the command line options available to you.
+
+env = ENV.fetch("APP_ENV") { ENV.fetch("RACK_ENV", "development") }
+
+# Number of worker processes to spawn
+# If more than 1, Itsi will be booted in Cluster mode
+workers ENV.fetch("ITSI_WORKERS") {
+  require "etc"
+  env == "development" ? 1 : Etc.nprocessors
+}
+
+# Number of threads to spawn per worker process
+# For pure CPU bound applicationss, you'll get the best results keeping this number low
+# Setting a value of 1 is great for superficial benchmarks, but in reality
+# it's better to set this a bit higher to allow expensive requests to get overtaken and minimize head-of-line blocking
+threads ENV.fetch("ITSI_THREADS", 3)
+
+# If your application is IO bound (e.g. performing a lot of proxied HTTP requests, or heavy queries etc)
+# you can see *substantial* benefits from enabling this option.
+# To set this option, pass a string, not a class (as we will not have loaded the class yet)
+# E.g.
+# `fiber_scheduler "Itsi::Scheduler"` - The default fast and light-weight scheduler that comes with Itsi
+# `fiber_scheduler "Async::Scheduler"` - Bring your own scheduler!
+fiber_scheduler nil
+
+# By default Itsi will run the Rack app from config.ru.
+# You can provide an alternative Rack app file name here
+# Or you can inline the app directly inside Itsi.rb.
+# Only one of `run` and `rackup_file` can be used.
+# E.g.
+# require 'rack'
+# run(Rack::Builder.app do
+#   use Rack::CommonLogger
+#   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+# end)
+rackup_file "config.ru"
+
+# If you bind to https, without specifying a certificate, Itsi will use a self-signed certificate.
+# The self-signed certificate will use a CA generated for your host and stored inside `ITSI_LOCAL_CA_DIR` (Defaults to ~/.itsi)
+# bind "https://localhost:3000"
+# bind "https://localhost:3000?domains=dev.itsi.fyi"
+#
+# If you want to use let's encrypt to generate you a real certificate you and pass cert=acme and an acme_email address to generate one.
+# bind "https://itsi.fyi?cert=acme&acme_email=admin@itsi.fyi"
+# You can generate certificates for multiple domains at once, by passing a comma-separated list of domains
+# bind "https://0.0.0.0?domains=foo.itsi.fyi,bar.itsi.fyi&cert=acme&acme_email=admin@itsi.fyi"
+#
+# If you already have a certificate you can specify it using the cert and key parameters
+# bind "https://itsi.fyi?cert=/path/to/cert.pem&key=/path/to/key.pem"
+#
+# You can also bind to a unix socket or a tls unix socket. E.g.
+# bind "unix:///tmp/itsi.sock"
+# bind "tls:///tmp/itsi.secure.sock"
+
+if env == "development"
+  bind "http://localhost:3000"
+else
+  bind "https://0.0.0.0?domains=#{ENV["PRODUCTION_DOMAINS"]}&cert=acme&acme_email=admin@itsi.fyi"
+end
+
+# If you want to preload the application, set preload to true
+# to load the entire rack-app defined in rack_file_name before forking.
+# Alternatively, you can preload just a specific set of gems in a group in your gemfile,
+# by providing the group name here.
+# E.g.
+#
+# preload :preload # Load gems inside the preload group
+# preload false # Don't preload.
+#
+# If you want to be able to perform zero-downtime deploys using a single itsi process,
+# you should disable preloads, so that the application is loaded fresh each time a new worker boots
+preload true
+
+# Set the maximum memory limit for each worker process in bytes
+# When this limit is reached, the worker will be gracefully restarted.
+# Only one worker is restarted at a time to ensure we don't take down
+# all of them at once, if they reach the threshold simultaneously.
+worker_memory_limit 1024 * 1024 * 1024
+
+# You can provide an optional block of code to run, when a worker hits its memory threshold (Use this to send yourself an alert,
+# write metrics to disk etc. etc.)
+after_memory_threshold_reached do |pid|
+  puts "Worker #{pid} has reached its memory threshold and will restart"
+end
+
+# Do clean up of any non-threadsafe resources before forking a new worker here.
+before_fork {}
+
+# Reinitialize any non-threadsafe resources after forking a new worker here.
+after_fork {}
+
+# Shutdown timeout
+# Number of seconds to wait for workers to gracefully shutdown before killing them.
+shutdown_timeout 5
+
+# Set this to false for application environments that require rack.input to be a rewindable body
+# (like Rails). For rack applications that can stream inputs, you can set this to true for a more memory-efficient approach.
+stream_body false
+
+# OOB GC responses threshold
+# Specifies how frequently OOB gc should be triggered during periods where there is a gap in queued requests.
+# Setting this too low can substantially worsen performance
+oob_gc_responses_threshold 512
+
+# Log level
+# Set this to one of the following values: debug, info, warn, error, fatal
+# Can also be set using the ITSI_LOG environment variable
+log_level :info
+
+# Log Format
+# Set this to be either :ansi or :json. If you leave it blank Itsi will try
+# and auto-detect the format based on the TTY environment.
+log_format :auto