passenger 5.0.18 → 5.0.19

data/lib/phusion_passenger/request_handler/thread_handler.rb

@@ -1,422 +0,0 @@
-#  Phusion Passenger - https://www.phusionpassenger.com/
-#  Copyright (c) 2010-2015 Phusion
-#
-#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
-#
-#  Permission is hereby granted, free of charge, to any person obtaining a copy
-#  of this software and associated documentation files (the "Software"), to deal
-#  in the Software without restriction, including without limitation the rights
-#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-#  copies of the Software, and to permit persons to whom the Software is
-#  furnished to do so, subject to the following conditions:
-#
-#  The above copyright notice and this permission notice shall be included in
-#  all copies or substantial portions of the Software.
-#
-#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-#  THE SOFTWARE.
-
-PhusionPassenger.require_passenger_lib 'constants'
-PhusionPassenger.require_passenger_lib 'debug_logging'
-PhusionPassenger.require_passenger_lib 'message_channel'
-PhusionPassenger.require_passenger_lib 'utils'
-PhusionPassenger.require_passenger_lib 'utils/native_support_utils'
-PhusionPassenger.require_passenger_lib 'utils/unseekable_socket'
-
-module PhusionPassenger
-  class RequestHandler
-
-    # This class encapsulates the logic of a single RequestHandler thread.
-    class ThreadHandler
-      include DebugLogging
-      include Utils
-
-      class Interrupted < StandardError
-      end
-
-      REQUEST_METHOD = 'REQUEST_METHOD'.freeze
-      GET            = 'GET'.freeze
-      PING           = 'PING'.freeze
-      OOBW           = 'OOBW'.freeze
-      PASSENGER_CONNECT_PASSWORD  = 'PASSENGER_CONNECT_PASSWORD'.freeze
-      CONTENT_LENGTH = 'CONTENT_LENGTH'.freeze
-      TRANSFER_ENCODING = 'TRANSFER_ENCODING'.freeze
-
-      MAX_HEADER_SIZE = 128 * 1024
-
-      OBJECT_SPACE_SUPPORTS_LIVE_OBJECTS      = ObjectSpace.respond_to?(:live_objects)
-      OBJECT_SPACE_SUPPORTS_ALLOCATED_OBJECTS = ObjectSpace.respond_to?(:allocated_objects)
-      OBJECT_SPACE_SUPPORTS_COUNT_OBJECTS     = ObjectSpace.respond_to?(:count_objects)
-      GC_SUPPORTS_TIME        = GC.respond_to?(:time)
-      GC_SUPPORTS_CLEAR_STATS = GC.respond_to?(:clear_stats)
-
-      attr_reader :thread
-      attr_reader :stats_mutex
-      attr_reader :interruptable
-      attr_reader :iteration
-
-      def initialize(request_handler, options = {})
-        @request_handler   = request_handler
-        @server_socket     = Utils.require_option(options, :server_socket)
-        @socket_name       = Utils.require_option(options, :socket_name)
-        @protocol          = Utils.require_option(options, :protocol)
-        @app_group_name    = Utils.require_option(options, :app_group_name)
-        Utils.install_options_as_ivars(self, options,
-          :app,
-          :union_station_core,
-          :connect_password,
-          :keepalive_enabled
-        )
-
-        @stats_mutex   = Mutex.new
-        @interruptable = false
-        @iteration     = 0
-
-        if @protocol == :session
-          metaclass = class << self; self; end
-          metaclass.class_eval do
-            alias parse_request parse_session_request
-          end
-        elsif @protocol == :http
-          metaclass = class << self; self; end
-          metaclass.class_eval do
-            alias parse_request parse_http_request
-          end
-        else
-          raise ArgumentError, "Unknown protocol specified"
-        end
-      end
-
-      def install
-        @thread = Thread.current
-        Thread.current[:passenger_thread_handler] = self
-        PhusionPassenger.call_event(:starting_request_handler_thread)
-      end
-
-      def main_loop(finish_callback)
-        socket_wrapper = Utils::UnseekableSocket.new
-        channel        = MessageChannel.new
-        buffer         = ''
-        buffer.force_encoding('binary') if buffer.respond_to?(:force_encoding)
-
-        begin
-          finish_callback.call
-          while true
-            hijacked = accept_and_process_next_request(socket_wrapper, channel, buffer)
-            socket_wrapper = Utils::UnseekableSocket.new if hijacked
-          end
-        rescue Interrupted
-          # Do nothing.
-        end
-        debug("Thread handler main loop exited normally")
-      ensure
-        @stats_mutex.synchronize { @interruptable = true }
-      end
-
-    private
-      # Returns true if the socket has been hijacked, false otherwise.
-      def accept_and_process_next_request(socket_wrapper, channel, buffer)
-        @stats_mutex.synchronize do
-          @interruptable = true
-        end
-        if @last_connection
-          connection = @last_connection
-          channel.io = connection
-          @last_connection = nil
-          headers = parse_request(connection, channel, buffer)
-        else
-          connection = socket_wrapper.wrap(@server_socket.accept)
-        end
-        @stats_mutex.synchronize do
-          @interruptable = false
-          @iteration    += 1
-        end
-        trace(3, "Accepted new request on socket #{@socket_name}")
-        if !headers
-          # New socket accepted, instead of keeping-alive an old one
-          channel.io = connection
-          headers = parse_request(connection, channel, buffer)
-        end
-        if headers
-          prepare_request(connection, headers)
-          begin
-            if headers[REQUEST_METHOD] == GET
-              process_request(headers, connection, socket_wrapper, @protocol == :http)
-            elsif headers[REQUEST_METHOD] == PING
-              process_ping(headers, connection)
-              false
-            elsif headers[REQUEST_METHOD] == OOBW
-              process_oobw(headers, connection)
-              false
-            else
-              process_request(headers, connection, socket_wrapper, @protocol == :http)
-            end
-          rescue Exception
-            has_error = true
-            raise
-          ensure
-            if headers[RACK_HIJACK_IO]
-              socket_wrapper = nil
-              connection = nil
-              channel = nil
-            end
-            finalize_request(connection, headers, has_error)
-            trace(3, "Request done.")
-          end
-        else
-          trace(2, "No headers parsed; disconnecting client.")
-          false
-        end
-      rescue Interrupted
-        raise
-      rescue => e
-        if socket_wrapper && socket_wrapper.source_of_exception?(e)
-          # EPIPE is harmless, it just means that the client closed the connection.
-          if !e.is_a?(Errno::EPIPE)
-            print_exception("Passenger RequestHandler's client socket", e)
-          end
-        else
-          if headers
-            PhusionPassenger.log_request_exception(headers, e)
-          end
-          # should_reraise_error? returns true except in unit tests,
-          # so we normally stop the request handler upon encountering
-          # non-EPIPE errors. We do this because process_request is already
-          # supposed to catch application-level exceptions. If an
-          # exception happened outside of process_request, then it's
-          # probably serious enough to warrant stopping the request handler.
-          raise e if should_reraise_error?(e)
-        end
-        # Here we do not know whether the connection was hijacked, but
-        # to be on the safe side (and have a new socket_wrapper created)
-        # let's say that it is.
-        true
-      ensure
-        # Close connection if keep-alive not possible
-        if connection && !connection.closed? && !@last_connection
-          # The 'close_write' here prevents forked child
-          # processes from unintentionally keeping the
-          # connection open.
-          begin
-            connection.close_write
-          rescue SystemCallError, IOError
-          end
-          begin
-            connection.close
-          rescue SystemCallError
-          end
-        end
-      end
-
-      def parse_session_request(connection, channel, buffer)
-        headers_data = channel.read_scalar(buffer, MAX_HEADER_SIZE)
-        if headers_data.nil?
-          return
-        end
-        headers = Utils::NativeSupportUtils.split_by_null_into_hash(headers_data)
-        if @connect_password && headers[PASSENGER_CONNECT_PASSWORD] != @connect_password
-          warn "*** Passenger RequestHandler warning: " <<
-            "someone tried to connect with an invalid connect password."
-          return
-        else
-          return headers
-        end
-      rescue SecurityError => e
-        warn("*** Passenger RequestHandler warning: " <<
-          "HTTP header size exceeded maximum.")
-        return
-      end
-
-      # Like parse_session_request, but parses an HTTP request. This is a very minimalistic
-      # HTTP parser and is not intended to be complete, fast or secure, since the HTTP server
-      # socket is intended to be used for debugging purposes only.
-      def parse_http_request(connection, channel, buffer)
-        headers = {}
-
-        data = ""
-        while data !~ /\r\n\r\n/ && data.size < MAX_HEADER_SIZE
-          data << connection.readpartial(16 * 1024)
-        end
-        if data.size >= MAX_HEADER_SIZE
-          warn("*** Passenger RequestHandler warning: " <<
-            "HTTP header size exceeded maximum.")
-          return
-        end
-
-        data.gsub!(/\r\n\r\n.*/, '')
-        data.split("\r\n").each_with_index do |line, i|
-          if i == 0
-            # GET / HTTP/1.1
-            line =~ /^([A-Za-z]+) (.+?) (HTTP\/\d\.\d)$/
-            request_method = $1
-            request_uri    = $2
-            protocol       = $3
-            if request_method.nil?
-              warn("*** Passenger RequestHandler warning: " <<
-                "Invalid HTTP request.")
-              return
-            end
-            path_info, query_string    = request_uri.split("?", 2)
-            headers[REQUEST_METHOD]    = request_method
-            headers["REQUEST_URI"]     = request_uri
-            headers["QUERY_STRING"]    = query_string || ""
-            headers["SCRIPT_NAME"]     = ""
-            headers["PATH_INFO"]       = path_info
-            headers["SERVER_NAME"]     = "127.0.0.1"
-            headers["SERVER_PORT"]     = connection.addr[1].to_s
-            headers["SERVER_PROTOCOL"] = protocol
-          else
-            header, value = line.split(/\s*:\s*/, 2)
-            header.upcase!            # "Foo-Bar" => "FOO-BAR"
-            header.gsub!("-", "_")    #           => "FOO_BAR"
-            if header == CONTENT_LENGTH || header == "CONTENT_TYPE"
-              headers[header] = value
-            else
-              headers["HTTP_#{header}"] = value
-            end
-          end
-        end
-
-        if @connect_password && headers["HTTP_X_PASSENGER_CONNECT_PASSWORD"] != @connect_password
-          warn "*** Passenger RequestHandler warning: " <<
-            "someone tried to connect with an invalid connect password."
-          return
-        else
-          return headers
-        end
-      rescue EOFError
-        return
-      end
-
-      def process_ping(env, connection)
-        connection.write("pong")
-      end
-
-      def process_oobw(env, connection)
-        PhusionPassenger.call_event(:oob_work)
-        connection.write("oobw done")
-      end
-
-    # def process_request(env, connection, socket_wrapper, full_http_response)
-    #   raise NotImplementedError, "Override with your own implementation!"
-    # end
-
-      def prepare_request(connection, headers)
-        transfer_encoding = headers[TRANSFER_ENCODING]
-        content_length = headers[CONTENT_LENGTH]
-        @can_keepalive = @keepalive_enabled &&
-          !transfer_encoding &&
-          !content_length
-        @keepalive_performed = false
-
-        if !transfer_encoding && !content_length
-          connection.simulate_eof!
-        end
-
-        if @union_station_core && headers[PASSENGER_TXN_ID]
-          txn_id = headers[PASSENGER_TXN_ID]
-          transaction = @union_station_core.continue_transaction(txn_id,
-            @app_group_name,
-            :requests,
-            PhusionPassenger.union_station_key)
-          headers[UNION_STATION_REQUEST_TRANSACTION] = transaction
-          headers[UNION_STATION_CORE] = @union_station_core
-          headers[PASSENGER_APP_GROUP_NAME] = @app_group_name
-          Thread.current[UNION_STATION_REQUEST_TRANSACTION] = transaction
-          Thread.current[UNION_STATION_CORE] = @union_station_core
-          Thread.current[PASSENGER_TXN_ID] = txn_id
-          if OBJECT_SPACE_SUPPORTS_LIVE_OBJECTS
-            transaction.message("Initial objects on heap: #{ObjectSpace.live_objects}")
-          end
-          if OBJECT_SPACE_SUPPORTS_ALLOCATED_OBJECTS
-            transaction.message("Initial objects allocated so far: #{ObjectSpace.allocated_objects}")
-          elsif OBJECT_SPACE_SUPPORTS_COUNT_OBJECTS
-            count = ObjectSpace.count_objects
-            transaction.message("Initial objects allocated so far: #{count[:TOTAL] - count[:FREE]}")
-          end
-          if GC_SUPPORTS_TIME
-            transaction.message("Initial GC time: #{GC.time}")
-          end
-          transaction.begin_measure("app request handler processing")
-        end
-
-        #################
-      end
-
-      def finalize_request(connection, headers, has_error)
-        transaction = headers[UNION_STATION_REQUEST_TRANSACTION]
-        Thread.current[UNION_STATION_CORE] = nil
-        Thread.current[UNION_STATION_REQUEST_TRANSACTION] = nil
-
-        if connection
-          connection.stop_simulating_eof!
-        end
-
-        if transaction && !transaction.closed?
-          exception_occurred = false
-          begin
-            transaction.end_measure("app request handler processing", has_error)
-            if OBJECT_SPACE_SUPPORTS_LIVE_OBJECTS
-              transaction.message("Final objects on heap: #{ObjectSpace.live_objects}")
-            end
-            if OBJECT_SPACE_SUPPORTS_ALLOCATED_OBJECTS
-              transaction.message("Final objects allocated so far: #{ObjectSpace.allocated_objects}")
-            elsif OBJECT_SPACE_SUPPORTS_COUNT_OBJECTS
-              count = ObjectSpace.count_objects
-              transaction.message("Final objects allocated so far: #{count[:TOTAL] - count[:FREE]}")
-            end
-            if GC_SUPPORTS_TIME
-              transaction.message("Final GC time: #{GC.time}")
-            end
-            if GC_SUPPORTS_CLEAR_STATS
-              # Clear statistics to void integer wraps.
-              GC.clear_stats
-            end
-          rescue Exception
-            # Maybe this exception was raised while communicating
-            # with the UstRouter. If that is the case then
-            # transaction.close may also raise an exception, but we're only
-            # interested in the original exception. So if this
-            # situation occurs we must ignore any exceptions raised
-            # by transaction.close.
-            exception_occurred = true
-            raise
-          ensure
-            # It is important that the following call receives an ACK
-            # from the UstRouter and that we don't close the socket
-            # connection until the ACK has been received, otherwise
-            # the Passenger core may close the transaction before this
-            # process's openTransaction command is processed.
-            begin
-              transaction.close
-            rescue
-              raise if !exception_occurred
-            end
-          end
-        end
-
-        if !has_error && @keepalive_performed && connection
-          trace(3, "Keep-aliving connection.")
-          @last_connection = connection
-        end
-
-        #################
-      end
-
-      def should_reraise_error?(e)
-        # Stubable by unit tests.
-        return true
-      end
-
-      def should_swallow_app_error?(e, socket_wrapper)
-        return socket_wrapper && socket_wrapper.source_of_exception?(e) && e.is_a?(Errno::EPIPE)
-      end
-    end
-
-  end # class RequestHandler
-end # module PhusionPassenger

data/lib/phusion_passenger/standalone/start_command.rb

@@ -1,824 +0,0 @@
-#  Phusion Passenger - https://www.phusionpassenger.com/
-#  Copyright (c) 2010-2015 Phusion
-#
-#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
-#
-#  Permission is hereby granted, free of charge, to any person obtaining a copy
-#  of this software and associated documentation files (the "Software"), to deal
-#  in the Software without restriction, including without limitation the rights
-#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-#  copies of the Software, and to permit persons to whom the Software is
-#  furnished to do so, subject to the following conditions:
-#
-#  The above copyright notice and this permission notice shall be included in
-#  all copies or substantial portions of the Software.
-#
-#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-#  THE SOFTWARE.
-
-require 'optparse'
-require 'thread'
-PhusionPassenger.require_passenger_lib 'constants'
-PhusionPassenger.require_passenger_lib 'ruby_core_enhancements'
-PhusionPassenger.require_passenger_lib 'standalone/command'
-PhusionPassenger.require_passenger_lib 'standalone/config_utils'
-PhusionPassenger.require_passenger_lib 'utils'
-PhusionPassenger.require_passenger_lib 'utils/tmpio'
-PhusionPassenger.require_passenger_lib 'platform_info/ruby'
-
-# ## Coding notes
-#
-# ### Lazy library loading
-#
-# We lazy load as many libraries as possible not only to improve startup performance,
-# but also to ensure that we don't require libraries before we've passed the dependency
-# checking stage of the runtime installer.
-#
-# ### Path handling
-#
-# Handle paths as follows so that the behavior complies with the documentation:
-# - Immediately absolutize all paths in the option parser, so that relative paths passed
-#   through the command line are relative to the current working directory.
-# - Add the path's option key to ConfigUtils#resolve_config_file_paths so that relative
-#   paths in Passengerfile.json are absolutized relative to Passengerfile.json.
-
-module PhusionPassenger
-  module Standalone
-
-    class StartCommand < Command
-      DEFAULT_OPTIONS = {
-        :environment       => ENV['RAILS_ENV'] || ENV['RACK_ENV'] || ENV['NODE_ENV'] ||
-          ENV['PASSENGER_APP_ENV'] || 'development',
-        :spawn_method      => Kernel.respond_to?(:fork) ? DEFAULT_SPAWN_METHOD : 'direct',
-        :engine            => "nginx",
-        :nginx_version     => PREFERRED_NGINX_VERSION,
-        :log_level         => DEFAULT_LOG_LEVEL,
-        :auto              => !STDIN.tty? || !STDOUT.tty?,
-        :ctls              => [],
-        :envvars           => {}
-      }.freeze
-
-      def run
-        parse_options
-        load_local_config_file
-        remerge_all_options
-        sanity_check_options_and_set_defaults
-
-        lookup_runtime_and_ensure_installed
-        set_stdout_stderr_binmode
-        exit if @options[:runtime_check_only]
-
-        find_apps
-        find_pid_and_log_file(@app_finder, @options)
-        create_working_dir
-        initialize_vars
-        start_engine
-        begin
-          show_intro_message
-          maybe_daemonize
-          touch_temp_dir_in_background
-          ########################
-          ########################
-          watch_log_files_in_background if should_watch_logs?
-          wait_until_engine_has_exited if should_wait_until_engine_has_exited?
-        rescue Interrupt
-          trapsafe_shutdown_and_cleanup(true)
-          exit 2
-        rescue SignalException => signal
-          trapsafe_shutdown_and_cleanup(true)
-          if signal.message == 'SIGINT' || signal.message == 'SIGTERM'
-            exit 2
-          else
-            raise
-          end
-        rescue Exception
-          trapsafe_shutdown_and_cleanup(true)
-          raise
-        else
-          trapsafe_shutdown_and_cleanup(false)
-        ensure
-          reset_traps_intterm
-        end
-      end
-
-    private
-      ################# Configuration loading, option parsing and initialization ###################
-
-      def self.create_option_parser(options)
-        # Clear @parsed_options so that #remerge_all_options works.
-        options.clear
-
-        # If you add or change an option, make sure to update the following places too:
-        # lib/phusion_passenger/standalone/start_command/builtin_engine.rb, #build_daemon_controller_options
-        # resources/templates/config/standalone.erb
-        OptionParser.new do |opts|
-          nl = "\n" + ' ' * 37
-          opts.banner = "Usage: passenger start [DIRECTORY] [OPTIONS]\n"
-          opts.separator "Starts #{PROGRAM_NAME} Standalone and serve one or more web applications."
-          opts.separator ""
-
-          opts.separator "Server options:"
-          opts.on("-a", "--address HOST", String, "Bind to the given address.#{nl}" +
-            "Default: 0.0.0.0") do |value|
-            options[:address] = value
-          end
-          opts.on("-p", "--port NUMBER", Integer,
-            "Use the given port number. Default: 3000") do |value|
-            options[:port] = value
-          end
-          opts.on("-S", "--socket FILE", String,
-            "Bind to Unix domain socket instead of TCP#{nl}" +
-            "socket") do |value|
-            options[:socket_file] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("--ssl", "Enable SSL support (Nginx#{nl}" +
-            "engine only)") do
-            options[:ssl] = true
-          end
-          opts.on("--ssl-certificate PATH", String,
-            "Specify the SSL certificate path#{nl}" +
-            "(Nginx engine only)") do |value|
-            options[:ssl_certificate] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("--ssl-certificate-key PATH", String,
-            "Specify the SSL key path") do |value|
-            options[:ssl_certificate_key] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("--ssl-port PORT", Integer,
-            "Listen for SSL on this port, while#{nl}" +
-            "listening for HTTP on the normal port#{nl}" +
-            "(Nginx engine only)") do |value|
-            options[:ssl_port] = value
-          end
-          opts.on("-d", "--daemonize", "Daemonize into the background") do
-            options[:daemonize] = true
-          end
-          opts.on("--user USERNAME", String, "User to run as. Ignored unless#{nl}" +
-            "running as root") do |value|
-            options[:user] = value
-          end
-          opts.on("--log-file FILENAME", String,
-            "Where to write log messages. Default:#{nl}" +
-            "console, or /dev/null when daemonized") do |value|
-            options[:log_file] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("--pid-file FILENAME", String, "Where to store the PID file") do |value|
-            options[:pid_file] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("--instance-registry-dir PATH", String,
-            "Use the given instance registry directory") do |value|
-            options[:instance_registry_dir] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("--data-buffer-dir PATH", String,
-            "Use the given data buffer directory") do |value|
-            options[:data_buffer_dir] = File.absolute_path_no_resolve(value)
-          end
-
-          opts.separator ""
-          opts.separator "Application loading options:"
-          opts.on("-e", "--environment ENV", String,
-            "Framework environment.#{nl}" +
-            "Default: #{DEFAULT_OPTIONS[:environment]}") do |value|
-            options[:environment] = value
-          end
-          opts.on("--ruby FILENAME", String, "Executable to use for Ruby apps#{nl}" +
-            "Default: " + PlatformInfo.ruby_command + " (current context)") do |value|
-            options[:ruby] = value
-          end
-          opts.on("--nodejs FILENAME", String, "Executable to use for NodeJs apps") do |value|
-            options[:nodejs] = value
-          end
-          opts.on("--python FILENAME", String, "Executable to use for Python apps") do |value|
-            options[:python] = value
-          end
-          opts.on("--meteor-app-settings FILENAME", String,
-            "Settings file to use for (development mode) Meteor apps") do |value|
-            options[:meteor_app_settings] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("-R", "--rackup FILE", String,
-            "Consider application a Ruby app, and use#{nl}" +
-            "the given rackup file") do |value|
-            options[:app_type] = "rack"
-            options[:startup_file] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("--app-type NAME", String,
-            "Force app to be detected as the given type") do |value|
-            options[:app_type] = value
-          end
-          opts.on("--startup-file FILENAME", String,
-            "Force given startup file to be used") do |value|
-            options[:startup_file] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("--spawn-method NAME", String,
-            "The spawn method to use. Default: #{DEFAULT_OPTIONS[:spawn_method]}") do |value|
-            options[:spawn_method] = value
-          end
-          opts.on("--static-files-dir PATH", String,
-            "Specify the static files dir (Nginx engine#{nl}" +
-            "only)") do |val|
-            options[:static_files_dir] = File.absolute_path_no_resolve(val)
-          end
-          opts.on("--restart-dir PATH", String, "Specify the restart dir") do |val|
-            options[:restart_dir] = File.absolute_path_no_resolve(val)
-          end
-          opts.on("--friendly-error-pages", "Turn on friendly error pages") do
-            options[:friendly_error_pages] = true
-          end
-          opts.on("--no-friendly-error-pages", "Turn off friendly error pages") do
-            options[:friendly_error_pages] = false
-          end
-          opts.on("--load-shell-envvars",
-            "Load shell startup files before loading#{nl}" +
-            "application") do
-            options[:load_shell_envvars] = true
-          end
-          opts.on("--debugger", "Enable debugger support") do
-            options[:debugger] = true
-          end
-
-          opts.separator ""
-          opts.separator "Process management options:"
-          opts.on("--max-pool-size NUMBER", Integer,
-            "Maximum number of application processes.#{nl}" +
-            "Default: #{DEFAULT_MAX_POOL_SIZE}") do |value|
-            if value < 1
-              abort "*** ERROR: you may only specify for --max-pool-size a number greater than or equal to 1"
-            end
-            options[:max_pool_size] = value
-          end
-          opts.on("--min-instances NUMBER", Integer,
-            "Minimum number of processes per#{nl}" +
-            "application. Default: 1") do |value|
-            options[:min_instances] = value
-          end
-          opts.on("--pool-idle-time SECONDS", Integer,
-            "Maximum time that processes may be idle.#{nl}" +
-            "Default: #{DEFAULT_POOL_IDLE_TIME}") do |value|
-            options[:pool_idle_time] = value
-          end
-          opts.on("--max-preloader-idle-time SECONDS", Integer,
-            "Maximum time that preloader processes may#{nl}" +
-            "be idle. A value of 0 means that preloader#{nl}" +
-            "processes never timeout. Default: #{DEFAULT_MAX_PRELOADER_IDLE_TIME}") do |value|
-            options[:max_preloader_idle_time] = value
-          end
-          opts.on("--concurrency-model NAME", String,
-            "The concurrency model to use, either#{nl}" +
-            "'process' or 'thread' (Enterprise only).#{nl}" +
-            "Default: #{DEFAULT_CONCURRENCY_MODEL}") do |value|
-            options[:concurrency_model] = value
-          end
-          opts.on("--thread-count NAME", Integer,
-            "The number of threads to use when using#{nl}" +
-            "the 'thread' concurrency model (Enterprise#{nl}" +
-            "only). Default: #{DEFAULT_APP_THREAD_COUNT}") do |value|
-            options[:thread_count] = value
-          end
-          opts.on("--rolling-restarts", "Enable rolling restarts (Enterprise only)") do
-            options[:rolling_restarts] = true
-          end
-          opts.on("--resist-deployment-errors", "Enable deployment error resistance#{nl}" +
-            "(Enterprise only)") do
-            options[:resist_deployment_errors] = true
-          end
-
-          opts.separator ""
-          opts.separator "Request handling options:"
-          opts.on("--max-request-time SECONDS", "Abort requests that take too much time#{nl}" +
-            "(Enterprise only)") do |val|
-            options[:max_request_time] = val
-          end
-          opts.on("--sticky-sessions", "Enable sticky sessions") do
-            options[:sticky_sessions] = true
-          end
-          opts.on("--sticky-sessions-cookie-name NAME", String,
-            "Cookie name to use for sticky sessions.#{nl}" +
-            "Default: #{DEFAULT_STICKY_SESSIONS_COOKIE_NAME}") do |value|
-            options[:sticky_sessions_cookie_name] = value
-          end
-          opts.on("--vary-turbocache-by-cookie NAME", String,
-            "Vary the turbocache by the cookie of the#{nl}" +
-            "given name") do |value|
-            options[:vary_turbocache_by_cookie] = value
-          end
-          opts.on("--disable-turbocaching", "Disable turbocaching") do
-            options[:turbocaching] = false
-          end
-
-          opts.separator ""
-          opts.separator "Union Station options:"
-          opts.on("--union-station-gateway HOST:PORT", String,
-            "Specify Union Station Gateway host and port") do |value|
-            host, port = value.split(":", 2)
-            port = port.to_i
-            port = 443 if port == 0
-            options[:union_station_gateway_address] = host
-            options[:union_station_gateway_port] = port.to_i
-          end
-          opts.on("--union-station-key KEY", String, "Specify Union Station key") do |value|
-            options[:union_station_key] = value
-          end
-
-          opts.separator ""
-          opts.separator "Nginx engine options:"
-          opts.on("--nginx-bin FILENAME", String, "Nginx binary to use as core") do |value|
-            options[:nginx_bin] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("--nginx-version VERSION", String,
-            "Nginx version to use as core.#{nl}" +
-            "Default: #{PREFERRED_NGINX_VERSION}") do |value|
-            options[:nginx_version] = value
-          end
-          opts.on("--nginx-tarball FILENAME", String,
-            "If Nginx needs to be installed, then the#{nl}" +
-            "given tarball will be used instead of#{nl}" +
-            "downloading from the Internet") do |value|
-            options[:nginx_tarball] = File.absolute_path_no_resolve(value)
-          end
-          opts.on("--nginx-config-template FILENAME", String,
-            "The template to use for generating the#{nl}" +
-            "Nginx config file") do |value|
-            options[:nginx_config_template] = File.absolute_path_no_resolve(value)
-          end
-
-          opts.separator ""
-          opts.separator "Advanced options:"
-          opts.on("--engine NAME", String,
-            "Underlying HTTP engine to use. Available#{nl}" +
-            "options: nginx (default), builtin") do |value|
-            options[:engine] = value
-          end
-          opts.on("--log-level NUMBER", Integer, "Log level to use. Default: #{DEFAULT_LOG_LEVEL}") do |value|
-            options[:log_level] = value
-          end
-          opts.on("--auto", "Run in non-interactive mode. Default when#{nl}" +
-            "stdin or stdout is not a TTY") do
-            options[:auto] = true
-          end
-          opts.on("--ctl NAME=VALUE", String) do |value|
-            if value !~ /=.+/
-              abort "*** ERROR: invalid --ctl format: #{value}"
-            end
-            options[:ctls] ||= []
-            options[:ctls] << value
-          end
-          opts.on("--binaries-url-root URL", String,
-            "If Nginx needs to be installed, then the#{nl}" +
-            "specified URL will be checked for binaries#{nl}" +
-            "prior to a local build") do |value|
-            options[:binaries_url_root] = value
-          end
-          opts.on("--no-download-binaries", "Never download binaries") do
-            options[:download_binaries] = false
-          end
-          opts.on("--runtime-check-only",
-            "Quit after checking whether the#{nl}" +
-            "#{PROGRAM_NAME} Standalone runtime files#{nl}" +
-            "are installed") do
-            options[:runtime_check_only] = true
-          end
-          opts.on("--no-install-runtime", "Abort if runtime must be installed") do
-            options[:dont_install_runtime] = true
-          end
-          opts.on("--no-compile-runtime", "Abort if runtime must be compiled") do
-            options[:dont_compile_runtime] = true
-          end
-        end
-      end
-
-      def load_local_config_file
-        if @argv.empty?
-          app_dir = File.absolute_path_no_resolve(".")
-        elsif @argv.size == 1
-          app_dir = @argv[0]
-        end
-        @local_options = {}
-        if app_dir
-          begin
-            ConfigUtils.load_local_config_file!(app_dir, @local_options)
-          rescue ConfigUtils::ConfigLoadError => e
-            abort "*** ERROR: #{e.message}"
-          end
-        end
-      end
-
-      # We want the command line options to override the options in the local config
-      # file, but the local config file could only be parsed when the command line
-      # options have been parsed. In this method we remerge all the config options
-      # from different sources so that options are overriden according to the following
-      # order:
-      #
-      # - DEFAULT_OPTIONS
-      # - global config file
-      # - local config file
-      # - command line options
-      def remerge_all_options
-        @options = DEFAULT_OPTIONS.
-          merge(@global_options).
-          merge(@local_options).
-          merge(@parsed_options)
-        @options.delete(:config_filename)
-      end
-
-      def sanity_check_options_and_set_defaults
-        if @argv.size > 1
-          PhusionPassenger.require_passenger_lib 'standalone/app_finder'
-          if !AppFinder.supports_multi?
-            abort "You can only specify a single application directory as argument."
-          end
-        end
-
-        if (@options[:address] || @options[:port]) && @options[:socket_file]
-          abort "You cannot specify both --address/--port and --socket. Please choose either one."
-        end
-        if @options[:ssl] && !@options[:ssl_certificate]
-          abort "You specified --ssl. Please specify --ssl-certificate as well."
-        end
-        if @options[:ssl] && !@options[:ssl_certificate_key]
-          abort "You specified --ssl. Please specify --ssl-certificate-key as well."
-        end
-        if @options[:engine] != "builtin" && @options[:engine] != "nginx"
-          abort "You've specified an invalid value for --engine. The only values allowed are: builtin, nginx."
-        end
-
-        if !@options[:socket_file]
-          @options[:address] ||= "0.0.0.0"
-          @options[:port] ||= 3000
-        end
-
-        if @options[:engine] == "builtin"
-          # We explicitly check that some options are set and warn the user about this,
-          # in case they are using the builtin engine. We don't warn about options
-          # that begin with --nginx- because that should be obvious.
-          check_nginx_option_used_with_builtin_engine(:ssl, "--ssl")
-          check_nginx_option_used_with_builtin_engine(:ssl_certificate, "--ssl-certificate")
-          check_nginx_option_used_with_builtin_engine(:ssl_certificate_key, "--ssl-certificate-key")
-          check_nginx_option_used_with_builtin_engine(:ssl_port, "--ssl-port")
-          check_nginx_option_used_with_builtin_engine(:static_files_dir, "--static-files-dir")
-        end
-
-        #############
-      end
-
-      def check_nginx_option_used_with_builtin_engine(option, argument)
-        if @options.has_key?(option)
-          STDERR.puts "*** Warning: the #{argument} option is only allowed if you use " +
-            "the 'nginx' engine. You are currently using the 'builtin' engine, so " +
-            "this option has been ignored. To switch to the Nginx engine, please " +
-            "pass --engine=nginx."
-        end
-      end
-
-      def lookup_runtime_and_ensure_installed
-        @agent_exe = PhusionPassenger.find_support_binary(AGENT_EXE)
-        if @options[:nginx_bin]
-          @nginx_binary = @options[:nginx_bin]
-          if !@nginx_binary
-            abort "*** ERROR: Nginx binary #{@options[:nginx_bin]} does not exist"
-          end
-          if !@agent_exe
-            install_runtime
-            @agent_exe = PhusionPassenger.find_support_binary(AGENT_EXE)
-          end
-        else
-          nginx_name = "nginx-#{@options[:nginx_version]}"
-          @nginx_binary = PhusionPassenger.find_support_binary(nginx_name)
-          if !@agent_exe || !@nginx_binary
-            install_runtime
-            @agent_exe = PhusionPassenger.find_support_binary(AGENT_EXE)
-            @nginx_binary = PhusionPassenger.find_support_binary(nginx_name)
-          end
-        end
-      end
-
-      def install_runtime
-        if @options[:dont_install_runtime]
-          abort "*** ERROR: Refusing to install the #{PROGRAM_NAME} Standalone runtime " +
-            "because --no-install-runtime is given."
-        end
-
-        args = [
-          "--brief",
-          "--no-force-tip",
-          # Use default Utils::Download timeouts, which are short. We want short
-          # timeouts so that if the primary server is down and is not responding
-          # (as opposed to responding quickly with an error), then the system
-          # quickly switches to a mirror.
-          "--connect-timeout", "0",
-          "--idle-timeout", "0"
-        ]
-        if @options[:auto]
-          args << "--auto"
-        end
-        if @options[:binaries_url_root]
-          args << "--url-root"
-          args << @options[:binaries_url_root]
-        end
-        if @options[:nginx_version]
-          args << "--nginx-version"
-          args << @options[:nginx_version]
-        end
-        if @options[:nginx_tarball]
-          args << "--nginx-tarball"
-          args << @options[:nginx_tarball]
-        end
-        if @options[:dont_compile_runtime]
-          args << "--no-compile"
-        end
-        PhusionPassenger.require_passenger_lib 'config/install_standalone_runtime_command'
-        PhusionPassenger::Config::InstallStandaloneRuntimeCommand.new(args).run
-        puts
-        puts "--------------------------"
-        puts
-      end
-
-      def set_stdout_stderr_binmode
-        # We already set STDOUT and STDERR to binmode in bin/passenger, which
-        # fixes https://github.com/phusion/passenger-ruby-heroku-demo/issues/11.
-        # However RuntimeInstaller sets them to UTF-8, so here we set them back.
-        STDOUT.binmode
-        STDERR.binmode
-      end
-
-
-      ################## Core logic ##################
-
-      def find_apps
-        PhusionPassenger.require_passenger_lib 'standalone/app_finder'
-        @app_finder = AppFinder.new(@argv, @options)
-        @apps = @app_finder.scan
-        if @app_finder.multi_mode? && @options[:engine] != 'nginx'
-          puts "Mass deployment enabled, so forcing engine to 'nginx'."
-          @options[:engine] = 'nginx'
-        end
-      end
-
-      def find_pid_and_log_file(app_finder, options)
-        exec_root = app_finder.execution_root
-        if options[:socket_file]
-          pid_basename = "passenger.pid"
-          log_basename = "passenger.log"
-        else
-          pid_basename = "passenger.#{options[:port]}.pid"
-          log_basename = "passenger.#{options[:port]}.log"
-        end
-        if File.directory?("#{exec_root}/tmp/pids")
-          options[:pid_file] ||= "#{exec_root}/tmp/pids/#{pid_basename}"
-        else
-          options[:pid_file] ||= "#{exec_root}/#{pid_basename}"
-        end
-        if File.directory?("log")
-          options[:log_file] ||= "#{exec_root}/log/#{log_basename}"
-        else
-          options[:log_file] ||= "#{exec_root}/#{log_basename}"
-        end
-      end
-
-      def create_working_dir
-        # We don't remove the working dir in 'passenger start'. In daemon
-        # mode 'passenger start' just quits and lets background processes
-        # running. A specific background process, temp-dir-toucher, is
-        # responsible for cleaning up the working dir.
-        @working_dir = PhusionPassenger::Utils.mktmpdir("passenger-standalone.")
-        File.chmod(0755, @working_dir)
-        Dir.mkdir("#{@working_dir}/logs")
-        @can_remove_working_dir = true
-      end
-
-      def initialize_vars
-        @console_mutex = Mutex.new
-        @termination_pipe = IO.pipe
-        @threads = []
-        @interruptable_threads = []
-      end
-
-      def start_engine
-        metaclass = class << self; self; end
-        if @options[:engine] == 'nginx'
-          PhusionPassenger.require_passenger_lib 'standalone/start_command/nginx_engine'
-          metaclass.send(:include, PhusionPassenger::Standalone::StartCommand::NginxEngine)
-        else
-          PhusionPassenger.require_passenger_lib 'standalone/start_command/builtin_engine'
-          metaclass.send(:include, PhusionPassenger::Standalone::StartCommand::BuiltinEngine)
-        end
-        start_engine_real
-      end
-
-      # Returns the URL that the server will be listening on
-      # for the given app.
-      def listen_url(app)
-        if app[:socket_file]
-          "unix:#{app[:socket_file]}"
-        else
-          if @options[:engine] == 'nginx' && app[:ssl] && !app[:ssl_port]
-            scheme = "https"
-          else
-            scheme = "http"
-          end
-          result = "#{scheme}://"
-          if app[:port] == 80
-            result << app[:address]
-          else
-            result << compose_ip_and_port(app[:address], app[:port])
-          end
-          result << "/"
-          result
-        end
-      end
-
-      def compose_ip_and_port(ip, port)
-        if ip =~ /:/
-          # IPv6
-          "[#{ip}]:#{port}"
-        else
-          "#{ip}:#{port}"
-        end
-      end
-
-      def show_intro_message
-        puts "=============== Phusion Passenger Standalone web server started ==============="
-        puts "PID file: #{@options[:pid_file]}"
-        puts "Log file: #{@options[:log_file]}"
-        puts "Environment: #{@options[:environment]}"
-        puts "Accessible via: #{listen_url(@apps[0])}"
-
-        puts
-        if @options[:daemonize]
-          puts "Serving in the background as a daemon."
-        else
-          puts "You can stop #{PROGRAM_NAME} Standalone by pressing Ctrl-C."
-        end
-        puts "Problems? Check https://www.phusionpassenger.com/library/admin/standalone/troubleshooting/"
-        puts "==============================================================================="
-      end
-
-      def maybe_daemonize
-        if @options[:daemonize]
-          PhusionPassenger.require_passenger_lib 'platform_info/ruby'
-          if PlatformInfo.ruby_supports_fork?
-            daemonize
-          else
-            abort "Unable to daemonize using the current Ruby interpreter " +
-              "(#{PlatformInfo.ruby_command}) because it does not support forking."
-          end
-        end
-      end
-
-      def daemonize
-        pid = fork
-        if pid
-          # Parent
-          exit!(0)
-        else
-          # Child
-          trap "HUP", "IGNORE"
-          STDIN.reopen("/dev/null", "r")
-          STDOUT.reopen(@options[:log_file], "a")
-          STDERR.reopen(@options[:log_file], "a")
-          STDOUT.sync = true
-          STDERR.sync = true
-          Process.setsid
-          @threads.clear
-        end
-      end
-
-      def touch_temp_dir_in_background
-        result = system(@agent_exe,
-          "temp-dir-toucher",
-          @working_dir,
-          "--cleanup",
-          "--daemonize",
-          "--pid-file", "#{@working_dir}/temp_dir_toucher.pid",
-          "--log-file", @options[:log_file])
-        if !result
-          abort "Cannot start #{@agent_exe} temp-dir-toucher"
-        end
-        @can_remove_working_dir = false
-      end
-
-      def watch_log_file(log_file)
-        if File.exist?(log_file)
-          backward = 0
-        else
-          # tail bails out if the file doesn't exist, so wait until it exists.
-          while !File.exist?(log_file)
-            sleep 1
-          end
-          backward = 10
-        end
-
-        IO.popen("tail -f -n #{backward} \"#{log_file}\"", "rb") do |f|
-          begin
-            while true
-              begin
-                line = f.readline
-                @console_mutex.synchronize do
-                  STDOUT.write(line)
-                  STDOUT.flush
-                end
-              rescue EOFError
-                break
-              end
-            end
-          ensure
-            Process.kill('TERM', f.pid) rescue nil
-          end
-        end
-      end
-
-      def watch_log_files_in_background
-        @apps.each do |app|
-          thread = Utils.create_thread_and_abort_on_exception do
-            watch_log_file("#{app[:root]}/log/#{@options[:environment]}.log")
-          end
-          @threads << thread
-          @interruptable_threads << thread
-        end
-        thread = Utils.create_thread_and_abort_on_exception do
-          watch_log_file(@options[:log_file])
-        end
-        @threads << thread
-        @interruptable_threads << thread
-      end
-
-      def should_watch_logs?
-        return !@options[:daemonize] && @options[:log_file] != "/dev/null"
-      end
-
-      def should_wait_until_engine_has_exited?
-        return !@options[:daemonize] || @app_finder.multi_mode?
-      end
-
-
-      ################## Shut down and cleanup ##################
-
-      def capture_traps_intterm
-        return if @traps_captured
-        @traps_captured = 1
-        trap("INT", &method(:trapped_intterm))
-        trap("TERM", &method(:trapped_intterm))
-      end
-
-      def reset_traps_intterm
-        @traps_captured = nil
-        trap("INT", "DEFAULT")
-        trap("TERM", "DEFAULT")
-      end
-
-      def trapped_intterm(signal)
-        if @traps_captured == 1
-          @traps_captured += 1
-          puts "Ignoring signal #{signal} during shutdown. Send it again to force exit."
-        else
-          exit!(1)
-        end
-      end
-
-      def trapsafe_shutdown_and_cleanup(error_occurred)
-        # Ignore INT and TERM once, to allow clean shutdown in e.g. Foreman
-        capture_traps_intterm
-
-        # Stop engine
-        if @engine && (error_occurred || should_wait_until_engine_has_exited?)
-          @console_mutex.synchronize do
-            STDOUT.write("Stopping web server...")
-            STDOUT.flush
-            @engine.stop
-            STDOUT.puts " done"
-            STDOUT.flush
-          end
-          @engine = nil
-        end
-
-        # Stop threads
-        if @threads
-          if !@termination_pipe[1].closed?
-            @termination_pipe[1].write("x")
-            @termination_pipe[1].close
-          end
-          @interruptable_threads.each do |thread|
-            thread.terminate
-          end
-          @interruptable_threads = []
-          @threads.each do |thread|
-            thread.join
-          end
-          @threads = nil
-        end
-
-        if @can_remove_working_dir
-          FileUtils.remove_entry_secure(@working_dir)
-          @can_remove_working_dir = false
-        end
-      end
-
-      #################
-    end
-
-  end # module Standalone
-end # module PhusionPassenger