rainbows 0.5.0 → 0.6.0

data/lib/rainbows/rev.rb

@@ -1,6 +1,7 @@
 # -*- encoding: binary -*-
-require 'rainbows/rev/heartbeat'
-require 'rainbows/ev_core'
+require 'rainbows/rev/core'
+require 'rainbows/rev/client'
+require 'rainbows/rev/deferred_response'
 
 module Rainbows
 
@@ -23,161 +24,6 @@ module Rainbows
   # temporary file before the application is entered.
 
   module Rev
-
-    include Base
-
-    class Client < ::Rev::IO
-      include Rainbows::EvCore
-      G = Rainbows::G
-
-      def initialize(io)
-        G.cur += 1
-        super(io)
-        post_init
-        @deferred_bodies = [] # for (fast) regular files only
-      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
-      # here to prevent connections from being closed on us.
-      def defer_body(io)
-        @deferred_bodies << io
-        on_write_complete unless @hp.headers? # triggers a write
-      end
-
-      def app_call
-        begin
-          (@env[RACK_INPUT] = @input).rewind
-          alive = @hp.keepalive?
-          @env[REMOTE_ADDR] = @remote_addr
-          response = G.app.call(@env.update(RACK_DEFAULTS))
-          alive &&= G.alive
-          out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if @hp.headers?
-
-          DeferredResponse.write(self, response, out)
-          if alive
-            @env.clear
-            @hp.reset
-            @state = :headers
-            # keepalive requests are always body-less, so @input is unchanged
-            @hp.headers(@env, @buf) and next
-          else
-            quit
-          end
-          return
-        end while true
-      end
-
-      def on_write_complete
-        if body = @deferred_bodies.first
-          return if DeferredResponse === body
-          begin
-            begin
-              write(body.sysread(CHUNK_SIZE))
-            rescue EOFError # expected at file EOF
-              @deferred_bodies.shift
-              body.close
-              close if :close == @state && @deferred_bodies.empty?
-            end
-          rescue Object => e
-            handle_error(e)
-          end
-        else
-          close if :close == @state
-        end
-      end
-
-      def on_close
-        G.cur -= 1
-      end
-    end
-
-    class Server < ::Rev::IO
-      G = Rainbows::G
-
-      def on_readable
-        return if G.cur >= G.max
-        begin
-          Client.new(@_io.accept_nonblock).attach(::Rev::Loop.default)
-        rescue Errno::EAGAIN, Errno::ECONNABORTED
-        end
-      end
-
-    end
-
-    class DeferredResponse < ::Rev::IO
-      include Unicorn
-      include Rainbows::Const
-      G = Rainbows::G
-
-      def self.defer!(client, response, out)
-        body = response.last
-        headers = Rack::Utils::HeaderHash.new(response[1])
-
-        # to_io is not part of the Rack spec, but make an exception
-        # here since we can't get here without checking to_path first
-        io = body.to_io if body.respond_to?(:to_io)
-        io ||= ::IO.new($1.to_i) if body.to_path =~ %r{\A/dev/fd/(\d+)\z}
-        io ||= File.open(body.to_path, 'rb')
-        st = io.stat
-
-        if st.socket? || st.pipe?
-          do_chunk = !!(headers['Transfer-Encoding'] =~ %r{\Achunked\z}i)
-          do_chunk = false if headers.delete('X-Rainbows-Autochunk') == 'no'
-          # too tricky to support keepalive/pipelining when a response can
-          # take an indeterminate amount of time here.
-          if out.nil?
-            do_chunk = false
-          else
-            out[0] = CONN_CLOSE
-          end
-
-          io = new(io, client, do_chunk, body).attach(::Rev::Loop.default)
-        elsif st.file?
-          headers.delete('Transfer-Encoding')
-          headers['Content-Length'] ||= st.size.to_s
-        else # char/block device, directory, whatever... nobody cares
-          return response
-        end
-        client.defer_body(io)
-        [ response.first, headers.to_hash, [] ]
-      end
-
-      def self.write(client, response, out)
-        response.last.respond_to?(:to_path) and
-          response = defer!(client, response, out)
-        HttpResponse.write(client, response, out)
-      end
-
-      def initialize(io, client, do_chunk, body)
-        super(io)
-        @client, @do_chunk, @body = client, do_chunk, body
-      end
-
-      def on_read(data)
-        @do_chunk and @client.write(sprintf("%x\r\n", data.size))
-        @client.write(data)
-        @do_chunk and @client.write("\r\n")
-      end
-
-      def on_close
-        @do_chunk and @client.write("0\r\n\r\n")
-        @client.quit
-        @body.respond_to?(:close) and @body.close
-      end
-    end
-
-    # runs inside each forked worker, this sits around and waits
-    # for connections and doesn't die until the parent dies (or is
-    # given a INT, QUIT, or TERM signal)
-    def worker_loop(worker)
-      init_worker_process(worker)
-      rloop = ::Rev::Loop.default
-      Heartbeat.new(worker.tmp).attach(rloop)
-      LISTENERS.map! { |s| Server.new(s).attach(rloop) }
-      rloop.run
-    end
-
+    include Core
   end
 end

data/lib/rainbows/rev/client.rb

@@ -0,0 +1,73 @@
+# -*- encoding: binary -*-
+require 'rainbows/ev_core'
+module Rainbows
+  module Rev
+
+    class Client < ::Rev::IO
+      include Rainbows::EvCore
+      G = Rainbows::G
+
+      def initialize(io)
+        G.cur += 1
+        super(io)
+        post_init
+        @deferred_bodies = [] # for (fast) regular files only
+      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
+      # here to prevent connections from being closed on us.
+      def defer_body(io, out_headers)
+        @deferred_bodies << io
+        schedule_write unless out_headers # triggers a write
+      end
+
+      def app_call
+        begin
+          (@env[RACK_INPUT] = @input).rewind
+          @env[REMOTE_ADDR] = @remote_addr
+          response = APP.call(@env.update(RACK_DEFAULTS))
+          alive = @hp.keepalive? && G.alive
+          out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if @hp.headers?
+
+          DeferredResponse.write(self, response, out)
+          if alive
+            @env.clear
+            @hp.reset
+            @state = :headers
+            # keepalive requests are always body-less, so @input is unchanged
+            @hp.headers(@env, @buf) and next
+          else
+            quit
+          end
+          return
+        end while true
+      end
+
+      def on_write_complete
+        if body = @deferred_bodies.first
+          return if DeferredResponse === body
+          begin
+            begin
+              write(body.sysread(CHUNK_SIZE))
+            rescue EOFError # expected at file EOF
+              @deferred_bodies.shift
+              body.close
+              close if :close == @state && @deferred_bodies.empty?
+            end
+          rescue => e
+            handle_error(e)
+          end
+        else
+          close if :close == @state
+        end
+      end
+
+      def on_close
+        G.cur -= 1
+      end
+
+    end # module Client
+  end # module Rev
+end # module Rainbows

data/lib/rainbows/rev/core.rb

@@ -0,0 +1,42 @@
+# -*- encoding: binary -*-
+require 'rev'
+Rev::VERSION >= '0.3.0' or abort 'rev >= 0.3.0 is required'
+require 'rainbows/rev/heartbeat'
+
+module Rainbows
+  module Rev
+    class Server < ::Rev::IO
+      G = Rainbows::G
+      LOOP = ::Rev::Loop.default
+      # CL and MAX will be defined in the corresponding worker loop
+
+      def on_readable
+        return if G.cur >= MAX
+        begin
+          CL.new(@_io.accept_nonblock).attach(LOOP)
+        rescue Errno::EAGAIN, Errno::ECONNABORTED
+        end
+      end
+    end # class Server
+
+    module Core
+      include Base
+
+      # runs inside each forked worker, this sits around and waits
+      # for connections and doesn't die until the parent dies (or is
+      # given a INT, QUIT, or TERM signal)
+      def worker_loop(worker)
+        init_worker_process(worker)
+        mod = self.class.const_get(@use)
+        Server.const_set(:MAX, @worker_connections)
+        Server.const_set(:CL, mod.const_get(:Client))
+        EvCore.setup(EvCore)
+        rloop = ::Rev::Loop.default
+        Heartbeat.new(1, true).attach(rloop)
+        LISTENERS.map! { |s| Server.new(s).attach(rloop) }
+        rloop.run
+      end
+
+    end # module Core
+  end # module Rev
+end # module Rainbows

data/lib/rainbows/rev/deferred_response.rb

@@ -0,0 +1,74 @@
+# -*- encoding: binary -*-
+module Rainbows
+  module Rev
+
+    # this is class is specific to Rev for writing large static files
+    # or proxying IO-derived objects
+    class DeferredResponse < ::Rev::IO
+      include Unicorn
+      include Rainbows::Const
+      G = Rainbows::G
+      HH = Rack::Utils::HeaderHash
+
+      # we only want to attach to the Rev::Loop belonging to the
+      # main thread in Ruby 1.9
+      LOOP = ::Rev::Loop.default
+
+      def self.defer!(client, response, out)
+        body = response.last
+        headers = HH.new(response[1])
+
+        # to_io is not part of the Rack spec, but make an exception
+        # here since we can't get here without checking to_path first
+        io = body.to_io if body.respond_to?(:to_io)
+        io ||= ::IO.new($1.to_i) if body.to_path =~ %r{\A/dev/fd/(\d+)\z}
+        io ||= File.open(body.to_path, 'rb')
+        st = io.stat
+
+        if st.socket? || st.pipe?
+          do_chunk = !!(headers['Transfer-Encoding'] =~ %r{\Achunked\z}i)
+          do_chunk = false if headers.delete('X-Rainbows-Autochunk') == 'no'
+          # too tricky to support keepalive/pipelining when a response can
+          # take an indeterminate amount of time here.
+          if out.nil?
+            do_chunk = false
+          else
+            out[0] = CONN_CLOSE
+          end
+
+          io = new(io, client, do_chunk, body).attach(LOOP)
+        elsif st.file?
+          headers.delete('Transfer-Encoding')
+          headers['Content-Length'] ||= st.size.to_s
+        else # char/block device, directory, whatever... nobody cares
+          return response
+        end
+        client.defer_body(io, out)
+        [ response.first, headers.to_hash, [] ]
+      end
+
+      def self.write(client, response, out)
+        response.last.respond_to?(:to_path) and
+          response = defer!(client, response, out)
+        HttpResponse.write(client, response, out)
+      end
+
+      def initialize(io, client, do_chunk, body)
+        super(io)
+        @client, @do_chunk, @body = client, do_chunk, body
+      end
+
+      def on_read(data)
+        @do_chunk and @client.write(sprintf("%x\r\n", data.size))
+        @client.write(data)
+        @do_chunk and @client.write("\r\n")
+      end
+
+      def on_close
+        @do_chunk and @client.write("0\r\n\r\n")
+        @client.quit
+        @body.respond_to?(:close) and @body.close
+      end
+    end # class DeferredResponse
+  end # module Rev
+end # module Rainbows

data/lib/rainbows/rev/heartbeat.rb

@@ -1,7 +1,4 @@
 # -*- encoding: binary -*-
-require 'rev'
-Rev::VERSION >= '0.3.0' or abort 'rev >= 0.3.0 is required'
-
 module Rainbows
   module Rev
 
@@ -11,15 +8,9 @@ module Rainbows
     # will also detect and execute the graceful exit if triggered
     # by SIGQUIT
     class Heartbeat < ::Rev::TimerWatcher
-      # +tmp+ must be a +File+ that responds to +chmod+
-      def initialize(tmp)
-        @m, @tmp = 0, tmp
-        super(1, true)
-      end
 
       def on_timer
-        @tmp.chmod(@m = 0 == @m ? 1 : 0)
-        exit if (! G.alive && G.cur <= 0)
+        exit if (! G.tick && G.cur <= 0)
       end
 
     end

data/lib/rainbows/rev_thread_spawn.rb

@@ -0,0 +1,94 @@
+# -*- encoding: binary -*-
+require 'rainbows/rev'
+require 'rainbows/ev_thread_core'
+
+warn "Rainbows::RevThreadSpawn is extremely experimental"
+
+module Rainbows
+
+  # This concurrency model is EXTREMELY experimental and does
+  # not perform very well.
+  #
+  # A combination of the Rev and ThreadSpawn models.  This allows Ruby
+  # 1.8 and 1.9 to effectively serve more than ~1024 concurrent clients
+  # on systems that support kqueue or epoll while still using
+  # Thread-based concurrency for application processing.  It exposes
+  # Unicorn::TeeInput for a streamable "rack.input" for upload
+  # processing within the app.  Threads are spawned immediately after
+  # header processing is done for calling the application.  Rack
+  # applications running under this mode should be thread-safe.
+  # DevFdResponse should be used with this class to proxy asynchronous
+  # responses.  All network I/O between the client and server are
+  # handled by the main thread (even when streaming "rack.input").
+  #
+  # Caveats:
+  #
+  # * TeeInput performance under Ruby 1.8 is terrible unless you
+  #   match the length argument of your env["rack.input"]#read
+  #   calls so that it is greater than or equal to Rev::IO::INPUT_SIZE.
+  #   Most applications depending on Rack to do multipart POST
+  #   processing should be alright as the current Rev::IO::INPUT_SIZE
+  #   of 16384 bytes matches the read size used by
+  #   Rack::Utils::Multipart::parse_multipart.
+
+  module RevThreadSpawn
+    class Client < Rainbows::Rev::Client
+      include EvThreadCore
+      LOOP = ::Rev::Loop.default
+      DR = Rainbows::Rev::DeferredResponse
+      TEE_RESUMER = ::Rev::AsyncWatcher.new
+
+      def pause
+        @lock.synchronize { disable if enabled? }
+      end
+
+      def resume
+        @lock.synchronize { enable unless enabled? }
+        TEE_RESUMER.signal
+      end
+
+      def write(data)
+        if Thread.current != @thread && @lock.locked?
+          # we're being called inside on_writable
+          super
+        else
+          @lock.synchronize { super }
+        end
+      end
+
+      def defer_body(io, out_headers)
+        @lock.synchronize { super }
+      end
+
+      def response_write(response, out)
+        DR.write(self, response, out)
+        (out && CONN_ALIVE == out.first) or
+            @lock.synchronize {
+              quit
+              schedule_write
+            }
+      end
+
+      def on_writable
+        # don't ever want to block in the main loop with lots of clients,
+        # libev is level-triggered so we'll always get another chance later
+        if @lock.try_lock
+          begin
+            super
+          ensure
+            @lock.unlock
+          end
+        end
+      end
+
+    end
+
+    include Rainbows::Rev::Core
+
+    def init_worker_process(worker)
+      super
+      Client::TEE_RESUMER.attach(::Rev::Loop.default)
+    end
+
+  end
+end