itsi 0.1.11 → 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,33 +1,13 @@
 #!/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,
-  # Config file
-  config_file: nil
-}
-
-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]"
 
@@ -35,20 +15,25 @@ OptionParser.new do |opts|
     options[:config_file] = config_file
   end
 
-  opts.on("-w", "--workers WORKERS", Integer, "Number of workers (default: #{options[:workers]})") do |w|
+  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
 
@@ -74,8 +59,8 @@ OptionParser.new do |opts|
   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?
+          "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
 
@@ -124,51 +109,25 @@ OptionParser.new do |opts|
     puts opts
     exit
   end
-end.parse!
 
-require "itsi/server/config"
-if ARGV.pop == "init"
-  Itsi::Server::Config.write_default
-  exit(0)
-  # Add initialization code here
-end
+  opts.on("--reexec PARAMS", String, "Reexec the server with the given parameters") do |params|
+    options[:reexec] = params
+  end
 
-options = Itsi::Server::Config.load(options)
-loader = nil
-
-if options[:app] || File.exist?(options[:rackup_file])
-  loader ||= lambda do
-    require "rack"
-    require_relative "../lib/itsi/server/scheduler_mode" if options[:scheduler_class]
-    require "itsi/scheduler" if [true, "Itsi::Scheduler"].include?(options[:scheduler_class])
-    require "itsi/server"
-    return options[:app] if options[:app]
-    Array(Rack::Builder.parse_file(options[:rackup_file])).first
-  end
-
-  if options[:preload] == true
-    # If preload is true, we'll invoke our loader now, and just return a no-op proc
-    # which returns the app as loader. We still need to optionally load the scheduler class and rack
-    # in case the app has been provided directly in Itsi.rb instead of in config.ru
-    require "rack"
-    require_relative "../lib/itsi/server/scheduler_mode" if options[:scheduler_class]
-    require "itsi/scheduler" if [true, "Itsi::Scheduler"].include?(options[:scheduler_class])
-    loader = (options[:app] || loader[]).method(:itself).to_proc
-  elsif options[:preload]
-    # If a group name is given, we'll stick to just loading the gem group by the same name from the Gemfile.
-    # But we'll fall through to the default delayed loader for the full app.
-    require "bundler"
-    Bundler.setup
-    Bundler.require(options[:preload])
-    nil
+  opts.on("--listeners LISTENERS", String, "Listeners for reexec") do |listeners|
+    options[:listeners] = listeners
   end
-end
+end.parse!
 
-# Make sure Itsi is loaded, if not already loaded by the rack_app above.
-# Start the Itsi server
-require "itsi/server"
 
-Itsi::Server.start(
-  loader: loader,
-  **options.except(:preload, :rackup_file)
-)
+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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-env = ENV.fetch('APP_ENV') { ENV.fetch('RACK_ENV', 'development') }
 
 # This is the default Itsi configuration file, installed when you run `itsi init`
 # It contains a sane starting point for configuring your Itsi server.
@@ -7,18 +6,20 @@ env = ENV.fetch('APP_ENV') { ENV.fetch('RACK_ENV', 'development') }
 # 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
+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)
+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.
@@ -38,7 +39,7 @@ fiber_scheduler nil
 #   use Rack::CommonLogger
 #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
 # end)
-rackup_file 'config.ru'
+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)
@@ -57,10 +58,10 @@ rackup_file 'config.ru'
 # bind "unix:///tmp/itsi.sock"
 # bind "tls:///tmp/itsi.secure.sock"
 
-if env == 'development'
-  bind 'http://localhost:3000'
+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"
+  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
@@ -80,7 +81,7 @@ preload true
 # 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 48 * 1024 * 1024
+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.)
@@ -107,15 +108,6 @@ stream_body false
 # Setting this too low can substantially worsen performance
 oob_gc_responses_threshold 512
 
-# 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