class Rack::Server

# File lib/rack/server.rb, line 258
def default_middleware_by_environment
  m = Hash.new {|h, k| h[k] = []}
  m["deployment"] = [
    [Rack::ContentLength],
    logging_middleware,
    [Rack::TempfileReaper]
  ]
  m["development"] = [
    [Rack::ContentLength],
    logging_middleware,
    [Rack::ShowExceptions],
    [Rack::Lint],
    [Rack::TempfileReaper]
  ]

  m
end

# File lib/rack/server.rb, line 252
def logging_middleware
  lambda { |server|
    /CGI/.match?(server.server.name) || server.options[:quiet] ? nil : [Rack::CommonLogger, $stderr]
  }
end

# File lib/rack/server.rb, line 276
def middleware
  default_middleware_by_environment
end

# File lib/rack/server.rb, line 214
def initialize(options = nil)
  @ignore_options = []

  if options
    @use_default_options = false
    @options = options
    @app = options[:app] if options[:app]
  else
    argv = defined?(SPEC_ARGV) ? SPEC_ARGV : ARGV
    @use_default_options = true
    @options = parse_options(argv)
  end
end

# File lib/rack/server.rb, line 166
def self.start(options = nil)
  new(options).start
end

# File lib/rack/server.rb, line 247
def app
  @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
end

# File lib/rack/server.rb, line 233
def default_options
  environment  = ENV['RACK_ENV'] || 'development'
  default_host = environment == 'development' ? 'localhost' : '0.0.0.0'

  {
    environment: environment,
    pid: nil,
    Port: 9292,
    Host: default_host,
    AccessLog: [],
    config: "config.ru"
  }
end

# File lib/rack/server.rb, line 281
def middleware
  self.class.middleware
end

# File lib/rack/server.rb, line 228
def options
  merged_options = @use_default_options ? default_options.merge(@options) : @options
  merged_options.reject { |k, v| @ignore_options.include?(k) }
end

# File lib/rack/server.rb, line 329
def server
  @_server ||= Rack::Handler.get(options[:server])

  unless @_server
    @_server = Rack::Handler.default

    # We already speak FastCGI
    @ignore_options = [:File, :Port] if @_server.to_s == 'Rack::Handler::FastCGI'
  end

  @_server
end

# File lib/rack/server.rb, line 285
def start(&block)
  if options[:warn]
    $-w = true
  end

  if includes = options[:include]
    $LOAD_PATH.unshift(*includes)
  end

  Array(options[:require]).each do |library|
    require library
  end

  if options[:debug]
    $DEBUG = true
    require 'pp'
    p options[:server]
    pp wrapped_app
    pp app
  end

  check_pid! if options[:pid]

  # Touch the wrapped app, so that the config.ru is loaded before
  # daemonization (i.e. before chdir, etc).
  handle_profiling(options[:heapfile], options[:profile_mode], options[:profile_file]) do
    wrapped_app
  end

  daemonize_app if options[:daemonize]

  write_pid if options[:pid]

  trap(:INT) do
    if server.respond_to?(:shutdown)
      server.shutdown
    else
      exit
    end
  end

  server.run(wrapped_app, **options, &block)
end

# File lib/rack/server.rb, line 410
def build_app(app)
  middleware[options[:environment]].reverse_each do |middleware|
    middleware = middleware.call(self) if middleware.respond_to?(:call)
    next unless middleware
    klass, *args = middleware
    app = klass.new(app, *args)
  end
  app
end

# File lib/rack/server.rb, line 343
def build_app_and_options_from_config
  if !::File.exist? options[:config]
    abort "configuration #{options[:config]} not found"
  end

  app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
  @options.merge!(options) { |key, old, new| old }
  app
end

# File lib/rack/server.rb, line 391
def build_app_from_string
  Rack::Builder.new_from_string(self.options[:builder])
end

# File lib/rack/server.rb, line 439
def check_pid!
  case pidfile_process_status
  when :running, :not_owned
    $stderr.puts "A server is already running. Check #{options[:pid]}."
    exit(1)
  when :dead
    ::File.delete(options[:pid])
  end
end

# File lib/rack/server.rb, line 424
def daemonize_app
  # Cannot be covered as it forks
  # :nocov:
  Process.daemon
  # :nocov:
end

# File lib/rack/server.rb, line 353
def handle_profiling(heapfile, profile_mode, filename)
  if heapfile
    require "objspace"
    ObjectSpace.trace_object_allocations_start
    yield
    GC.start
    ::File.open(heapfile, "w") { |f| ObjectSpace.dump_all(output: f) }
    exit
  end

  if profile_mode
    require "stackprof"
    require "tempfile"

    make_profile_name(filename) do |filename|
      ::File.open(filename, "w") do |f|
        StackProf.run(mode: profile_mode, out: f) do
          yield
        end
        puts "Profile written to: #{filename}"
      end
    end
    exit
  end

  yield
end

# File lib/rack/server.rb, line 381
def make_profile_name(filename)
  if filename
    yield filename
  else
    ::Dir::Tmpname.create("profile.dump") do |tmpname, _, _|
      yield tmpname
    end
  end
end

# File lib/rack/server.rb, line 406
def opt_parser
  Options.new
end

# File lib/rack/server.rb, line 395
def parse_options(args)
  # Don't evaluate CGI ISINDEX parameters.
  # http://www.meb.uni-bonn.de/docs/cgi/cl.html
  args.clear if ENV.include?(REQUEST_METHOD)

  @options = opt_parser.parse!(args)
  @options[:config] = ::File.expand_path(options[:config])
  ENV["RACK_ENV"] = options[:environment]
  @options
end

# File lib/rack/server.rb, line 449
def pidfile_process_status
  return :exited unless ::File.exist?(options[:pid])

  pid = ::File.read(options[:pid]).to_i
  return :dead if pid == 0

  Process.kill(0, pid)
  :running
rescue Errno::ESRCH
  :dead
rescue Errno::EPERM
  :not_owned
end

# File lib/rack/server.rb, line 420
def wrapped_app
  @wrapped_app ||= build_app app
end

# File lib/rack/server.rb, line 431
def write_pid
  ::File.open(options[:pid], ::File::CREAT | ::File::EXCL | ::File::WRONLY ){ |f| f.write("#{Process.pid}") }
  at_exit { ::FileUtils.rm_f(options[:pid]) }
rescue Errno::EEXIST
  check_pid!
  retry
end