rainbows 0.5.0 → 0.6.0

data/FAQ

@@ -48,3 +48,42 @@ It depends on the size and amount of static files you're serving.  If
 you're serving a lot of static files (especially large ones), then by
 all means use nginx.  If not, then \Rainbows! is likely a "good enough"
 solution even if nginx will always outperform it in raw throughput.
+
+
+=== How do I support SSL?
+
+If you need a streaming "rack.input" to do upload processing within your
+Rack application, then {stunnel}[http://stunnel.org/] is required.
+Otherwise, nginx is a perfectly good reverse proxy.
+
+Refer to the {Unicorn FAQ}[http://unicorn.bogomips.org/FAQ.html] on how
+to ensure redirects go to "https://" URLs.
+
+
+=== Is there a "rainbows_rails" command like there is "unicorn_rails"?
+
+Only if you write one and plan to support it.
+
+"unicorn_rails" was written primarily to support older versions of
+Rails.  Since \Rainbows! is designed for newer Rails, it can just use
+a "config.ru" file like other Rack frameworks and applications.
+
+For Rails 2.3.x and later, the following config.ru will work for you:
+
+  ENV["RAILS_ENV"] ||= ENV["RACK_ENV"]
+  require "config/environment"
+  use Rails::Rack::Static
+  run ActionController::Dispatcher.new
+
+For older versions of Rails, the following config.ru will work:
+
+  ENV["RAILS_ENV"] ||= ENV["RACK_ENV"]
+  require 'config/boot'
+  require 'config/environment'
+  require 'unicorn/app/old_rails'
+  require 'unicorn/app/old_rails/static' # not needed with Unicorn 0.95+
+  use Unicorn::App::OldRails::Static
+  run Unicorn::App::OldRails.new
+
+One thing to watch out for is that RAILS_ENV will not be set in the
+environment for you, thus we set it to match RACK_ENV.

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v0.5.0.GIT
+DEF_VER=v0.6.0.GIT
 
 LF='
 '

data/GNUmakefile

@@ -64,7 +64,7 @@ NEWS: GIT-VERSION-FILE
 	$(rake) -s news_rdoc > $@+
 	mv $@+ $@
 
-SINCE = 0.4.0
+SINCE = 0.5.0
 ChangeLog: log_range = $(shell test -n "$(SINCE)" && echo v$(SINCE)..)
 ChangeLog: GIT-VERSION-FILE
 	@echo "ChangeLog from $(GIT_URL) ($(SINCE)..$(GIT_VERSION))" > $@+

data/Rakefile

@@ -24,6 +24,7 @@ def tags
 end
 
 cgit_url = "http://git.bogomips.org/cgit/rainbows.git"
+git_url = ENV['GIT_URL'] || 'git://git.bogomips.org/rainbows.git'
 
 desc 'prints news as an Atom feed'
 task :news_atom do
@@ -88,8 +89,6 @@ desc "print release notes for Rubyforge"
 task :release_notes do
   require 'rubygems'
 
-  git_url = ENV['GIT_URL'] || 'git://git.bogomips.org/rainbows.git'
-
   spec = Gem::Specification.load('rainbows.gemspec')
   puts spec.description.strip
   puts ""
@@ -117,3 +116,41 @@ task :publish_news do
   rf.login
   rf.post_news('rainbows', subject, body)
 end
+
+desc "post to RAA"
+task :raa_update do
+  require 'rubygems'
+  require 'net/http'
+  require 'net/netrc'
+  rc = Net::Netrc.locate('rainbows-raa') or abort "~/.netrc not found"
+  password = rc.password
+
+  s = Gem::Specification.load('rainbows.gemspec')
+  desc = [ s.description.strip ]
+  desc << ""
+  desc << "* #{s.email}"
+  desc << "* #{git_url}"
+  desc << "* #{cgit_url}"
+  desc = desc.join("\n")
+  uri = URI.parse('http://raa.ruby-lang.org/regist.rhtml')
+  form = {
+    :name => s.name,
+    :short_description => s.summary,
+    :version => s.version.to_s,
+    :status => 'experimental',
+    :owner => s.authors.first,
+    :email => s.email,
+    :category_major => 'Library',
+    :category_minor => 'Web',
+    :url => s.homepage,
+    :download => "http://rubyforge.org/frs/?group_id=8977",
+    :license => "Ruby's",
+    :description_style => 'Plain',
+    :description => desc,
+    :pass => password,
+    :submit => "Update",
+  }
+  res = Net::HTTP.post_form(uri, form)
+  p res
+  puts res.body
+end

data/lib/rainbows.rb

@@ -5,9 +5,20 @@ module Rainbows
 
   # global vars because class/instance variables are confusing me :<
   # this struct is only accessed inside workers and thus private to each
-  G = Struct.new(:cur, :max, :logger, :alive, :app).new
   # G.cur may not be used the network concurrency model
-  G.alive = true
+  class State < Struct.new(:alive,:m,:cur,:server,:tmp)
+    def tick
+      tmp.chmod(self.m = m == 0 ? 1 : 0)
+      alive && server.master_pid == Process.ppid or quit!
+    end
+
+    def quit!
+      self.alive = false
+      server.class.const_get(:LISTENERS).map! { |s| s.close rescue nil }
+      false
+    end
+  end
+  G = State.new(true, 0, 0)
 
   require 'rainbows/const'
   require 'rainbows/http_server'
@@ -56,6 +67,7 @@ module Rainbows
     :ThreadSpawn => 30,
     :ThreadPool => 10,
     :Rev => 50,
+    :RevThreadSpawn => 50,
     :EventMachine => 50,
   }.each do |model, _|
     u = model.to_s.gsub(/([a-z0-9])([A-Z0-9])/) { "#{$1}_#{$2.downcase!}" }

data/lib/rainbows/base.rb

@@ -10,14 +10,6 @@ module Rainbows
     include Rainbows::Const
     G = Rainbows::G
 
-    # write a response without caring if it went out or not for error
-    # messages.
-    # TODO: merge into Unicorn::HttpServer
-    def emergency_response(client, response_str)
-      client.write_nonblock(response_str) rescue nil
-      client.close rescue nil
-    end
-
     def listen_loop_error(e)
       G.alive or return
       logger.error "Unhandled listen loop exception #{e.inspect}."
@@ -26,20 +18,13 @@ module Rainbows
 
     def init_worker_process(worker)
       super(worker)
-      G.cur = 0
-      G.max = worker_connections
-      G.logger = logger
-      G.app = app
+      G.tmp = worker.tmp
 
       # we're don't use the self-pipe mechanism in the Rainbows! worker
       # since we don't defer reopening logs
       HttpServer::SELF_PIPE.each { |x| x.close }.clear
-      trap(:USR1) { reopen_worker_logs(worker.nr) rescue nil }
-      trap(:QUIT) do
-        G.alive = false
-        # closing anything we IO.select on will raise EBADF
-        HttpServer::LISTENERS.map! { |s| s.close rescue nil }
-      end
+      trap(:USR1) { reopen_worker_logs(worker.nr) }
+      trap(:QUIT) { G.quit! }
       [:TERM, :INT].each { |sig| trap(sig) { exit!(0) } } # instant shutdown
       logger.info "Rainbows! #@use worker_connections=#@worker_connections"
     end
@@ -79,23 +64,16 @@ module Rainbows
     # 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
     # the socket is closed at the end of this function
-    rescue EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
-      emergency_response(client, ERROR_500_RESPONSE)
-    rescue HttpParserError # try to tell the client they're bad
-      buf.empty? or emergency_response(client, ERROR_400_RESPONSE)
-    rescue Object => e
-      emergency_response(client, ERROR_500_RESPONSE)
-      logger.error "Read error: #{e.inspect}"
-      logger.error e.backtrace.join("\n")
+    rescue => e
+      handle_error(client, e)
     end
 
-    def join_threads(threads, worker)
-      Rainbows::G.alive = false
+    def join_threads(threads)
+      G.quit!
       expire = Time.now + (timeout * 2.0)
-      m = 0
       until (threads.delete_if { |thr| ! thr.alive? }).empty?
         threads.each { |thr|
-          worker.tmp.chmod(m = 0 == m ? 1 : 0)
+          G.tick
           thr.join(1)
           break if Time.now >= expire
         }

data/lib/rainbows/const.rb

@@ -3,7 +3,7 @@
 module Rainbows
 
   module Const
-    RAINBOWS_VERSION = '0.5.0'
+    RAINBOWS_VERSION = '0.6.0'
 
     include Unicorn::Const
 

data/lib/rainbows/ev_core.rb

@@ -8,6 +8,10 @@ module Rainbows
     include Rainbows::Const
     G = Rainbows::G
 
+    def self.setup(klass)
+      klass.const_set(:APP, G.server.app)
+    end
+
     def post_init
       @remote_addr = ::TCPSocket === @_io ? @_io.peeraddr.last : LOCALHOST
       @env = {}
@@ -28,8 +32,8 @@ module Rainbows
       when HttpParserError # try to tell the client they're bad
         ERROR_400_RESPONSE
       else
-        G.logger.error "Read error: #{e.inspect}"
-        G.logger.error e.backtrace.join("\n")
+        G.server.logger.error "Read error: #{e.inspect}"
+        G.server.logger.error e.backtrace.join("\n")
         ERROR_500_RESPONSE
       end
       write(msg)

data/lib/rainbows/ev_thread_core.rb

@@ -0,0 +1,80 @@
+# -*- encoding: binary -*-
+require 'thread' # for Queue
+require 'rainbows/ev_core'
+
+module Rainbows
+
+  # base module for mixed Thread + evented models like RevThreadSpawn
+  module EvThreadCore
+    include EvCore
+
+    def post_init
+      super
+      @lock = Mutex.new
+      @thread = nil
+    end
+
+    # we pass ourselves off as a Socket to Unicorn::TeeInput and this
+    # is the only method Unicorn::TeeInput requires from the socket
+    def readpartial(length, buf = "")
+      # we must modify the original buffer if there was one
+      length == 0 and return buf.replace("")
+
+      # wait on the main loop to feed us
+      while @tbuf.size == 0
+        @tbuf.write(@state.pop)
+        resume
+      end
+      buf.replace(@tbuf.read(length))
+    end
+
+    def app_spawn(input)
+      begin
+        @thread.nil? or @thread.join # only one thread per connection
+        env = @env.dup
+        alive, headers = @hp.keepalive?, @hp.headers?
+        @thread = Thread.new(self) do |client|
+          begin
+            env[REMOTE_ADDR] = @remote_addr
+            env[RACK_INPUT] = input || TeeInput.new(client, env, @hp, @buf)
+            response = APP.call(env.update(RACK_DEFAULTS))
+            if 100 == response.first.to_i
+              write(EXPECT_100_RESPONSE)
+              env.delete(HTTP_EXPECT)
+              response = APP.call(env)
+            end
+
+            alive &&= G.alive
+            out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if headers
+            response_write(response, out)
+          rescue => e
+            handle_error(e) rescue nil
+          end
+        end
+        if alive # in case we pipeline
+          @hp.reset
+          redo if @hp.headers(@env.clear, @buf)
+        end
+      end while false
+    end
+
+    def on_read(data)
+      case @state
+      when :headers
+        @hp.headers(@env, @buf << data) or return
+        if 0 == @hp.content_length
+          app_spawn(HttpRequest::NULL_IO) # common case
+        else # nil or len > 0
+          @state, @tbuf = Queue.new, ::IO::Buffer.new
+          app_spawn(nil)
+        end
+      when Queue
+        pause
+        @state << data
+      end
+      rescue => e
+        handle_error(e)
+    end
+
+  end
+end

data/lib/rainbows/event_machine.rb

@@ -53,18 +53,17 @@ module Rainbows
       def app_call
         begin
           (@env[RACK_INPUT] = @input).rewind
-          alive = @hp.keepalive?
           @env[REMOTE_ADDR] = @remote_addr
           @env[ASYNC_CALLBACK] = method(:response_write)
 
-          response = catch(:async) { G.app.call(@env.update(RACK_DEFAULTS)) }
+          response = catch(:async) { APP.call(@env.update(RACK_DEFAULTS)) }
 
           # too tricky to support pipelining with :async since the
           # second (pipelined) request could be a stuck behind a
           # long-running async response
           (response.nil? || -1 == response.first) and return @state = :close
 
-          alive &&= G.alive
+          alive = @hp.keepalive? && G.alive
           out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if @hp.headers?
           response_write(response, out, alive)
 
@@ -166,22 +165,17 @@ module Rainbows
 
     module Server
 
-      def initialize(conns)
-        @limit = Rainbows::G.max + HttpServer::LISTENERS.size
-        @em_conns = conns
-      end
-
       def close
         detach
         @io.close
       end
 
       def notify_readable
-        return if @em_conns.size >= @limit
+        return if CUR.size >= MAX
         begin
           io = @io.accept_nonblock
           sig = EM.attach_fd(io.fileno, false)
-          @em_conns[sig] = Client.new(sig, io)
+          CUR[sig] = Client.new(sig, io)
         rescue Errno::EAGAIN, Errno::ECONNABORTED
         end
       end
@@ -192,24 +186,26 @@ module Rainbows
     # given a INT, QUIT, or TERM signal)
     def worker_loop(worker)
       init_worker_process(worker)
-      m = 0
 
       # enable them both, should be non-fatal if not supported
       EM.epoll
       EM.kqueue
       logger.info "EventMachine: epoll=#{EM.epoll?} kqueue=#{EM.kqueue?}"
+      Server.const_set(:MAX, G.server.worker_connections +
+                             HttpServer::LISTENERS.size)
+      EvCore.setup(Client)
       EM.run {
         conns = EM.instance_variable_get(:@conns) or
           raise RuntimeError, "EM @conns instance variable not accessible!"
+        Server.const_set(:CUR, conns)
         EM.add_periodic_timer(1) do
-          worker.tmp.chmod(m = 0 == m ? 1 : 0)
-          unless G.alive
+          unless G.tick
             conns.each_value { |client| Client === client and client.quit }
             EM.stop if conns.empty? && EM.reactor_running?
           end
         end
         LISTENERS.map! do |s|
-          EM.watch(s, Server, conns) { |c| c.notify_readable = true }
+          EM.watch(s, Server) { |c| c.notify_readable = true }
         end
       }
     end

data/lib/rainbows/http_response.rb

@@ -30,7 +30,7 @@ module Rainbows
 
       body.each { |chunk| socket.write(chunk) }
       ensure
-        body.respond_to?(:close) and body.close rescue nil
+        body.respond_to?(:close) and body.close
     end
   end
 end

data/lib/rainbows/http_server.rb

@@ -5,21 +5,27 @@ module Rainbows
   class HttpServer < ::Unicorn::HttpServer
     include Rainbows
 
-    @@instance = nil
-
     class << self
       def setup(block)
-        @@instance.instance_eval(&block)
+        G.server.instance_eval(&block)
       end
     end
 
     def initialize(app, options)
-      @@instance = self
+      G.server = self
       rv = super(app, options)
       defined?(@use) or use(:Base)
       @worker_connections ||= MODEL_WORKER_CONNECTIONS[@use]
     end
 
+    def reopen_worker_logs(worker_nr)
+      logger.info "worker=#{worker_nr} reopening logs..."
+      Unicorn::Util.reopen_logs
+      logger.info "worker=#{worker_nr} done reopening logs"
+      rescue
+        G.quit! # let the master reopen and refork us
+    end
+
     #:stopdoc:
     #
     # Add one second to the timeout since our fchmod heartbeat is less