From 180485d49ea858f83ef2a28a9e07224aa514edc7 Mon Sep 17 00:00:00 2001 From: Eric Wong Date: Fri, 22 Oct 2010 16:21:03 -0700 Subject: unindent most files This simplifies and disambiguates most constant resolution issues as well as lowering our identation level. Hopefully this makes code easier to understand. --- lib/rainbows/http_server.rb | 163 ++++++++++++++++++++++---------------------- 1 file changed, 80 insertions(+), 83 deletions(-) (limited to 'lib/rainbows/http_server.rb') diff --git a/lib/rainbows/http_server.rb b/lib/rainbows/http_server.rb index 0ed6717..3826a23 100644 --- a/lib/rainbows/http_server.rb +++ b/lib/rainbows/http_server.rb @@ -1,100 +1,97 @@ # -*- encoding: binary -*- # :enddoc: -module Rainbows - class HttpServer < ::Unicorn::HttpServer - include Rainbows +class Rainbows::HttpServer < Unicorn::HttpServer + G = Rainbows::G - class << self - def setup(block) - G.server.instance_eval(&block) - end - end - - def initialize(app, options) - G.server = self - @logger = Unicorn::Configurator::DEFAULTS[:logger] - rv = super(app, options) - defined?(@use) or use(:Base) - @worker_connections ||= MODEL_WORKER_CONNECTIONS[@use] - end + def self.setup(block) + G.server.instance_eval(&block) + 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 + def initialize(app, options) + G.server = self + @logger = Unicorn::Configurator::DEFAULTS[:logger] + rv = super(app, options) + defined?(@use) or use(:Base) + @worker_connections ||= Rainbows::MODEL_WORKER_CONNECTIONS[@use] + end - #:stopdoc: - # - # Add one second to the timeout since our fchmod heartbeat is less - # precise (and must be more conservative) than Unicorn does. We - # handle many clients per process and can't chmod on every - # connection we accept without wasting cycles. That added to the - # fact that we let clients keep idle connections open for long - # periods of time means we have to chmod at a fixed interval. - def timeout=(nr) - @timeout = nr + 1 - end - #:startdoc: + 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 - def use(*args) - model = args.shift or return @use - mod = begin - Rainbows.const_get(model) - rescue NameError => e - logger.error "error loading #{model.inspect}: #{e}" - e.backtrace.each { |l| logger.error l } - raise ArgumentError, "concurrency model #{model.inspect} not supported" - end + #:stopdoc: + # + # Add one second to the timeout since our fchmod heartbeat is less + # precise (and must be more conservative) than Unicorn does. We + # handle many clients per process and can't chmod on every + # connection we accept without wasting cycles. That added to the + # fact that we let clients keep idle connections open for long + # periods of time means we have to chmod at a fixed interval. + def timeout=(nr) + @timeout = nr + 1 + end + #:startdoc: - Module === mod or - raise ArgumentError, "concurrency model #{model.inspect} not supported" - extend(mod) - args.each do |opt| - case opt - when Hash; O.update(opt) - when Symbol; O[opt] = true - else; raise ArgumentError, "can't handle option: #{opt.inspect}" - end - end - mod.setup if mod.respond_to?(:setup) - Const::RACK_DEFAULTS['rainbows.model'] = @use = model.to_sym - Const::RACK_DEFAULTS['rack.multithread'] = !!(model.to_s =~ /Thread/) + def use(*args) + model = args.shift or return @use + mod = begin + Rainbows.const_get(model) + rescue NameError => e + logger.error "error loading #{model.inspect}: #{e}" + e.backtrace.each { |l| logger.error l } + raise ArgumentError, "concurrency model #{model.inspect} not supported" + end - case @use - when :Rev, :EventMachine, :NeverBlock - Const::RACK_DEFAULTS['rainbows.autochunk'] = true + Module === mod or + raise ArgumentError, "concurrency model #{model.inspect} not supported" + extend(mod) + args.each do |opt| + case opt + when Hash; O.update(opt) + when Symbol; O[opt] = true + else; raise ArgumentError, "can't handle option: #{opt.inspect}" end end - - def worker_connections(*args) - return @worker_connections if args.empty? - nr = args[0] - (Integer === nr && nr > 0) or - raise ArgumentError, "worker_connections must be a positive Integer" - @worker_connections = nr + mod.setup if mod.respond_to?(:setup) + new_defaults = { + 'rainbows.model' => (@use = model.to_sym), + 'rack.multithread' => !!(model.to_s =~ /Thread/), + } + case @use + when :Rev, :EventMachine, :NeverBlock + new_defaults['rainbows.autochunk'] = true end + Rainbows::Const::RACK_DEFAULTS.update(new_defaults) + end - def keepalive_timeout(nr) - (Integer === nr && nr >= 0) or - raise ArgumentError, "keepalive must be a non-negative Integer" - G.kato = nr - end + def worker_connections(*args) + return @worker_connections if args.empty? + nr = args[0] + (Integer === nr && nr > 0) or + raise ArgumentError, "worker_connections must be a positive Integer" + @worker_connections = nr + end - def client_max_body_size(nr) - err = "client_max_body_size must be nil or a non-negative Integer" - case nr - when nil - when Integer - nr >= 0 or raise ArgumentError, err - else - raise ArgumentError, err - end - Rainbows.max_bytes = nr - end + def keepalive_timeout(nr) + (Integer === nr && nr >= 0) or + raise ArgumentError, "keepalive must be a non-negative Integer" + G.kato = nr end + def client_max_body_size(nr) + err = "client_max_body_size must be nil or a non-negative Integer" + case nr + when nil + when Integer + nr >= 0 or raise ArgumentError, err + else + raise ArgumentError, err + end + Rainbows.max_bytes = nr + end end -- cgit v1.2.3-24-ge0c7