puma 2.7.0 → 3.1.1

data/ext/puma_http11/puma_http11.c

@@ -176,14 +176,12 @@ static VALUE find_common_field_value(const char *field, size_t flen)
 void http_field(puma_parser* hp, const char *field, size_t flen,
                                  const char *value, size_t vlen)
 {
-  VALUE v = Qnil;
   VALUE f = Qnil;
+  VALUE v;
 
   VALIDATE_MAX_LENGTH(flen, FIELD_NAME);
   VALIDATE_MAX_LENGTH(vlen, FIELD_VALUE);
 
-  v = rb_str_new(value, vlen);
-
   f = find_common_field_value(field, flen);
 
   if (f == Qnil) {
@@ -201,7 +199,17 @@ void http_field(puma_parser* hp, const char *field, size_t flen,
     f = rb_str_new(hp->buf, new_size);
   }
 
-  rb_hash_aset(hp->request, f, v);
+  /* check for duplicate header */
+  v = rb_hash_aref(hp->request, f);
+
+  if (v == Qnil) {
+      v = rb_str_new(value, vlen);
+      rb_hash_aset(hp->request, f, v);
+  } else {
+      /* if duplicate header, normalize to comma-separated values */
+      rb_str_cat2(v, ", ");
+      rb_str_cat(v, value, vlen);
+  }
 }
 
 void request_method(puma_parser* hp, const char *at, size_t length)

data/lib/puma.rb

@@ -12,3 +12,4 @@ require 'thread'
 # Ruby Puma
 require 'puma/const'
 require 'puma/server'
+require 'puma/launcher'

data/lib/puma/app/status.rb

@@ -48,6 +48,13 @@ module Puma
             return rack_response(200, OK_STATUS)
           end
 
+        when /\/reload-worker-directory$/
+          if !@cli.send(:reload_worker_directory)
+            return rack_response(404, '{ "error": "reload_worker_directory not available" }')
+          else
+            return rack_response(200, OK_STATUS)
+          end
+
         when /\/stats$/
           return rack_response(200, @cli.stats)
         else

data/lib/puma/binder.rb

@@ -1,9 +1,12 @@
 require 'puma/const'
+require 'uri'
 
 module Puma
   class Binder
     include Puma::Const
 
+    RACK_VERSION = [1,3].freeze
+
     def initialize(events)
       @events = events
       @listeners = []
@@ -11,21 +14,21 @@ module Puma
       @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 => 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 infering
+        # 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
       }
 
@@ -87,13 +90,18 @@ module Puma
             logger.log "* Inherited #{str}"
             io = inherit_tcp_listener uri.host, uri.port, fd
           else
+            params = Util.parse_query uri.query
+
+            opt = params.key?('low_latency')
+            bak = params.fetch('backlog', 1024).to_i
+
             logger.log "* Listening on #{str}"
-            io = add_tcp_listener uri.host, uri.port
+            io = add_tcp_listener uri.host, uri.port, opt, bak
           end
 
           @listeners << [str, 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}"
@@ -102,42 +110,84 @@ module Puma
             logger.log "* Listening on #{str}"
 
             umask = nil
+            mode = nil
+            backlog = nil
 
             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
           end
 
           @listeners << [str, io]
         when "ssl"
-          if IS_JRUBY
-            @events.error "SSL not supported on JRuby"
-            raise UnsupportedOption
-          end
+          MiniSSL.check
 
-          params = Rack::Utils.parse_query uri.query
+          params = Util.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']
+          if defined?(JRUBY_VERSION)
+            unless params['keystore']
+              @events.error "Please specify the Java keystore via 'keystore='"
+            end
 
-          unless params['cert']
-            @events.error "Please specify the SSL cert via 'cert='"
-          end
+            ctx.keystore = params['keystore']
 
-          ctx.cert = params['cert']
+            unless params['keystore-pass']
+              @events.error "Please specify the Java keystore password  via 'keystore-pass='"
+            end
+
+            ctx.keystore_pass = params['keystore-pass']
+          else
+            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']
+
+            if ['peer', 'force_peer'].include?(params['verify_mode'])
+              unless params['ca']
+                @events.error "Please specify the SSL ca via 'ca='"
+              end
+            end
 
-          ctx.verify_mode = MiniSSL::VERIFY_NONE
+            ctx.ca = params['ca'] if params['ca']
+
+            if  params['verify_mode']
+              ctx.verify_mode = case params['verify_mode']
+                                when "peer"
+                                  MiniSSL::VERIFY_PEER
+                                when "force_peer"
+                                  MiniSSL::VERIFY_PEER | MiniSSL::VERIFY_FAIL_IF_NO_PEER_CERT
+                                when "none"
+                                  MiniSSL::VERIFY_NONE
+                                else
+                                  @events.error "Please specify a valid verify_mode="
+                                  MiniSSL::VERIFY_NONE
+                                end
+            end
+          end
 
           if fd = @inherited_fds.delete(str)
             logger.log "* Inherited #{str}"
@@ -186,17 +236,21 @@ module Puma
     # allow to accumulate before returning connection refused.
     #
     def add_tcp_listener(host, port, optimize_for_latency=true, backlog=1024)
-      host = host[1..-2] if host[0..0] == '['
+      host = host[1..-2] if host and host[0..0] == '['
       s = TCPServer.new(host, port)
       if optimize_for_latency
         s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
       end
       s.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
       s.listen backlog
+      @connected_port = s.addr[1]
+
       @ios << s
       s
     end
 
+    attr_reader :connected_port
+
     def inherit_tcp_listener(host, port, fd)
       if fd.kind_of? TCPServer
         s = fd
@@ -210,13 +264,11 @@ 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
+
+      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)
@@ -234,20 +286,24 @@ module Puma
     end
 
     def inherited_ssl_listener(fd, ctx)
-      if IS_JRUBY
-        @events.error "SSL not supported on JRuby"
-        raise UnsupportedOption
-      end
-
       require 'puma/minissl'
+      MiniSSL.check
+
       s = TCPServer.for_fd(fd)
-      @ios << MiniSSL::Server.new(s, ctx)
+      ssl = MiniSSL::Server.new(s, ctx)
+
+      env = @proto_env.dup
+      env[HTTPS_KEY] = HTTPS
+      @envs[ssl] = env
+
+      @ios << ssl
+
       s
     end
 
     # Tell the server to listen on +path+ as a UNIX domain socket.
     #
-    def add_unix_listener(path, umask=nil)
+    def add_unix_listener(path, umask=nil, mode=nil, backlog=nil)
       @unix_paths << path
 
       # Let anyone connect by default
@@ -256,10 +312,10 @@ module Puma
       begin
         old_mask = File.umask(umask)
 
-        if File.exists? path
+        if File.exist? path
           begin
             old = UNIXSocket.new path
-          rescue SystemCallError
+          rescue SystemCallError, IOError
             File.unlink path
           else
             old.close
@@ -268,11 +324,20 @@ module Puma
         end
 
         s = UNIXServer.new(path)
+        s.listen backlog if 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
 
@@ -286,6 +351,10 @@ module Puma
       end
       @ios << s
 
+      env = @proto_env.dup
+      env[REMOTE_ADDR] = "127.0.0.1"
+      @envs[s] = env
+
       s
     end
 

data/lib/puma/capistrano.rb

@@ -1,13 +1,13 @@
+$stderr.puts "DEPRECATED: To manage puma with capistrano, use https://github.com/seuros/capistrano-puma"
+
 Capistrano::Configuration.instance.load do
-  after 'deploy:stop', 'puma:stop'
-  after 'deploy:start', 'puma:start'
-  after 'deploy:restart', 'puma:restart'
 
   # Ensure the tmp/sockets directory is created by the deploy:setup task and
   # symlinked in by the deploy:update task. This is not handled by Capistrano
   # v2 but is fixed in v3.
   shared_children.push('tmp/sockets')
 
+  _cset(:puma_default_hooks)    { true }
   _cset(:puma_cmd)    { "#{fetch(:bundle_cmd, 'bundle')} exec puma" }
   _cset(:pumactl_cmd) { "#{fetch(:bundle_cmd, 'bundle')} exec pumactl" }
   _cset(:puma_env)    { fetch(:rack_env, fetch(:rails_env, 'production')) }
@@ -15,10 +15,16 @@ Capistrano::Configuration.instance.load do
   _cset(:puma_socket) { "unix://#{shared_path}/sockets/puma.sock" }
   _cset(:puma_role)   { :app }
 
+  if fetch(:puma_default_hooks)
+    after 'deploy:stop', 'puma:stop'
+    after 'deploy:start', 'puma:start'
+    after 'deploy:restart', 'puma:restart'
+  end
+
   namespace :puma do
     desc 'Start puma'
     task :start, :roles => lambda { puma_role }, :on_no_matching_servers => :continue do
-      run "cd #{current_path} && #{puma_cmd} #{start_options}", :pty => false
+      run "cd #{current_path} && #{puma_rails_additional_env} #{puma_cmd} #{start_options}", :pty => false
     end
 
     desc 'Stop puma'
@@ -29,7 +35,7 @@ Capistrano::Configuration.instance.load do
     desc 'Restart puma'
     task :restart, :roles => lambda { puma_role }, :on_no_matching_servers => :continue do
       begin
-        run "cd #{current_path} && #{pumactl_cmd} -S #{state_path} restart"
+        run "cd #{current_path} && #{puma_rails_additional_env} #{pumactl_cmd} -S #{state_path} restart"
       rescue Capistrano::CommandError => ex
         puts "Failed to restart puma: #{ex}\nAssuming not started."
         start
@@ -38,7 +44,12 @@ Capistrano::Configuration.instance.load do
 
     desc 'Restart puma (phased restart)'
     task :phased_restart, :roles => lambda { puma_role }, :on_no_matching_servers => :continue do
-      run "cd #{current_path} && #{pumactl_cmd} -S #{state_path} phased-restart"
+      begin
+        run "cd #{current_path} && #{puma_rails_additional_env} #{pumactl_cmd} -S #{state_path} phased-restart"
+      rescue Capistrano::CommandError => ex
+        puts "Failed to restart puma: #{ex}\nAssuming not started."
+        start
+      end
     end
 
   end
@@ -63,11 +74,17 @@ Capistrano::Configuration.instance.load do
     fetch(:rack_env, fetch(:rails_env, 'production'))
   end
 
+  #add additional env when start rails, such as : secret key, db username, db pwd or other what you want.
+  def puma_rails_additional_env
+    fetch(:puma_rails_additional_env, '')
+  end
+
   def state_path
     (config_file ? configuration.options[:state] : nil) || puma_state
   end
 
   def configuration
+    require 'puma'
     require 'puma/configuration'
 
     config = Puma::Configuration.new(:config_file => config_file)

data/lib/puma/cli.rb

@@ -1,23 +1,22 @@
 require 'optparse'
 require 'uri'
 
-require 'puma/server'
-require 'puma/const'
-require 'puma/configuration'
-require 'puma/binder'
-require 'puma/detect'
-require 'puma/daemon_ext'
-require 'puma/util'
-require 'puma/single'
-require 'puma/cluster'
-
-require 'rack/commonlogger'
-require 'rack/utils'
+require 'puma/launcher'
 
 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.
     #
@@ -26,497 +25,193 @@ module Puma
     #
     def initialize(argv, events=Events.stdio)
       @debug = false
-      @argv = argv
+      @argv = argv.dup
 
       @events = events
 
-      @status = nil
-      @runner = nil
+      @conf = nil
 
-      @config = nil
+      @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
-
-    # The Binder object containing the sockets bound to.
-    attr_reader :binder
-
-    # The Configuration object used.
-    attr_reader :config
-
-    # The Hash of options used to configure puma.
-    attr_reader :options
-
-    # The Events object used to output information.
-    attr_reader :events
-
-    # 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,
-        :worker_boot => []
-      }
-
-      @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
-          @options[:worker_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 the 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 "--preload", "Preload the app. Cluster mode only" do
-          @options[:preload_app] = true
-        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
-            @options[:max_threads] = max
-          else
-            @options[:min_threads] = 0
-            @options[:max_threads] = arg
+        if file = @argv.shift
+          @conf.configure do |c|
+            c.rackup file
           end
         end
-
-        o.on "--tcp-mode", "Run the app in raw TCP mode instead of HTTP mode" do
-          @options[:mode] = :tcp
-        end
-
-        o.on "-V", "--version", "Print the version information" do
-          puts "puma version #{Puma::Const::VERSION}"
-          exit 1
-        end
-
-        o.on "-w", "--workers COUNT",
-                   "Activate cluster mode: How many worker processes to create" do |arg|
-          @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
-
-    def write_state
-      write_pid
-
-      require 'yaml'
-
-      if path = @options[:state]
-        state = { "pid" => Process.pid }
-
-        cfg = @config.dup
-
-        [ :logger, :worker_boot, :on_restart ].each { |o| cfg.options.delete o }
 
-        state["config"] = cfg
-
-        File.open(path, "w") do |f|
-          f.write state.to_yaml
+      @conf.configure do |c|
+        if @stdout || @stderr
+          c.stdout_redirect @stdout, @stderr, @append
         end
-      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
+        if @control_url
+          c.activate_control_app @control_url, @control_options
         end
-
-        cur = Process.pid
-
-        at_exit do
-          if cur == Process.pid
-            delete_pidfile
-          end
-        end
-      end
-    end
-
-    def set_rack_environment
-      # Try the user option first, then the environment variable,
-      # finally default to development
-
-      env = @options[:environment] ||
-                   ENV['RACK_ENV'] ||
-                     'development'
-
-      @options[:environment] = env
-      ENV['RACK_ENV'] = env
-    end
-
-    def delete_pidfile
-      if path = @options[:pidfile]
-        File.unlink path if File.exists? path
-      end
-    end
-
-    # :nodoc:
-    def parse_options
-      @parser.parse! @argv
-
-      if @argv.last
-        @options[:rackup] = @argv.shift
-      end
-
-      @config = Puma::Configuration.new @options
-
-      # Advertise the Configuration
-      Puma.cli_config = @config
-
-      @config.load
-
-      if clustered?
-        unsupported "worker mode not supported on JRuby or Windows",
-                    jruby? || windows?
-      end
-
-      if @options[:daemon] and windows?
-        unsupported "daemon mode not supported on Windows"
       end
-    end
-
-    def clustered?
-      @options[:workers] > 0
-    end
 
-    def graceful_stop
-      @runner.stop_blocked
-      log "- Goodbye!"
+      @launcher = Puma::Launcher.new(@conf, :events => @events, :argv => argv)
     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
-          @options[:worker_directory] = 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
+    attr_reader :launcher
 
-        @restart_argv = arg0 + ARGV
-      end
+    # Parse the options, load the rackup, start the server and wait
+    # for it to finish.
+    #
+    def run
+      @launcher.run
     end
 
-    def restart_args
-      if cmd = @options[:restart_cmd]
-        cmd.split(' ') + @original_argv
-      else
-        @restart_argv
-      end
+  private
+    def unsupported(str)
+      @events.error(str)
+      raise UnsupportedOption
     end
 
-    def jruby_daemon_start
-      require 'puma/jruby_restart'
-      JRubyRestart.daemon_start(@restart_dir, restart_args)
-    end
+    # Build the OptionParser object to handle the available options.
+    #
 
-    def restart!
-      @options[:on_restart].each do |block|
-        block.call self
-      end
+    def setup_options
+      @conf = Configuration.new do |c|
+        @parser = OptionParser.new do |o|
+          o.on "-b", "--bind URI", "URI to bind to (tcp://, unix://, ssl://)" do |arg|
+            c.bind arg
+          end
 
-      if jruby?
-        @binder.listeners.each_with_index do |(str,io),i|
-          io.close
+          o.on "-C", "--config PATH", "Load PATH as a config file" do |arg|
+            c.load arg
+          end
 
-          # 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
+          o.on "--control URL", "The bind url to use for the control server",
+            "Use 'auto' to use temp unix server" do |arg|
+            if arg
+              @control_url = arg
+            elsif Puma.jruby?
+              unsupported "No default url available on JRuby"
+            end
           end
-        end
 
-        require 'puma/jruby_restart'
-        JRubyRestart.chdir_exec(@restart_dir, restart_args)
+          o.on "--control-token TOKEN",
+            "The token to use as authentication for the control server" do |arg|
+            @control_options[:auth_token] = arg
+          end
 
-      elsif windows?
-        @binder.listeners.each_with_index do |(str,io),i|
-          io.close
+          o.on "-d", "--daemon", "Daemonize the server into the background" do
+            c.daemonize
+            c.quiet
+          end
 
-          # 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
+          o.on "--debug", "Log lowlevel debugging information" do
+            c.debug
           end
-        end
 
-        argv = restart_args
+          o.on "--dir DIR", "Change to DIR before starting" do |d|
+            c.directory d
+          end
 
-        Dir.chdir @restart_dir
+          o.on "-e", "--environment ENVIRONMENT",
+            "The environment to run the Rack app on (default development)" do |arg|
+            c.environment arg
+          end
 
-        argv += [redirects] unless RUBY_VERSION < '1.9'
-        Kernel.exec(*argv)
+          o.on "-I", "--include PATH", "Specify $LOAD_PATH directories" do |arg|
+            $LOAD_PATH.unshift(*arg.split(':'))
+          end
 
-      else
-        redirects = {:close_others => true}
-        @binder.listeners.each_with_index do |(l,io),i|
-          ENV["PUMA_INHERIT_#{i}"] = "#{io.to_i}:#{l}"
-          redirects[io.to_i] = io.to_i
-        end
+          o.on "-p", "--port PORT", "Define the TCP port to bind to",
+            "Use -b for more advanced options" do |arg|
+            c.bind "tcp://#{Configuration::DefaultTCPHost}:#{arg}"
+          end
 
-        argv = restart_args
+          o.on "--pidfile PATH", "Use PATH as a pidfile" do |arg|
+            c.pidfile arg
+          end
 
-        Dir.chdir @restart_dir
+          o.on "--preload", "Preload the app. Cluster mode only" do
+            c.preload_app!
+          end
 
-        argv += [redirects] unless RUBY_VERSION < '1.9'
-        Kernel.exec(*argv)
-      end
-    end
+          o.on "--prune-bundler", "Prune out the bundler env if possible" do
+            c.prune_bundler
+          end
 
-    # 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
+          o.on "-q", "--quiet", "Do not log requests internally (default true)" do
+            c.quiet
+          end
 
-      if dir = @options[:directory]
-        Dir.chdir dir
-      end
+          o.on "-v", "--log-requests", "Log requests as they occur" do
+            c.log_requests
+          end
 
-      set_rack_environment
+          o.on "-R", "--restart-cmd CMD",
+            "The puma command to run during a hot restart",
+            "Default: inferred" do |cmd|
+            c.restart_command cmd
+          end
 
-      if clustered?
-        @events = PidEvents.new STDOUT, STDERR
-        @options[:logger] = @events
+          o.on "-S", "--state PATH", "Where to store the state details" do |arg|
+            c.state_path arg
+          end
 
-        @runner = Cluster.new(self)
-      else
-        @runner = Single.new(self)
-      end
+          o.on '-t', '--threads INT', "min:max threads to use (default 0:16)" do |arg|
+            min, max = arg.split(":")
+            if max
+              c.threads min, max
+            else
+              c.threads 0, max
+            end
+          end
 
-      setup_signals
+          o.on "--tcp-mode", "Run the app in raw TCP mode instead of HTTP mode" do
+            c.tcp_mode!
+          end
 
-      @status = :run
+          o.on "-V", "--version", "Print the version information" do
+            puts "puma version #{Puma::Const::VERSION}"
+            exit 0
+          end
 
-      @runner.run
+          o.on "-w", "--workers COUNT",
+            "Activate cluster mode: How many worker processes to create" do |arg|
+            c.workers arg
+          end
 
-      case @status
-      when :halt
-        log "* Stopping immediately!"
-      when :run, :stop
-        graceful_stop
-      when :restart
-        log "* Restarting..."
-        @runner.before_restart
-        restart!
-      when :exit
-        # nothing
-      end
+          o.on "--tag NAME", "Additional text to display in process listing" do |arg|
+            c.tag arg
+          end
 
-    ensure
-      delete_pidfile
-    end
+          o.on "--redirect-stdout FILE", "Redirect STDOUT to a specific file" do |arg|
+            @stdout = arg.to_s
+          end
 
-    def setup_signals
-      begin
-        Signal.trap "SIGUSR2" do
-          restart
-        end
-      rescue Exception
-        log "*** SIGUSR2 not implemented, signal based restart unavailable!"
-      end
+          o.on "--redirect-stderr FILE", "Redirect STDERR to a specific file" do |arg|
+            @stderr = arg.to_s
+          end
 
-      begin
-        Signal.trap "SIGUSR1" do
-          phased_restart
-        end
-      rescue Exception
-        log "*** SIGUSR1 not implemented, signal based restart unavailable!"
-      end
+          o.on "--[no-]redirect-append", "Append to redirected files" do |val|
+            @append = val
+          end
 
-      begin
-        Signal.trap "SIGTERM" do
-          stop
-        end
-      rescue Exception
-        log "*** SIGTERM not implemented, signal based gracefully stopping unavailable!"
-      end
+          o.banner = "puma <options> <rackup file>"
 
-      if jruby?
-        Signal.trap("INT") do
-          @status = :exit
-          graceful_stop
-          exit
+          o.on_tail "-h", "--help", "Show help" do
+            $stdout.puts o
+            exit 0
+          end
         end
       end
     end
-
-    def stop
-      @status = :stop
-      @runner.stop
-    end
-
-    def restart
-      @status = :restart
-      @runner.restart
-    end
-
-    def phased_restart
-      unless @runner.respond_to?(:phased_restart) and @runner.phased_restart
-        log "* phased-restart called but not available, restarting normally."
-        return restart
-      end
-      true
-    end
-
-    def stats
-      @runner.stats
-    end
-
-    def halt
-      @status = :halt
-      @runner.halt
-    end
   end
 end