rainbows 1.0.0 → 2.0.0

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v1.0.0.GIT
+DEF_VER=v2.0.0.GIT
 
 LF='
 '

data/lib/rainbows.rb

@@ -39,7 +39,6 @@ module Rainbows
   require 'rainbows/http_server'
   require 'rainbows/response'
   require 'rainbows/client'
-  require 'rainbows/tee_input'
   require 'rainbows/process_client'
   autoload :Base, 'rainbows/base'
   autoload :Sendfile, 'rainbows/sendfile'

data/lib/rainbows/client.rb

@@ -1,9 +1,9 @@
 # -*- encoding: binary -*-
 # :enddoc:
 
-require 'rainbows/read_timeout'
+require 'rainbows/timed_read'
 
 class Rainbows::Client < Kgio::Socket
-  include Rainbows::ReadTimeout
+  include Rainbows::TimedRead
 end
 Kgio.accept_class = Rainbows::Client

data/lib/rainbows/const.rb

@@ -2,7 +2,7 @@
 # :enddoc:
 module Rainbows::Const
 
-  RAINBOWS_VERSION = '1.0.0'
+  RAINBOWS_VERSION = '2.0.0'
 
   include Unicorn::Const
 

data/lib/rainbows/dev_fd_response.rb

@@ -54,7 +54,7 @@ class Rainbows::DevFdResponse < Struct.new(:app)
       # we need to make sure our pipe output is Fiber-compatible
       case env["rainbows.model"]
       when :FiberSpawn, :FiberPool, :RevFiberSpawn
-        io.respond_to?(:wait_readable) or
+        io.respond_to?(:kgio_wait_readable) or
           io = Rainbows::Fiber::IO.new(io)
       when :Revactor
         io = Rainbows::Revactor::Proxy.new(io)

data/lib/rainbows/fiber/base.rb

@@ -56,19 +56,6 @@ module Rainbows::Fiber::Base
     max.nil? || max > (now + 1) ? 1 : max - now
   end
 
-  def wait_headers_readable(client)
-    io = client.to_io
-    expire = nil
-    begin
-      return io.recv_nonblock(1, Socket::MSG_PEEK)
-    rescue Errno::EAGAIN
-      return if expire && expire < Time.now
-      expire ||= Time.now + G.kato
-      client.wait_readable
-      retry
-    end
-  end
-
   def process(client)
     G.cur += 1
     process_client(client)

data/lib/rainbows/fiber/body.rb

@@ -18,7 +18,7 @@ module Rainbows::Fiber::Body # :nodoc:
       begin
         offset += (n = sock.sendfile_nonblock(body, offset, count))
       rescue Errno::EAGAIN
-        client.wait_writable
+        client.kgio_wait_writable
         retry
       rescue EOFError
         break

data/lib/rainbows/fiber/io.rb

@@ -52,8 +52,8 @@ class Rainbows::Fiber::IO
           return
         when String
           buf = rv
-        when Kgio::WaitWritable
-          wait_writable
+        when :wait_writable
+          kgio_wait_writable
         end
       end while true
     else
@@ -61,7 +61,7 @@ class Rainbows::Fiber::IO
         (rv = @to_io.write_nonblock(buf)) == buf.bytesize and return
         buf = byte_slice(buf, rv..-1)
       rescue Errno::EAGAIN
-        wait_writable
+        kgio_wait_writable
       end while true
     end
   end
@@ -75,15 +75,28 @@ class Rainbows::Fiber::IO
   end
 
   # used for reading headers (respecting keepalive_timeout)
-  def read_timeout
+  def timed_read(buf)
     expire = nil
-    begin
-      return @to_io.read_nonblock(16384)
-    rescue Errno::EAGAIN
-      return if expire && expire < Time.now
-      expire ||= Time.now + G.kato
-      wait_readable
-    end while true
+    if @to_io.respond_to?(:kgio_tryread)
+      begin
+        case rv = @to_io.kgio_tryread(16384, buf)
+        when :wait_readable
+          return if expire && expire < Time.now
+          expire ||= Time.now + G.kato
+          kgio_wait_readable
+        else
+          return rv
+        end
+      end while true
+    else
+      begin
+        return @to_io.read_nonblock(16384, buf)
+      rescue Errno::EAGAIN
+        return if expire && expire < Time.now
+        expire ||= Time.now + G.kato
+        kgio_wait_readable
+      end while true
+    end
   end
 
   def readpartial(length, buf = "")
@@ -93,8 +106,8 @@ class Rainbows::Fiber::IO
         case rv
         when nil
           raise EOFError, "end of file reached", []
-        when Kgio::WaitReadable
-          wait_readable
+        when :wait_readable
+          kgio_wait_readable
         else
           return rv
         end
@@ -103,7 +116,7 @@ class Rainbows::Fiber::IO
       begin
         return @to_io.read_nonblock(length, buf)
       rescue Errno::EAGAIN
-        wait_readable
+        kgio_wait_readable
       end while true
     end
   end
@@ -128,7 +141,9 @@ end
 require 'rainbows/fiber/io/methods'
 require 'rainbows/fiber/io/compat'
 Rainbows::Client.__send__(:include, Rainbows::Fiber::IO::Methods)
-Rainbows::Fiber::IO.__send__(:include, Rainbows::Fiber::IO::Compat)
-Rainbows::Fiber::IO.__send__(:include, Rainbows::Fiber::IO::Methods)
-Kgio.wait_readable = :wait_readable
-Kgio.wait_writable = :wait_writable
+class Rainbows::Fiber::IO
+  include Rainbows::Fiber::IO::Compat
+  include Rainbows::Fiber::IO::Methods
+  alias_method :wait_readable, :kgio_wait_readable
+  alias_method :wait_writable, :kgio_wait_writable
+end

data/lib/rainbows/fiber/io/methods.rb

@@ -25,7 +25,7 @@ module Rainbows::Fiber::IO::Methods
     super
   end
 
-  def wait_readable
+  def kgio_wait_readable
     fd = fileno
     @f = Fiber.current
     RD[fd] = self
@@ -33,7 +33,7 @@ module Rainbows::Fiber::IO::Methods
     RD[fd] = nil
   end
 
-  def wait_writable
+  def kgio_wait_writable
     fd = fileno
     @f = Fiber.current
     WR[fd] = self

data/lib/rainbows/fiber/rev/methods.rb

@@ -3,7 +3,7 @@
 module Rainbows::Fiber::Rev::Methods
   class Watcher < Rev::IOWatcher
     def initialize(fio, flag)
-      @f = fio.f || Fiber.current
+      @f = Fiber.current
       super(fio, flag)
       attach(Rev::Loop.default)
     end
@@ -15,30 +15,23 @@ module Rainbows::Fiber::Rev::Methods
     alias on_writable on_readable
   end
 
-  def initialize(*args)
-    @f = Fiber.current
-    super(*args)
-    @r = @w = false
-  end
-
   def close
-    @w.detach if @w
-    @r.detach if @r
-    @r = @w = false
+    @w.detach if defined?(@w) && @w.attached?
+    @r.detach if defined?(@r) && @r.attached?
     super
   end
 
-  def wait_writable
-    @w ||= Watcher.new(self, :w)
+  def kgio_wait_writable
+    @w = Watcher.new(self, :w) unless defined?(@w)
     @w.enable unless @w.enabled?
     Fiber.yield
     @w.disable
   end
 
-  def wait_readable
-    @r ||= Watcher.new(self, :r)
+  def kgio_wait_readable
+    @r = Watcher.new(self, :r) unless defined?(@r)
     @r.enable unless @r.enabled?
-    KATO << @f
+    KATO << Fiber.current
     Fiber.yield
     @r.disable
   end

data/lib/rainbows/max_body.rb

@@ -1,81 +1,78 @@
 # -*- encoding: binary -*-
-# :enddoc:
 
-# middleware used to enforce client_max_body_size for TeeInput users,
-# there is no need to configure this middleware manually, it will
+# Middleware used to enforce client_max_body_size for TeeInput users.
+#
+# There is no need to configure this middleware manually, it will
 # automatically be configured for you based on the client_max_body_size
-# setting
-class Rainbows::MaxBody < Struct.new(:app)
+# setting.
+#
+# For more fine-grained conrol, you may also define it per-endpoint in
+# your Rack config.ru like this:
+#
+#        map "/limit_1M" do
+#          use Rainbows::MaxBody, 1024*1024
+#          run MyApp
+#        end
+#        map "/limit_10M" do
+#          use Rainbows::MaxBody, 1024*1024*10
+#          run MyApp
+#        end
 
-  # this is meant to be included in Rainbows::TeeInput (and derived
-  # classes) to limit body sizes
-  module Limit
-    TmpIO = Unicorn::TmpIO
-    MAX_BODY = Rainbows::Const::MAX_BODY
+class Rainbows::MaxBody
 
-    def initialize(socket, request)
-      @parser = request
-      @buf = request.buf
-      @env = request.env
-      @len = request.content_length
 
-      max = Rainbows.max_bytes # never nil, see MaxBody.setup
-      if @len && @len > max
-        socket.write(Rainbows::Const::ERROR_413_RESPONSE)
-        socket.close
-        raise IOError, "Content-Length too big: #@len > #{max}", []
-      end
+  # :call-seq:
+  #   # in config.ru:
+  #   use Rainbows::MaxBody, 4096
+  #   run YourApplication.new
+  def initialize(app, limit = Rainbows.max_bytes)
+    Integer === limit or raise ArgumentError, "limit not an Integer"
+    @app, @limit = app, limit
+  end
 
-      @socket = socket
-      @buf2 = ""
-      if @buf.size > 0
-        parser.filter_body(@buf2, @buf) and finalize_input
-        @buf2.size > max and raise IOError, "chunked request body too big", []
-      end
-      @tmp = @len && @len < MAX_BODY ? StringIO.new("") : TmpIO.new
-      if @buf2.size > 0
-        @tmp.write(@buf2)
-        @tmp.rewind
-        max -= @buf2.size
-      end
-      @max_body = max
-    end
+  # :stopdoc:
+  RACK_INPUT = "rack.input".freeze
+  CONTENT_LENGTH = "CONTENT_LENGTH"
+  HTTP_TRANSFER_ENCODING = "HTTP_TRANSFER_ENCODING"
 
-    def tee(length, dst)
-      rv = super
-      if rv && ((@max_body -= rv.size) < 0)
-        # make HttpParser#keepalive? => false to force an immediate disconnect
-        # after we write
-        @parser.reset
-        throw :rainbows_EFBIG
+  # our main Rack middleware endpoint
+  def call(env)
+    catch(:rainbows_EFBIG) do
+      len = env[CONTENT_LENGTH]
+      if len && len.to_i > @limit
+        return err
+      elsif /\Achunked\z/i =~ env[HTTP_TRANSFER_ENCODING]
+        limit_input!(env)
       end
-      rv
-    end
-
+      @app.call(env)
+    end || err
   end
 
   # this is called after forking, so it won't ever affect the master
   # if it's reconfigured
-  def self.setup
+  def self.setup # :nodoc:
     Rainbows.max_bytes or return
     case Rainbows::G.server.use
-    when :Rev, :EventMachine, :NeverBlock
+    when :Rev, :EventMachine, :NeverBlock, :RevThreadSpawn, :RevThreadPool
       return
     end
 
-    Rainbows::TeeInput.__send__(:include, Limit)
-
     # force ourselves to the outermost middleware layer
     Rainbows::G.server.app = self.new(Rainbows::G.server.app)
   end
 
   # Rack response returned when there's an error
-  def err(env)
-    [ 413, [ %w(Content-Length 0), %w(Content-Type text/plain) ], [] ]
+  def err # :nodoc:
+    [ 413, { 'Content-Length' => '0', 'Content-Type' => 'text/plain' }, [] ]
   end
 
-  # our main Rack middleware endpoint
-  def call(env)
-    catch(:rainbows_EFBIG) { app.call(env) } || err(env)
+  def limit_input!(env)
+    input = env[RACK_INPUT]
+    klass = input.respond_to?(:rewind) ? RewindableWrapper : Wrapper
+    env[RACK_INPUT] = klass.new(input, @limit)
   end
+
+  # :startdoc:
 end
+require 'rainbows/max_body/wrapper'
+require 'rainbows/max_body/rewindable_wrapper'

data/lib/rainbows/max_body/rewindable_wrapper.rb

@@ -0,0 +1,18 @@
+# -*- encoding: binary -*-
+# :enddoc:
+class Rainbows::MaxBody::RewindableWrapper < Rainbows::MaxBody::Wrapper
+  def initialize(rack_input, limit)
+    @orig_limit = limit
+    super
+  end
+
+  def rewind
+    @limit = @orig_limit
+    @rbuf = ''
+    @input.rewind
+  end
+
+  def size
+    @input.size
+  end
+end

data/lib/rainbows/max_body/wrapper.rb

@@ -0,0 +1,70 @@
+# -*- encoding: binary -*-
+# :enddoc:
+#
+# This is only used for chunked request bodies, which are rare
+class Rainbows::MaxBody::Wrapper
+  def initialize(rack_input, limit)
+    @input, @limit, @rbuf = rack_input, limit, ''
+  end
+
+  def each(&block)
+    while line = gets
+      yield line
+    end
+  end
+
+  # chunked encoding means this method behaves more like readpartial,
+  # since Rack does not support a method named "readpartial"
+  def read(length = nil, rv = '')
+    if length
+      if length <= @rbuf.size
+        length < 0 and raise ArgumentError, "negative length #{length} given"
+        rv.replace(@rbuf.slice!(0, length))
+      elsif @rbuf.empty?
+        checked_read(length, rv) or return
+      else
+        rv.replace(@rbuf.slice!(0, @rbuf.size))
+      end
+      rv.empty? && length != 0 ? nil : rv
+    else
+      rv.replace(read_all)
+    end
+  end
+
+  def gets
+    sep = $/
+    if sep.nil?
+      rv = read_all
+      return rv.empty? ? nil : rv
+    end
+    re = /\A(.*?#{Regexp.escape(sep)})/
+
+    begin
+      @rbuf.sub!(re, '') and return $1
+
+      if tmp = checked_read(16384)
+        @rbuf << tmp
+      elsif @rbuf.empty? # EOF
+        return nil
+      else # EOF, return whatever is left
+        return @rbuf.slice!(0, @rbuf.size)
+      end
+    end while true
+  end
+
+  def checked_read(length = 16384, buf = '')
+    if @input.read(length, buf)
+      throw :rainbows_EFBIG if ((@limit -= buf.size) < 0)
+      return buf
+    end
+  end
+
+  def read_all
+    rv = @rbuf.slice!(0, @rbuf.size)
+    tmp = ''
+    while checked_read(16384, tmp)
+      rv << tmp
+    end
+    rv
+  end
+end

data/lib/rainbows/process_client.rb

@@ -6,13 +6,9 @@ module Rainbows::ProcessClient
   HttpParser = Unicorn::HttpParser
   NULL_IO = Unicorn::HttpRequest::NULL_IO
   RACK_INPUT = Unicorn::HttpRequest::RACK_INPUT
-  TeeInput = Rainbows::TeeInput
+  TeeInput = Unicorn::TeeInput
   include Rainbows::Const
 
-  def wait_headers_readable(client)
-    IO.select([client], nil, nil, G.kato)
-  end
-
   # once a client is accepted, it is processed in its entirety here
   # in 3 easy steps: read request, call app, write app response
   # this is used by synchronous concurrency models
@@ -21,11 +17,12 @@ module Rainbows::ProcessClient
     hp = HttpParser.new
     client.kgio_read!(16384, buf = hp.buf)
     remote_addr = client.kgio_addr
+    alive = false
 
     begin # loop
       until env = hp.parse
-        wait_headers_readable(client) or return
-        buf << client.kgio_read!(16384)
+        client.timed_read(buf2 ||= "") or return
+        buf << buf2
       end
 
       env[CLIENT_IO] = client
@@ -43,12 +40,12 @@ module Rainbows::ProcessClient
       if hp.headers?
         headers = HH.new(headers)
         range = make_range!(env, status, headers) and status = range.shift
-        env = hp.keepalive? && G.alive
-        headers[CONNECTION] = env ? KEEP_ALIVE : CLOSE
+        alive = hp.next? && G.alive
+        headers[CONNECTION] = alive ? KEEP_ALIVE : CLOSE
         client.write(response_header(status, headers))
       end
       write_body(client, body, range)
-    end while env && hp.reset.nil?
+    end while alive
   # if we get any error, try to write something back to the client
   # assuming we haven't closed the socket, but don't get hung up
   # if the socket is already closed or broken.  We'll always ensure

data/lib/rainbows/rev/client.rb

@@ -30,7 +30,7 @@ module Rainbows
             case rv = @_io.kgio_trywrite(buf)
             when nil
               return enable_write_watcher
-            when Kgio::WaitWritable
+            when :wait_writable
               break # fall through to super(buf)
             when String
               buf = rv # retry, skb could grow or been drained
@@ -42,6 +42,19 @@ module Rainbows
         super(buf)
       end
 
+      def on_readable
+        buf = @_io.kgio_tryread(16384)
+        case buf
+        when :wait_readable
+        when nil # eof
+          close
+        else
+          on_read buf
+        end
+      rescue Errno::ECONNRESET
+        close
+      end
+
       # queued, optional response bodies, it should only be unpollable "fast"
       # devices where read(2) is uninterruptable.  Unfortunately, NFS and ilk
       # are also part of this.  We'll also stick DeferredResponse bodies in

data/lib/rainbows/rev/master.rb

@@ -2,20 +2,23 @@
 # :enddoc:
 require 'rainbows/rev'
 
-class Rainbows::Rev::Master < Rev::AsyncWatcher
+class Rainbows::Rev::Master < Rev::IOWatcher
 
   def initialize(queue)
-    super()
+    @reader, @writer = Kgio::Pipe.new
+    super(@reader)
     @queue = queue
   end
 
   def <<(output)
     @queue << output
-    signal
+    @writer.kgio_trywrite("\0")
   end
 
-  def on_signal
-    client, response = @queue.pop
-    client.response_write(response)
+  def on_readable
+    if String === @reader.kgio_tryread(1)
+      client, response = @queue.pop
+      client.response_write(response)
+    end
   end
 end

data/lib/rainbows/revactor.rb

@@ -43,6 +43,7 @@ module Rainbows::Revactor
     end
     hp = Unicorn::HttpParser.new
     buf = hp.buf
+    alive = false
 
     begin
       until env = hp.parse
@@ -51,7 +52,7 @@ module Rainbows::Revactor
 
       env[CLIENT_IO] = client
       env[RACK_INPUT] = 0 == hp.content_length ?
-               NULL_IO : TeeInput.new(TeeSocket.new(client), hp)
+               NULL_IO : Unicorn::TeeInput.new(TeeSocket.new(client), hp)
       env[REMOTE_ADDR] = remote_addr
       status, headers, body = app.call(env.update(RACK_DEFAULTS))
 
@@ -64,12 +65,12 @@ module Rainbows::Revactor
       if hp.headers?
         headers = HH.new(headers)
         range = make_range!(env, status, headers) and status = range.shift
-        env = hp.keepalive? && G.alive && G.kato > 0
-        headers[CONNECTION] = env ? KEEP_ALIVE : CLOSE
+        alive = hp.next? && G.alive && G.kato > 0
+        headers[CONNECTION] = alive ? KEEP_ALIVE : CLOSE
         client.write(response_header(status, headers))
       end
       write_body(client, body, range)
-    end while env && hp.reset.nil?
+    end while alive
   rescue ::Revactor::TCP::ReadError
   rescue => e
     Rainbows::Error.write(io, e)

data/lib/rainbows/{read_timeout.rb → timed_read.rb}

@@ -1,25 +1,21 @@
 # -*- encoding: binary -*-
 # :enddoc:
-module Rainbows::ReadTimeout
+module Rainbows::TimedRead
   G = Rainbows::G # :nodoc:
 
-  def wait_readable
+  def kgio_wait_readable
     IO.select([self], nil, nil, G.kato)
   end
 
   # used for reading headers (respecting keepalive_timeout)
-  def read_timeout(buf = "")
+  def timed_read(buf)
     expire = nil
     begin
       case rv = kgio_tryread(16384, buf)
       when :wait_readable
-        now = Time.now.to_f
-        if expire
-          now > expire and return
-        else
-          expire = now + G.kato
-        end
-        wait_readable
+        return if expire && expire < Time.now
+        expire ||= Time.now + G.kato
+        kgio_wait_readable
       else
         return rv
       end

data/lib/rainbows/writer_thread_pool.rb

@@ -42,6 +42,10 @@ module Rainbows
         to_io.kgio_trywrite(buf)
       end
 
+      def timed_read(buf)
+        to_io.timed_read(buf)
+      end
+
       def write(buf)
         q << [ to_io, buf ]
       end

data/lib/rainbows/writer_thread_spawn.rb

@@ -47,6 +47,10 @@ module Rainbows
         to_io.kgio_trywrite(buf)
       end
 
+      def timed_read(buf)
+        to_io.timed_read(buf)
+      end
+
       def queue_writer
         # not using Thread.pass here because that spins the CPU during
         # I/O wait and will eat cycles from other worker processes.

data/rainbows.gemspec

@@ -44,7 +44,7 @@ Gem::Specification.new do |s|
   s.add_dependency(%q<rack>, ['~> 1.1'])
 
   # we need Unicorn for the HTTP parser and process management
-  s.add_dependency(%q<unicorn>, ["~> 2.0.0"])
+  s.add_dependency(%q<unicorn>, ["~> 3.0.0"])
   s.add_development_dependency(%q<isolate>, "~> 3.0.0")
 
   # optional runtime dependencies depending on configuration

data/t/sha1-random-size.ru

@@ -7,11 +7,25 @@ app = lambda do |env|
     return [ 100, {}, [] ]
   digest = Digest::SHA1.new
   input = env['rack.input']
-  if buf = input.read(rand(cap))
-    begin
-      raise "#{buf.size} > #{cap}" if buf.size > cap
-      digest.update(buf)
-    end while input.read(rand(cap), buf)
+  case env["PATH_INFO"]
+  when "/gets_read_mix"
+    warn "GETS_READ_MIX #{env['HTTP_TRANSFER_ENCODING'].inspect}"
+    if buf = input.gets
+      warn "input.rbuf: #{input.instance_variable_get(:@rbuf).inspect}"
+      begin
+        digest.update(buf)
+        warn "buf.size : #{buf.size}"
+      end while input.read(rand(cap), buf)
+    end
+  when "/each"
+    input.each { |buf| digest.update(buf) }
+  else
+    if buf = input.read(rand(cap))
+      begin
+        raise "#{buf.size} > #{cap}" if buf.size > cap
+        digest.update(buf)
+      end while input.read(rand(cap), buf)
+    end
   end
 
   [ 200, {'Content-Type' => 'text/plain'}, [ digest.hexdigest << "\n" ] ]

data/t/t0104-rack-input-limit-tiny.sh

@@ -3,7 +3,7 @@
 test -r random_blob || die "random_blob required, run with 'make $0'"
 req_curl_chunked_upload_err_check
 
-t_plan 6 "rack.input client_max_body_size tiny"
+t_plan 18 "rack.input client_max_body_size tiny"
 
 t_begin "setup and startup" && {
 	rtmpfiles curl_out curl_err cmbs_config
@@ -21,6 +21,7 @@ t_begin "stops a regular request" && {
 	  http://$listen/ > $curl_out 2> $curl_err || > $ok
 	dbgcat curl_err
 	dbgcat curl_out
+	grep 413 $curl_err
 	test -e $ok
 }
 
@@ -31,6 +32,7 @@ t_begin "stops a large chunked request" && {
 	  http://$listen/ > $curl_out 2> $curl_err || > $ok
 	dbgcat curl_err
 	dbgcat curl_out
+	grep 413 $curl_err
 	test -e $ok
 }
 
@@ -56,6 +58,136 @@ t_begin "small size sha1 content-length ok" && {
 	test "$(cat $curl_out)" = $blob_sha1
 }
 
+t_begin "stops a regular request (gets_read_mix)" && {
+	rm -f $ok
+	dd if=/dev/zero bs=257 count=1 of=$tmp
+	curl -vsSf -T $tmp -H Expect: \
+	  http://$listen/gets_read_mix > $curl_out 2> $curl_err || > $ok
+	dbgcat curl_err
+	dbgcat curl_out
+	grep 413 $curl_err
+	test -e $ok
+}
+
+t_begin "stops a large chunked request (gets_read_mix)" && {
+	rm -f $ok
+	dd if=/dev/zero bs=257 count=1 | \
+	  curl -vsSf -T- -H Expect: \
+	  http://$listen/gets_read_mix > $curl_out 2> $curl_err || > $ok
+	dbgcat curl_err
+	dbgcat curl_out
+	grep 413 $curl_err
+	test -e $ok
+}
+
+t_begin "stops a large line-based chunked request (gets_read_mix)" && {
+	rm -f $ok
+	</dev/null awk 'BEGIN{for(i=22;--i>=0;) print "hello world"}' | \
+	  curl -vsSf -T- -H Expect: \
+	  http://$listen/gets_read_mix > $curl_out 2> $curl_err || > $ok
+	dbgcat curl_err
+	dbgcat curl_out
+	grep 413 $curl_err
+	test -e $ok
+}
+
+t_begin "OK with line-based chunked request (gets_read_mix)" && {
+	rm -f $ok
+	</dev/null awk 'BEGIN{for(i=21;--i>=0;) print "hello world"}' | \
+	  curl -vsSf -T- -H Expect: \
+	  http://$listen/gets_read_mix > $curl_out 2> $curl_err
+	dbgcat curl_err
+	dbgcat curl_out
+	test x"$(cat $curl_out)" = x23eab3cebcbe22a0456c8462e3d3bb01ae761702
+}
+
+t_begin "small size sha1 chunked ok (gets_read_mix)" && {
+	blob_sha1=b376885ac8452b6cbf9ced81b1080bfd570d9b91
+	rm -f $ok
+	dd if=/dev/zero bs=256 count=1 | \
+	  curl -vsSf -T- -H Expect: \
+	  http://$listen/gets_read_mix > $curl_out 2> $curl_err
+	dbgcat curl_err
+	dbgcat curl_out
+	test "$(cat $curl_out)" = $blob_sha1
+}
+
+t_begin "small size sha1 content-length ok (gets_read_mix)" && {
+	blob_sha1=b376885ac8452b6cbf9ced81b1080bfd570d9b91
+	rm -f $ok
+	dd if=/dev/zero bs=256 count=1 of=$tmp
+	curl -vsSf -T $tmp -H Expect: \
+	  http://$listen/gets_read_mix > $curl_out 2> $curl_err
+	dbgcat curl_err
+	dbgcat curl_out
+	test "$(cat $curl_out)" = $blob_sha1
+}
+
+t_begin "stops a regular request (each)" && {
+	rm -f $ok
+	dd if=/dev/zero bs=257 count=1 of=$tmp
+	curl -vsSf -T $tmp -H Expect: \
+	  http://$listen/each > $curl_out 2> $curl_err || > $ok
+	dbgcat curl_err
+	dbgcat curl_out
+	grep 413 $curl_err
+	test -e $ok
+}
+
+t_begin "stops a large chunked request (each)" && {
+	rm -f $ok
+	dd if=/dev/zero bs=257 count=1 | \
+	  curl -vsSf -T- -H Expect: \
+	  http://$listen/each > $curl_out 2> $curl_err || > $ok
+	dbgcat curl_err
+	dbgcat curl_out
+	grep 413 $curl_err
+	test -e $ok
+}
+
+t_begin "small size sha1 chunked ok (each)" && {
+	blob_sha1=b376885ac8452b6cbf9ced81b1080bfd570d9b91
+	rm -f $ok
+	dd if=/dev/zero bs=256 count=1 | \
+	  curl -vsSf -T- -H Expect: \
+	  http://$listen/each > $curl_out 2> $curl_err
+	dbgcat curl_err
+	dbgcat curl_out
+	test "$(cat $curl_out)" = $blob_sha1
+}
+
+t_begin "small size sha1 content-length ok (each)" && {
+	blob_sha1=b376885ac8452b6cbf9ced81b1080bfd570d9b91
+	rm -f $ok
+	dd if=/dev/zero bs=256 count=1 of=$tmp
+	curl -vsSf -T $tmp -H Expect: \
+	  http://$listen/each > $curl_out 2> $curl_err
+	dbgcat curl_err
+	dbgcat curl_out
+	test "$(cat $curl_out)" = $blob_sha1
+}
+
+t_begin "stops a large line-based chunked request (each)" && {
+	rm -f $ok
+	</dev/null awk 'BEGIN{for(i=22;--i>=0;) print "hello world"}' | \
+	  curl -vsSf -T- -H Expect: \
+	  http://$listen/each > $curl_out 2> $curl_err || > $ok
+	dbgcat curl_err
+	dbgcat curl_out
+	grep 413 $curl_err
+	test -e $ok
+}
+
+t_begin "OK with line-based chunked request (each)" && {
+	rm -f $ok
+	</dev/null awk 'BEGIN{for(i=21;--i>=0;) print "hello world"}' | \
+	  curl -vsSf -T- -H Expect: \
+	  http://$listen/each > $curl_out 2> $curl_err
+	dbgcat curl_err
+	dbgcat curl_out
+	test x"$(cat $curl_out)" = x23eab3cebcbe22a0456c8462e3d3bb01ae761702
+}
+
 t_begin "shutdown" && {
 	kill $rainbows_pid
 }

data/t/t0105-rack-input-limit-bigger.sh

@@ -22,6 +22,7 @@ t_begin "stops a regular request" && {
 	rm -f $tmp
 	dbgcat curl_err
 	dbgcat curl_out
+	grep 413 $curl_err
 	test -e $ok
 }
 
@@ -32,6 +33,7 @@ t_begin "stops a large chunked request" && {
 	  http://$listen/ > $curl_out 2> $curl_err || > $ok
 	dbgcat curl_err
 	dbgcat curl_out
+	grep 413 $curl_err
 	test -e $ok
 }
 

data/t/test_isolate.rb

@@ -15,8 +15,8 @@ $stdout.reopen($stderr)
 
 Isolate.now!(opts) do
   gem 'rack', '1.1.0' # Cramp currently requires ~> 1.1.0
-  gem 'kgio', '1.3.1'
-  gem 'unicorn', '2.0.0'
+  gem 'kgio', '2.0.0'
+  gem 'unicorn', '3.0.0'
   gem 'kcar', '0.1.1'
 
   if engine == "ruby"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rainbows
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 15
   prerelease: false
   segments: 
-  - 1
+  - 2
   - 0
   - 0
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Rainbows! hackers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-28 00:00:00 +00:00
+date: 2010-11-20 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,12 +41,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 7
         segments: 
-        - 2
+        - 3
         - 0
         - 0
-        version: 2.0.0
+        version: 3.0.0
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -112,11 +112,12 @@ extra_rdoc_files:
 - lib/rainbows/http_response.rb
 - lib/rainbows/http_server.rb
 - lib/rainbows/max_body.rb
+- lib/rainbows/max_body/rewindable_wrapper.rb
+- lib/rainbows/max_body/wrapper.rb
 - lib/rainbows/never_block.rb
 - lib/rainbows/never_block/event_machine.rb
 - lib/rainbows/process_client.rb
 - lib/rainbows/queue_pool.rb
-- lib/rainbows/read_timeout.rb
 - lib/rainbows/response.rb
 - lib/rainbows/response/body.rb
 - lib/rainbows/response/range.rb
@@ -138,10 +139,10 @@ extra_rdoc_files:
 - lib/rainbows/sendfile.rb
 - lib/rainbows/server_token.rb
 - lib/rainbows/stream_file.rb
-- lib/rainbows/tee_input.rb
 - lib/rainbows/thread_pool.rb
 - lib/rainbows/thread_spawn.rb
 - lib/rainbows/thread_timeout.rb
+- lib/rainbows/timed_read.rb
 - lib/rainbows/writer_thread_pool.rb
 - lib/rainbows/writer_thread_spawn.rb
 - LICENSE
@@ -215,11 +216,12 @@ files:
 - lib/rainbows/http_response.rb
 - lib/rainbows/http_server.rb
 - lib/rainbows/max_body.rb
+- lib/rainbows/max_body/rewindable_wrapper.rb
+- lib/rainbows/max_body/wrapper.rb
 - lib/rainbows/never_block.rb
 - lib/rainbows/never_block/event_machine.rb
 - lib/rainbows/process_client.rb
 - lib/rainbows/queue_pool.rb
-- lib/rainbows/read_timeout.rb
 - lib/rainbows/response.rb
 - lib/rainbows/response/body.rb
 - lib/rainbows/response/range.rb
@@ -241,10 +243,10 @@ files:
 - lib/rainbows/sendfile.rb
 - lib/rainbows/server_token.rb
 - lib/rainbows/stream_file.rb
-- lib/rainbows/tee_input.rb
 - lib/rainbows/thread_pool.rb
 - lib/rainbows/thread_spawn.rb
 - lib/rainbows/thread_timeout.rb
+- lib/rainbows/timed_read.rb
 - lib/rainbows/writer_thread_pool.rb
 - lib/rainbows/writer_thread_spawn.rb
 - local.mk.sample

data/lib/rainbows/tee_input.rb

@@ -1,18 +0,0 @@
-# -*- encoding: binary -*-
-# :enddoc:
-module Rainbows
-
-  # acts like tee(1) on an input input to provide a input-like stream
-  # while providing rewindable semantics through a File/StringIO
-  # backing store.  On the first pass, the input is only read on demand
-  # so your Rack application can use input notification (upload progress
-  # and like).  This should fully conform to the Rack::InputWrapper
-  # specification on the public API.  This class is intended to be a
-  # strict interpretation of Rack::InputWrapper functionality and will
-  # not support any deviations from it.
-  class TeeInput < Unicorn::TeeInput
-
-    # empty class, this is to avoid unecessarily modifying Unicorn::TeeInput
-    # when MaxBody::Limit is included
-  end
-end