itsi 0.2.10 → 0.2.12

data/gems/scheduler/lib/itsi/schedule_refinement.rb

@@ -0,0 +1,96 @@
+module Itsi
+  module ScheduleRefinement
+    # Useful helper functions for using cooperative multi-tasking in Ruby.
+    # Opt-in to usage by executing `using Itsi::ScheduleRefinement` in any places
+    # you intend to use it.
+    #
+    # After this you can do things like the following
+    #
+    # 1. Launch batch concurrent fire-and-forget jobs.
+    # * 100.times.schedule_each{ sleep 0.1 }
+    #
+    # 2. Launch batch concurrent transofmrs
+    # See how `schedule_map` retains ordering, despite sleeping for randomized amount of time.
+    #
+    # * 100.times.schedule_map{|i| sleep Random.rand(0.0..0.05); i }
+    #
+    # 3. Manually organize fibers to run concurrently.
+    #
+    # require "net/http"
+    # schedule do
+    #   req1, req2 = Queue.new, Queue.new
+    #   schedule do
+    #     puts "Making request 1"
+    #     req1 << Net::HTTP.get(URI("http://httpbin.org/get"))
+    #     puts "Finished request 1"
+    #   end
+    #
+    #   schedule do
+    #     puts "Making request 2"
+    #     req2 << Net::HTTP.get(URI("http://httpbin.org/get"))
+    #     puts "Finished request 2"
+    #   end
+    #
+    #   res1, res2 = [req1, req2].map(&:pop)
+    # end
+    refine Kernel do
+      private def schedule(&blk) # rubocop:disable Metrics/MethodLength
+        return unless blk
+
+        if Fiber.scheduler.nil?
+          result = nil
+          Thread.new do
+            Fiber.set_scheduler Itsi::Scheduler.new
+            Fiber.schedule { result = blk.call }
+          end.join
+          result
+        else
+          Fiber.schedule(&blk)
+        end
+      end
+    end
+
+    module EnumerableExtensions
+      using ScheduleRefinement
+      def schedule_each(&block)
+        enum = Enumerator.new do |y|
+          schedule do
+            each { |item| schedule{ y.yield(item) } }
+          end
+        end
+
+        block_given? ? enum.each(&block) : enum.each
+      end
+
+      def schedule_map(&block)
+        return Enumerator.new do |y|
+          schedule do
+            with_index.each_with_object([]) do |(item, index), agg|
+              schedule do
+                agg[index] = (y << item)
+              end
+            end
+          end
+        end.map unless block_given?
+        schedule do
+          with_index.each_with_object([]) do |(item, index), agg|
+            schedule do
+              agg[index] = block[item]
+            end
+          end
+        end
+      end
+    end
+
+
+    refine Enumerator do
+      define_method(:schedule_each, EnumerableExtensions.instance_method(:schedule_each))
+      define_method(:schedule_map, EnumerableExtensions.instance_method(:schedule_map))
+    end
+
+    refine Enumerable do
+      define_method(:schedule_each, EnumerableExtensions.instance_method(:schedule_each))
+      define_method(:schedule_map, EnumerableExtensions.instance_method(:schedule_map))
+    end
+  end
+end

data/gems/scheduler/lib/itsi/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Scheduler
-    VERSION = "0.2.10"
+    VERSION = "0.2.12"
   end
 end

data/gems/scheduler/lib/itsi/scheduler.rb

@@ -2,6 +2,7 @@
 
 require_relative "scheduler/version"
 require_relative "scheduler/itsi_scheduler"
+require_relative "schedule_refinement"
 
 module Itsi
   class Scheduler

data/gems/server/Cargo.lock

@@ -1644,7 +1644,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "itsi-server"
-version = "0.2.10"
+version = "0.2.12"
 dependencies = [
  "argon2",
  "async-channel",

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

@@ -11,7 +11,8 @@ module Itsi
     include ResponseStatusShortcodes
     attr_accessor :hijacked
 
-    EMPTY_IO = StringIO.new("")
+    EMPTY_IO = StringIO.new("").tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
+
     RACK_HEADER_MAP = StandardHeaders::ALL.map do |header|
       rack_form = if header == "content-type"
                     "CONTENT_TYPE"
@@ -49,9 +50,7 @@ module Itsi
       "rack.version" => nil,
       "rack.url_scheme" => "",
       "rack.input" => "",
-      "rack.hijack" => "",
-      "CONTENT_TYPE" => nil,
-      "CONTENT_LENGTH" => nil
+      "rack.hijack" => ""
     }.freeze
 
     def to_rack_env
@@ -75,20 +74,20 @@ module Itsi
       env["rack.hijack"] = method(:hijack)
       headers.each do |(k, v)|
         env[case k
-          when "content-type" then "CONTENT_TYPE"
-          when "content-length" then "CONTENT_LENGTH"
-          when "accept" then "HTTP_ACCEPT"
-          when "accept-encoding" then "HTTP_ACCEPT_ENCODING"
-          when "accept-language" then "HTTP_ACCEPT_LANGUAGE"
-          when "user-agent" then "HTTP_USER_AGENT"
-          when "referer" then "HTTP_REFERER"
-          when "origin" then "HTTP_ORIGIN"
-          when "cookie" then "HTTP_COOKIE"
-          when "authorization" then "HTTP_AUTHORIZATION"
-          when "x-forwarded-for" then "HTTP_X_FORWARDED_FOR"
-          when "x-forwarded-proto" then "HTTP_X_FORWARDED_PROTO"
-          else RACK_HEADER_MAP[k]
-          end
+            when "content-type" then "CONTENT_TYPE"
+            when "content-length" then "CONTENT_LENGTH"
+            when "accept" then "HTTP_ACCEPT"
+            when "accept-encoding" then "HTTP_ACCEPT_ENCODING"
+            when "accept-language" then "HTTP_ACCEPT_LANGUAGE"
+            when "user-agent" then "HTTP_USER_AGENT"
+            when "referer" then "HTTP_REFERER"
+            when "origin" then "HTTP_ORIGIN"
+            when "cookie" then "HTTP_COOKIE"
+            when "authorization" then "HTTP_AUTHORIZATION"
+            when "x-forwarded-for" then "HTTP_X_FORWARDED_FOR"
+            when "x-forwarded-proto" then "HTTP_X_FORWARDED_PROTO"
+            else RACK_HEADER_MAP[k]
+            end
         ] = v
       end
       env
@@ -154,8 +153,8 @@ module Itsi
     def build_input_io
       case body_parts
       when nil then EMPTY_IO
-      when String then StringIO.new(body_parts)
-      when Array then File.open(body_parts.first, "rb")
+      when String then StringIO.new(body_parts).tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
+      when Array then File.open(body_parts.first, "rb").tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
       else body_parts
       end
     end

data/gems/server/lib/itsi/server/config/config_helpers.rb

@@ -11,14 +11,17 @@ module Itsi
           ].flatten
 
           listing.each do |file|
-            current = klass.subclasses
+            current = klass.subclasses.dup
             require file
             following = klass.subclasses
             new_class = (following - current).first
 
             documentation_file = "#{file[/(.*)\.rb/, 1]}.md"
             documentation_file = "#{file[%r{(.*)/[^/]+\.rb}, 1]}/_index.md" unless File.exist?(documentation_file)
-            next unless File.exist?(documentation_file) && new_class
+            unless File.exist?(documentation_file) && new_class
+              new_class&.documentation "Documentation not found"
+              next
+            end
 
             new_class.documentation IO.read(documentation_file)
                                       .gsub(/^---.*?\n.*?-+/m, "") # Strip frontmatter

data/gems/server/lib/itsi/server/config/middleware/endpoint/_index.md

@@ -5,9 +5,10 @@ prev: deny_list/
 next: controller/
 ---
 
+> If you're after running a rack app using a fully-featured framework, e.g. a Ruby on Rails or Sinatra, take a look at the [Rackup File](/middleware/rackup_file) middleware instead.
+
 The **endpoint** middleware allows you to define an ultra light-weight, inline, Ruby endpoint.
 
-> If you're after running a rack app using a fully-featured framework, e.g. a Ruby on Rails or Sinatra, take a look at the [Rackup File](/middleware/rackup_file) middleware instead.
 This feature can be useful for quickly prototyping, building small pieces of isolated functionality, or minimal endpoints where high throughput is essential.
 
 `endpoint` has several variants, that further restrict the endpoint to respond to specific HTTP methods:

data/gems/server/lib/itsi/server/config/middleware/endpoint/delete.rb

@@ -26,12 +26,13 @@ module Itsi
             paths: Array(Or(Type(String), Type(Regexp))),
             handler: Type(Proc) & Required(),
             http_methods: Array(Type(String)),
+            script_name: Type(String).default(nil),
             nonblocking: Bool()
           }
         end
 
-        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, &handler_proc)
-          location.endpoint(path, handler, http_methods: ["DELETE"], nonblocking: nonblocking, &handler_proc)
+        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, script_name: nil, &handler_proc) # rubocop:disable Metrics/ParameterLists,Lint/MissingSuper
+          location.endpoint(path, handler, http_methods: ["DELETE"], nonblocking: nonblocking, script_name: script_name, &handler_proc)
         end
 
         def build!

data/gems/server/lib/itsi/server/config/middleware/endpoint/endpoint.rb

@@ -28,17 +28,24 @@ module Itsi
             paths: Array(Or(Type(String), Type(Regexp))),
             handler: Type(Proc) & Required(),
             http_methods: Array(Type(String)),
+            script_name: Type(String).default(nil),
             nonblocking: Bool()
           }
         end
 
-        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, &handler_proc)
+        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, script_name: nil, &handler_proc)
           raise "Can not combine a controller method and inline handler" if handler && handler_proc
           handler_proc = location.controller.method(handler).to_proc if handler.is_a?(Symbol) || handler.is_a?(String)
 
           super(
             location,
-            { paths: Array(path), handler: handler_proc, http_methods: http_methods, nonblocking: nonblocking }
+            {
+              paths: Array(path),
+              handler: handler_proc,
+              http_methods: http_methods,
+              nonblocking: nonblocking,
+              script_name: script_name
+            }
           )
 
           num_required, keywords = Itsi::Server::TypedHandlers::SourceParser.extract_expr_from_source_location(handler_proc)
@@ -75,7 +82,11 @@ module Itsi
 
         def build!
           params = @params
-          app = { preloader: -> { params[:handler] }, nonblocking: @params[:nonblocking] }
+          app = {
+            preloader: -> { params[:handler] },
+            nonblocking: @params[:nonblocking],
+            script_name: @params[:script_name]
+          }
 
           if @params[:paths] == [""] && @params[:http_methods].empty?
             location.middleware[:app] = app

data/gems/server/lib/itsi/server/config/middleware/endpoint/get.rb

@@ -26,12 +26,13 @@ module Itsi
             paths: Array(Or(Type(String), Type(Regexp))),
             handler: Type(Proc) & Required(),
             http_methods: Array(Type(String)),
+            script_name: Type(String).default(nil),
             nonblocking: Bool()
           }
         end
 
-        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, &handler_proc)
-          location.endpoint(path, handler, http_methods: ["GET", "HEAD"], nonblocking: nonblocking, &handler_proc)
+        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, script_name: nil, &handler_proc) # rubocop:disable Lint/MissingSuper,Metrics/ParameterLists
+          location.endpoint(path, handler, http_methods: ["GET", "HEAD"], nonblocking: nonblocking, script_name: script_name, &handler_proc)
         end
 
         def build!

data/gems/server/lib/itsi/server/config/middleware/endpoint/patch.rb

@@ -26,12 +26,13 @@ module Itsi
             paths: Array(Or(Type(String), Type(Regexp))),
             handler: Type(Proc) & Required(),
             http_methods: Array(Type(String)),
+            script_name: Type(String).default(nil),
             nonblocking: Bool()
           }
         end
 
-        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, &handler_proc)
-          location.endpoint(path, handler, http_methods: ["PATCH"], nonblocking: nonblocking, &handler_proc)
+        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, script_name: nil, &handler_proc) # rubocop:disable Lint/MissingSuper
+          location.endpoint(path, handler, http_methods: ["PATCH"], nonblocking: nonblocking, script_name: script_name, &handler_proc)
         end
 
         def build!

data/gems/server/lib/itsi/server/config/middleware/endpoint/post.rb

@@ -26,12 +26,13 @@ module Itsi
             paths: Array(Or(Type(String), Type(Regexp))),
             handler: Type(Proc) & Required(),
             http_methods: Array(Type(String)),
+            script_name: Type(String).default(nil),
             nonblocking: Bool()
           }
         end
 
-        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, &handler_proc)
-          location.endpoint(path, handler, http_methods: ["POST"], nonblocking: nonblocking, &handler_proc)
+        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, script_name: nil, &handler_proc) # rubocop:disable Lint/MissingSuper
+          location.endpoint(path, handler, http_methods: ["POST"], nonblocking: nonblocking, script_name: script_name, &handler_proc)
         end
 
         def build!

data/gems/server/lib/itsi/server/config/middleware/endpoint/put.rb

@@ -26,12 +26,13 @@ module Itsi
             paths: Array(Or(Type(String), Type(Regexp))),
             handler: Type(Proc) & Required(),
             http_methods: Array(Type(String)),
+            script_name: Type(String).default(nil),
             nonblocking: Bool()
           }
         end
 
-        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, &handler_proc)
-          location.endpoint(path, handler, http_methods: ["PUT"], nonblocking: nonblocking, &handler_proc)
+        def initialize(location, path="", handler=nil, http_methods: [], nonblocking: false, script_name: nil, &handler_proc) # rubocop:disable Lint/MissingSuper,Metrics/ParameterLists
+          location.endpoint(path, handler, http_methods: ["PUT"], nonblocking: nonblocking, script_name: script_name, &handler_proc)
         end
 
         def build!

data/gems/server/lib/itsi/server/config/middleware/rackup_file.md

@@ -44,6 +44,24 @@ $ curl http://0.0.0.0:3000/root/child_path
 :/root/child_path
 ```
 
+### `SCRIPT_NAME` and `PATH_INFO` Rack ENV variables.
+Rack applications mounted at a subpath will, by default, receive a `SCRIPT_NAME` value that includes the subpath at which the app is mounted, and a `PATH_INFO` value that is relative to the subpath at which the rack app is mounted.
+If you wish to use location blocks only to control the middleware that applies to a rack app, but still have it behave as if it were mounted elsewhere (e.g. at the root), you can explicitly set the `script_name` option.
+E.g.
+
+```ruby
+location "/subpath/*" do
+  rackup_file "config.ru", script_name: '/'
+end
+```
+
+```bash
+# Our script-name override kicks in here, even though the app is mounted under `/subpath`
+$ curl http://0.0.0.0:3000/subpath/child_path
+/:/subpath/child_path
+```
+
+
 ### Options
 * `nonblocking` (default false). Determines whether requests sent to this Rack application should be run on non-blocking threads. Only applies if running in hybrid (non-blocking and blocking thread pool) mode. Otherwise this is a no-op and will run in whatever mode is set globally.
 * `sendfile` (default true). Determines whether Itsi should respect the `X-Sendfile` header set by the Rack application and use the `sendfile` function to efficiently send files. (Despite the name, this does not use the OS-level `sendfile` system call). Note. Itsi enforces the restriction that the referenced file must be within a child directory of the application root.

data/gems/server/lib/itsi/server/config/middleware/rackup_file.rb

@@ -15,6 +15,7 @@ module Itsi
         schema do
           {
             nonblocking: Bool().default(false),
+            script_name: Type(String).default(nil),
             sendfile: Bool().default(true)
           }
         end
@@ -31,6 +32,7 @@ module Itsi
             preloader: -> { @app },
             sendfile: @params[:sendfile],
             nonblocking: @params[:nonblocking],
+            script_name: @params[:script_name],
             base_path: "^(?<base_path>#{location.paths_from_parent.gsub(/\.\*\)$/, ")")}).*$"
           }
           location.middleware[:app] = app_args

data/gems/server/lib/itsi/server/config/middleware/run.md

@@ -39,7 +39,6 @@ run(Rack::Builder.app do
   use Rack::CommonLogger
   run ->(env) { [200, { 'content-type' => 'text/plain' }, [[env['SCRIPT_NAME'], env['PATH_INFO']].join(":") ]  ] }
 end)
-
 ```
 
 ```bash
@@ -50,6 +49,26 @@ $ curl http://0.0.0.0:3000/root/child_path
 :/root/child_path
 ```
 
+### `SCRIPT_NAME` and `PATH_INFO` Rack ENV variables.
+Rack applications mounted at a subpath will, by default, receive a `SCRIPT_NAME` value that includes the subpath at which the app is mounted, and a `PATH_INFO` value that is relative to the subpath at which the rack app is mounted.
+If you wish to use location blocks only to control the middleware that applies to a rack app, but still have it behave as if it were mounted elsewhere (e.g. at the root), you can explicitly set the `script_name` option.
+E.g.
+
+```ruby
+location "/subpath/*" do
+  run(Rack::Builder.app do
+    use Rack::CommonLogger
+    run ->(env) { [200, { 'content-type' => 'text/plain' }, [[env['SCRIPT_NAME'], env['PATH_INFO']].join(":") ]  ] }
+  end, script_name: '/')
+end
+```
+
+```bash
+# Our script-name override kicks in here, even though the app is mounted under `/subpath`
+$ curl http://0.0.0.0:3000/subpath/child_path
+/:/subpath/child_path
+```
+
 ### Options
 * `nonblocking` (default false). Determines whether requests sent to this Rack application should be run on non-blocking threads. Only applies if running in hybrid (non-blocking and blocking thread pool) mode. Otherwise this is a no-op and will run in whatever mode is set globally.
 * `sendfile` (default true). Determines whether Itsi should respect the `X-Sendfile` header set by the Rack application and use the `sendfile` function to efficiently send files. (Despite the name, this does not use the OS-level `sendfile` system call). Note. Itsi enforces the restriction that the referenced file must be within a child directory of the application root.

data/gems/server/lib/itsi/server/config/middleware/run.rb

@@ -15,6 +15,7 @@ module Itsi
         schema do
           {
             nonblocking: Bool().default(false),
+            script_name: Type(String).default(nil),
             sendfile: Bool().default(true)
           }
         end
@@ -30,6 +31,7 @@ module Itsi
             preloader: -> { Itsi::Server::RackInterface.for(@app) },
             sendfile: @params[:sendfile],
             nonblocking: @params[:nonblocking],
+            script_name: @params[:script_name],
             base_path: "^(?<base_path>#{location.paths_from_parent.gsub(/\.\*\)$/, ')')}).*$"
           }
           location.middleware[:app] = app_args

data/gems/server/lib/itsi/server/config/options/certificates.md

@@ -9,11 +9,11 @@ Itsi can automatically generate TLS certificates for you, both in development an
 To automatically generate a TLS certificate in development, just bind using the `https` scheme.
 E.g.
 ```ruby {filename=Itsi.rb}
-bind "https://localhost"
+bind "https://0.0.0.0"
 
 or
 
-bind "https://localhost:8443"
+bind "https://0.0.0.0:8443"
 ```
 Itsi will generate a local development CA for you if it does not yet exist, then use this to
 sign a just-in-time certificate for your server.

data/gems/server/lib/itsi/server/config/options/ruby_thread_request_backlog_size.md

@@ -0,0 +1,18 @@
+---
+title: Ruby Thread Request Backlog Size
+url: /options/ruby_thread_request_backlog_size
+---
+
+Configures the size of the backlog queue for incoming requests in the Ruby thread pool.
+Up to this many requests can be queued at once before the server rejects further requests to Ruby workers (note this does not block other requests to proxied hosts or for static assets).
+
+The default value is `30 x number of threads`.
+
+## Configuration
+```ruby {filename=Itsi.rb}
+ruby_thread_request_backlog_size 20
+```
+
+```ruby {filename=Itsi.rb}
+ruby_thread_request_backlog_size 100
+```

data/gems/server/lib/itsi/server/config/options/ruby_thread_request_backlog_size.rb

@@ -0,0 +1,19 @@
+module Itsi
+  class Server
+    module Config
+      class RubyThreadRequestBacklogSize < Option
+
+        insert_text <<~SNIPPET
+        ruby_thread_request_backlog_size ${1|10,25,50,100|}
+        SNIPPET
+
+        detail "The maximum number of requests that can be queued for processing by the Ruby thread."
+
+        schema do
+          (Type(Integer)).default(nil)
+        end
+
+      end
+    end
+  end
+end

data/gems/server/lib/itsi/server/config/options/scheduler_threads.md

@@ -3,7 +3,7 @@ title: Scheduler Threads
 url: /options/scheduler_threads
 ---
 
-You can explicitly spawn a pool of non-blocking scheduler threads and divide work across traditional blocking and non-blocking threads, using [location](/middleware/location) blocks.
+You can explicitly spawn a pool of non-blocking scheduler threads and divide work across traditional/blocking and non-blocking threads, using [location](/middleware/location) blocks.
 
 This allows you to safely dip your toes into using non-blocking threads for specific I/O heavy operations without having to port an entire application to non-blocking I/O.
 
@@ -25,10 +25,17 @@ fiber_scheduler true
 # We mount the same app *twice*.
 # For a specific route prefix, all requests will be sent to non blocking threads.
 # All others fall through to the default mount
+
 location "/heavy_io/*" do
+  # You can optionally use the `script_name: ""` option here to set the base path for the mounted app (useful if a nested app
+  # should still serve requests as if it was mounted at the root).
+  # Otherwise it will infer the script-name based on the parent location block.
   rackup_file "./config.ru", nonblocking: true
 end
 
 rackup_file "./config.ru"
 
 ```
+## Examples.
+
+See [https://github.com/wouterken/itsi/tree/main/examples/hybrid_scheduler_mode](hybrid_scheduler_mode) example in the Git repository.

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

@@ -134,6 +134,9 @@ module Itsi
           oob_gc_responses_threshold: args.fetch(:oob_gc_responses_threshold) do
             itsifile_config.fetch(:oob_gc_responses_threshold, nil)
           end,
+          ruby_thread_request_backlog_size: args.fetch(:ruby_thread_request_backlog_size) do
+            itsifile_config.fetch(:ruby_thread_request_backlog_size, nil)
+          end,
           log_level: args.fetch(:log_level) { itsifile_config.fetch(:log_level, nil) },
           log_format: args.fetch(:log_format) { itsifile_config.fetch(:log_format, nil) },
           log_target: args.fetch(:log_target) { itsifile_config.fetch(:log_target, nil) },

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

@@ -31,8 +31,8 @@ fiber_scheduler nil
 
 # 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"
+# bind "https://0.0.0.0:3000"
+# bind "https://0.0.0.0: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"

data/gems/server/lib/itsi/server/rack/handler/itsi.rb

@@ -8,10 +8,11 @@ module Rack
         port = options.fetch(:Port, 3001)
         ::Itsi::Server.start(
           {
-            app: app,
             binds: ["http://#{host}:#{port}"]
           }
-        )
+        ) do
+          run app
+        end
       end
     end
   end

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

@@ -40,13 +40,12 @@ module Itsi
         # 2. Set Headers
         body_streamer = streaming_body?(body) ? body : headers.delete("rack.hijack")
         headers.each do |key, value|
-          unless value.is_a?(Array)
+          if value.is_a?(Array)
+            value.each do |v|
+              response[key] = v
+            end
+          elsif value.is_a?(String)
             response[key] = value
-            next
-          end
-
-          value.each do |v|
-            response[key] = v
           end
         end
 

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

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.2.10"
+    VERSION = "0.2.12"
   end
 end

data/gems/server/test/helpers/test_helper.rb

@@ -3,6 +3,7 @@
 ENV["ITSI_LOG"] = "off"
 
 require "minitest/reporters"
+require "rackup"
 require "itsi/server"
 require "itsi/scheduler"
 require "socket"
@@ -24,7 +25,9 @@ def free_bind(protocol = "http", unix_socket: false)
   end
 end
 
-def server(app: nil, protocol: "http", bind: free_bind(protocol), itsi_rb: nil, cleanup: true, timeout: 5, &blk)
+def server(app: nil, app_with_lint: nil, protocol: "http", bind: free_bind(protocol), itsi_rb: nil, cleanup: true,
+           timeout: 5, &blk)
+  app ||= Rack::Lint.new(app_with_lint) if app_with_lint
   itsi_rb ||= lambda do
     # Inline Itsi.rb
     bind bind

data/gems/server/test/options/ruby_thread_request_backlog_size.rb

@@ -0,0 +1,37 @@
+require_relative "../helpers/test_helper"
+
+class TestRubyThreadRequestBacklogSize < Minitest::Test
+
+  def test_ruby_thread_request_backlog_size
+    server(
+      itsi_rb: lambda do
+        threads 1
+        workers 1
+        ruby_thread_request_backlog_size 1
+        get("/foo"){|r| sleep 0.1; r.ok "ok" }
+      end) do
+      responses = 3.times.map{ Thread.new{ get_resp("/foo") } }.map(&:value)
+
+      assert_equal "ok", responses.first.body
+      assert_equal "200", responses.first.code
+      assert_equal "503", responses.last.code
+    end
+  end
+
+  def test_ruby_thread_request_backlog_size_default
+    server(
+      itsi_rb: lambda do
+        threads 1
+        workers 1
+        # ruby_thread_request_backlog_size 1 - Disabled. Should revert to more generous default
+        get("/foo"){|r| sleep 0.01; r.ok "ok" }
+      end) do
+      responses = 29.times.map{ Thread.new{ get_resp("/foo") } }.map(&:value)
+
+      assert_equal "ok", responses.first.body
+      assert_equal "200", responses.first.code
+      assert_equal "ok", responses.last.body
+      assert_equal "200", responses.last.code
+    end
+  end
+end