wsv 0.9.0 → 0.10.0

data/lib/wsv/server.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require "openssl"
 require "socket"
 require_relative "app"
 require_relative "request"
 require_relative "response"
+require_relative "server/banner"
+require_relative "server/browser_launcher"
+require_relative "server/deadline_reader"
 
 module Wsv
   class Server
@@ -20,7 +24,11 @@ module Wsv
       out: $stdout,
       err: $stderr,
       read_timeout: DEFAULT_READ_TIMEOUT,
-      max_connections: DEFAULT_MAX_CONNECTIONS
+      max_connections: DEFAULT_MAX_CONNECTIONS,
+      tls: nil,
+      spa: false,
+      open: false,
+      cors: false
     )
       @host = host
       @port = port
@@ -29,7 +37,10 @@ module Wsv
       @err = err
       @read_timeout = read_timeout
       @max_connections = max_connections
-      @app = App.new(@root)
+      @tls = tls
+      @ssl_context = tls&.to_ssl_context
+      @open = open
+      @app = App.new(@root, spa: spa, cors: cors)
       @running = false
       @mutex = Mutex.new
       @active = 0
@@ -40,6 +51,7 @@ module Wsv
       @running = true
       log_startup
       trap_signals
+      open_in_browser if @open
       accept_loop
     ensure
       close
@@ -66,6 +78,8 @@ module Wsv
     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
@@ -104,6 +118,9 @@ module Wsv
         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
@@ -113,21 +130,6 @@ module Wsv
       end
     end
 
-    class DeadlineReader
-      def initialize(io, deadline)
-        @io = io
-        @deadline = deadline
-      end
-
-      def gets(limit)
-        remaining = @deadline - Time.now
-        raise IO::TimeoutError if remaining <= 0
-
-        @io.timeout = remaining
-        @io.gets(limit)
-      end
-    end
-
     def accept_loop
       while @running
         client = nil
@@ -162,24 +164,58 @@ module Wsv
         true
       end
 
-      return reject(client) unless accepted
+      return spawn_rejection(client) unless accepted
 
       begin
         Thread.new do
           Thread.current.report_on_exception = false
-          handle(client)
+          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)
+      end
+    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).
+    def spawn_rejection(client)
+      Thread.new do
+        Thread.current.report_on_exception = false
         reject(client)
       end
+    rescue ThreadError
+      reject(client)
+    end
+
+    def maybe_wrap_tls(client)
+      return client unless @ssl_context
+
+      client.timeout = @read_timeout
+      ssl = OpenSSL::SSL::SSLSocket.new(client, @ssl_context)
+      ssl.sync_close = true
+      ssl.accept
+      ssl
+    rescue StandardError
+      # If wrapping or the handshake failed, `handle` 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
+        client.close
+      rescue StandardError
+        nil
+      end
+      raise
     end
 
     def reject(client)
-      write_response(client, Response.text(503))
+      # 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
@@ -196,28 +232,18 @@ module Wsv
         end
       end
     rescue ArgumentError
+      # Signal.trap raises ArgumentError when called from a context that
+      # cannot install signal handlers (e.g. embedded in a non-main thread,
+      # which is how tests start the server). Skip silently in that case.
       nil
     end
 
     def log_startup
-      @out.puts "Serving: #{root}"
-      @out.puts "Bind:    #{url_for(host)}"
-      @out.puts "Local:   #{url_for('127.0.0.1')}" unless localhost?(host)
-      @out.puts "Stop:    Ctrl-C"
-      warn_public_bind unless localhost?(host)
-    end
-
-    def warn_public_bind
-      @err.puts "WARNING: binding to #{host} exposes #{root} on your network."
-      @err.puts "         Pass --host 127.0.0.1 (or omit --host) for local-only access."
-    end
-
-    def url_for(display_host)
-      "http://#{display_host}:#{port}/"
+      Banner.new(host: host, port: port, root: root, out: @out, err: @err, tls: @tls).emit
     end
 
-    def localhost?(display_host)
-      ["127.0.0.1", "localhost", "::1"].include?(display_host)
+    def open_in_browser
+      BrowserLauncher.new(host: host, port: port, tls: @tls, err: @err).launch
     end
   end
 end

data/lib/wsv/status.rb

@@ -4,6 +4,7 @@ module Wsv
   module Status
     REASONS = {
       200 => "OK",
+      204 => "No Content",
       206 => "Partial Content",
       301 => "Moved Permanently",
       304 => "Not Modified",

data/lib/wsv/tls_context/resolver.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Wsv
+  class TlsContext
+    class Resolver
+      XDG_DIR = "wsv"
+      CERT_FILE = "cert.pem"
+      KEY_FILE = "key.pem"
+
+      def self.resolve(cert_path: nil, key_path: nil)
+        new(cert_path: cert_path, key_path: key_path).resolve
+      end
+
+      def initialize(cert_path: nil, key_path: nil)
+        @cert_path = cert_path
+        @key_path = key_path
+      end
+
+      def resolve
+        return from_files(@cert_path, @key_path) if @cert_path && @key_path
+
+        raise ArgumentError, "--cert and --key must be provided together" if @cert_path || @key_path
+
+        xdg = xdg_pair
+        return from_files(*xdg) if xdg
+
+        ephemeral
+      end
+
+      private
+
+      def from_files(cert_path, key_path)
+        cert = OpenSSL::X509::Certificate.new(File.read(cert_path))
+        key = OpenSSL::PKey.read(File.read(key_path))
+        raise ArgumentError, "key file at #{key_path} does not contain a private key" unless key.private?
+        unless cert.check_private_key(key)
+          raise ArgumentError,
+                "TLS certificate at #{cert_path} does not match the key at #{key_path}"
+        end
+
+        TlsContext.new(cert: cert, key: key)
+      end
+
+      def ephemeral
+        key = OpenSSL::PKey::RSA.new(2048)
+        cert = SelfSignedCert.build(key)
+        TlsContext.new(cert: cert, key: key, ephemeral: true)
+      end
+
+      def xdg_pair
+        cert = File.join(xdg_base, XDG_DIR, CERT_FILE)
+        key  = File.join(xdg_base, XDG_DIR, KEY_FILE)
+        cert_exists = File.exist?(cert)
+        key_exists  = File.exist?(key)
+        return [cert, key] if cert_exists && key_exists
+
+        if cert_exists ^ key_exists
+          raise ArgumentError, "found only one of #{cert} / #{key} -- both must exist or neither"
+        end
+
+        nil
+      end
+
+      def xdg_base
+        ENV["XDG_CONFIG_HOME"] || File.join(Dir.home, ".config")
+      end
+    end
+  end
+end

data/lib/wsv/tls_context/self_signed_cert.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "securerandom"
+
+module Wsv
+  class TlsContext
+    class SelfSignedCert
+      SUBJECT = "/CN=localhost"
+      SAN = "DNS:localhost,IP:127.0.0.1,IP:::1"
+      VALIDITY_SECONDS = 365 * 24 * 60 * 60
+
+      def self.build(key)
+        new(key).build
+      end
+
+      def initialize(key)
+        @key = key
+      end
+
+      def build
+        cert = OpenSSL::X509::Certificate.new
+        cert.version = 2
+        cert.serial = SecureRandom.random_number((2**63) - 1) + 1
+        cert.subject = OpenSSL::X509::Name.parse(SUBJECT)
+        cert.issuer = cert.subject
+        cert.public_key = @key.public_key
+        cert.not_before = Time.now - 60
+        cert.not_after = Time.now + VALIDITY_SECONDS
+        ef = OpenSSL::X509::ExtensionFactory.new(cert, cert)
+        cert.add_extension(ef.create_extension("subjectAltName", SAN))
+        cert.add_extension(ef.create_extension("basicConstraints", "CA:FALSE", true))
+        cert.sign(@key, OpenSSL::Digest.new("SHA256"))
+        cert
+      end
+    end
+  end
+end

data/lib/wsv/tls_context.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "openssl"
+require_relative "tls_context/self_signed_cert"
+require_relative "tls_context/resolver"
+
+module Wsv
+  class TlsContext
+    attr_reader :cert, :key
+
+    def initialize(cert:, key:, ephemeral: false)
+      @cert = cert
+      @key = key
+      @ephemeral = ephemeral
+    end
+
+    def ephemeral?
+      @ephemeral
+    end
+
+    def to_ssl_context
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.cert = @cert
+      ctx.key = @key
+      ctx.min_version = OpenSSL::SSL::TLS1_2_VERSION
+      ctx
+    end
+  end
+end

data/lib/wsv/version.rb

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

data/lib/wsv.rb

@@ -6,7 +6,9 @@ require_relative "wsv/mime_types"
 require_relative "wsv/path_resolver"
 require_relative "wsv/request"
 require_relative "wsv/response"
+require_relative "wsv/cors"
 require_relative "wsv/app"
+require_relative "wsv/tls_context"
 require_relative "wsv/server"
 require_relative "wsv/cli"
 

data/test/app_test.rb

@@ -186,6 +186,124 @@ class AppTest < Minitest::Test
     assert_equal "3", response.headers["Content-Length"]
   end
 
+  def test_spa_fallback_serves_index_for_missing_path
+    File.write(File.join(@dir, "index.html"), "<h1>SPA</h1>")
+    spa_app = Wsv::App.new(File.realpath(@dir), spa: true)
+
+    response = spa_app.call(req("GET", "/users/123"))
+
+    assert_equal 200, response.status
+    assert_equal "<h1>SPA</h1>", response.body
+    assert_equal "text/html; charset=utf-8", response.headers["Content-Type"]
+  end
+
+  def test_spa_fallback_head_serves_index_headers_without_body
+    File.write(File.join(@dir, "index.html"), "<h1>SPA</h1>")
+    spa_app = Wsv::App.new(File.realpath(@dir), spa: true)
+
+    response = spa_app.call(req("HEAD", "/users/123"))
+
+    assert_equal 200, response.status
+    assert_equal "", response.body
+    assert_equal "text/html; charset=utf-8", response.headers["Content-Type"]
+    assert_equal "12", response.headers["Content-Length"]
+  end
+
+  def test_spa_disabled_returns_404_for_missing_path
+    File.write(File.join(@dir, "index.html"), "<h1>SPA</h1>")
+
+    response = @app.call(req("GET", "/users/123"))
+
+    assert_equal 404, response.status
+  end
+
+  def test_spa_keeps_403_for_dotfile
+    File.write(File.join(@dir, "index.html"), "<h1>SPA</h1>")
+    File.write(File.join(@dir, ".env"), "secret")
+    spa_app = Wsv::App.new(File.realpath(@dir), spa: true)
+
+    response = spa_app.call(req("GET", "/.env"))
+
+    assert_equal 403, response.status
+  end
+
+  def test_spa_keeps_403_for_path_traversal
+    File.write(File.join(@dir, "index.html"), "<h1>SPA</h1>")
+    spa_app = Wsv::App.new(File.realpath(@dir), spa: true)
+
+    response = spa_app.call(req("GET", "/../etc/passwd"))
+
+    assert_equal 403, response.status
+  end
+
+  def test_spa_returns_404_when_no_index_html
+    spa_app = Wsv::App.new(File.realpath(@dir), spa: true)
+
+    response = spa_app.call(req("GET", "/users/123"))
+
+    assert_equal 404, response.status
+  end
+
+  def test_spa_serves_real_file_when_path_matches
+    File.write(File.join(@dir, "index.html"), "<h1>SPA</h1>")
+    File.write(File.join(@dir, "robots.txt"), "User-agent: *")
+    spa_app = Wsv::App.new(File.realpath(@dir), spa: true)
+
+    response = spa_app.call(req("GET", "/robots.txt"))
+
+    assert_equal 200, response.status
+    assert_equal "User-agent: *", response.body
+  end
+
+  def test_custom_404_page_when_404_html_exists
+    File.write(File.join(@dir, "404.html"), "<h1>not found</h1>")
+
+    response = @app.call(req("GET", "/missing.txt"))
+
+    assert_equal 404, response.status
+    assert_equal "<h1>not found</h1>", response.body
+    assert_equal "text/html; charset=utf-8", response.headers["Content-Type"]
+  end
+
+  def test_no_custom_404_falls_back_to_plain_text
+    response = @app.call(req("GET", "/missing.txt"))
+
+    assert_equal 404, response.status
+    assert_includes response.body, "404 Not Found"
+    assert_equal "text/plain; charset=utf-8", response.headers["Content-Type"]
+  end
+
+  def test_custom_404_does_not_apply_to_403
+    File.write(File.join(@dir, "404.html"), "<h1>not found</h1>")
+    File.write(File.join(@dir, ".env"), "secret")
+
+    response = @app.call(req("GET", "/.env"))
+
+    assert_equal 403, response.status
+    refute_includes response.body, "<h1>not found</h1>"
+  end
+
+  def test_spa_mode_takes_precedence_over_custom_404
+    File.write(File.join(@dir, "index.html"), "<h1>SPA</h1>")
+    File.write(File.join(@dir, "404.html"), "<h1>not found</h1>")
+    spa_app = Wsv::App.new(File.realpath(@dir), spa: true)
+
+    response = spa_app.call(req("GET", "/users/123"))
+
+    assert_equal 200, response.status
+    assert_equal "<h1>SPA</h1>", response.body
+  end
+
+  def test_custom_404_works_with_head
+    File.write(File.join(@dir, "404.html"), "<h1>not found</h1>")
+
+    response = @app.call(req("HEAD", "/missing.txt"))
+
+    assert_equal 404, response.status
+    assert_equal "", response.body
+    assert_equal "text/html; charset=utf-8", response.headers["Content-Type"]
+  end
+
   def test_serves_single_byte_range
     File.write(File.join(@dir, "data.bin"), "abcdefghij")
 
@@ -219,6 +337,82 @@ 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"))
+
+    refute response.headers.key?("Access-Control-Allow-Origin")
+  end
+
+  def test_cors_adds_acao_to_successful_response
+    File.write(File.join(@dir, "x.txt"), "hi")
+    cors_app = Wsv::App.new(File.realpath(@dir), cors: true)
+
+    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"]
+  end
+
+  def test_cors_preflight_returns_204_with_methods_and_max_age
+    cors_app = Wsv::App.new(File.realpath(@dir), cors: true)
+
+    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)
+
+    response = cors_app.call(req("OPTIONS", "/x.txt", "access-control-request-headers" => "X-Custom, Authorization"))
+
+    assert_equal 204, response.status
+    assert_equal "X-Custom, Authorization", response.headers["Access-Control-Allow-Headers"]
+  end
+
+  def test_cors_preflight_omits_allow_headers_when_not_requested
+    cors_app = Wsv::App.new(File.realpath(@dir), cors: true)
+
+    response = cors_app.call(req("OPTIONS", "/x.txt"))
+
+    refute response.headers.key?("Access-Control-Allow-Headers")
+  end
+
+  def test_options_without_cors_returns_405
+    response = @app.call(req("OPTIONS", "/x.txt"))
+
+    assert_equal 405, response.status
+    assert_equal "GET, HEAD", response.headers["Allow"]
+  end
+
+  def test_cors_405_advertises_options_in_allow
+    cors_app = Wsv::App.new(File.realpath(@dir), cors: true)
+
+    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
     File.write(File.join(@dir, "data.bin"), "abcdefghij")
 

data/test/browser_launcher_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class BrowserLauncherTest < Minitest::Test
+  def test_loopback_host_used_directly
+    launcher = build(host: "127.0.0.1")
+
+    assert_equal "http://127.0.0.1:8000/", launcher.send(:url)
+  end
+
+  def test_wildcard_v4_translated_to_loopback
+    launcher = build(host: "0.0.0.0")
+
+    assert_equal "http://127.0.0.1:8000/", launcher.send(:url)
+  end
+
+  def test_wildcard_v6_translated_to_loopback
+    launcher = build(host: "::")
+
+    assert_equal "http://[::1]:8000/", launcher.send(:url)
+  end
+
+  def test_ipv6_literal_host_is_bracketed
+    launcher = build(host: "::1")
+
+    assert_equal "http://[::1]:8000/", launcher.send(:url)
+  end
+
+  def test_specific_host_passes_through
+    launcher = build(host: "192.168.1.5")
+
+    assert_equal "http://192.168.1.5:8000/", launcher.send(:url)
+  end
+
+  def test_https_scheme_when_tls_present
+    launcher = build(host: "127.0.0.1", tls: Object.new)
+
+    assert_equal "https://127.0.0.1:8000/", launcher.send(:url)
+  end
+
+  def test_logs_when_platform_unsupported
+    err = StringIO.new
+    launcher = build(host: "127.0.0.1", err: err)
+    launcher.define_singleton_method(:platform_command) { nil }
+
+    launcher.launch
+
+    assert_includes err.string, "not supported on this platform"
+  end
+
+  private
+
+  def build(host:, tls: nil, err: StringIO.new)
+    Wsv::Server::BrowserLauncher.new(host: host, port: 8000, tls: tls, err: err)
+  end
+end

data/test/cli_test.rb

@@ -42,6 +42,8 @@ class CLITest < Minitest::Test
     assert_equal 0, code
     assert_includes out.string, "Usage: wsv"
     assert_includes out.string, "--host HOST"
+    assert_includes out.string, "Examples:"
+    assert_includes out.string, "wsv _site"
   end
 
   def test_version
@@ -68,4 +70,66 @@ class CLITest < Minitest::Test
     assert_equal 1, code
     assert_includes err.string, "directory does not exist"
   end
+
+  def test_tls_flag_parses
+    Dir.mktmpdir do |dir|
+      options = Wsv::CLI.new([]).parse_options(["--tls", dir])
+
+      assert options[:tls]
+    end
+  end
+
+  def test_cert_without_key_errors
+    err = StringIO.new
+    Dir.mktmpdir do |dir|
+      code = Wsv::CLI.new(["--cert", "/nonexistent/cert.pem", dir], err: err).run
+
+      assert_equal 1, code
+      assert_includes err.string, "must be provided together"
+    end
+  end
+
+  def test_cert_and_key_parses
+    Dir.mktmpdir do |dir|
+      options = Wsv::CLI.new([]).parse_options(["--cert", "a.pem", "--key", "b.pem", dir])
+
+      assert_equal "a.pem", options[:cert]
+      assert_equal "b.pem", options[:key]
+    end
+  end
+
+  def test_spa_flag_parses
+    Dir.mktmpdir do |dir|
+      options = Wsv::CLI.new([]).parse_options(["--spa", dir])
+
+      assert options[:spa]
+      assert_equal dir, options[:directory]
+    end
+  end
+
+  def test_cors_flag_parses
+    Dir.mktmpdir do |dir|
+      options = Wsv::CLI.new([]).parse_options(["--cors", dir])
+
+      assert options[:cors]
+      assert_equal dir, options[:directory]
+    end
+  end
+
+  def test_cors_default_off
+    Dir.mktmpdir do |dir|
+      options = Wsv::CLI.new([]).parse_options([dir])
+
+      refute options[:cors]
+    end
+  end
+
+  def test_open_flag_parses
+    Dir.mktmpdir do |dir|
+      options = Wsv::CLI.new([]).parse_options(["--open", dir])
+
+      assert options[:open]
+      assert_equal dir, options[:directory]
+    end
+  end
 end