yahns 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b72841cf8d034892a5616279ac723d75439b9a2c
-  data.tar.gz: 01710a8efb79f9eb9262775c4f3dcea178c302c9
+  metadata.gz: ed39f1e1cd058304e952eec64aa936763d1afd90
+  data.tar.gz: 97d35c0cbf569626a2ad5670f558c09736c76d97
 SHA512:
-  metadata.gz: d80a9d094e857d97f7192c1aa79ad7235dae23a85bd2a0967c8a83cf26960f04dcfc89300182b8fb2235dde9b6cae7ca3717d2c89e830f6815c625c0c2d99d15
-  data.tar.gz: 11a80294b69429051ddcdc3121f12f4179251271de70bf344a73b39deaea190b91d3004a273f162e57fcc12306ae48bd7cda1c5c6758d306de88585f6f7d7131
+  metadata.gz: bf372119bfdf2226d133e1b0ff4a74f51d2f79811901da42f601f4c92f872c13c2a31fbd872eb38b1f7fa2f34db5871037ebc4d1be282fdc14a690664238fe07
+  data.tar.gz: 5e4af052c543e3154ad7c9a5abdd4af95aa9c711a53236e9cd5b74ada45585e7ae4d6b0fbd279dc6fd19422a946aa1e2de5241c0fd5439d25579029e627a8fb7

data/Documentation/design_notes.txt

@@ -0,0 +1,101 @@
+event queues in yahns
+---------------------
+
+There are currently 2 classes of queues and 2 classes of thread pools
+in yahns.
+
+While non-blocking I/O with epoll or kqueue is a cheap way to handle
+thousands of socket connections, multi-threading is required for many
+existing APIs, including Rack and standard POSIX filesystem interfaces.
+
+listen queue + accept() thread pool
+-----------------------------------
+
+Like all TCP servers, there is a standard listen queue for every listen
+socket we have inside the kernel.
+
+Each listen queue has a dedicated thread pool running _blocking_
+accept(2) (or accept4(2)) syscall in a loop.  We use dedicated threads
+and blocking accept to benefit from "wake-one" behavior in the Linux
+kernel.  By default, this thread pool only has thread per-process, doing
+nothing but accepting sockets and injecting into to the event queue
+(used by epoll or kqueue).
+
+worker thread pool
+------------------
+
+This is where all the interesting application dispatch happens in yahns.
+epoll(2) (or kqueue(2)) descriptor is the heart of event queue.  This
+design allows clients to migrate between different threads as they
+become active, preventing head-of-line blocking in traditional designs
+where a client is pinned to a thread (at the cost of weaker cache
+locality).
+
+The critical component for implementing this thread pool is "one-shot"
+notifications in the epoll and kqueue APIs, allowing them to be used as
+readiness queues for feeding the thread pool.  Used correctly, this
+allows us to guarantee exclusive access to a client socket without
+additional locks managed in userspace.
+
+Idle threads will sit performing epoll_wait (or kqueue) indefinitely
+until a socket is reported as "ready" by the kernel.
+
+queue flow
+----------
+
+Once a client is accept(2)-ed, it is immediately pushed into the worker
+thread pool (via EPOLL_CTL_ADD or EV_ADD).  This mimics the effect of
+TCP_DEFER_ACCEPT (in Linux) and the "dataready" accept filter (in
+FreeBSD) from the perspective of the epoll_wait(2)/kqueue(2) caller.
+No explicit locking controlled from userspace is necessary.
+
+TCP_DEFER_ACCEPT/"dataready"/"httpready" themselves are not used as it
+has some documented and unresolved issues (and adds latency).
+
+  https://bugs.launchpad.net/ubuntu/+source/apache2/+bug/134274
+  http://labs.apnic.net/blabs/?p=57
+
+Denial-of-Service and head-of-line blocking mitigation
+------------------------------------------------------
+
+As mentioned before, traditional uses of multi-threaded event loops may
+suffer from head-of-line blocking because clients on a busy thread may
+not be able to migrate to a non-busy thread.  In yahns, a client
+automatically migrates to the next available thread in the worker thread
+pool.
+
+yahns can safely yield a client after every HTTP request, forcing the
+client to be rescheduled (via epoll/kqueue) after any existing clients
+have completed processing.
+
+"Yielding" a client is accomplished by re-arming the already "ready"
+socket by using EPOLL_CTL_MOD (with EPOLLONESHOT) with a one-shot
+notification requeues the descriptor at the end of the internal epoll
+ready queue; achieving a similar effect to yielding a thread (via
+sched_yield or Thread.pass) in a purely multi-threaded design.
+
+Once the client is yielded, epoll_wait is called again to pull
+the next client off the ready queue.
+
+Output buffering notes
+----------------------
+
+yahns will not read data from a client socket if there is any outgoing
+data buffered by yahns.  This prevents clients from performing a DoS
+sending a barrage of requests but not reading them (this should be
+obvious behavior for any server!).
+
+If outgoing data cannot fit into the kernel socket buffer, we buffer to
+the filesystem immediately to avoid putting pressure on malloc (or the
+Ruby GC).  This also allows use of the sendfile(2) syscall to avoid
+extra copies into the kernel.
+
+Input buffering notes (for Rack)
+--------------------------------
+
+As seen by the famous "Slowloris" example, slow clients can ruin some
+HTTP servers.  By default, yahns will use non-blocking I/O to
+fully-buffer an HTTP request before allowing the Rack 1.x application
+dispatch to block a thread.  This unfortunately means we double the
+amount of data copied, but prevents us from being hogged by slow clients
+due to the synchronous nature of Rack 1.x API for handling uploads.

data/GIT-VERSION-FILE

@@ -1 +1 @@
-VERSION = 1.5.0
+VERSION = 1.6.0

data/GIT-VERSION-GEN

@@ -4,7 +4,7 @@
 CONSTANT = "Yahns::VERSION"
 RVF = "lib/yahns/version.rb"
 GVF = "GIT-VERSION-FILE"
-DEF_VER = "v1.5.0"
+DEF_VER = "v1.6.0"
 vn = DEF_VER
 
 # First see if there is a version file (included in release tarballs),

data/NEWS

@@ -1,3 +1,35 @@
+yahns 1.6.0 - reduced allocations and bugfixes / 2015-03-09
+-----------------------------------------------------------
+
+This release fixes a bug where previously-configured-but-now-removed
+listeners were inherited across USR2 upgrades are not shutdown
+immediately in the child.
+
+There are also minor reductions in allocations which can save a few
+hundred bytes statically and also whenever write buffering is necessary
+for large responses.
+
+Some minor documentation updates improvements in extras, too.
+
+shortlog of changes since 1.5.0:
+      README: add link to mailing list archives
+      test_ssl: factor out server SSLContext creation
+      doc: add design_notes document
+      reduce File::Stat object allocations
+      update comments about wbuf_close return values
+      wbuf: lazily (re)create temporary file
+      fix compatibility with unicorn.git
+      skip tests requiring String#b on 1.9.3
+      use the monotonic clock under Ruby 2.1+
+      favor Class.new for method-less classes
+      extras/proxy_pass: save memory in String#split arg
+      extras/proxy_pass: do not name unused variable
+      extras/proxy_pass: log exceptions leading to 502
+      extras/proxy_pass: flesh out upload support + tests
+      acceptor: close inherited-but-unneeded sockets
+
+See the git repository for more: git clone git://yhbt.net/yahns
+
 yahns 1.5.0 - initial OpenSSL support and bugfixes / 2014-12-21
 ---------------------------------------------------------------
 

data/README

@@ -68,6 +68,7 @@ You may subscribe by sending an email to:
 
 You may also subscribe to the public-inbox at git://yhbt.net/yahns-public
 using ssoma <http://ssoma.public-inbox.org/>
+Mailing list archives browsable at: http://yhbt.net/yahns-public/
 
 This README is our homepage, we would rather be working on HTTP servers
 all day than worrying about the next browser vulnerability because

data/extras/proxy_pass.rb

@@ -117,7 +117,7 @@ class ProxyPass # :nodoc:
     case dest
     when %r{\Ahttp://([^/]+)(/.*)\z}
       path = $2
-      host, port = $1.split(/:/)
+      host, port = $1.split(':')
       @sockaddr = Socket.sockaddr_in(port || 80, host)
 
       # methods from Rack::Request we want:
@@ -135,12 +135,7 @@ class ProxyPass # :nodoc:
   end
 
   def call(env)
-    case request_method = env["REQUEST_METHOD"]
-    when "GET", "HEAD" # OK
-    else
-      return [ 405, [%w(Content-Length 0), %w(Content-Length 0)], [] ]
-    end
-
+    request_method = env['REQUEST_METHOD']
     req = Rack::Request.new(env)
     path = @path.gsub(/\$(\w+)/) { req.__send__($1.to_sym) }
     req = "#{request_method} #{path} HTTP/1.1\r\n" \
@@ -170,7 +165,7 @@ class ProxyPass # :nodoc:
     send_body(env["rack.input"], ures, chunked) if chunked || clen
 
     # wait for the response here
-    status, header, body = res = ures.rack
+    _, header, body = res = ures.rack
 
     # don't let the upstream Connection and Keep-Alive headers leak through
     header.delete_if do |k,_|
@@ -189,6 +184,10 @@ class ProxyPass # :nodoc:
     res
   rescue => e
     retry if ures && ures.fail_retryable? && request_method != "POST"
+    if defined?(Yahns::Log)
+      logger = env['rack.logger'] and
+        Yahns::Log.exception(logger, 'proxy_pass', e)
+    end
     ERROR_502
   end
 
@@ -200,7 +199,7 @@ class ProxyPass # :nodoc:
         buf.replace("#{buf.size.to_s(16)}\r\n#{buf}\r\n")
         ures.req_write(buf, @timeout)
       end
-      ures.req_write("0\r\n\r\n")
+      ures.req_write("0\r\n\r\n", @timeout)
     else # common if we hit uploads
       while input.read(16384, buf)
         ures.req_write(buf, @timeout)

data/lib/yahns/acceptor.rb

@@ -19,7 +19,10 @@ module Yahns::Acceptor # :nodoc:
 
   # just keep looping this on every acceptor until the associated thread dies
   def ac_quit
-    return true unless defined?(@thrs)
+    unless defined?(@thrs) # acceptor has not started yet, freshly inherited
+      close
+      return true
+    end
     @thrs.each { |t| t[:yahns_quit] = true }
     return true if __ac_quit_done?
 

data/lib/yahns/client_expire_generic.rb

@@ -2,7 +2,7 @@
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 module Yahns::ClientExpireGeneric # :nodoc:
   def __timestamp
-    Time.now.to_f
+    Yahns.now
   end
 
   def yahns_init

data/lib/yahns/fdmap.rb

@@ -81,7 +81,7 @@ class Yahns::Fdmap # :nodoc:
   def __expire(timeout)
     return if @count == 0
     nr = 0
-    now = Time.now.to_f
+    now = Yahns.now
     (now - @last_expire) >= 1.0 or return # don't expire too frequently
 
     # @fdmap_ary may be huge, so always expire a bunch at once to
@@ -93,7 +93,7 @@ class Yahns::Fdmap # :nodoc:
       nr += c.yahns_expire(tout)
     end
 
-    @last_expire = Time.now.to_f
+    @last_expire = Yahns.now
     msg = timeout ? "timeout=#{timeout}" : "client_timeout"
     @logger.info("dropping #{nr} of #@count clients for #{msg}")
   end

data/lib/yahns/http_client.rb

@@ -4,8 +4,9 @@
 class Yahns::HttpClient < Kgio::Socket # :nodoc:
   NULL_IO = StringIO.new("")
 
-  # FIXME: we shouldn't have this at all
-  Unicorn::HttpParser.keepalive_requests = 0xffffffff
+  # FIXME: we shouldn't have this at all when we go Unicorn 5-only
+  Unicorn::HttpParser.respond_to?(:keepalive_requests=) and
+    Unicorn::HttpParser.keepalive_requests = 0xffffffff
 
   include Yahns::HttpResponse
   QEV_FLAGS = Yahns::Queue::QEV_RD # used by acceptor

data/lib/yahns/server.rb

@@ -385,7 +385,7 @@ class Yahns::Server # :nodoc:
   def quit_enter(alive)
     if alive
       @logger.info("gracefully exiting shutdown_timeout=#@shutdown_timeout")
-      @shutdown_expire ||= Time.now + @shutdown_timeout + 1
+      @shutdown_expire ||= Yahns.now + @shutdown_timeout + 1
     else # drop connections immediately if signaled twice
       @logger.info("graceful exit aborted, exiting immediately")
       # we will still call any app-defined at_exit hooks here
@@ -416,7 +416,7 @@ class Yahns::Server # :nodoc:
     # response bodies out (e.g. "tail -F")  Oh well, have a timeout
     begin
       @wthr.delete_if { |t| t.join(0.01) }
-    end while @wthr[0] && Time.now <= @shutdown_expire
+    end while @wthr[0] && Yahns.now <= @shutdown_expire
 
     # cleanup, our job is done
     @queues.each(&:close).clear
@@ -466,7 +466,7 @@ class Yahns::Server # :nodoc:
 
   def dropping(fdmap)
     if drop_acceptors[0] || fdmap.size > 0
-      timeout = @shutdown_expire < Time.now ? -1 : @shutdown_timeout
+      timeout = @shutdown_expire < Yahns.now ? -1 : @shutdown_timeout
       fdmap.desperate_expire(timeout)
       true
     else

data/lib/yahns/stream_file.rb

@@ -31,12 +31,14 @@ class Yahns::StreamFile # :nodoc:
       end
     end
     @sf_offset = offset
-    @sf_count = count || @tmpio.stat.size
+    @sf_count = count || @tmpio.size
     @wbuf_persist = persist # whether or not we keep the connection alive
     @body = body
   end
 
-  # called by last wbuf_flush
+  # called by last wbuf_flush,
+  # returns true / false for persistent/non-persistent connections,
+  # :ignore for hijacked connections
   def wbuf_close(client)
     @tmpio.close if NeedClose === @tmpio
     wbuf_close_common(client)

data/lib/yahns/version.rb

@@ -1 +1 @@
-Yahns::VERSION = '1.5.0' # :nodoc:
+Yahns::VERSION = '1.6.0' # :nodoc:

data/lib/yahns/wbuf.rb

@@ -1,5 +1,5 @@
 # -*- encoding: binary -*-
-# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net> et. al.
+# Copyright (C) 2013-2015 all contributors <yahns-public@yhbt.net>
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require_relative 'wbuf_common'
 
@@ -31,7 +31,7 @@ class Yahns::Wbuf # :nodoc:
   include Yahns::WbufCommon
 
   def initialize(body, persist, tmpdir)
-    @tmpio = Yahns::TmpIO.new(tmpdir)
+    @tmpio = nil
     @tmpdir = tmpdir
     @sf_offset = @sf_count = 0
     @wbuf_persist = persist # whether or not we keep the connection alive
@@ -50,6 +50,7 @@ class Yahns::Wbuf # :nodoc:
       @bypass = false # ugh, continue to buffering to file
     end while @bypass
 
+    @tmpio ||= Yahns::TmpIO.new(@tmpdir)
     @sf_count += @tmpio.write(buf)
     case rv = client.trysendfile(@tmpio, @sf_offset, @sf_count)
     when Integer
@@ -64,16 +65,15 @@ class Yahns::Wbuf # :nodoc:
 
     # we're all caught up, try to prevent dirty data from getting flushed
     # to disk if we can help it.
-    @tmpio.close
+    @tmpio = @tmpio.close
     @sf_offset = 0
-    @tmpio = Yahns::TmpIO.new(@tmpdir)
     @bypass = true
     nil
   end
 
   # called by last wbuf_flush
   def wbuf_close(client)
-    @tmpio = @tmpio.close
+    @tmpio = @tmpio.close if @tmpio
     wbuf_close_common(client)
   end
 end

data/lib/yahns/wbuf_common.rb

@@ -9,7 +9,9 @@ rescue LoadError
 end
 
 module Yahns::WbufCommon # :nodoc:
-  # returns nil on success, :wait_*able when blocked
+  # returns true / false for persistent/non-persistent connections
+  # returns :wait_*able when blocked
+  # returns :ignore if hijacked
   # currently, we rely on each thread having exclusive access to the
   # client socket, so this is never called concurrently with wbuf_write
   def wbuf_flush(client)

data/lib/yahns.rb

@@ -10,7 +10,9 @@ require 'sleepy_penguin'
 # on unicorn at all
 [ :ClientShutdown, :Const, :SocketHelper, :StreamInput, :TeeInput,
   :SSLConfigurator, :Configurator, :TmpIO, :Util, :Worker, :SSLServer,
-  :HttpServer ].each { |sym| Unicorn.__send__(:remove_const, sym) }
+  :HttpServer ].each do |sym|
+    Unicorn.__send__(:remove_const, sym) if Unicorn.const_defined?(sym)
+end
 
 # yahns exposes no user-visible API outside of the config file
 # Internals are subject to change.
@@ -48,10 +50,21 @@ module Yahns # :nodoc:
   # application dispatch.  This is always raised with an empty backtrace
   # since there is nothing in the application stack that is responsible
   # for client shutdowns/disconnects.
-  class ClientShutdown < EOFError # :nodoc:
-  end
+  ClientShutdown = Class.new(EOFError) # :nodoc:
+
+  ClientTimeout = Class.new(RuntimeError) # :nodoc:
 
-  class ClientTimeout < RuntimeError # :nodoc:
+  # try to use the monotonic clock in Ruby >= 2.1, it is immune to clock
+  # offset adjustments and generates less garbage (Float vs Time object)
+  begin
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    def self.now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  rescue NameError, NoMethodError
+    def self.now # Ruby <= 2.0
+      Time.now.to_f
+    end
   end
 end
 

data/test/server_helper.rb

@@ -72,10 +72,10 @@ module ServerHelper
     @ru = nil
   end
 
-  def mkserver(cfg)
+  def mkserver(cfg, srv = @srv)
     fork do
-      ENV["YAHNS_FD"] = @srv.fileno.to_s
-      @srv.autoclose = false
+      ENV["YAHNS_FD"] = srv.fileno.to_s
+      srv.autoclose = false
       yield if block_given?
       Yahns::Server.new(cfg).start.join
     end

data/test/test_extras_autoindex.rb

@@ -11,6 +11,7 @@ class TestExtrasAutoindex < Testcase
   def setup
     @tmpdir = Dir.mktmpdir
     server_helper_setup
+    skip 'Ruby 2.x required' unless ''.respond_to?(:b)
   end
 
   def teardown

data/test/test_extras_proxy_pass.rb

@@ -0,0 +1,100 @@
+# Copyright (C) 2015 all contributors <yahns-public@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require_relative 'server_helper'
+
+class TestExtrasProxyPass < Testcase
+  ENV["N"].to_i > 1 and parallelize_me!
+  include ServerHelper
+
+  class ProxiedApp
+    def call(env)
+      h = [ %w(Content-Length 3), %w(Content-Type text/plain) ]
+      case env['REQUEST_METHOD']
+      when 'GET'
+        [ 200, h, [ "hi\n"] ]
+      when 'HEAD'
+        [ 200, h, [] ]
+      when 'PUT'
+        buf = env['rack.input'].read
+        [ 201, {
+          'Content-Length' => buf.bytesize.to_s,
+          'Content-Type' => 'text/plain',
+          }, [ buf ] ]
+      end
+    end
+  end
+
+  def setup
+    @srv2 = TCPServer.new(ENV["TEST_HOST"] || "127.0.0.1", 0)
+    server_helper_setup
+  end
+
+  def teardown
+    @srv2.close if defined?(@srv2) && !@srv2.closed?
+    server_helper_teardown
+  end
+
+  def test_proxy_pass
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    host2, port2 = @srv2.addr[3], @srv2.addr[1]
+    pid = mkserver(cfg) do
+      $LOAD_PATH.unshift "#{Dir.pwd}/extras"
+      require 'proxy_pass'
+      @srv2.close
+      cfg.instance_eval do
+        app(:rack, ProxyPass.new("http://#{host2}:#{port2}/")) do
+          listen "#{host}:#{port}"
+        end
+        stderr_path err.path
+      end
+    end
+
+    pid2 = mkserver(cfg, @srv2) do
+      @srv.close
+      cfg.instance_eval do
+        app(:rack, ProxiedApp.new) do
+          listen "#{host2}:#{port2}"
+        end
+        stderr_path err.path
+      end
+    end
+
+    gplv3 = File.open('COPYING')
+
+    Net::HTTP.start(host, port) do |http|
+      res = http.request(Net::HTTP::Get.new('/'))
+      assert_equal 200, res.code.to_i
+      n = res.body.bytesize
+      assert_operator n, :>, 1
+      res = http.request(Net::HTTP::Head.new('/'))
+      assert_equal 200, res.code.to_i
+      assert_equal n, res['Content-Length'].to_i
+      assert_nil res.body
+
+      # chunked encoding
+      req = Net::HTTP::Put.new('/')
+      req.body_stream = gplv3
+      req.content_type = 'application/octet-stream'
+      req['Transfer-Encoding'] = 'chunked'
+      res = http.request(req)
+      gplv3.rewind
+      assert_equal gplv3.read, res.body
+      assert_equal 201, res.code.to_i
+
+      # normal content-length
+      gplv3.rewind
+      req = Net::HTTP::Put.new('/')
+      req.body_stream = gplv3
+      req.content_type = 'application/octet-stream'
+      req.content_length = gplv3.size
+      res = http.request(req)
+      gplv3.rewind
+      assert_equal gplv3.read, res.body
+      assert_equal 201, res.code.to_i
+    end
+  ensure
+    gplv3.close if gplv3
+    quit_wait pid
+    quit_wait pid2
+  end
+end

data/test/test_extras_try_gzip_static.rb

@@ -12,6 +12,7 @@ class TestExtrasTryGzipStatic < Testcase
   def setup
     @tmpdir = Dir.mktmpdir
     server_helper_setup
+    skip 'Ruby 2.x required' unless ''.respond_to?(:b)
   end
 
   def teardown

data/test/test_output_buffering.rb

@@ -123,7 +123,7 @@ class TestOutputBuffering < Testcase
           def gplv3.each
             raise "SHOULD NOT BE CALLED"
           end
-          size = gplv3.stat.size
+          size = gplv3.size
           len = size.to_s
           ranges = Rack::Utils.byte_ranges(e, size)
           status = 200

data/test/test_server.rb

@@ -804,4 +804,43 @@ class TestServer < Testcase
   ensure
     quit_wait(pid)
   end
+
+  def test_inherit_too_many
+    err = @err
+    s2 = TCPServer.new(ENV["TEST_HOST"] || "127.0.0.1", 0)
+    cfg = Yahns::Config.new
+    host, port = @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      ru = lambda { |_| [ 200, {'Content-Length'=>'2'}, ['HI'] ] }
+      GTL.synchronize { app(:rack, ru) { listen "#{host}:#{port}" } }
+      logger(Logger.new(err.path))
+    end
+    mkserver(cfg, @srv) do
+      s2.autoclose = false
+      ENV["YAHNS_FD"] = "#{@srv.fileno},#{s2.fileno}"
+    end
+    run_client(host, port) { |res| assert_equal "HI", res.body }
+    th = Thread.new do
+      c = s2.accept
+      c.readpartial(1234)
+      c.write "HTTP/1.0 666 OK\r\n\r\nGO AWAY"
+      c.close
+      :OK
+    end
+    Thread.pass
+    s2host, s2port = s2.addr[3], s2.addr[1]
+    Net::HTTP.start(s2host, s2port) do |http|
+      res = http.request(Net::HTTP::Get.new("/"))
+      assert_equal 666, res.code.to_i
+      assert_equal "GO AWAY", res.body
+    end
+    assert_equal :OK, th.value
+    tmpc = TCPSocket.new(s2host, s2port)
+    a2 = s2.accept
+    assert_nil IO.select([a2], nil, nil, 0.05)
+    tmpc.close
+    assert_nil a2.read(1)
+    a2.close
+    s2.close
+  end
 end

data/test/test_ssl.rb

@@ -53,13 +53,16 @@ AQjjxMXhwULlmuR/K+WwlaZPiLIBYalLAZQ7ZbOPeVkJ8ePao0eLAgEC
     ssl
   end
 
-  def test_ssl_basic
-    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
-    host, port = @srv.addr[3], @srv.addr[1]
+  def srv_ctx
     ctx = OpenSSL::SSL::SSLContext.new
     ctx.ciphers = "ADH"
     ctx.tmp_dh_callback = proc { TEST_KEY_DH1024 }
+    ctx
+  end
 
+  def test_ssl_basic
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    ctx = srv_ctx
     pid = mkserver(cfg) do
       cfg.instance_eval do
         ru = lambda { |_| [ 200, {'Content-Length'=>'2'}, ['HI'] ] }

data/test/test_stream_file.rb

@@ -9,7 +9,7 @@ class TestStreamFile < Testcase
 
   def test_stream_file
     fp = File.open("COPYING")
-    sf = Yahns::StreamFile.new(fp, true, 0, fp.stat.size)
+    sf = Yahns::StreamFile.new(fp, true, 0, fp.size)
     refute sf.respond_to?(:close)
     sf.wbuf_close(nil)
     assert fp.closed?
@@ -18,7 +18,7 @@ class TestStreamFile < Testcase
   def test_fd
     fp = File.open("COPYING")
     obj = DevFD.new("/dev/fd/#{fp.fileno}")
-    sf = Yahns::StreamFile.new(obj, true, 0, fp.stat.size)
+    sf = Yahns::StreamFile.new(obj, true, 0, fp.size)
     io = sf.instance_variable_get :@tmpio
     assert_instance_of IO, io.to_io
     assert_equal fp.fileno, io.fileno

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yahns
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - yahns hackers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-21 00:00:00.000000000 Z
+date: 2015-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kgio
@@ -96,6 +96,7 @@ files:
 - COPYING
 - Documentation/.gitignore
 - Documentation/GNUmakefile
+- Documentation/design_notes.txt
 - Documentation/yahns-rackup.txt
 - Documentation/yahns.txt
 - Documentation/yahns_config.txt
@@ -178,6 +179,7 @@ files:
 - test/test_extras_autoindex.rb
 - test/test_extras_exec_cgi.rb
 - test/test_extras_exec_cgi.sh
+- test/test_extras_proxy_pass.rb
 - test/test_extras_try_gzip_static.rb
 - test/test_fdmap.rb
 - test/test_input.rb