passenger 5.0.21 → 5.0.22

data/src/ruby_supportlib/phusion_passenger/standalone/config_utils.rb

@@ -23,6 +23,7 @@
 #  THE SOFTWARE.
 
 PhusionPassenger.require_passenger_lib 'ruby_core_enhancements'
+PhusionPassenger.require_passenger_lib 'standalone/config_options_list'
 
 module PhusionPassenger
   module Standalone
@@ -46,6 +47,23 @@ module PhusionPassenger
           USER_NAMESPACE_DIRNAME, "standalone", "config.json")
       end
 
+      def load_local_config_file_from_app_dir_param!(argv)
+        if argv.empty?
+          app_dir = Dir.logical_pwd
+        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
+        local_options
+      end
+
       def load_local_config_file!(app_dir, options)
         config_file = File.join(app_dir, "Passengerfile.json")
         if !File.exist?(config_file)
@@ -79,28 +97,224 @@ module PhusionPassenger
         end
 
         result = {}
+        config_file_dir = File.dirname(File.absolute_logical_path(filename))
         config.each_pair do |key, val|
-          result[key.to_sym] = val
+          key = key.to_sym
+          spec_item = CONFIG_NAME_INDEX[key]
+          if spec_item
+            begin
+              result[key] = parse_config_value(spec_item, val, config_file_dir)
+            rescue ConfigLoadError => e
+              raise ConfigLoadError, "cannot parse config file #{filename} " \
+                "(error in config option '#{key}': #{e.message})"
+            end
+          else
+            result[key] = val
+          end
         end
 
-        resolve_config_file_paths(result, filename)
-
         result
       end
 
-      # Absolutize relative paths. Make them relative to the config file in which
-      # it's specified.
-      def resolve_config_file_paths(config_file_options, config_filename)
-        options = config_file_options
-        config_file_dir = File.dirname(File.absolute_logical_path(config_filename))
+      def load_env_config!
+        begin
+          load_env_config
+        rescue ConfigUtils::ConfigLoadError => e
+          abort "*** ERROR: #{e.message}"
+        end
+      end
+
+      def load_env_config
+        config = {}
+        pwd = Dir.logical_pwd
+
+        ENV.each_pair do |name, value|
+          next if name !~ /^PASSENGER_(.+)/
+          key = $1.downcase.to_sym
+          spec_item = CONFIG_NAME_INDEX[key]
+          next if !spec_item
+          next if !config_type_supported_in_envvar?(spec_item[:type])
+          next if value.empty?
+
+          begin
+            config[key] = parse_config_value(spec_item, value, pwd)
+          rescue ConfigLoadError => e
+            raise ConfigLoadError, "cannot parse environment variable '#{name}' " \
+              "(#{e.message})"
+          end
+        end
+
+        config
+      end
+
+      def add_option_parser_options_from_config_spec(parser, spec, options)
+        spec.each do |spec_item|
+          next if spec_item[:cli].nil?
+          args = []
+
+          if spec_item[:short_cli]
+            args << spec_item[:short_cli]
+          end
+
+          args << make_long_cli_switch(spec_item)
+
+          if type = determine_cli_switch_type(spec_item)
+            args << type
+          end
+
+          args << format_cli_switch_description(spec_item)
+
+          cli_parser = make_cli_switch_parser(parser, spec_item, options)
+
+          parser.on(*args, &cli_parser)
+        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. This method remerges all the
+      # config options from different sources so that options are overriden
+      # according to the following order:
+      #
+      # - CONFIG_DEFAULTS
+      # - global config file
+      # - local config file
+      # - environment variables
+      # - command line options
+      def remerge_all_config(global_options, local_options, env_options, parsed_options)
+        CONFIG_DEFAULTS.merge(remerge_all_config_without_defaults(
+          global_options, local_options, env_options, parsed_options))
+      end
+
+      def remerge_all_config_without_defaults(global_options, local_options, env_options, parsed_options)
+        global_options.
+          merge(local_options).
+          merge(env_options).
+          merge(parsed_options)
+      end
+
+      def find_pid_and_log_file(execution_root, options)
+        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?("#{execution_root}/tmp/pids")
+          options[:pid_file] ||= "#{execution_root}/tmp/pids/#{pid_basename}"
+        else
+          options[:pid_file] ||= "#{execution_root}/#{pid_basename}"
+        end
+        if File.directory?("#{execution_root}/log")
+          options[:log_file] ||= "#{execution_root}/log/#{log_basename}"
+        else
+          options[:log_file] ||= "#{execution_root}/#{log_basename}"
+        end
+      end
+
+    private
+      def config_type_supported_in_envvar?(type)
+        type == :string || type == :integer || type == :boolean ||
+          type == :path
+      end
+
+      def parse_config_value(spec_item, value, base_dir)
+        if parser = spec_item[:config_value_parser]
+          return parser.call(value, base_dir)
+        end
+
+        case spec_item[:type]
+        when :string
+          value.to_s
+        when :integer
+          value = value.to_i
+          if spec_item[:min] && value < spec_item[:min]
+            raise ConfigLoadError, "value must be greater than or equal to #{spec_item[:min]}"
+          else
+            value
+          end
+        when :boolean
+          value = value.to_s.downcase
+          value == 'true' || value == 'yes' || value == 'on' || value == '1'
+        when :path
+          File.absolute_logical_path(value.to_s, base_dir)
+        when :array
+          if value.is_a?(Array)
+            value
+          else
+            raise ConfigLoadError, "array expected"
+          end
+        when :map
+          if value.is_a?(Hash)
+            value
+          else
+            raise ConfigLoadError, "map expected"
+          end
+        else
+          raise ArgumentError, "Unsupported type #{spec_item[:type]}"
+        end
+      end
+
+      def make_long_cli_switch(spec_item)
+        case spec_item[:type]
+        when :string, :integer, :path, :array, :map
+          "#{spec_item[:cli]} #{spec_item[:type_desc]}"
+        when :boolean
+          spec_item[:cli]
+        else
+          raise ArgumentError,
+            "Cannot create long CLI switch for type #{spec_item[:type]}"
+        end
+      end
+
+      def determine_cli_switch_type(spec_item)
+        case spec_item[:type]
+        when :string, :path, :array, :map
+          String
+        when :integer
+          Integer
+        when :boolean
+          nil
+        else
+          raise ArgumentError,
+            "Cannot determine CLI switch type for #{spec_item[:type]}"
+        end
+      end
 
-        keys = [:socket_file, :ssl_certificate, :ssl_certificate_key, :log_file,
-          :pid_file, :instance_registry_dir, :data_buffer_dir, :meteor_app_settings,
-          :rackup, :startup_file, :static_files_dir, :restart_dir,
-          :nginx_config_template]
-        keys.each do |key|
-          if filename = options[key]
-            options[key] = File.expand_path(filename, config_file_dir)
+      def format_cli_switch_description(spec_item)
+        desc = spec_item[:desc]
+        return '(no description)' if desc.nil?
+        result = desc.gsub("\n", "\n" + ' ' * 37)
+        result.gsub!('%DEFAULT%', (spec_item[:default] || 'N/A').to_s)
+        result
+      end
+
+      def make_cli_switch_parser(parser, spec_item, options)
+        if cli_parser = spec_item[:cli_parser]
+          lambda do |value|
+            cli_parser.call(options, value)
+          end
+        elsif spec_item[:type] == :integer
+          lambda do |value|
+            if spec_item[:min] && value < spec_item[:min]
+              abort "*** ERROR: you may only specify for #{spec_item[:cli]} " \
+                "a number greater than or equal to #{spec_item[:min]}"
+            end
+            options[spec_item[:name]] = value
+          end
+        elsif spec_item[:type] == :path
+          lambda do |value|
+            options[spec_item[:name]] = File.absolute_logical_path(value,
+              Dir.logical_pwd)
+          end
+        elsif spec_item[:type] == :boolean
+          lambda do |value|
+            options[spec_item[:name]] = true
+          end
+        else
+          lambda do |value|
+            options[spec_item[:name]] = value
           end
         end
       end

data/src/ruby_supportlib/phusion_passenger/standalone/start_command.rb

@@ -39,34 +39,15 @@ PhusionPassenger.require_passenger_lib 'platform_info/ruby'
 # 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
+        load_env_config
         remerge_all_options
         sanity_check_options_and_set_defaults
 
@@ -111,9 +92,6 @@ module PhusionPassenger
       ################# Configuration loading, option parsing and initialization ###################
 
       def self.create_option_parser(options)
-        # Clear @parsed_options so that #remerge_all_options works.
-        options.clear
-
         logical_pwd = Dir.logical_pwd
 
         # If you add or change an option, make sure to update the following places too:
@@ -121,312 +99,63 @@ module PhusionPassenger
         #   function #build_daemon_controller_options
         # - resources/templates/config/standalone.erb
         OptionParser.new do |opts|
+          defaults = CONFIG_DEFAULTS
           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_logical_path(value, logical_pwd)
-          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_logical_path(value, logical_pwd)
-          end
-          opts.on("--ssl-certificate-key PATH", String,
-            "Specify the SSL key path") do |value|
-            options[:ssl_certificate_key] = File.absolute_logical_path(value, logical_pwd)
-          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_logical_path(value, logical_pwd)
-          end
-          opts.on("--pid-file FILENAME", String, "Where to store the PID file") do |value|
-            options[:pid_file] = File.absolute_logical_path(value, logical_pwd)
-          end
-          opts.on("--instance-registry-dir PATH", String,
-            "Use the given instance registry directory") do |value|
-            options[:instance_registry_dir] = File.absolute_logical_path(value, logical_pwd)
-          end
-          opts.on("--data-buffer-dir PATH", String,
-            "Use the given data buffer directory") do |value|
-            options[:data_buffer_dir] = File.absolute_logical_path(value, logical_pwd)
-          end
+          ConfigUtils.add_option_parser_options_from_config_spec(opts,
+            SERVER_CONFIG_SPEC, options)
 
           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_logical_path(value, logical_pwd)
-          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_logical_path(value, logical_pwd)
-          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_logical_path(value, logical_pwd)
-          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 |value|
-            options[:static_files_dir] = File.absolute_logical_path(value, logical_pwd)
-          end
-          opts.on("--restart-dir PATH", String, "Specify the restart dir") do |value|
-            options[:restart_dir] = File.absolute_logical_path(value, logical_pwd)
-          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
+          ConfigUtils.add_option_parser_options_from_config_spec(opts,
+            APPLICATION_LOADING_CONFIG_SPECS, options)
 
           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
+          ConfigUtils.add_option_parser_options_from_config_spec(opts,
+            PROCESS_MANAGEMENT_CONFIG_SPECS, options)
 
           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
+          ConfigUtils.add_option_parser_options_from_config_spec(opts,
+            REQUEST_HANDLING_CONFIG_SPECS, options)
 
           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
+          ConfigUtils.add_option_parser_options_from_config_spec(opts,
+            UNION_STATION_CONFIG_SPECS, options)
 
           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_logical_path(value, logical_pwd)
-          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_logical_path(value, logical_pwd)
-          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_logical_path(value, logical_pwd)
-          end
+          ConfigUtils.add_option_parser_options_from_config_spec(opts,
+            NGINX_ENGINE_CONFIG_SPECS, options)
 
           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
+          ConfigUtils.add_option_parser_options_from_config_spec(opts,
+            ADVANCED_CONFIG_SPECS, options)
         end
       end
 
       def load_local_config_file
-        if @argv.empty?
-          app_dir = Dir.logical_pwd
-        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
+        @local_options = ConfigUtils.
+          load_local_config_file_from_app_dir_param!(@argv)
+      end
+
+      def load_env_config
+        @env_options = ConfigUtils.load_env_config!
       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)
+        @options = ConfigUtils.remerge_all_config(@global_options,
+          @local_options, @env_options, @parsed_options)
+        @options_without_defaults = ConfigUtils.
+          remerge_all_config_without_defaults(@global_options,
+            @local_options, @env_options, @parsed_options)
       end
 
       def sanity_check_options_and_set_defaults
@@ -437,7 +166,8 @@ module PhusionPassenger
           end
         end
 
-        if (@options[:address] || @options[:port]) && @options[:socket_file]
+        if (@options_without_defaults[:address] || @options_without_defaults[:port]) &&
+            @options_without_defaults[:socket_file]
           abort "You cannot specify both --address/--port and --socket. Please choose either one."
         end
         if @options[:ssl] && !@options[:ssl_certificate]
@@ -450,11 +180,6 @@ module PhusionPassenger
           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
@@ -563,24 +288,7 @@ module PhusionPassenger
       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
+        ConfigUtils.find_pid_and_log_file(app_finder.execution_root, options)
       end
 
       def create_working_dir
@@ -716,7 +424,11 @@ module PhusionPassenger
           backward = 10
         end
 
-        IO.popen("tail -f -n #{backward} \"#{log_file}\"", "rb") do |f|
+        if PlatformInfo.os_name != 'solaris'
+          backward_arg = "-n #{backward}"
+        end
+
+        IO.popen("tail -f #{backward_arg} \"#{log_file}\"", "rb") do |f|
           begin
             while true
               begin