wsv 0.10.0 → 0.11.0

data/lib/wsv/server.rb

@@ -3,17 +3,16 @@
 require "openssl"
 require "socket"
 require_relative "app"
-require_relative "request"
-require_relative "response"
+require_relative "cors"
 require_relative "server/banner"
 require_relative "server/browser_launcher"
-require_relative "server/deadline_reader"
+require_relative "server/connection"
+require_relative "server/connection_throttle"
 
 module Wsv
   class Server
     DEFAULT_READ_TIMEOUT = 10
     DEFAULT_MAX_CONNECTIONS = 8
-    DRAIN_TIMEOUT = 5
 
     attr_reader :host, :port, :root
 
@@ -36,14 +35,13 @@ module Wsv
       @out = out
       @err = err
       @read_timeout = read_timeout
-      @max_connections = max_connections
       @tls = tls
       @ssl_context = tls&.to_ssl_context
       @open = open
-      @app = App.new(@root, spa: spa, cors: cors)
+      @cors = Cors.new if cors
+      @app = App.new(@root, spa: spa, cors: @cors)
+      @throttle = ConnectionThrottle.new(max: max_connections, err: err)
       @running = false
-      @mutex = Mutex.new
-      @active = 0
     end
 
     def start
@@ -62,74 +60,8 @@ module Wsv
       close
     end
 
-    def handle(client)
-      reader = DeadlineReader.new(client, Time.now + @read_timeout)
-      request = Request.parse(reader)
-      case request
-      when :empty
-        nil
-      when :malformed
-        write_response(client, Response.text(400))
-      else
-        write_response(client, @app.call(request))
-      end
-    rescue Request::TooLarge => e
-      write_response(client, Response.text(e.status_code))
-    rescue IO::TimeoutError
-      write_response(client, Response.text(408))
-    rescue StandardError => e
-      # Treat unmapped failures as connection-scoped and close with 400 rather
-      # than letting one bad request path bring down the server.
-      @err.puts "wsv: #{e.class}: #{e.message}"
-      write_response(client, Response.text(400))
-    ensure
-      graceful_close(client)
-    end
-
     private
 
-    def write_response(client, response)
-      return if client.closed?
-
-      response.write_to(client)
-    rescue Errno::EPIPE, Errno::ECONNRESET, IOError
-      nil
-    end
-
-    def graceful_close(client)
-      return if client.closed?
-
-      drain_recv(client)
-    rescue StandardError
-      nil
-    ensure
-      begin
-        client.close unless client.closed?
-      rescue StandardError
-        nil
-      end
-    end
-
-    def drain_recv(client)
-      deadline = Time.now + DRAIN_TIMEOUT
-      loop do
-        return if Time.now >= deadline
-
-        chunk = client.read_nonblock(8192, exception: false)
-        case chunk
-        when nil, :wait_writable
-          # nil = EOF. :wait_writable can come back from SSLSocket during a
-          # renegotiation (read needs an underlying write). Either way,
-          # there's nothing more we can usefully drain right now.
-          return
-        when :wait_readable
-          remaining = deadline - Time.now
-          return if remaining <= 0
-          return unless client.wait_readable([remaining, 0.2].min)
-        end
-      end
-    end
-
     def accept_loop
       while @running
         client = nil
@@ -157,38 +89,25 @@ module Wsv
     end
 
     def spawn_handler(client)
-      accepted = @mutex.synchronize do
-        next false if @active >= @max_connections
-
-        @active += 1
-        true
-      end
-
-      return spawn_rejection(client) unless accepted
-
-      begin
-        Thread.new do
-          Thread.current.report_on_exception = false
-          handle(maybe_wrap_tls(client))
-        ensure
-          @mutex.synchronize { @active -= 1 }
-        end
-      rescue ThreadError => e
-        @err.puts "wsv: thread error: #{e.message}"
-        @mutex.synchronize { @active -= 1 }
-        spawn_rejection(client)
+      accepted = @throttle.try_spawn do
+        Connection.new(maybe_wrap_tls(client), err: @err, cors: @cors).serve(@app, read_timeout: @read_timeout)
       end
+      spawn_rejection(client) unless accepted
     end
 
     # Reject in a separate thread so a slow client cannot block accept_loop
-    # via graceful_close's drain_recv (up to DRAIN_TIMEOUT seconds).
+    # via Connection#graceful_close (up to Connection::DRAIN_TIMEOUT seconds).
+    # In TLS mode `client` is the raw TCPSocket before any handshake; writing
+    # a plaintext 503 would corrupt the TLS handshake the client is about to
+    # start, so suppress the reply in that case.
     def spawn_rejection(client)
+      reply = !@ssl_context
       Thread.new do
         Thread.current.report_on_exception = false
-        reject(client)
+        Connection.new(client, err: @err, cors: @cors).reject(reply: reply)
       end
     rescue ThreadError
-      reject(client)
+      Connection.new(client, err: @err, cors: @cors).reject(reply: reply)
     end
 
     def maybe_wrap_tls(client)
@@ -200,7 +119,7 @@ module Wsv
       ssl.accept
       ssl
     rescue StandardError
-      # If wrapping or the handshake failed, `handle` is never called and
+      # If wrapping or the handshake failed, `serve` is never called and
       # its ensure does not get a chance to close the underlying socket.
       # Close it here so we do not leak a TCPSocket per failed handshake.
       begin
@@ -211,15 +130,6 @@ module Wsv
       raise
     end
 
-    def reject(client)
-      # In TLS mode `client` is the raw TCPSocket before any handshake.
-      # Writing a plaintext 503 over it would corrupt the TLS handshake
-      # the client is about to start, so just close in that case.
-      write_response(client, Response.text(503)) unless @ssl_context
-    ensure
-      graceful_close(client)
-    end
-
     def close
       @server&.close unless @server&.closed?
     end

data/lib/wsv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wsv
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/lib/wsv.rb

@@ -4,6 +4,7 @@ require_relative "wsv/version"
 require_relative "wsv/status"
 require_relative "wsv/mime_types"
 require_relative "wsv/path_resolver"
+require_relative "wsv/range_request"
 require_relative "wsv/request"
 require_relative "wsv/response"
 require_relative "wsv/cors"

data/test/app_test.rb

@@ -337,50 +337,34 @@ class AppTest < Minitest::Test
     assert_equal "bytes", response.headers["Accept-Ranges"]
   end
 
-  def test_cors_disabled_omits_acao_header
-    File.write(File.join(@dir, "x.txt"), "hi")
-
-    response = @app.call(req("GET", "/x.txt"))
+  # CORS overlay (Access-Control-Allow-Origin / Vary) is applied by
+  # Server::Connection, not by App. App only short-circuits OPTIONS preflight
+  # and adds OPTIONS to the Allow header. End-to-end CORS behavior is covered
+  # by server_test.rb.
 
-    refute response.headers.key?("Access-Control-Allow-Origin")
-  end
-
-  def test_cors_adds_acao_to_successful_response
+  def test_app_does_not_add_cors_headers_directly
     File.write(File.join(@dir, "x.txt"), "hi")
-    cors_app = Wsv::App.new(File.realpath(@dir), cors: true)
+    cors_app = Wsv::App.new(File.realpath(@dir), cors: Wsv::Cors.new)
 
     response = cors_app.call(req("GET", "/x.txt"))
 
-    assert_equal 200, response.status
-    assert_equal "hi", response.body
-    assert_equal "*", response.headers["Access-Control-Allow-Origin"]
-    assert_equal "Origin", response.headers["Vary"]
-  end
-
-  def test_cors_adds_acao_to_error_response
-    cors_app = Wsv::App.new(File.realpath(@dir), cors: true)
-
-    response = cors_app.call(req("GET", "/missing.txt"))
-
-    assert_equal 404, response.status
-    assert_equal "*", response.headers["Access-Control-Allow-Origin"]
+    refute response.headers.key?("Access-Control-Allow-Origin")
+    refute response.headers.key?("Vary")
   end
 
   def test_cors_preflight_returns_204_with_methods_and_max_age
-    cors_app = Wsv::App.new(File.realpath(@dir), cors: true)
+    cors_app = Wsv::App.new(File.realpath(@dir), cors: Wsv::Cors.new)
 
     response = cors_app.call(req("OPTIONS", "/x.txt"))
 
     assert_equal 204, response.status
-    assert_equal "*", response.headers["Access-Control-Allow-Origin"]
     assert_equal "GET, HEAD, OPTIONS", response.headers["Access-Control-Allow-Methods"]
     assert_equal "86400", response.headers["Access-Control-Max-Age"]
-    assert_equal "Origin", response.headers["Vary"]
     assert_equal "", response.body
   end
 
   def test_cors_preflight_echoes_requested_headers
-    cors_app = Wsv::App.new(File.realpath(@dir), cors: true)
+    cors_app = Wsv::App.new(File.realpath(@dir), cors: Wsv::Cors.new)
 
     response = cors_app.call(req("OPTIONS", "/x.txt", "access-control-request-headers" => "X-Custom, Authorization"))
 
@@ -389,7 +373,7 @@ class AppTest < Minitest::Test
   end
 
   def test_cors_preflight_omits_allow_headers_when_not_requested
-    cors_app = Wsv::App.new(File.realpath(@dir), cors: true)
+    cors_app = Wsv::App.new(File.realpath(@dir), cors: Wsv::Cors.new)
 
     response = cors_app.call(req("OPTIONS", "/x.txt"))
 
@@ -404,13 +388,12 @@ class AppTest < Minitest::Test
   end
 
   def test_cors_405_advertises_options_in_allow
-    cors_app = Wsv::App.new(File.realpath(@dir), cors: true)
+    cors_app = Wsv::App.new(File.realpath(@dir), cors: Wsv::Cors.new)
 
     response = cors_app.call(req("POST", "/x.txt"))
 
     assert_equal 405, response.status
     assert_equal "GET, HEAD, OPTIONS", response.headers["Allow"]
-    assert_equal "*", response.headers["Access-Control-Allow-Origin"]
   end
 
   def test_multipart_range_falls_through_to_200

data/test/banner_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class BannerTest < Minitest::Test
+  include TlsTestHelpers
+
+  ROOT = Dir.tmpdir
+
+  def test_warns_when_binding_to_non_loopback
+    err = StringIO.new
+    build(host: "0.0.0.0", err: err).emit
+
+    assert_includes err.string, "WARNING"
+    assert_includes err.string, "0.0.0.0"
+  end
+
+  def test_no_warning_for_loopback_bind
+    err = StringIO.new
+    build(host: "127.0.0.1", err: err).emit
+
+    refute_includes err.string, "WARNING"
+  end
+
+  def test_brackets_ipv6_address_in_url
+    out = StringIO.new
+    build(host: "::1", port: 8000, out: out).emit
+
+    assert_includes out.string, "http://[::1]:8000/"
+    refute_includes out.string, "http://::1:8000/"
+  end
+
+  def test_percent_encodes_ipv6_zone_identifier
+    out = StringIO.new
+    build(host: "fe80::1%eth0", port: 8000, out: out).emit
+
+    assert_includes out.string, "http://[fe80::1%25eth0]:8000/"
+  end
+
+  def test_logs_https_scheme_when_tls_enabled
+    out = StringIO.new
+    build(host: "127.0.0.1", port: 8000, out: out, tls: ephemeral_tls).emit
+
+    assert_includes out.string, "https://"
+  end
+
+  def test_warns_about_self_signed_cert
+    err = StringIO.new
+    build(host: "127.0.0.1", err: err, tls: ephemeral_tls).emit
+
+    assert_includes err.string, "self-signed"
+  end
+
+  private
+
+  def build(host:, port: 0, root: ROOT, out: StringIO.new, err: StringIO.new, tls: nil)
+    Wsv::Server::Banner.new(host: host, port: port, root: root, out: out, err: err, tls: tls)
+  end
+end

data/test/cors_test.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class CorsTest < Minitest::Test
+  def setup
+    @cors = Wsv::Cors.new
+  end
+
+  def test_allow_methods_returns_array
+    assert_equal %w[GET HEAD OPTIONS], @cors.allow_methods
+  end
+
+  # `Cors#preflight` returns the preflight-specific headers only;
+  # Server::Connection adds ACAO / Vary on top, uniformly.
+
+  def test_preflight_returns_204
+    response = @cors.preflight(req)
+
+    assert_equal 204, response.status
+  end
+
+  def test_preflight_includes_allow_methods_and_max_age
+    response = @cors.preflight(req)
+
+    assert_equal "GET, HEAD, OPTIONS", response.headers["Access-Control-Allow-Methods"]
+    assert_equal "86400", response.headers["Access-Control-Max-Age"]
+  end
+
+  def test_preflight_omits_acao_and_vary
+    response = @cors.preflight(req)
+
+    refute response.headers.key?("Access-Control-Allow-Origin")
+    refute response.headers.key?("Vary")
+  end
+
+  def test_preflight_echoes_requested_headers
+    response = @cors.preflight(req("access-control-request-headers" => "X-Custom, Authorization"))
+
+    assert_equal "X-Custom, Authorization", response.headers["Access-Control-Allow-Headers"]
+  end
+
+  def test_preflight_omits_allow_headers_when_not_requested
+    response = @cors.preflight(req)
+
+    refute response.headers.key?("Access-Control-Allow-Headers")
+  end
+
+  def test_overlay_adds_acao_and_vary
+    base = Wsv::Response.text(200)
+    overlaid = @cors.overlay(base)
+
+    assert_equal "*", overlaid.headers["Access-Control-Allow-Origin"]
+    assert_equal "Origin", overlaid.headers["Vary"]
+  end
+
+  def test_overlay_preserves_existing_headers
+    base = Wsv::Response.text(404)
+    overlaid = @cors.overlay(base)
+
+    assert_equal "text/plain; charset=utf-8", overlaid.headers["Content-Type"]
+  end
+
+  def test_overlay_returns_a_new_response_keeping_status
+    base = Wsv::Response.text(404)
+    overlaid = @cors.overlay(base)
+
+    assert_equal 404, overlaid.status
+  end
+
+  private
+
+  def req(headers = {})
+    Wsv::Request.new(method: "OPTIONS", target: "/", version: "HTTP/1.1", headers: headers)
+  end
+end

data/test/range_request_test.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class RangeRequestTest < Minitest::Test
+  def test_nil_header_is_full
+    result = Wsv::RangeRequest.parse(nil, 100)
+
+    assert_predicate result, :full?
+  end
+
+  def test_empty_header_is_full
+    result = Wsv::RangeRequest.parse("", 100)
+
+    assert_predicate result, :full?
+  end
+
+  def test_unparseable_syntax_is_full
+    # Per RFC 7233 an unparseable Range is treated as if absent.
+    result = Wsv::RangeRequest.parse("garbage", 100)
+
+    assert_predicate result, :full?
+  end
+
+  def test_empty_range_is_full
+    # `bytes=-` matches the regex but yields no bounds; treat as absent.
+    result = Wsv::RangeRequest.parse("bytes=-", 100)
+
+    assert_predicate result, :full?
+  end
+
+  def test_bounded_range
+    result = Wsv::RangeRequest.parse("bytes=2-5", 100)
+
+    assert_predicate result, :partial?
+    assert_equal 2..5, result.bounds
+  end
+
+  def test_open_range
+    result = Wsv::RangeRequest.parse("bytes=5-", 10)
+
+    assert_predicate result, :partial?
+    assert_equal 5..9, result.bounds
+  end
+
+  def test_suffix_range
+    result = Wsv::RangeRequest.parse("bytes=-3", 10)
+
+    assert_predicate result, :partial?
+    assert_equal 7..9, result.bounds
+  end
+
+  def test_suffix_larger_than_file_clamps_to_zero
+    result = Wsv::RangeRequest.parse("bytes=-99", 10)
+
+    assert_predicate result, :partial?
+    assert_equal 0..9, result.bounds
+  end
+
+  def test_bounded_last_past_file_clamps_to_end
+    result = Wsv::RangeRequest.parse("bytes=5-99", 10)
+
+    assert_predicate result, :partial?
+    assert_equal 5..9, result.bounds
+  end
+
+  def test_zero_byte_suffix_is_unsatisfiable
+    result = Wsv::RangeRequest.parse("bytes=-0", 10)
+
+    assert_predicate result, :unsatisfiable?
+  end
+
+  def test_suffix_against_empty_file_is_unsatisfiable
+    result = Wsv::RangeRequest.parse("bytes=-3", 0)
+
+    assert_predicate result, :unsatisfiable?
+  end
+
+  def test_open_range_past_file_is_unsatisfiable
+    result = Wsv::RangeRequest.parse("bytes=10-", 5)
+
+    assert_predicate result, :unsatisfiable?
+  end
+
+  def test_bounded_first_past_file_is_unsatisfiable
+    result = Wsv::RangeRequest.parse("bytes=10-20", 5)
+
+    assert_predicate result, :unsatisfiable?
+  end
+
+  def test_inverted_bounded_range_is_unsatisfiable
+    result = Wsv::RangeRequest.parse("bytes=5-3", 100)
+
+    assert_predicate result, :unsatisfiable?
+  end
+
+  def test_multipart_range_is_full
+    # `bytes=0-2,5-7` doesn't match the single-range regex; treat as absent.
+    result = Wsv::RangeRequest.parse("bytes=0-2,5-7", 100)
+
+    assert_predicate result, :full?
+  end
+end