puma 2.0.0.b5 → 5.0.0.beta1

data/lib/puma/binder.rb

@@ -1,31 +1,41 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'socket'
+
 require 'puma/const'
+require 'puma/util'
+require 'puma/minissl/context_builder'
 
 module Puma
   class Binder
     include Puma::Const
 
+    RACK_VERSION = [1,6].freeze
+
     def initialize(events)
       @events = events
       @listeners = []
       @inherited_fds = {}
+      @activated_sockets = {}
       @unix_paths = []
 
       @proto_env = {
-        "rack.version".freeze => Rack::VERSION,
+        "rack.version".freeze => RACK_VERSION,
         "rack.errors".freeze => events.stderr,
         "rack.multithread".freeze => true,
         "rack.multiprocess".freeze => false,
-        "rack.run_once".freeze => true,
+        "rack.run_once".freeze => false,
         "SCRIPT_NAME".freeze => ENV['SCRIPT_NAME'] || "",
 
-        # Rack blows up if this is an empty string, and Rack::Lint
-        # blows up if it's nil. So 'text/plain' seems like the most
-        # sensible default value.
-        "CONTENT_TYPE".freeze => "text/plain",
+        # I'd like to set a default CONTENT_TYPE here but some things
+        # depend on their not being a default set and inferring
+        # it from the content. And so if i set it here, it won't
+        # infer properly.
 
         "QUERY_STRING".freeze => "",
         SERVER_PROTOCOL => HTTP_11,
-        SERVER_SOFTWARE => PUMA_VERSION,
+        SERVER_SOFTWARE => PUMA_SERVER_STRING,
         GATEWAY_INTERFACE => CGI_VER
       }
 
@@ -33,7 +43,8 @@ module Puma
       @ios = []
     end
 
-    attr_reader :listeners, :ios
+    attr_reader :ios, :listeners, :unix_paths, :proto_env, :envs, :activated_sockets, :inherited_fds
+    attr_writer :ios, :listeners
 
     def env(sock)
       @envs.fetch(sock, @proto_env)
@@ -41,95 +52,123 @@ module Puma
 
     def close
       @ios.each { |i| i.close }
-      @unix_paths.each { |i| File.unlink i }
     end
 
-    def import_from_env
-      remove = []
+    def connected_ports
+      ios.map { |io| io.addr[1] }.uniq
+    end
 
-      ENV.each do |k,v|
-        if k =~ /PUMA_INHERIT_\d+/
-          fd, url = v.split(":", 2)
-          @inherited_fds[url] = fd.to_i
-          remove << k
-        end
-      end
+    def create_inherited_fds(env_hash)
+      env_hash.select {|k,v| k =~ /PUMA_INHERIT_\d+/}.each do |_k, v|
+        fd, url = v.split(":", 2)
+        @inherited_fds[url] = fd.to_i
+      end.keys # pass keys back for removal
+    end
 
-      remove.each do |k|
-        ENV.delete k
+    # systemd socket activation.
+    # LISTEN_FDS = number of listening sockets. e.g. 2 means accept on 2 sockets w/descriptors 3 and 4.
+    # LISTEN_PID = PID of the service process, aka us
+    # see https://www.freedesktop.org/software/systemd/man/systemd-socket-activate.html
+    def create_activated_fds(env_hash)
+      return [] unless env_hash['LISTEN_FDS'] && env_hash['LISTEN_PID'].to_i == $$
+      env_hash['LISTEN_FDS'].to_i.times do |index|
+        sock = TCPServer.for_fd(socket_activation_fd(index))
+        key = begin # Try to parse as a path
+          [:unix, Socket.unpack_sockaddr_un(sock.getsockname)]
+        rescue ArgumentError # Try to parse as a port/ip
+          port, addr = Socket.unpack_sockaddr_in(sock.getsockname)
+          addr = "[#{addr}]" if addr =~ /\:/
+          [:tcp, addr, port]
+        end
+        @activated_sockets[key] = sock
+        @events.debug "Registered #{key.join ':'} for activation from LISTEN_FDS"
       end
+      ["LISTEN_FDS", "LISTEN_PID"] # Signal to remove these keys from ENV
     end
 
-    def parse(binds, logger)
+    def parse(binds, logger, log_msg = 'Listening')
       binds.each do |str|
         uri = URI.parse str
         case uri.scheme
         when "tcp"
           if fd = @inherited_fds.delete(str)
-            logger.log "* Inherited #{str}"
             io = inherit_tcp_listener uri.host, uri.port, fd
+            logger.log "* Inherited #{str}"
+          elsif sock = @activated_sockets.delete([ :tcp, uri.host, uri.port ])
+            io = inherit_tcp_listener uri.host, uri.port, sock
+            logger.log "* Activated #{str}"
           else
-            logger.log "* Listening on #{str}"
-            io = add_tcp_listener uri.host, uri.port
+            params = Util.parse_query uri.query
+
+            opt = params.key?('low_latency')
+            bak = params.fetch('backlog', 1024).to_i
+
+            io = add_tcp_listener uri.host, uri.port, opt, bak
+
+            @ios.each do |i|
+              next unless TCPServer === i
+              addr = if i.local_address.ipv6?
+                "[#{i.local_address.ip_unpack[0]}]:#{i.local_address.ip_unpack[1]}"
+              else
+                i.local_address.ip_unpack.join(':')
+              end
+
+              logger.log "* #{log_msg} on tcp://#{addr}"
+            end
           end
 
-          @listeners << [str, io]
+          @listeners << [str, io] if io
         when "unix"
-          path = "#{uri.host}#{uri.path}"
+          path = "#{uri.host}#{uri.path}".gsub("%20", " ")
 
           if fd = @inherited_fds.delete(str)
-            logger.log "* Inherited #{str}"
             io = inherit_unix_listener path, fd
+            logger.log "* Inherited #{str}"
+          elsif sock = @activated_sockets.delete([ :unix, path ])
+            io = inherit_unix_listener path, sock
+            logger.log "* Activated #{str}"
           else
-            logger.log "* Listening on #{str}"
-
             umask = nil
+            mode = nil
+            backlog = 1024
 
             if uri.query
-              params = Rack::Utils.parse_query uri.query
+              params = Util.parse_query uri.query
               if u = params['umask']
                 # Use Integer() to respect the 0 prefix as octal
                 umask = Integer(u)
               end
+
+              if u = params['mode']
+                mode = Integer('0'+u)
+              end
+
+              if u = params['backlog']
+                backlog = Integer(u)
+              end
             end
 
-            io = add_unix_listener path, umask
+            io = add_unix_listener path, umask, mode, backlog
+            logger.log "* #{log_msg} on #{str}"
           end
 
           @listeners << [str, io]
         when "ssl"
-          if IS_JRUBY
-            @events.error "SSL not supported on JRuby"
-            raise UnsupportedOption
-          end
-
-          params = Rack::Utils.parse_query uri.query
-          require 'puma/minissl'
-
-          ctx = MiniSSL::Context.new
-          unless params['key']
-            @events.error "Please specify the SSL key via 'key='"
-          end
-
-          ctx.key = params['key']
-
-          unless params['cert']
-            @events.error "Please specify the SSL cert via 'cert='"
-          end
-
-          ctx.cert = params['cert']
-
-          ctx.verify_mode = MiniSSL::VERIFY_NONE
+          params = Util.parse_query uri.query
+          ctx = MiniSSL::ContextBuilder.new(params, @events).context
 
           if fd = @inherited_fds.delete(str)
             logger.log "* Inherited #{str}"
-            io = inherited_ssl_listener fd, ctx
+            io = inherit_ssl_listener fd, ctx
+          elsif sock = @activated_sockets.delete([ :tcp, uri.host, uri.port ])
+            io = inherit_ssl_listener sock, ctx
+            logger.log "* Activated #{str}"
           else
-            logger.log "* Listening on #{str}"
             io = add_ssl_listener uri.host, uri.port, ctx
+            logger.log "* Listening on #{str}"
           end
 
-          @listeners << [str, io]
+          @listeners << [str, io] if io
         else
           logger.error "Invalid URI: #{str}"
         end
@@ -153,6 +192,16 @@ module Puma
         end
       end
 
+      # Also close any unused activated sockets
+      @activated_sockets.each do |key, sock|
+        logger.log "* Closing unused activated socket: #{key.join ':'}"
+        begin
+          sock.close
+        rescue SystemCallError
+        end
+        # We have to unlink a unix socket path that's not being used
+        File.unlink key[1] if key[0] == :unix
+      end
     end
 
     # Tell the server to listen on host +host+, port +port+.
@@ -163,14 +212,23 @@ module Puma
     # allow to accumulate before returning connection refused.
     #
     def add_tcp_listener(host, port, optimize_for_latency=true, backlog=1024)
-      s = TCPServer.new(host, port)
+      if host == "localhost"
+        loopback_addresses.each do |addr|
+          add_tcp_listener addr, port, optimize_for_latency, backlog
+        end
+        return
+      end
+
+      host = host[1..-2] if host and host[0..0] == '['
+      tcp_server = TCPServer.new(host, port)
       if optimize_for_latency
-        s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        tcp_server.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
       end
-      s.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
-      s.listen backlog
-      @ios << s
-      s
+      tcp_server.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
+      tcp_server.listen backlog
+
+      @ios << tcp_server
+      tcp_server
     end
 
     def inherit_tcp_listener(host, port, fd)
@@ -186,13 +244,18 @@ module Puma
 
     def add_ssl_listener(host, port, ctx,
                          optimize_for_latency=true, backlog=1024)
-      if IS_JRUBY
-        @events.error "SSL not supported on JRuby"
-        raise UnsupportedOption
-      end
-
       require 'puma/minissl'
 
+      MiniSSL.check
+
+      if host == "localhost"
+        loopback_addresses.each do |addr|
+          add_ssl_listener addr, port, ctx, optimize_for_latency, backlog
+        end
+        return
+      end
+
+      host = host[1..-2] if host[0..0] == '['
       s = TCPServer.new(host, port)
       if optimize_for_latency
         s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
@@ -200,6 +263,7 @@ module Puma
       s.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
       s.listen backlog
 
+
       ssl = MiniSSL::Server.new s, ctx
       env = @proto_env.dup
       env[HTTPS_KEY] = HTTPS
@@ -209,45 +273,115 @@ module Puma
       s
     end
 
-    def inherited_ssl_listener(fd, ctx)
-      if IS_JRUBY
-        @events.error "SSL not supported on JRuby"
-        raise UnsupportedOption
+    def inherit_ssl_listener(fd, ctx)
+      require 'puma/minissl'
+      MiniSSL.check
+
+      if fd.kind_of? TCPServer
+        s = fd
+      else
+        s = TCPServer.for_fd(fd)
       end
+      ssl = MiniSSL::Server.new(s, ctx)
+
+      env = @proto_env.dup
+      env[HTTPS_KEY] = HTTPS
+      @envs[ssl] = env
+
+      @ios << ssl
 
-      require 'puma/minissl'
-      s = TCPServer.for_fd(fd)
-      @ios << MiniSSL::Server.new(s, ctx)
       s
     end
 
     # Tell the server to listen on +path+ as a UNIX domain socket.
     #
-    def add_unix_listener(path, umask=nil)
-      @unix_paths << path
+    def add_unix_listener(path, umask=nil, mode=nil, backlog=1024)
+      @unix_paths << path unless File.exist? path
 
       # Let anyone connect by default
       umask ||= 0
 
       begin
         old_mask = File.umask(umask)
+
+        if File.exist? path
+          begin
+            old = UNIXSocket.new path
+          rescue SystemCallError, IOError
+            File.unlink path
+          else
+            old.close
+            raise "There is already a server bound to: #{path}"
+          end
+        end
+
         s = UNIXServer.new(path)
+        s.listen backlog
         @ios << s
       ensure
         File.umask old_mask
       end
 
+      if mode
+        File.chmod mode, path
+      end
+
+      env = @proto_env.dup
+      env[REMOTE_ADDR] = "127.0.0.1"
+      @envs[s] = env
+
       s
     end
 
     def inherit_unix_listener(path, fd)
-      @unix_paths << path
+      @unix_paths << path unless File.exist? path
 
-      s = UNIXServer.for_fd fd
+      if fd.kind_of? TCPServer
+        s = fd
+      else
+        s = UNIXServer.for_fd fd
+      end
       @ios << s
 
+      env = @proto_env.dup
+      env[REMOTE_ADDR] = "127.0.0.1"
+      @envs[s] = env
+
       s
     end
 
+    def close_listeners
+      listeners.each do |l, io|
+        io.close unless io.closed? # Ruby 2.2 issue
+        uri = URI.parse(l)
+        next unless uri.scheme == 'unix'
+        unix_path = "#{uri.host}#{uri.path}"
+        File.unlink unix_path if unix_paths.include? unix_path
+      end
+    end
+
+    def redirects_for_restart
+      redirects = listeners.map { |a| [a[1].to_i, a[1].to_i] }.to_h
+      redirects[:close_others] = true
+      redirects
+    end
+
+    def redirects_for_restart_env
+      listeners.each_with_object({}).with_index do |(listen, memo), i|
+        memo["PUMA_INHERIT_#{i}"] = "#{listen[1].to_i}:#{listen[0]}"
+      end
+    end
+
+    private
+
+    def loopback_addresses
+      Socket.ip_address_list.select do |addrinfo|
+        addrinfo.ipv6_loopback? || addrinfo.ipv4_loopback?
+      end.map { |addrinfo| addrinfo.ip_address }.uniq
+    end
+
+    def socket_activation_fd(int)
+      int + 3 # 3 is the magic number you add to follow the SA protocol
+    end
   end
 end

data/lib/puma/cli.rb

@@ -1,726 +1,231 @@
+# frozen_string_literal: true
+
 require 'optparse'
 require 'uri'
 
-require 'puma/server'
-require 'puma/const'
+require 'puma'
 require 'puma/configuration'
-require 'puma/binder'
-require 'puma/detect'
-require 'puma/daemon_ext'
-require 'puma/util'
-
-require 'rack/commonlogger'
-require 'rack/utils'
+require 'puma/launcher'
+require 'puma/const'
+require 'puma/events'
 
 module Puma
+  class << self
+    # The CLI exports its Puma::Configuration object here to allow
+    # apps to pick it up. An app needs to use it conditionally though
+    # since it is not set if the app is launched via another
+    # mechanism than the CLI class.
+    attr_accessor :cli_config
+  end
+
   # Handles invoke a Puma::Server in a command line style.
   #
   class CLI
+    KEYS_NOT_TO_PERSIST_IN_STATE = Launcher::KEYS_NOT_TO_PERSIST_IN_STATE
+
     # Create a new CLI object using +argv+ as the command line
     # arguments.
     #
     # +stdout+ and +stderr+ can be set to IO-like objects which
     # this object will report status on.
     #
-    def initialize(argv, stdout=STDOUT, stderr=STDERR)
+    def initialize(argv, events=Events.stdio)
       @debug = false
-      @argv = argv
-      @stdout = stdout
-      @stderr = stderr
-
-      @phase = 0
-      @workers = []
+      @argv = argv.dup
 
-      @events = Events.new @stdout, @stderr
+      @events = events
 
-      @server = nil
-      @status = nil
+      @conf = nil
 
-      @restart = false
-      @phased_state = :idle
+      @stdout = nil
+      @stderr = nil
+      @append = false
 
-      ENV['NEWRELIC_DISPATCHER'] ||= "puma"
+      @control_url = nil
+      @control_options = {}
 
       setup_options
 
-      generate_restart_data
-
-      @binder = Binder.new(@events)
-      @binder.import_from_env
-    end
-
-    def restart_on_stop!
-      @restart = true
-    end
-
-    def generate_restart_data
-      # Use the same trick as unicorn, namely favor PWD because
-      # it will contain an unresolved symlink, useful for when
-      # the pwd is /data/releases/current.
-      if dir = ENV['PWD']
-        s_env = File.stat(dir)
-        s_pwd = File.stat(Dir.pwd)
-
-        if s_env.ino == s_pwd.ino and s_env.dev == s_pwd.dev
-          @restart_dir = dir
-        end
-      end
-
-      @restart_dir ||= Dir.pwd
-
-      @original_argv = ARGV.dup
-
-      if defined? Rubinius::OS_ARGV
-        @restart_argv = Rubinius::OS_ARGV
-      else
-        require 'rubygems'
-
-        # if $0 is a file in the current directory, then restart
-        # it the same, otherwise add -S on there because it was
-        # picked up in PATH.
-        #
-        if File.exists?($0)
-          arg0 = [Gem.ruby, $0]
-        else
-          arg0 = [Gem.ruby, "-S", $0]
-        end
-
-        # Detect and reinject -Ilib from the command line
-        lib = File.expand_path "lib"
-        arg0[1,0] = ["-I", lib] if $:[0] == lib
-
-        @restart_argv = arg0 + ARGV
-      end
-    end
-
-    def restart!
-      @options[:on_restart].each do |blk|
-        blk.call self
-      end
-
-      if jruby?
-        @binder.listeners.each_with_index do |(str,io),i|
-          io.close
-
-          # We have to unlink a unix socket path that's not being used
-          uri = URI.parse str
-          if uri.scheme == "unix"
-            path = "#{uri.host}#{uri.path}"
-            File.unlink path
-          end
-        end
-
-        require 'puma/jruby_restart'
-        JRubyRestart.chdir_exec(@restart_dir, Gem.ruby, *@restart_argv)
-      else
-        @binder.listeners.each_with_index do |(l,io),i|
-          ENV["PUMA_INHERIT_#{i}"] = "#{io.to_i}:#{l}"
-        end
-
-        if cmd = @options[:restart_cmd]
-          argv = cmd.split(' ') + @original_argv
-        else
-          argv = @restart_argv
-        end
-
-        Dir.chdir @restart_dir
-        Kernel.exec(*argv)
-      end
-    end
-
-    # Delegate +log+ to +@events+
-    #
-    def log(str)
-      @events.log str
-    end
-
-    # Delegate +error+ to +@events+
-    #
-    def error(str)
-      @events.error str
-    end
-
-    def debug(str)
-      if @options[:debug]
-        @events.log "- #{str}"
-      end
-    end
-
-    def jruby?
-      IS_JRUBY
-    end
-
-    def windows?
-      RUBY_PLATFORM =~ /mswin32|ming32/
-    end
-
-    def unsupported(str, cond=true)
-      return unless cond
-      @events.error str
-      raise UnsupportedOption
-    end
-
-    # Build the OptionParser object to handle the available options.
-    #
-    def setup_options
-      @options = {
-        :min_threads => 0,
-        :max_threads => 16,
-        :quiet => false,
-        :debug => false,
-        :binds => [],
-        :workers => 0,
-        :daemon => false,
-        :environment => "development"
-      }
-
-      @parser = OptionParser.new do |o|
-        o.on "-b", "--bind URI", "URI to bind to (tcp://, unix://, ssl://)" do |arg|
-          @options[:binds] << arg
-        end
-
-        o.on "-C", "--config PATH", "Load PATH as a config file" do |arg|
-          @options[:config_file] = arg
-        end
-
-        o.on "--control URL", "The bind url to use for the control server",
-                              "Use 'auto' to use temp unix server" do |arg|
-          if arg
-            @options[:control_url] = arg
-          elsif jruby?
-            unsupported "No default url available on JRuby"
-          end
-        end
-
-        o.on "--control-token TOKEN",
-             "The token to use as authentication for the control server" do |arg|
-          @options[:control_auth_token] = arg
-        end
-
-        o.on "-d", "--daemon", "Daemonize the server into the background" do
-          @options[:daemon] = true
-          @options[:quiet] = true
-        end
-
-        o.on "--debug", "Log lowlevel debugging information" do
-          @options[:debug] = true
-        end
-
-        o.on "--dir DIR", "Change to DIR before starting" do |d|
-          @options[:directory] = d.to_s
-        end
-
-        o.on "-e", "--environment ENVIRONMENT",
-             "The environment to run the Rack app on (default development)" do |arg|
-          @options[:environment] = arg
-        end
-
-        o.on "-I", "--include PATH", "Specify $LOAD_PATH directories" do |arg|
-          $LOAD_PATH.unshift(*arg.split(':'))
-        end
-
-        o.on "-p", "--port PORT", "Define what port TCP port to bind to",
-                                  "Use -b for more advanced options" do |arg|
-          @options[:binds] << "tcp://#{Configuration::DefaultTCPHost}:#{arg}"
-        end
-
-        o.on "--pidfile PATH", "Use PATH as a pidfile" do |arg|
-          @options[:pidfile] = arg
-        end
-
-        o.on "-q", "--quiet", "Quiet down the output" do
-          @options[:quiet] = true
-        end
-
-        o.on "-R", "--restart-cmd CMD",
-             "The puma command to run during a hot restart",
-             "Default: inferred" do |cmd|
-          @options[:restart_cmd] = cmd
-        end
-
-        o.on "-S", "--state PATH", "Where to store the state details" do |arg|
-          @options[:state] = arg
-        end
+      begin
+        @parser.parse! @argv
 
-        o.on '-t', '--threads INT', "min:max threads to use (default 0:16)" do |arg|
-          min, max = arg.split(":")
-          if max
-            @options[:min_threads] = min.to_i
-            @options[:max_threads] = max.to_i
-          else
-            @options[:min_threads] = 0
-            @options[:max_threads] = arg.to_i
+        if file = @argv.shift
+          @conf.configure do |user_config, file_config|
+            file_config.rackup file
           end
         end
-
-        o.on "-w", "--workers COUNT",
-                   "Activate cluster mode: How many worker processes to create" do |arg|
-          unsupported "-w not supported on JRuby and Windows",
-                      jruby? || windows?
-
-          @options[:workers] = arg.to_i
-        end
-
-      end
-
-      @parser.banner = "puma <options> <rackup file>"
-
-      @parser.on_tail "-h", "--help", "Show help" do
-        log @parser
+      rescue UnsupportedOption
         exit 1
       end
-    end
 
-    # If configured, write the pid of the current process out
-    # to a file.
-    #
-    def write_pid
-      if path = @options[:pidfile]
-        File.open(path, "w") do |f|
-          f.puts Process.pid
+      @conf.configure do |user_config, file_config|
+        if @stdout || @stderr
+          user_config.stdout_redirect @stdout, @stderr, @append
         end
-      end
-    end
-
-    def set_rack_environment 
-      # Try the user option first, then the environment variable,
-      # finally default to development
-
-      ENV['RACK_ENV'] = @options[:environment] ||
-                        ENV['RACK_ENV'] ||
-                        'development'
-    end
-
-    def delete_pidfile
-      if path = @options[:pidfile]
-        File.unlink path
-      end
-    end
-
-    def write_state
-      write_pid
-
-      require 'yaml'
-
-      if path = @options[:state]
-        state = { "pid" => Process.pid }
 
-        cfg = @config.dup
-        cfg.options.delete :on_restart
-
-        state["config"] = cfg
-
-        File.open(path, "w") do |f|
-          f.write state.to_yaml
+        if @control_url
+          user_config.activate_control_app @control_url, @control_options
         end
       end
-    end
-
-    # :nodoc:
-    def parse_options
-      @parser.parse! @argv
 
-      if @argv.last
-        @options[:rackup] = @argv.shift
-      end
-
-      @config = Puma::Configuration.new @options
-      @config.load
-    end
-
-    def graceful_stop(server)
-      log " - Gracefully stopping, waiting for requests to finish"
-      @status.stop(true) if @status
-      server.stop(true)
-      delete_pidfile
-      log " - Goodbye!"
+      @launcher = Puma::Launcher.new(@conf, :events => @events, :argv => argv)
     end
 
-    def redirect_io
-      stdout = @options[:redirect_stdout]
-      stderr = @options[:redirect_stderr]
-      append = @options[:redirect_append]
-
-      if stdout
-        STDOUT.reopen stdout, (append ? "a" : "w")
-        STDOUT.puts "=== puma startup: #{Time.now} ==="
-      end
-
-      if stderr
-        STDERR.reopen stderr, (append ? "a" : "w")
-        STDERR.puts "=== puma startup: #{Time.now} ==="
-      end
-    end
+    attr_reader :launcher
 
     # Parse the options, load the rackup, start the server and wait
     # for it to finish.
     #
     def run
-      begin
-        parse_options
-      rescue UnsupportedOption
-        exit 1
-      end
-
-      if dir = @options[:directory]
-        Dir.chdir dir
-      end
-
-      clustered = @options[:workers] > 0
-
-      if clustered
-        @events = PidEvents.new STDOUT, STDERR
-        @options[:logger] = @events
-      end
-
-      set_rack_environment
-
-      if clustered
-        run_cluster
-      else
-        run_single
-      end
+      @launcher.run
     end
 
-    def run_single
-      write_state
-
-      min_t = @options[:min_threads]
-      max_t = @options[:max_threads]
-
-      log "Puma #{Puma::Const::PUMA_VERSION} starting..."
-      log "* Min threads: #{min_t}, max threads: #{max_t}"
-      log "* Environment: #{ENV['RACK_ENV']}"
-
-      @binder.parse @options[:binds], self
-
-      if @options[:daemon]
-        Process.daemon(true, true)
-      end
-
-      server = Puma::Server.new @config.app, @events
-      server.binder = @binder
-      server.min_threads = min_t
-      server.max_threads = max_t
-
-      @server = server
-
-      if str = @options[:control_url]
-        require 'puma/app/status'
-
-        uri = URI.parse str
-
-        app = Puma::App::Status.new server, self
-
-        if token = @options[:control_auth_token]
-          app.auth_token = token unless token.empty? or token == :none
-        end
-
-        status = Puma::Server.new app, @events
-        status.min_threads = 0
-        status.max_threads = 1
-
-        case uri.scheme
-        when "tcp"
-          log "* Starting status server on #{str}"
-          status.add_tcp_listener uri.host, uri.port
-        when "unix"
-          log "* Starting status server on #{str}"
-          path = "#{uri.host}#{uri.path}"
-
-          status.add_unix_listener path
-        else
-          error "Invalid status URI: #{str}"
-        end
-
-        status.run
-        @status = status
-      end
-
-      begin
-        Signal.trap "SIGUSR2" do
-          @restart = true
-          server.begin_restart
-        end
-      rescue Exception
-        log "*** Sorry signal SIGUSR2 not implemented, restart feature disabled!"
-      end
-
-      begin
-        Signal.trap "SIGTERM" do
-          log " - Gracefully stopping, waiting for requests to finish"
-          server.stop false
-        end
-      rescue Exception
-        log "*** Sorry signal SIGTERM not implemented, gracefully stopping feature disabled!"
-      end
-
-      unless @options[:daemon]
-        log "Use Ctrl-C to stop"
-      end
-
-      redirect_io
-
-      if jruby?
-        Signal.trap("INT") do
-          graceful_stop server
-          exit
-        end
-      end
-
-      begin
-        server.run.join
-      rescue Interrupt
-        graceful_stop server
-      end
-
-      if @restart
-        log "* Restarting..."
-        @status.stop true if @status
-        restart!
-      end
-    end
-
-    def worker
-      $0 = "puma: cluster worker: #{@master_pid}"
-      Signal.trap "SIGINT", "IGNORE"
-
-      @master_read.close
-      @suicide_pipe.close
-
-      Thread.new do
-        IO.select [@check_pipe]
-        log "! Detected parent died, dieing"
-        exit! 1
-      end
-
-      min_t = @options[:min_threads]
-      max_t = @options[:max_threads]
-
-      server = Puma::Server.new @config.app, @events
-      server.min_threads = min_t
-      server.max_threads = max_t
-      server.binder = @binder
-
-      Signal.trap "SIGTERM" do
-        server.stop
-      end
-
-      @worker_write << "b#{Process.pid}\n"
-
-      server.run.join
-
-    ensure
-      @worker_write.close
+    private
+    def unsupported(str)
+      @events.error(str)
+      raise UnsupportedOption
     end
 
-    def stop_workers
-      log "- Gracefully shutting down workers..."
-      @workers.each { |x| x.term }
-
-      begin
-        Process.waitall
-      rescue Interrupt
-        log "! Cancelled waiting for workers"
-      else
-        log "- Goodbye!"
+    def configure_control_url(command_line_arg)
+      if command_line_arg
+        @control_url = command_line_arg
+      elsif Puma.jruby?
+        unsupported "No default url available on JRuby"
       end
     end
 
-    def start_phased_restart
-      @phase += 1
-      log "- Starting phased worker restart, phase: #{@phase}"
-    end
-
-    class Worker
-      def initialize(pid, phase)
-        @pid = pid
-        @phase = phase
-        @stage = :started
-      end
-
-      attr_reader :pid, :phase
-
-      def booted?
-        @stage == :booted
-      end
-
-      def boot!
-        @stage = :booted
-      end
-
-      def term
-        begin
-          Process.kill "TERM", @pid
-        rescue Errno::ESRCH
-        end
-      end
-    end
+    # Build the OptionParser object to handle the available options.
+    #
 
-    def spawn_workers
-      diff = @options[:workers] - @workers.size
+    def setup_options
+      @conf = Configuration.new do |user_config, file_config|
+        @parser = OptionParser.new do |o|
+          o.on "-b", "--bind URI", "URI to bind to (tcp://, unix://, ssl://)" do |arg|
+            user_config.bind arg
+          end
 
-      diff.times do
-        pid = fork { worker }
-        debug "Spawned worker: #{pid}"
-        @workers << Worker.new(pid, @phase)
-      end
+          o.on "-C", "--config PATH", "Load PATH as a config file" do |arg|
+            file_config.load arg
+          end
 
-      if diff > 0
-        @phased_state = :idle
-      end
-    end
+          o.on "--control-url URL", "The bind url to use for the control server. Use 'auto' to use temp unix server" do |arg|
+            configure_control_url(arg)
+          end
 
-    def all_workers_booted?
-      @workers.count { |w| !w.booted? } == 0
-    end
+          o.on "--control-token TOKEN",
+            "The token to use as authentication for the control server" do |arg|
+            @control_options[:auth_token] = arg
+          end
 
-    def check_workers
-      while true
-        pid = Process.waitpid(-1, Process::WNOHANG)
-        break unless pid
+          o.on "--debug", "Log lowlevel debugging information" do
+            user_config.debug
+          end
 
-        @workers.delete_if { |w| w.pid == pid }
-      end
+          o.on "--dir DIR", "Change to DIR before starting" do |d|
+            user_config.directory d
+          end
 
-      spawn_workers
+          o.on "-e", "--environment ENVIRONMENT",
+            "The environment to run the Rack app on (default development)" do |arg|
+            user_config.environment arg
+          end
 
-      if @phased_state == :idle && all_workers_booted?
-        # If we're running at proper capacity, check to see if
-        # we need to phase any workers out (which will restart
-        # in the right phase).
-        #
-        w = @workers.find { |x| x.phase != @phase }
+          o.on "-f", "--fork-worker=[REQUESTS]", OptionParser::DecimalInteger,
+            "Fork new workers from existing worker. Cluster mode only",
+            "Auto-refork after REQUESTS (default 1000)" do |*args|
+            user_config.fork_worker(*args.compact)
+          end
 
-        if w
-          @phased_state = :waiting
-          log "- Stopping #{w.pid} for phased upgrade..."
-          w.term
-        end
-      end
-    end
+          o.on "-I", "--include PATH", "Specify $LOAD_PATH directories" do |arg|
+            $LOAD_PATH.unshift(*arg.split(':'))
+          end
 
-    def run_cluster
-      log "Puma #{Puma::Const::PUMA_VERSION} starting in cluster mode..."
-      log "* Process workers: #{@options[:workers]}"
-      log "* Min threads: #{@options[:min_threads]}, max threads: #{@options[:max_threads]}"
-      log "* Environment: #{ENV['RACK_ENV']}"
+          o.on "-p", "--port PORT", "Define the TCP port to bind to",
+            "Use -b for more advanced options" do |arg|
+            user_config.bind "tcp://#{Configuration::DefaultTCPHost}:#{arg}"
+          end
 
-      @binder.parse @options[:binds], self
+          o.on "--pidfile PATH", "Use PATH as a pidfile" do |arg|
+            user_config.pidfile arg
+          end
 
-      @master_pid = Process.pid
+          o.on "--preload", "Preload the app. Cluster mode only" do
+            user_config.preload_app!
+          end
 
-      read, write = Puma::Util.pipe
+          o.on "--prune-bundler", "Prune out the bundler env if possible" do
+            user_config.prune_bundler
+          end
 
-      Signal.trap "SIGCHLD" do
-        write.write "!"
-      end
+          o.on "--extra-runtime-dependencies GEM1,GEM2", "Defines any extra needed gems when using --prune-bundler" do |arg|
+            user_config.extra_runtime_dependencies arg.split(',')
+          end
 
-      stop = false
+          o.on "-q", "--quiet", "Do not log requests internally (default true)" do
+            user_config.quiet
+          end
 
-      begin
-        Signal.trap "SIGUSR2" do
-          @restart = true
-          stop = true
-          write.write "!"
-        end
-      rescue Exception
-      end
+          o.on "-v", "--log-requests", "Log requests as they occur" do
+            user_config.log_requests
+          end
 
-      begin
-        Signal.trap "SIGTERM" do
-          stop = true
-          write.write "!"
-        end
-      rescue Exception
-      end
+          o.on "-R", "--restart-cmd CMD",
+            "The puma command to run during a hot restart",
+            "Default: inferred" do |cmd|
+            user_config.restart_command cmd
+          end
 
-      phased_restart = false
+          o.on "-S", "--state PATH", "Where to store the state details" do |arg|
+            user_config.state_path arg
+          end
 
-      begin
-        Signal.trap "SIGUSR1" do
-          phased_restart = true
-          write.write "!"
-        end
-      rescue Exception
-      end
+          o.on '-t', '--threads INT', "min:max threads to use (default 0:16)" do |arg|
+            min, max = arg.split(":")
+            if max
+              user_config.threads min, max
+            else
+              user_config.threads min, min
+            end
+          end
 
-      # Used by the workers to detect if the master process dies.
-      # If select says that @check_pipe is ready, it's because the
-      # master has exited and @suicide_pipe has been automatically
-      # closed.
-      #
-      @check_pipe, @suicide_pipe = Puma::Util.pipe
-
-      if @options[:daemon]
-        Process.daemon(true, true)
-      else
-        log "Use Ctrl-C to stop"
-      end
+          o.on "--early-hints", "Enable early hints support" do
+            user_config.early_hints
+          end
 
-      redirect_io
+          o.on "-V", "--version", "Print the version information" do
+            puts "puma version #{Puma::Const::VERSION}"
+            exit 0
+          end
 
-      write_state
+          o.on "-w", "--workers COUNT",
+            "Activate cluster mode: How many worker processes to create" do |arg|
+            user_config.workers arg
+          end
 
-      @master_read, @worker_write = read, write
-      spawn_workers
+          o.on "--tag NAME", "Additional text to display in process listing" do |arg|
+            user_config.tag arg
+          end
 
-      Signal.trap "SIGINT" do
-        stop = true
-        write.write "!"
-      end
+          o.on "--redirect-stdout FILE", "Redirect STDOUT to a specific file" do |arg|
+            @stdout = arg.to_s
+          end
 
-      begin
-        while !stop
-          begin
-            res = IO.select([read], nil, nil, 5)
-
-            if res
-              req = read.read_nonblock(1)
-
-              if req == "b"
-                pid = read.gets.to_i
-                w = @workers.find { |w| w.pid == pid }
-                if w
-                  w.boot!
-                  log "- Worker #{pid} booted, phase: #{w.phase}"
-                else
-                  log "! Out-of-sync worker list, no #{pid} worker"
-                end
-              end
-            end
+          o.on "--redirect-stderr FILE", "Redirect STDERR to a specific file" do |arg|
+            @stderr = arg.to_s
+          end
 
-            check_workers
+          o.on "--[no-]redirect-append", "Append to redirected files" do |val|
+            @append = val
+          end
 
-            if phased_restart
-              start_phased_restart
-              phased_restart = false
-            end
+          o.banner = "puma <options> <rackup file>"
 
-          rescue Interrupt
-            stop = true
+          o.on_tail "-h", "--help", "Show help" do
+            $stdout.puts o
+            exit 0
           end
         end
-
-        stop_workers
-      ensure
-        delete_pidfile
-        @check_pipe.close
-        @suicide_pipe.close
-        read.close
-        write.close
       end
-
-      if @restart
-        log "* Restarting..."
-        restart!
-      end
-    end
-
-    def stop
-      @status.stop(true) if @status
-      @server.stop(true) if @server
-      delete_pidfile
     end
   end
 end