Add streaming support.

lib/thin.rb

@@ -11,6 +11,7 @@ module Thin
   autoload :Command,            "thin/command"
   autoload :Connection,         "thin/connection"
   autoload :Daemonizable,       "thin/daemonizing"
+  autoload :FastEnumerator,     "thin/fast_enumerator"
   autoload :Logging,            "thin/logging"
   autoload :Headers,            "thin/headers"
   autoload :Request,            "thin/request"

lib/thin/connection.rb

@@ -102,24 +102,29 @@ def post_process(result)
       @response.persistent! if @request.persistent?
 
       # Send the response
-      @response.each do |chunk|
-        trace { chunk }
-        send_data chunk
+      responder = FastEnumerator.new(@response)
+
+      tick_look = EM.tick_loop do
+        if chunk = responder.next
+          trace chunk
+          send_data chunk
+        else
+          :stop
+        end
+      end
+
+      if @response.body.respond_to?(:callback) && @response.body.respond_to?(:errback)
+        # If the body is being deferred, then terminate afterward.
+        @response.body.callback &method(:terminate_request)
+        @response.body.errback  &method(:terminate_request)
+      else
+        tick_look.on_stop method(:terminate_request)
       end
 
     rescue Exception
       handle_error
       # Close connection since we can't handle response gracefully
       close_connection
-    ensure
-      # If the body is being deferred, then terminate afterward.
-      if @response.body.respond_to?(:callback) && @response.body.respond_to?(:errback)
-        @response.body.callback { terminate_request }
-        @response.body.errback  { terminate_request }
-      else
-        # Don't terminate the response if we're going async.
-        terminate_request unless result && result.first == AsyncResponse.first
-      end
     end
 
     # Logs catched exception and closes the connection.

lib/thin/fast_enumerator.rb

@@ -0,0 +1,40 @@
+require 'fiber' if defined?(Fiber)
+
+module Thin
+  # Turns out Enumerator#next is pretty slow and rolling our own w/ Fibers is a lot faster.
+  # Still not as fast as Enumerable#each but eh...
+  class FastEnumerator
+    if defined?(Fiber)
+
+      def initialize(array)
+        @fiber = Fiber.new do
+          array.each do |i|
+            Fiber.yield i
+          end
+        end
+      end
+
+      def next
+        nil unless @fiber.alive?
+        @fiber.resume
+      end
+
+    else
+
+      # Slow Enumerator based version for Rubies w/ no fibers.
+
+      def initialize(args)
+        @enum = array.each
+      end
+
+      def next
+        begin
+          @enum.next
+        rescue StopIteration
+          nil
+        end
+      end
+
+    end
+  end
+end