long_body 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 919ec90f6d67ef12a71c59222abc33cfb7c48256
+  data.tar.gz: 3ba12c21e137a5ecf7351c36a2c03dfdac80b536
+SHA512:
+  metadata.gz: 9947da48ea520ee2a2f5d7d73e103f0264853ce10ae868624d835f61097a78979d6e7c5be1385dfe0a51554e4da22920944c98c6990fcd4f75417b193e37fefc
+  data.tar.gz: 6fcb2f4830d5cc4be8ad2fce1c9c5f899a65423e30d37e3e24b1cfc87d8052bda8e9c24c507d411e7a6a4bb247478dd4a34fc58e6bc6fdf40239d24891edf669

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+gem 'rack', '~> 1'
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem 'thin', '~> 1.6'
+  gem 'puma', '~> 2', '>= 2.13.4'
+  gem "rspec", "~> 3.2", '< 3.3' # 3.3 does not work nicely with TextMate ATM
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.0.1"
+  gem "simplecov", ">= 0"
+  gem 'retriable'
+  gem 'passenger', '~> 5'
+  gem 'rainbows'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Julik Tarkhanov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# long_body
+
+Universal Rack middleware for immediate (after-headers) streaming of long Rack response bodies.
+Normally most Rack handler webservers will buffer your entire response, or buffer your response
+without telling you for some time before sending it.
+
+This module provides a universal wrapper that will use the features of a specific webserver
+to send your response with as little buffering as possible (direct to socket). For decent
+servers that allow `rack.hijack` it will use that, for Thin it will use deferrables.
+
+Note that within Thin sleeping in a long body might block the EM loop.
+
+## Usage examples
+
+Server-sent events combined with `Transfer-Encoding: chunked` (can be used for chat applications and so forth):
+
+    class EventSource
+      def each
+        20.times do | event_num |
+          yield "event: ping\n"
+          yield "data: ping_number_#{event_num}"
+          yield "\n\n"
+          sleep 3
+        end
+      end
+    end
+    
+    # config.ru
+    use LongBody
+    use Rack::Chunked
+    run ->(env) {
+      h = {'Content-Type' => 'text/event-stream'}
+      [200, h, EventSource.new]
+    }
+
+Streaming a large file, without buffering:
+
+    # config.ru
+    use LongBody
+    run ->(env) {
+      s = File.size("/tmp/large_file.bin")
+      h = {'Content-Length' => s}
+      [200, h, File.open(s, 'rb')]
+    }
+
+## Compatibility
+
+This gem is tested on Ruby 2.2, and should run acceptably well on Ruby 2.+. If you are using Thin you have to
+use Ruby 2.+ because of the fiber stack size limitation. If you are using Puma, Rainbows or other threaded
+server running this gem on 1.9.2 should be possible as well.
+
+<table>
+  <tr><th>Webserver</th><th>Version tested</th><th>Compatibility</th></tr>
+  <tr><td>Puma</td><td>2.13.4</td><td>Yes (use versions >= 2.13.4 due to a bug)</td></tr>
+  <tr><td>Passenger</td><td>5.0.15</td><td>Yes</td></tr>
+  <tr><td>Thin</td><td>1.6.3</td><td>Yes</td></tr>
+  <tr><td>Rainbows</td><td>4.6.2</td><td>Yes</td></tr>
+  <tr><td>WEBrick</td><td>stdlib 2.2.1</td><td>No (uses IO.pipe for hijack)</td></tr>
+</table>
+
+## Contributing to long_body
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2015 Julik Tarkhanov. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+require_relative 'lib/long_body/version'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "long_body"
+  gem.homepage = "http://github.com/julik/long_body"
+  gem.license = "MIT"
+  gem.summary = %Q{Direct-to-socket streaming of Rack response bodies}
+  gem.description = %Q{Direct-to-socket streaming of Rack response bodies}
+  gem.version = LongBody::VERSION
+  gem.email = "me@julik.nl"
+  gem.authors = ["Julik Tarkhanov"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "long_body #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/long_body/deferrable_body.rb

@@ -0,0 +1,32 @@
+# Lifted from https://github.com/macournoyer/thin_async/blob/master/lib/thin/async.rb
+# and originally written by James Tucker <raggi@rubyforge.org>
+class LongBody::DeferrableBody
+  include EM::Deferrable
+
+  def initialize
+    @queue = []
+  end
+
+  def call(body)
+    @queue << body
+    schedule_dequeue
+  end
+
+  def each(&blk)
+    @body_callback = blk
+    schedule_dequeue
+  end
+
+  private
+  
+  def schedule_dequeue
+    return unless @body_callback
+    EM.next_tick do
+      next unless body = @queue.shift
+      body.each do |chunk|
+        @body_callback.call(chunk)
+      end
+      schedule_dequeue unless @queue.empty?
+    end
+  end
+end

data/lib/long_body/hijack_handler.rb

@@ -0,0 +1,54 @@
+# The problem with fast each() bodies is that the Ruby process will
+# enter a busy wait if the write socket for the webserver is saturated.
+#
+# We can bypass that by releasing the CPU using a select(), but for that
+# we have to use "rack.hijack" in combination with a nonblocking write.
+#
+# For more on this:
+# http://apidock.com/ruby/IO/write_nonblock
+# http://old.blog.phusion.nl/2013/01/23/the-new-rack-socket-hijacking-api/
+#
+# By using this class as a middleware you will put a select() wait
+# spinlock on the output socket of the webserver.
+#
+# The middleware will only trigger for 200 and 206 responses, and only
+# if the Rack handler it is running on supports rack hijacking.
+module LongBody::HijackHandler
+  extend self
+  HIJACK_HEADER = 'rack.hijack'.freeze
+  
+  def perform(env, s, h, b)
+    # Replace the output with our socket moderating technology 2.0
+    h[HIJACK_HEADER] = create_socket_writer_lambda_with_body(b)
+    [s, h, []] # Recommended response body for partial hijack is an empty Array
+  end
+  
+  def create_socket_writer_lambda_with_body(rack_response_body)
+    lambda do |socket|
+      begin
+        rack_response_body.each do | chunk |
+          begin
+            num_bytes_written = socket.write_nonblock(chunk)
+            # If we could write only partially, make sure we do a retry on the next
+            # iteration with the remaining part
+            if num_bytes_written < chunk.bytesize
+              chunk = chunk[num_bytes_written..-1]
+              raise Errno::EINTR
+            end
+          rescue IO::WaitWritable, Errno::EINTR # The output socket is saturated.
+            # If we are running within a threaded server, 
+            # let another thread preempt here. We are waiting for IO
+            # and some other thread might have things to do here.
+            IO.select(nil, [socket]) # ...then wait on the socket to be writable again
+            retry # and off we go...
+          rescue Errno::EPIPE, Errno::EPROTOTYPE # Happens when the client aborts the connection
+            return
+          end
+        end
+      ensure
+        rack_response_body.close if rack_response_body.respond_to?(:close)
+        socket.close if socket.respond_to?(:closed?) && socket.respond_to?(:close) && !socket.closed?
+      end
+    end
+  end
+end

data/lib/long_body/lint_bypass.rb

@@ -0,0 +1,14 @@
+# Rack::Lint bails on async.callback responses. "Fix" it to bypass
+# if running within Thin and when async.callback is available.
+module Rack
+  class Lint
+    THIN_RE = /^thin/.freeze
+    def call(env=nil)
+      if env && env['async.callback'] && env['SERVER_SOFTWARE'].to_s =~ THIN_RE
+        @app.call(env)
+      else
+        dup._call(env)
+      end
+    end
+  end
+end

data/lib/long_body/thin_handler.rb

@@ -0,0 +1,114 @@
+# Turns an iterable Rack response body that responds to each() into
+# something that Thin can use within EventMachine. Uses internal Thin
+# interfaces so not applicable for other servers.
+module LongBody::ThinHandler
+  extend self
+  
+  AsyncResponse = [-1, {}, []].freeze
+
+  # A wrapper that allows us to access an object that yields from each()
+  # as if it were an Enumerator-ish object.
+  #
+  #   arr = %w( a b )
+  #   w = FiberWrapper.new(arr)
+  #   w.take #=> 'a'
+  #   w.take #=> 'b'
+  #   w.take #=> nil # Ended
+  class FiberWrapper
+    def initialize(eachable)
+      @fiber = Fiber.new do
+        eachable.each{|chunk| Fiber.yield(chunk.to_s) }
+        eachable.close if eachable.respond_to?(:close)
+        nil
+      end
+    end
+    
+    def take
+      @fiber.resume
+    rescue FiberError
+      nil
+    end
+  end
+  
+  # Controls the scheduling of the trickle-feed using EM.next_tick.
+  class ResponseSender
+    attr_reader :deferrable_body
+    def initialize(eachable_body)
+      require_relative 'deferrable_body'
+      require_relative 'lint_bypass'
+      @eachable_body = eachable_body
+      @enumerator = FiberWrapper.new(eachable_body)
+      @deferrable_body = LongBody::DeferrableBody.new
+    end
+    
+    def abort!
+      @eachable_body.abort!
+      @deferrable_body.fail
+    end
+    
+    def send_next_chunk
+      next_chunk = begin
+        @enumerator.take
+      rescue StandardError => e
+        abort!
+      end
+      
+      if next_chunk
+        @deferrable_body.call([next_chunk]) # Has to be given in an Array
+        EM.next_tick { send_next_chunk }
+      else
+        @deferrable_body.succeed
+      end
+    end
+  end
+  
+  # We need a way to raise from each() when the connection
+  # is closed prematurely.
+  class BodyWrapperWithExplicitClose
+    def abort!
+      @aborted = true; close
+    end
+    
+    def close
+      @rack_body.close if @rack_body.respond_to?(:close)
+    end
+    
+    def initialize(rack_body)
+      @rack_body = rack_body
+    end
+    
+    def each
+      @rack_body.each do | bytes |
+        # Break the body out of the loop if the response is aborted (client disconnect)
+        raise "Disconnect or connection close" if @aborted
+        yield(bytes)
+      end
+    end
+  end
+  
+  C_async_close = 'async.close'.freeze
+  C_async_callback = 'async.callback'.freeze
+  
+  def perform(env, s, h, b)
+    # Wrap in a handler that will raise from within each() 
+    # if async.close is triggered while the response is dripping by
+    b = BodyWrapperWithExplicitClose.new(b)
+    
+    # Wrap in a handler that manages the DeferrableBody
+    sender = ResponseSender.new(b)
+    
+    # Abort the body sending on both of those.
+    env[C_async_close].callback { sender.abort! }
+    env[C_async_close].errback { sender.abort! }
+    env[C_async_callback].call([s, h, sender.deferrable_body])
+    sender.send_next_chunk
+    
+    AsyncResponse # Let Thin know we are using async.*
+  end
+  
+  private
+  
+  def running_with_thin?(env)
+    defined?(Thin) && env[C_async_callback] && env[C_async_callback].respond_to?(:call)
+  end
+end

data/lib/long_body/version.rb

@@ -0,0 +1,3 @@
+class LongBody
+  VERSION = '0.0.1'
+end

data/lib/long_body.rb

@@ -0,0 +1,73 @@
+# The base middleware class to use in your Rack application, Sinatra, Rails etc.
+#
+#    use LongBody
+#
+# Note that if you want to use Rack::Chunked (and you most likely do) you have to insert it
+# below LongBody:
+#
+#    use LongBody
+#    use Rack::Chunked
+class LongBody
+  
+  require_relative 'long_body/version'
+  require_relative 'long_body/thin_handler'
+  require_relative 'long_body/hijack_handler'
+  
+  class MisconfiguredBody < StandardError
+    def message
+      "Either Transfer-Encoding: chunked or Content-Length: <digits> must be set. " +
+      "If uncertain, insert Rack::ContentLength into your middleware chain to set Content-Length " +
+      "for all responses that do not pre-specify it, and Rack::Chunked to apply chunked encoding " +
+      "to all responses of unknown length"
+    end
+  end
+  
+  STREAMABLE_CODES = [200, 206]
+  
+  def status_might_have_streamable_body?(status_code)
+    STREAMABLE_CODES.include?(status_code.to_i)
+  end
+  
+  def ensure_chunked_or_content_length!(header_hash)
+    unless header_hash['Transfer-Encoding'] == 'chunked' || header_hash['Content-Length']
+      raise MisconfiguredBody
+    end
+  end
+  
+  def initialize(app)
+    @app = app
+  end
+  
+  C_rack_logger = 'rack.logger'.freeze
+  HIJACK_SUPPORTED = 'rack.hijack?'.freeze
+  ASYNC_SUPPORT = 'async.callback'.freeze
+  
+  def call(env)
+    # Call the upstream first
+    s, h, b = @app.call(env)
+    
+    # If the response has nothing to do with the streaming response, just
+    # let it go through as it is not big enough to bother. Also if there is no hijack
+    # support there is no sense to bother at all.
+    return [s, h, b] unless status_might_have_streamable_body?(s)
+    
+    # If the body is nil or is not each-able, return the original response - there probably is some other
+    # async trickery going on downstream from us, and we should not intercept this response.
+    return [s, h, b] if (b.nil? || !b.respond_to?(:each) || (b.respond_to?(:empty?) && b.empty?))
+    
+    # Ensure either Content-Length or chunking is in place
+    ensure_chunked_or_content_length!(h)
+    
+    # TODO: ensure not already hijacked
+    
+    if env[ASYNC_SUPPORT]
+      env[C_rack_logger].info("Streaming via async.callback (Thin)") if env[C_rack_logger].respond_to?(:info)
+      ThinHandler.perform(env, s, h, b)
+    elsif env[HIJACK_SUPPORTED]
+      env[C_rack_logger].info("Streaming via hijack and IO.select") if env[C_rack_logger].respond_to?(:info)
+      HijackHandler.perform(env, s, h, b)
+    else
+      [s, h, b] # No recourse
+    end
+  end
+end

data/long_body.gemspec

@@ -0,0 +1,89 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: long_body 0.0.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "long_body"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Julik Tarkhanov"]
+  s.date = "2015-08-29"
+  s.description = "Direct-to-socket streaming of Rack response bodies"
+  s.email = "me@julik.nl"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "lib/long_body.rb",
+    "lib/long_body/deferrable_body.rb",
+    "lib/long_body/hijack_handler.rb",
+    "lib/long_body/lint_bypass.rb",
+    "lib/long_body/thin_handler.rb",
+    "lib/long_body/version.rb",
+    "long_body.gemspec",
+    "spec/long_body_spec.rb",
+    "spec/shared_webserver_examples.rb",
+    "spec/spec_helper.rb",
+    "spec/streaming_app.ru",
+    "spec/support/server_runners.rb",
+    "spec/test_download.rb"
+  ]
+  s.homepage = "http://github.com/julik/long_body"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.2"
+  s.summary = "Direct-to-socket streaming of Rack response bodies"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rack>, ["~> 1"])
+      s.add_development_dependency(%q<thin>, ["~> 1.6"])
+      s.add_development_dependency(%q<puma>, [">= 2.13.4", "~> 2"])
+      s.add_development_dependency(%q<rspec>, ["< 3.3", "~> 3.2"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<retriable>, [">= 0"])
+      s.add_development_dependency(%q<passenger>, ["~> 5"])
+      s.add_development_dependency(%q<rainbows>, [">= 0"])
+    else
+      s.add_dependency(%q<rack>, ["~> 1"])
+      s.add_dependency(%q<thin>, ["~> 1.6"])
+      s.add_dependency(%q<puma>, [">= 2.13.4", "~> 2"])
+      s.add_dependency(%q<rspec>, ["< 3.3", "~> 3.2"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<retriable>, [">= 0"])
+      s.add_dependency(%q<passenger>, ["~> 5"])
+      s.add_dependency(%q<rainbows>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rack>, ["~> 1"])
+    s.add_dependency(%q<thin>, ["~> 1.6"])
+    s.add_dependency(%q<puma>, [">= 2.13.4", "~> 2"])
+    s.add_dependency(%q<rspec>, ["< 3.3", "~> 3.2"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<retriable>, [">= 0"])
+    s.add_dependency(%q<passenger>, ["~> 5"])
+    s.add_dependency(%q<rainbows>, [">= 0"])
+  end
+end
+

data/spec/long_body_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require_relative 'test_download'
+require 'retriable'
+require_relative 'shared_webserver_examples'
+
+describe "LongBody" do
+  SERVERS.each do | server_engine |
+    context "on #{server_engine.name}" do
+      it_behaves_like "compliant"
+    end
+  end
+end

data/spec/shared_webserver_examples.rb

@@ -0,0 +1,61 @@
+RSpec.shared_examples "compliant" do
+  it "when the response is sent in full works with predefined Content-Length" do | example |
+    parts = TestDownload.perform("http://0.0.0.0:9393/with-content-length")
+    timings = parts.map(&:time_difference)
+    
+#   $postrun.puts ""
+#   $postrun.puts "#{example.full_description} part receive timings: #{timings.inspect}"
+#   $postrun.puts ""
+
+    expect(File).to exist('/tmp/streamer_close.mark')
+  
+    # Ensure the time recieved of each part is within the tolerances, and certainly
+    # at least 1 second after the previous
+    (1..(parts.length-1)).each do | part_i|
+      this_part = parts[part_i]
+      previous_part = parts[part_i -1]
+      received_after_previous = this_part.time_difference - previous_part.time_difference
+      
+      # Ensure there was some time before this chunk arrived. This is the most important test.
+      expect(received_after_previous).to be_within(1).of(0.3)
+    end
+  end
+
+  it 'when the response is sent in full works with chunked encoding' do | example |
+    parts = TestDownload.perform("http://0.0.0.0:9393/chunked")
+    timings = parts.map(&:time_difference)
+    
+#    $postrun.puts example.full_description
+#    $postrun.puts "Part receive timings: #{timings.inspect}"
+#    $postrun.puts ""
+    
+    expect(File).to exist('/tmp/streamer_close.mark')
+  
+    (1..(parts.length-1)).each do | part_i|
+      this_part = parts[part_i]
+      previous_part = parts[part_i -1]
+      received_after_previous = this_part.time_difference - previous_part.time_difference
+      
+      # Ensure there was some time before this chunk arrived. This is the most important test.
+      expect(received_after_previous).to be_within(1).of(0.3)
+    end
+  end
+
+  it 'when the HTTP client process is killed midflight, does not read more chunks from the body object' do
+    # This test checks whether the server makes the iterable body complete if the client closes the connection
+    # prematurely. If you have the callbacks set up wrong on Thin, for instance, it will read the response
+    # completely and potentially buffer it in memory, filling up your RAM. We need to ensure that the server
+    # uses it's internal mechanics to stop reading the body once the client is dropped.
+    pid = fork do
+      TestDownload.perform("http://0.0.0.0:9393/with-content-length")
+    end
+    sleep(1)
+    Process.kill("KILL", pid)
+    
+    written_parts_list = File.read("/tmp/streamer_messages.log").split("\n")
+    expect(written_parts_list.length).to be < 6
+    
+    expect(File).to exist('/tmp/streamer_close.mark')
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'long_body'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.order = 'random'
+  config.before :suite do
+    $postrun = StringIO.new
+    $postrun << "\n\n"
+    
+    SERVERS.each(&:start!)
+    
+    sleep 0.5 until SERVERS.all?(&:running?)
+  end
+  
+  config.before :each do
+    FileUtils.rm('/tmp/streamer_messages.log') if File.exist?('/tmp/streamer_messages.log')
+    FileUtils.rm('/tmp/streamer_close.log') if File.exist?('/tmp/streamer_close.log')
+  end
+  
+  config.after :suite do
+    SERVERS.each(&:stop!)
+    puts $postrun.string
+  end
+end

data/spec/streaming_app.ru

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/long_body')
+
+require 'fileutils'
+# The test app
+class Streamer
+  
+  class TestBody
+    def each
+      File.open("/tmp/streamer_messages.log", "w") do |f|
+        25.times do |i|
+          sleep 0.3
+          yield "Message number #{i}"
+          f.puts(i)
+          f.flush # Make sure it is on disk
+        end
+      end
+    end
+    
+    def close
+      FileUtils.touch('/tmp/streamer_close.mark')
+    end
+  end
+  
+  def self.call(env)
+    # The absence of Content-Length will trigger Rack::Chunking into work automatically.
+    [200, {'Content-Type' => 'text/plain'}, TestBody.new]
+  end
+end
+
+class StreamerWithLength < Streamer
+  def self.call(env)
+    s, h, b = super
+    [s, h.merge('Content-Length' => '415'), b]
+  end
+end
+
+map '/chunked' do
+  use LongBody
+  use Rack::Chunked
+  run Streamer
+end
+
+map '/with-content-length' do
+  use LongBody
+  run StreamerWithLength
+end
+
+map '/alive' do
+  run ->(env) { [200, {}, ['Yes']]}
+end

data/spec/support/server_runners.rb

@@ -0,0 +1,61 @@
+TEST_RACK_APP = File.join(File.dirname(File.expand_path(__FILE__)), '..', 'streaming_app.ru')
+
+class RunningServer < Struct.new(:name, :command, :port)
+  def command
+    super % [port, TEST_RACK_APP]
+  end
+   
+  def start!
+    # Boot Puma in a forked process
+    full_path = File.join(File.dirname(File.expand_path(__FILE__)), 'streaming_app.ru')
+    @pid = fork do
+      puts "Spinning up with #{command.inspect}"
+      # Do not pollute the RSpec output with the Puma logs, save the stuff
+      # to the logfiles instead
+      $stdout.reopen(File.open('%s_output.log' % name, 'a'))
+      $stderr.reopen(File.open('%s_output.log' % name, 'a'))
+      
+      # Since we have to do with timing tolerances, having the output drip in ASAP is useful
+      $stdout.sync = true
+      $stderr.sync = true
+      exec(command)
+    end
+    
+    Thread.new do
+      # Wait for Puma to be online, poll the alive URL until it stops responding
+      loop do
+        sleep 0.5
+        begin
+          this_server_url = "http://0.0.0.0:%d/alive" % port
+          TestDownload.perform(this_server_url)
+          puts "#{name} is alive!"
+          @running = true
+          break
+        rescue Errno::ECONNREFUSED
+        end
+      end
+    end
+    
+    trap("TERM") { stop! }
+  end
+  
+  def running?
+    !!@running
+  end
+  
+  def stop!
+    return unless @pid
+    
+    # Tell the webserver to quit, twice (we do not care if there are running responses)
+    %W( TERM TERM KILL ).each {|sig| Process.kill(sig, @pid); sleep 0.5 }
+    @pid = nil
+  end
+end
+
+SERVERS = [
+  RunningServer.new(:puma, "bundle exec puma --port %d %s", 9393),
+  RunningServer.new(:thin, "bundle exec thin --port %d --rackup %s start", 9394),
+  RunningServer.new(:rainbows, "bundle exec rainbows --port %d %s", 9395),
+  RunningServer.new(:passenger, "bundle exec passenger start  --port %d --rackup %s", 9396),
+]
+

data/spec/test_download.rb

@@ -0,0 +1,42 @@
+module TestDownload
+  extend self
+  Part = Struct.new(:time_difference, :payload)
+  def perform(uri)
+    response_chunks = []
+    uri = URI(uri.to_s)
+    conn = Net::HTTP.new(uri.host, uri.port)
+    conn.read_timeout = 120 # Might take LONG
+    conn.start do |http|
+      req = Net::HTTP::Get.new(uri.request_uri)
+      before_first = Time.now
+      http.request(req) do |res|
+        res.read_body do |chunk|
+          diff = (Time.now - before_first).to_f
+          response_chunks << Part.new(diff, chunk)
+        end
+      end
+    end
+    response_chunks
+  end
+  
+  def perform_and_abort_after_3_chunks(uri)
+    response_chunks = []
+    catch :abort do
+      uri = URI(uri.to_s)
+      conn = Net::HTTP.new(uri.host, uri.port)
+      conn.read_timeout = 120 # Might take LONG
+      conn.start do |http|
+        req = Net::HTTP::Get.new(uri.request_uri)
+        before_first = Time.now.to_i
+        http.request(req) do |res|
+          res.read_body do |chunk|
+            diff = Time.now.to_i - before_first
+            response_chunks << Part.new(diff, chunk)
+            throw :abort if response_chunks.length == 3
+          end
+        end
+      end
+    end
+    response_chunks
+  end
+end

metadata

@@ -0,0 +1,230 @@
+--- !ruby/object:Gem::Specification
+name: long_body
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.4
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.4
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: retriable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: passenger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: rainbows
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Direct-to-socket streaming of Rack response bodies
+email: me@julik.nl
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/long_body.rb
+- lib/long_body/deferrable_body.rb
+- lib/long_body/hijack_handler.rb
+- lib/long_body/lint_bypass.rb
+- lib/long_body/thin_handler.rb
+- lib/long_body/version.rb
+- long_body.gemspec
+- spec/long_body_spec.rb
+- spec/shared_webserver_examples.rb
+- spec/spec_helper.rb
+- spec/streaming_app.ru
+- spec/support/server_runners.rb
+- spec/test_download.rb
+homepage: http://github.com/julik/long_body
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Direct-to-socket streaming of Rack response bodies
+test_files: []