lib/rainbows/http_server.rb

   1 # -*- encoding: binary -*-
   2 # :enddoc:
   3
   4 class Rainbows::HttpServer < Unicorn::HttpServer
   5   def self.setup(block)
   6     Rainbows.server.instance_eval(&block)
   7   end
   8
   9   def initialize(app, options)
  10     Rainbows.server = self
  11     @logger = Unicorn::Configurator::DEFAULTS[:logger]
  12     rv = super(app, options)
  13     defined?(@use) or use(:Base)
  14     @worker_connections ||= Rainbows::MODEL_WORKER_CONNECTIONS[@use]
  15   end
  16
  17   def reopen_worker_logs(worker_nr)
  18     logger.info "worker=#{worker_nr} reopening logs..."
  19     Unicorn::Util.reopen_logs
  20     logger.info "worker=#{worker_nr} done reopening logs"
  21     rescue
  22       Rainbows.quit! # let the master reopen and refork us
  23   end
  24
  25   # Add one second to the timeout since our fchmod heartbeat is less
  26   # precise (and must be more conservative) than Unicorn does.  We
  27   # handle many clients per process and can't chmod on every
  28   # connection we accept without wasting cycles.  That added to the
  29   # fact that we let clients keep idle connections open for long
  30   # periods of time means we have to chmod at a fixed interval.
  31   def timeout=(nr)
  32     @timeout = nr + 1
  33   end
  34
  35   def load_config!
  36     use :Base
  37     Rainbows.keepalive_timeout = 5
  38     Rainbows.max_bytes = 1024 * 1024
  39     @worker_connections = nil
  40     super
  41     @worker_connections ||= Rainbows::MODEL_WORKER_CONNECTIONS[@use]
  42   end
  43
  44   def ready_pipe=(v)
  45     # hacky hook got force Rainbows! to load modules only in workers
  46     if defined?(@master_pid) && @master_pid == Process.ppid
  47       extend(Rainbows.const_get(@use))
  48     end
  49     super
  50   end
  51
  52   def use(*args)
  53     model = args.shift or return @use
  54     mod = begin
  55       Rainbows.const_get(model)
  56     rescue NameError => e
  57       logger.error "error loading #{model.inspect}: #{e}"
  58       e.backtrace.each { |l| logger.error l }
  59       raise ArgumentError, "concurrency model #{model.inspect} not supported"
  60     end
  61
  62     Module === mod or
  63       raise ArgumentError, "concurrency model #{model.inspect} not supported"
  64     args.each do |opt|
  65       case opt
  66       when Hash; O.update(opt)
  67       when Symbol; O[opt] = true
  68       else; raise ArgumentError, "can't handle option: #{opt.inspect}"
  69       end
  70     end
  71     mod.setup if mod.respond_to?(:setup)
  72     new_defaults = {
  73       'rainbows.model' => (@use = model.to_sym),
  74       'rack.multithread' => !!(model.to_s =~ /Thread/),
  75       'rainbows.autochunk' => [:Coolio,:Rev,:Epoll,:XEpoll,
  76                                :EventMachine,:NeverBlock].include?(@use),
  77     }
  78     Rainbows::Const::RACK_DEFAULTS.update(new_defaults)
  79   end
  80
  81   def worker_connections(*args)
  82     return @worker_connections if args.empty?
  83     nr = args[0]
  84     (Integer === nr && nr > 0) or
  85       raise ArgumentError, "worker_connections must be a positive Integer"
  86     @worker_connections = nr
  87   end
  88
  89   def keepalive_timeout(nr)
  90     (Integer === nr && nr >= 0) or
  91       raise ArgumentError, "keepalive_timeout must be a non-negative Integer"
  92     Rainbows.keepalive_timeout = nr
  93   end
  94
  95   def keepalive_requests(nr)
  96     Integer === nr or
  97       raise ArgumentError, "keepalive_requests must be a non-negative Integer"
  98     Unicorn::HttpRequest.keepalive_requests = nr
  99   end
 100
 101   def client_max_body_size(nr)
 102     err = "client_max_body_size must be nil or a non-negative Integer"
 103     case nr
 104     when nil
 105     when Integer
 106       nr >= 0 or raise ArgumentError, err
 107     else
 108       raise ArgumentError, err
 109     end
 110     Rainbows.max_bytes = nr
 111   end
 112 end