itsi-server 0.2.16 → 0.2.18

data/ext/itsi_server/src/services/static_file_server.rs

@@ -2,7 +2,7 @@ use crate::{
     default_responses::NOT_FOUND_RESPONSE,
     prelude::*,
     server::{
-        http_message_types::{HttpRequest, HttpResponse, RequestExt, ResponseFormat},
+        http_message_types::{HttpBody, HttpRequest, HttpResponse, RequestExt, ResponseFormat},
         middleware_stack::ErrorResponse,
         redirect_type::RedirectType,
     },
@@ -16,7 +16,6 @@ use http::{
     },
     HeaderName, HeaderValue, Response, StatusCode,
 };
-use http_body_util::{combinators::BoxBody, Full};
 use itsi_error::Result;
 use parking_lot::{Mutex, RwLock};
 use percent_encoding::percent_decode_str;
@@ -28,7 +27,6 @@ use std::{
     borrow::Cow,
     cmp::Ordering,
     collections::HashMap,
-    convert::Infallible,
     fs::Metadata,
     ops::Deref,
     path::{Path, PathBuf},
@@ -324,7 +322,7 @@ impl StaticFileServer {
             }) => Response::builder()
                 .status(StatusCode::MOVED_PERMANENTLY)
                 .header(header::LOCATION, redirect_to)
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap(),
             Err(not_found_behavior) => match not_found_behavior {
                 NotFoundBehavior::Error(error_response) => {
@@ -340,7 +338,7 @@ impl StaticFileServer {
                 NotFoundBehavior::Redirect(redirect) => Response::builder()
                     .status(redirect.r#type.status_code())
                     .header(header::LOCATION, redirect.to)
-                    .body(BoxBody::new(Full::new(Bytes::new())))
+                    .body(HttpBody::empty())
                     .unwrap(),
             },
         })
@@ -407,7 +405,7 @@ impl StaticFileServer {
 
         Response::builder()
             .status(StatusCode::NOT_FOUND)
-            .body(BoxBody::new(Full::new(Bytes::new())))
+            .body(HttpBody::empty())
             .unwrap()
     }
 
@@ -648,15 +646,8 @@ impl StaticFileServer {
         Err(nf)
     }
 
-    async fn stream_file_range(
-        &self,
-        path: PathBuf,
-        start: u64,
-        end: u64,
-    ) -> Option<BoxBody<Bytes, Infallible>> {
+    async fn stream_file_range(&self, path: PathBuf, start: u64, end: u64) -> Option<HttpBody> {
         use futures::TryStreamExt;
-        use http_body_util::StreamBody;
-        use hyper::body::Frame;
         use tokio::io::AsyncSeekExt;
         use tokio_util::io::ReaderStream;
 
@@ -687,32 +678,25 @@ impl StaticFileServer {
         let range_length = end - start + 1;
         let limited_reader = tokio::io::AsyncReadExt::take(file, range_length);
         let path_clone = path.clone();
-        let stream = ReaderStream::with_capacity(limited_reader, 64 * 1024)
-            .map_ok(Frame::data)
-            .map_err(move |e| {
-                warn!("Error streaming file {}: {}", path_clone.display(), e);
-                unreachable!("We handle IO errors above")
-            });
-
-        Some(BoxBody::new(StreamBody::new(stream)))
+        let stream = ReaderStream::with_capacity(limited_reader, 64 * 1024).map_err(move |e| {
+            warn!("Error streaming file {}: {}", path_clone.display(), e);
+            unreachable!("We handle IO errors above")
+        });
+        Some(HttpBody::stream(stream))
     }
 
-    async fn stream_file(&self, path: PathBuf) -> Option<BoxBody<Bytes, Infallible>> {
+    async fn stream_file(&self, path: PathBuf) -> Option<HttpBody> {
         use futures::TryStreamExt;
-        use http_body_util::StreamBody;
-        use hyper::body::Frame;
         use tokio_util::io::ReaderStream;
 
         match File::open(&path).await {
             Ok(file) => {
                 let path_clone = path.clone();
-                let stream = ReaderStream::with_capacity(file, 64 * 1024)
-                    .map_ok(Frame::data)
-                    .map_err(move |e| {
-                        warn!("Error streaming file {}: {}", path_clone.display(), e);
-                        unreachable!("We handle IO errors above")
-                    });
-                Some(BoxBody::new(StreamBody::new(stream)))
+                let stream = ReaderStream::with_capacity(file, 64 * 1024).map_err(move |e| {
+                    warn!("Error streaming file {}: {}", path_clone.display(), e);
+                    unreachable!("We handle IO errors above")
+                });
+                Some(HttpBody::stream(stream))
             }
             Err(e) => {
                 warn!(
@@ -749,7 +733,7 @@ impl StaticFileServer {
             return Response::builder()
                 .status(StatusCode::RANGE_NOT_SATISFIABLE)
                 .header("Content-Range", format!("bytes */{}", content_length))
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap();
         }
 
@@ -795,7 +779,7 @@ impl StaticFileServer {
                 builder = builder.header("Content-Range", range);
             }
 
-            return builder.body(BoxBody::new(Full::new(Bytes::new()))).unwrap();
+            return builder.body(HttpBody::empty()).unwrap();
         }
 
         // For GET requests, prepare the actual content
@@ -829,10 +813,7 @@ impl StaticFileServer {
         }
     }
 
-    fn serve_cached_content(
-        &self,
-        serve_cache_args: ServeCacheArgs,
-    ) -> http::Response<BoxBody<Bytes, Infallible>> {
+    fn serve_cached_content(&self, serve_cache_args: ServeCacheArgs) -> HttpResponse {
         let ServeCacheArgs(
             cache_entry,
             start,
@@ -855,7 +836,7 @@ impl StaticFileServer {
             return Response::builder()
                 .status(StatusCode::RANGE_NOT_SATISFIABLE)
                 .header("Content-Range", format!("bytes */{}", content_length))
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap();
         }
 
@@ -904,7 +885,7 @@ impl StaticFileServer {
                 builder = builder.header("Content-Range", range);
             }
 
-            return builder.body(BoxBody::new(Full::new(Bytes::new()))).unwrap();
+            return builder.body(HttpBody::empty()).unwrap();
         }
 
         if is_range_request {
@@ -920,7 +901,7 @@ impl StaticFileServer {
                 cache_entry.last_modified_http_date.clone(),
                 content_range,
                 &self.headers,
-                BoxBody::new(Full::new(range_bytes)),
+                HttpBody::full(range_bytes),
             )
         } else {
             // Return the full content
@@ -987,15 +968,15 @@ fn format_http_date_header(time: SystemTime) -> HeaderValue {
         .unwrap()
 }
 
-fn build_ok_body(bytes: Arc<Bytes>) -> BoxBody<Bytes, Infallible> {
-    BoxBody::new(Full::new(bytes.as_ref().clone()))
+fn build_ok_body(bytes: Arc<Bytes>) -> HttpBody {
+    HttpBody::full(bytes.as_ref().clone())
 }
 
 // Helper function to handle not modified responses
-fn build_not_modified_response() -> http::Response<BoxBody<Bytes, Infallible>> {
+fn build_not_modified_response() -> HttpResponse {
     Response::builder()
         .status(StatusCode::NOT_MODIFIED)
-        .body(BoxBody::new(Full::new(Bytes::new())))
+        .body(HttpBody::empty())
         .unwrap()
 }
 
@@ -1009,8 +990,8 @@ fn build_file_response(
     last_modified_http_date: HeaderValue,
     range_header: Option<String>,
     headers: &Option<HashMap<String, String>>,
-    body: BoxBody<Bytes, Infallible>,
-) -> http::Response<BoxBody<Bytes, Infallible>> {
+    body: HttpBody,
+) -> HttpResponse {
     let mut response = Response::new(body);
 
     *response.status_mut() = status;

data/lib/itsi/http_request.rb

@@ -14,50 +14,35 @@ module Itsi
     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"
-                  elsif header == "content-length"
-                    "CONTENT_LENGTH"
-                  else
-                    "HTTP_#{header.upcase.gsub(/-/, "_")}"
-                  end
+      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 { |_, key| "HTTP_#{key.upcase.gsub(/-/, "_")}" }
-    end
+    end.to_h
 
-    RACK_ENV_TEMPLATE = {
-      "SERVER_SOFTWARE" => "Itsi",
-      "rack.errors" => $stderr,
-      "rack.multithread" => true,
-      "rack.multiprocess" => true,
-      "rack.run_once" => false,
-      "rack.hijack?" => true,
-      "rack.multipart.buffer_size" => 16_384,
-      "SCRIPT_NAME" => "",
-      "REQUEST_METHOD" => "",
-      "PATH_INFO" => "",
-      "REQUEST_PATH" => "",
-      "QUERY_STRING" => "",
-      "REMOTE_ADDR" => "",
-      "SERVER_PORT" => "",
-      "SERVER_NAME" => "",
-      "SERVER_PROTOCOL" => "",
-      "HTTP_HOST" => "",
-      "HTTP_VERSION" => "",
-      "itsi.request" => "",
-      "itsi.response" => "",
-      "rack.version" => nil,
-      "rack.url_scheme" => "",
-      "rack.input" => "",
-      "rack.hijack" => ""
-    }.freeze
+    RACK_HEADER_MAP.default_proc = proc { |_, key| "HTTP_#{key.upcase.gsub(/-/, "_")}" }
+
+    HTTP_09 = "HTTP/0.9"
+    HTTP_09_ARR = ["HTTP/0.9"].freeze
+    HTTP_10 = "HTTP/1.0"
+    HTTP_10_ARR = ["HTTP/1.0"].freeze
+    HTTP_11 = "HTTP/1.1"
+    HTTP_11_ARR = ["HTTP/1.1"].freeze
+    HTTP_20 = "HTTP/2.0"
+    HTTP_20_ARR = ["HTTP/2.0"].freeze
+    HTTP_30 = "HTTP/3.0"
+    HTTP_30_ARR = ["HTTP/3.0"].freeze
 
     def to_rack_env
       path = self.path
       host = self.host
       version = self.version
-      env = RACK_ENV_TEMPLATE.dup
+      env = RackEnvPool.checkout
       env["SCRIPT_NAME"] = script_name
       env["REQUEST_METHOD"] = request_method
       env["REQUEST_PATH"] = env["PATH_INFO"] = path
@@ -68,11 +53,18 @@ module Itsi
       env["HTTP_VERSION"] = env["SERVER_PROTOCOL"] = version
       env["itsi.request"] = self
       env["itsi.response"] = response
-      env["rack.version"] = [version]
+      env["rack.version"] = \
+        case version
+        when HTTP_09 then HTTP_09_ARR
+        when HTTP_10 then HTTP_10_ARR
+        when HTTP_11 then HTTP_11_ARR
+        when HTTP_20 then HTTP_20_ARR
+        when HTTP_30 then HTTP_30_ARR
+        end
       env["rack.url_scheme"] = scheme
       env["rack.input"] = build_input_io
       env["rack.hijack"] = method(:hijack)
-      headers.each do |(k, v)|
+      each_header do |k, v|
         env[case k
             when "content-type" then "CONTENT_TYPE"
             when "content-length" then "CONTENT_LENGTH"

data/lib/itsi/http_response.rb

@@ -16,6 +16,7 @@ module Itsi
       body = body.to_s unless body.is_a?(String)
 
       if headers
+        reserve_headers(headers.size)
         headers.each do |key, value|
           if value.is_a?(Array)
             value.each { |v| add_header(key, v) }
@@ -40,5 +41,9 @@ module Itsi
         close
       end
     end
+
+    def flush
+      # No-op. Our Rust server performs stream coalescing and automatically flushes on a tight interval.
+    end
   end
 end

data/lib/itsi/rack_env_pool.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Itsi
+  module RackEnvPool
+
+    RACK_ENV_TEMPLATE = {
+      "SERVER_SOFTWARE" => "Itsi",
+      "rack.errors" => $stderr,
+      "rack.multithread" => true,
+      "rack.multiprocess" => true,
+      "rack.run_once" => false,
+      "rack.hijack?" => true,
+      "rack.multipart.buffer_size" => 16_384,
+      "SCRIPT_NAME" => "",
+      "REQUEST_METHOD" => "",
+      "PATH_INFO" => "",
+      "REQUEST_PATH" => "",
+      "QUERY_STRING" => "",
+      "REMOTE_ADDR" => "",
+      "SERVER_PORT" => "",
+      "SERVER_NAME" => "",
+      "SERVER_PROTOCOL" => "",
+      "HTTP_HOST" => "",
+      "HTTP_VERSION" => "",
+      "itsi.request" => "",
+      "itsi.response" => "",
+      "rack.version" => nil,
+      "rack.url_scheme" => "",
+      "rack.input" => "",
+      "rack.hijack" => ""
+    }.freeze
+
+    POOL = []
+
+    def self.checkout # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+      POOL.pop&.tap do |recycled|
+        recycled.keys.each do |key|
+          case key
+          when "SERVER_SOFTWARE" then recycled[key] = "Itsi"
+          when "rack.errors" then recycled[key] = $stderr
+          when "rack.multithread", "rack.multiprocess", "rack.hijack?" then recycled[key] = true
+          when "rack.run_once" then recycled[key] = false
+          when "rack.multipart.buffer_size" then recycled[key] = 16_384
+          when "SCRIPT_NAME", "REQUEST_METHOD", "PATH_INFO", "REQUEST_PATH", "QUERY_STRING", "REMOTE_ADDR",
+               "SERVER_PORT", "SERVER_NAME", "SERVER_PROTOCOL", "HTTP_HOST", "HTTP_VERSION", "itsi.request",
+               "itsi.response", "rack.version", "rack.url_scheme", "rack.input", "rack.hijack"
+            nil
+          else recycled.delete(key)
+          end
+        end
+      end || RACK_ENV_TEMPLATE.dup
+    end
+
+    def self.checkin(env)
+      POOL << env
+    end
+  end
+
+end

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# typed: true
+
 module Itsi
   class Server
     module Config
@@ -55,8 +58,7 @@ module Itsi
             nested_locations: [],
             middleware_loader: lambda do
               @options[:nested_locations].each(&:call)
-              @middleware[:app] ||= {}
-              @middleware[:app][:app_proc] = @middleware[:app]&.[](:preloader)&.call || DEFAULT_APP[]
+              @middleware[:app] = { app_proc: DEFAULT_APP[] } unless @middleware[:app] || @middleware[:static_assets]
               [flatten_routes, Config.errors_to_error_lines(errors)]
             end
           }
@@ -74,7 +76,7 @@ module Itsi
           define_method(option_name) do |*args, **kwargs, &blk|
             option.new(self, *args, **kwargs, &blk).build!
           rescue Exception => e # rubocop:disable Lint/RescueException
-            @errors << [e, caller[1]]
+            @errors << [e, e.backtrace.find { |r| !(r =~ %r{server/config}) }]
           end
         end
 
@@ -85,7 +87,7 @@ module Itsi
           rescue Config::Endpoint::InvalidHandlerException => e
             @errors << [e, "#{e.backtrace[0]}:in #{e.message}"]
           rescue Exception => e # rubocop:disable Lint/RescueException
-            @errors << [e, caller[1]]
+            @errors << [e, e.backtrace.find { |r| !(r =~ %r{server/config}) }]
           end
         end
 

data/lib/itsi/server/config/middleware/compression.md

@@ -13,7 +13,7 @@ You can enable several different compression algorithms, and choose to selective
     min_size: 1024 # 1KiB,
     algorithms: %w[zstd gzip deflate br],
     compress_streams: true,
-    mime_types: %[all],
+    mime_types: %w[all],
     level: "fastest"
 ```
 
@@ -24,7 +24,7 @@ You can enable several different compression algorithms, and choose to selective
     compress \
       min_size: 1024 # 1KiB,
       algorithms: %w[zstd gzip deflate br],
-      mime_types: %[image],
+      mime_types: %w[image],
       level: "fastest"
 
     static_assets: \
@@ -47,4 +47,4 @@ You can enable several different compression algorithms, and choose to selective
 # Pre-compressed `static_assets`
 Itsi also supports serving pre-compressed static assets directly from the file-system.
 This is configured inside the `static_assets` middleware.
-Go to the [static_assets](/middleware/static_assets.md) middleware for more information.
+Go to the [static_assets](/middleware/static_assets) middleware for more information.

data/lib/itsi/server/config/middleware/endpoint/controller.md

@@ -181,6 +181,6 @@ module UserController
   end
 end
 
-controller User
+controller UserController
 post "/", :create
 ```

data/lib/itsi/server/config/middleware/proxy.md

@@ -12,7 +12,7 @@ proxy \
   to: "http://backend.example.com/api{path}{query}",
   backends: ["127.0.0.1:3001", "127.0.0.1:3002"],
   backend_priority: "round_robin",
-  headers: { "X-Forwarded-For" => { rewrite: "{addr}" } },
+  headers: { "X-Forwarded-For" => "{addr}" },
   verify_ssl: false,
   timeout: 30,
   tls_sni: true,
@@ -54,7 +54,7 @@ proxy \
 3. **Header Overrides**
    The `headers` option lets you specify extra or overriding headers. Each header value may be a literal or a string rewrite. For example, overriding `"X-Forwarded-For"` to carry the client’s IP is done by:
    ```ruby
-   { "X-Forwarded-For" => { rewrite: "{addr}" } }
+   { "X-Forwarded-For" => "{addr}" }
    ```
 
 4. **Request Forwarding and Error Handling**

data/lib/itsi/server/config/middleware/proxy.rb

@@ -7,7 +7,7 @@ module Itsi
             to: "${1:http://backend.example.com{path_and_query}",
             backends: [${2:"127.0.0.1:3001", "127.0.0.1:3002"}],
             backend_priority: ${3|"round_robin","ordered","random"|},
-            headers: { ${4| "X-Forwarded-For" => { rewrite: "{addr}" },|} },
+            headers: { ${4| "X-Forwarded-For" =>  "{addr}"|} },
             verify_ssl: ${5|true,false|},
             timeout: ${6|30,60|},
             tls_sni: ${7|true,false|},

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

@@ -24,12 +24,12 @@ module Itsi
           super(location, params)
           raise "Rackup file must be a string" unless app.is_a?(String)
 
-          @app = Itsi::Server::RackInterface.for(app)
+          @app = app
         end
 
         def build!
           app_args = {
-            preloader: -> { @app },
+            preloader: -> { Itsi::Server::RackInterface.for(@app) },
             sendfile: @params[:sendfile],
             nonblocking: @params[:nonblocking],
             script_name: @params[:script_name],

data/lib/itsi/server/config/options/auto_reload_config.rb

@@ -2,9 +2,8 @@ module Itsi
   class Server
     module Config
       class AutoReloadConfig < Option
-
         insert_text <<~SNIPPET
-        auto_reload_config! # Auto-reload the server configuration each time it changes.
+          auto_reload_config! # Auto-reload the server configuration each time it changes.
         SNIPPET
 
         detail "Auto-reload the server configuration each time it changes."
@@ -14,24 +13,30 @@ module Itsi
         end
 
         def build!
+          return if @auto_reloading
+
+          src = caller.find { |l| !(l =~ %r{lib/itsi/server/config}) }.split(":").first
+
           location.instance_eval do
             return if @auto_reloading
 
             if @included
               @included.each do |file|
+                next if "#{file}" == src
+
                 if ENV["BUNDLE_BIN_PATH"]
-                  watch "#{file}.rb", [%w[bundle exec itsi restart]]
+                  watch "#{file}", [%w[bundle exec itsi restart]]
                 else
-                  watch "#{file}.rb", [%w[itsi restart]]
+                  watch "#{file}", [%w[itsi restart]]
                 end
               end
             end
             @auto_reloading = true
 
             if ENV["BUNDLE_BIN_PATH"]
-              watch "Itsi.rb", [%w[bundle exec itsi restart]]
+              watch src, [%w[bundle exec itsi restart]]
             else
-              watch "Itsi.rb", [%w[itsi restart]]
+              watch src, [%w[itsi restart]]
             end
           end
         end

data/lib/itsi/server/config/options/include.md

@@ -7,6 +7,7 @@ Use the `include` option to load additional files to be evaluated within the cur
 You can use this option to split a large configuration file into multiple smaller files.
 
 Files required using `include` are also subject to auto-reloading, when using the [auto_reload_config](/options/auto_reload_config) option.
+The path of the included file is evaluated relative to the current configuration file.
 
 ## Examples
 ```ruby {filename="Itsi.rb"}

data/lib/itsi/server/config/options/include.rb

@@ -2,34 +2,39 @@ module Itsi
   class Server
     module Config
       class Include < Option
-
         insert_text "include \"${1|other_file|}\" # Include another file to be loaded within the current configuration"
 
         detail "Include another file to be loaded within the current configuration"
 
         schema do
-          Type(String)
+          Type(String) & Required()
         end
 
         def build!
-          included_file = @params
+          caller_location = caller_locations(2, 1).first.path
+          included_file = \
+            if caller_location =~ %r{lib/itsi/server}
+              File.expand_path("#{@params}.rb")
+            else
+              File.expand_path("#{@params}.rb", File.dirname(caller_location))
+            end
+
           location.instance_eval do
             @included ||= []
             @included << included_file
 
             if @auto_reloading
               if ENV["BUNDLE_BIN_PATH"]
-                watch "#{included_file}.rb", [%w[bundle exec itsi restart]]
+                watch "#{included_file}", [%w[bundle exec itsi restart]]
               else
-                watch "#{included_file}.rb", [%w[itsi restart]]
+                watch "#{included_file}", [%w[itsi restart]]
               end
             end
           end
 
-          code = IO.read("#{included_file}.rb")
-          location.instance_eval(code, "#{included_file}.rb", 1)
+          code = IO.read(included_file)
+          location.instance_eval(code, included_file, 1)
         end
-
       end
     end
   end

data/lib/itsi/server/config/options/pipeline_flush.md

@@ -0,0 +1,16 @@
+---
+title: Pipeline Flush
+url: /options/pipeline_flush
+---
+
+Aggregates flushes to better support pipelined responses. (HTTP1 only)
+The default value is `false`.
+
+## Configuration
+```ruby {filename=Itsi.rb}
+pipeline_flush true
+```
+
+```ruby {filename=Itsi.rb}
+pipeline_flush false
+```

data/lib/itsi/server/config/options/pipeline_flush.rb

@@ -0,0 +1,19 @@
+module Itsi
+  class Server
+    module Config
+      class PipelineFlush < Option
+
+        insert_text <<~SNIPPET
+        pipeline_flush ${1|true,false|}
+        SNIPPET
+
+        detail "Aggregates flushes to better support pipelined responses. (HTTP1 only)."
+
+        schema do
+          (Bool() & Required()).default(false)
+        end
+
+      end
+    end
+  end
+end

data/lib/itsi/server/config/options/reuse_port.rb

@@ -2,17 +2,15 @@ module Itsi
   class Server
     module Config
       class ReusePort < Option
-
         insert_text <<~SNIPPET
-        reuse_port ${1|true,false|}
+          reuse_port ${1|true,false|}
         SNIPPET
 
         detail "Configures whether the server should set the reuse_port option on the underlying socket."
 
         schema do
-          (Bool() & Required()).default(false)
+          (Bool() & Required()).default(true)
         end
-
       end
     end
   end

data/lib/itsi/server/config/options/writev.md

@@ -0,0 +1,25 @@
+---
+title: Write Vectored
+url: /options/writev
+---
+
+Set whether HTTP/1 connections should try to use vectored writes,
+or always flatten into a single buffer.
+
+Note that setting this to false may mean more copies of body data,
+but may also improve performance when an IO transport doesn't
+support vectored writes well, such as most TLS implementations.
+
+Setting this to true will force hyper to use queued strategy
+which may eliminate unnecessary cloning on some TLS backends
+
+Default is `nil` in which case hyper will try to guess which mode to use
+
+## Configuration
+```ruby {filename=Itsi.rb}
+writev true
+```
+
+```ruby {filename=Itsi.rb}
+writev false
+```