Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:53
📄 app_finder.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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 'ruby_core_enhancements' PhusionPassenger.require_passenger_lib 'standalone/config_utils' PhusionPassenger.require_passenger_lib 'utils/file_system_watcher' module PhusionPassenger module Standalone class AppFinder STARTUP_FILES = [ "config.ru", "passenger_wsgi.py", "app.js", ".meteor" ] WATCH_ENTRIES = [ "config", "Passengerfile.json", "passenger-standalone.json" ] attr_accessor :dirs attr_reader :apps attr_reader :execution_root def self.supports_multi? false end def initialize(dirs, options = {}, local_options = {}) @dirs = dirs @options = options.dup determine_mode_and_execution_root(options, local_options) end def scan apps = [] watchlist = [] if single_mode? app_root = find_app_root apps << { :server_names => ["_"], :root => app_root } watchlist << app_root WATCH_ENTRIES.each do \|entry\| if File.exist?("#{app_root}/#{entry}") watchlist << "#{app_root}/#{entry}" end end apps.map! do \|app\| @options.merge(app) end end @apps = apps @watchlist = watchlist return apps end def monitor(termination_pipe) raise "You must call #scan first" if !@apps watcher = PhusionPassenger::Utils::FileSystemWatcher.new(@watchlist, termination_pipe) if wait_on_io(termination_pipe, 3) return end while true changed = watcher.wait_for_change watcher.close if changed old_apps = @apps # The change could be caused by a write to some Passengerfile.json file. # Wait for a short period so that the write has a chance to finish. if wait_on_io(termination_pipe, 0.25) return end new_apps = scan watcher = PhusionPassenger::Utils::FileSystemWatcher.new(@watchlist, termination_pipe) if old_apps != new_apps yield(new_apps) end # Don't process change events again for a short while, # but do detect changes while waiting. if wait_on_io(termination_pipe, 3) return end else return end end ensure watcher.close if watcher end def single_mode? return @mode == :single end def multi_mode? return !single_mode? end ################## private class ConfigLoadError < StandardError end def find_app_root if @dirs.empty? return File.absolute_logical_path(".") else return File.absolute_logical_path(@dirs[0]) end end # Only pass `local_options` if the directory that you're checking is # the directory that should be used in single mode. # # `local_options` must be the the value obtained from # `ConfigUtils.load_local_config_file_from_app_dir_param!`. def looks_like_app_directory?(dir, options = {}, local_options = {}) options = options.dup ConfigUtils.load_local_config_file!(dir, options) options[:app_type] \|\| options[:app_start_command] \|\| STARTUP_FILES.any? do \|file\| File.exist?("#{dir}/#{file}") end end def filename_to_server_names(filename) basename = File.basename(filename) names = [basename] if basename !~ /^www\.$/i names << "www.#{basename}" end return names end # Wait until the given IO becomes readable, or until the timeout has # been reached. Returns true if the IO became readable, false if the # timeout has been reached. def wait_on_io(io, timeout) return !!select([io], nil, nil, timeout) end def determine_mode_and_execution_root(options, local_options) @mode = :single if @dirs.empty? @execution_root = Dir.logical_pwd elsif @dirs.size == 1 @execution_root = File.absolute_logical_path(@dirs[0]) else @execution_root = Dir.logical_pwd end end ################## end end # module Standalone end # module PhusionPassenger	5.67 KB	2025-11-20 11:36
📄 command.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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. module PhusionPassenger module Standalone class Command def initialize(argv) @argv = argv.dup @options = self.class.create_default_options end private def self.create_default_options return {} end def parse_options load_and_merge_global_options(@options) @parsed_options = self.class.create_default_options @parser = self.class.create_option_parser(@parsed_options) begin @original_argv = @argv.dup @parser.parse!(@argv) @options.merge!(@parsed_options) rescue OptionParser::ParseError => e STDERR.puts "* ERROR: #{e}" abort @parser.to_s end if @options[:help] puts @parser exit end end def load_and_merge_global_options(options) path = ConfigUtils.global_config_file_path if File.exist?(path) begin @global_options = ConfigUtils.load_config_file(path) rescue ConfigUtils::ConfigLoadError => e STDERR.puts "* Warning: #{e.message}" return end @options.merge!(@global_options) else @global_options = {} end end end end # module Standalone end # module PhusionPassenger	2.54 KB	2025-11-20 11:36
📄 config_options_list.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2015-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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 'platform_info/ruby' # This file contains a specification of all supported Passenger Standalone # configuration options. The specifications are spread over multiple constants, # one for each category. The command line parser for `passenger start` is # automatically generated from these specifications. The configuration file # parser and the environment variable parser also use these specifications. # # A specification is an array of hashes. The following keys are supported: # # - :name # The name of the configuration option. If you omit this option, while # simultaneously setting the `:cli` option, then it means this configuration # option is available as a command line option only. # # - :type # (default: :string) # The value type. Supported types are: :string, :integer, :boolean, :path, # :array, :map, :hostname. # This is used for determining a default parser and for checking the value. # # - :type_desc # (default: automatically inferred) # A description of the value type, to be used in command line option help # messages. For example, the `:address` option should have the type desc # `HOST` so that the help message `--address HOST` is generated. Boolean # options have a `type_desc` of nil. # # - :cli # (default: automatically inferred) # The name of the corresponding command line option. If not specified, then # a default one will be automatically generated form the configuration option # name. For example, `:ssl_certificate_path` becomes `--ssl-certificate-path`. # If set to nil, then it means there is no corresponding command line option. # # - :cli_parser # (default: automatically inferred) # Command line options are parsed based on the configuration option type. # If you want to parse it differently, then you can set this option to a # lambda to specify a custom parser. # # - :short_cli # The name of the corresponding short command line option, if any. For # example, the `:address` option should have `short_cli` set to `-a`. # # - :desc # A description to be displayed in command line options help message. # # - :default # The default value. # # - :min # If :type is :integer, then this specifies the minimum accepted value. # Has no meaing if :type is not :integer. # This value is used by the default CLI parser to check whether the # passed argument is acceptable. module PhusionPassenger module Standalone # Server configuration options SERVER_CONFIG_SPEC = [ { :name => :address, :type => :hostname, :type_desc => 'HOST', :short_cli => '-a', :default => '0.0.0.0', :desc => "Bind to the given address.\n" \ "Default: %DEFAULT%" }, { :name => :port, :type => :integer, :short_cli => '-p', :default => 3000, :desc => 'Use the given port number. Default: %DEFAULT%' }, { :name => :socket_file, :type => :path, :type_desc => 'FILE', :cli => '--socket', :short_cli => '-S', :desc => "Bind to Unix domain socket instead of TCP\n" \ 'socket' }, { :name => :socket_backlog, :type => :integer, :cli => '--socket-backlog', :desc => "Override size of the socket backlog.\n" \ "Default: #{DEFAULT_SOCKET_BACKLOG}" }, { :name => :ssl, :type => :boolean, :desc => "Enable SSL support (Nginx\n" \ 'engine only)' }, { :name => :ssl_certificate, :type => :path, :desc => "Specify the SSL certificate path\n" \ '(Nginx engine only)' }, { :name => :ssl_certificate_key, :type => :path, :desc => "Specify the SSL key path (Nginx\n" \ 'engine only)' }, { :name => :ssl_port, :type => :integer, :type_desc => 'PORT', :desc => "Listen for SSL on this port, while\n" \ "listening for HTTP on the normal port\n" \ '(Nginx engine only)' }, { :name => :daemonize, :type => :boolean, :short_cli => '-d', :desc => 'Daemonize into the background' }, { :name => :user, :type_desc => 'USERNAME', :desc => "User to run as. Ignored unless\n" \ 'running as root' }, { :name => :log_file, :type => :path, :desc => "Where to write log messages. Default:\n" \ 'console, or /dev/null when daemonized' }, { :name => :pid_file, :type => :path, :desc => 'Where to store the PID file' }, { :name => :stop_timeout, :type => :integer, :default => 60, :desc => "How long in seconds to wait for the HTTP engine to gracefully shutdown,\nbefore killing it.\nDefault: %DEFAULT%" }, { :name => :instance_registry_dir, :type => :path, :desc => 'Use the given instance registry directory' }, { :name => :data_buffer_dir, :type => :path, :desc => 'Use the given data buffer directory' }, { :name => :core_file_descriptor_ulimit, :type => :integer, :desc => "Set custom file descriptor ulimit for the\n" \ "#{SHORT_PROGRAM_NAME} core" } ] # Application loading configuration options APPLICATION_LOADING_CONFIG_SPECS = [ { :name => :environment, :type_desc => 'NAME', :short_cli => '-e', :default => ENV['RAILS_ENV'] \|\| ENV['RACK_ENV'] \|\| ENV['NODE_ENV'] \|\| ENV['PASSENGER_APP_ENV'] \|\| 'development', :desc => "Web framework environment. Default:\n" \ "%DEFAULT%" }, { :name => :ruby, :type_desc => 'FILENAME', :desc => "Executable to use for Ruby apps.\n" \ "Default: #{PlatformInfo.ruby_command}\n" \ "(current context)" }, { :name => :python, :type_desc => 'FILENAME', :desc => 'Executable to use for Python apps' }, { :name => :nodejs, :type_desc => 'FILENAME', :desc => 'Executable to use for Node.js apps' }, { :name => :meteor_app_settings, :type => :path, :type_desc => 'FILENAME', :desc => "Settings file to use for (development mode)\n" \ 'Meteor apps' }, { :type => :path, :type_desc => 'FILENAME', :cli => '--rackup', :short_cli => '-R', :cli_parser => lambda do \|options, value\| options[:app_type] = 'rack' options[:startup_file] = File.absolute_logical_path(value, Dir.logical_pwd) end, :desc => "Consider application a Ruby app, and use\n" \ 'the given rackup file' }, { :name => :app_type, :type_desc => 'NAME', :desc => 'Force app to be detected as the given type' }, { :name => :startup_file, :type => :path, :type_desc => 'FILENAME', :desc => 'Force given startup file to be used' }, { :name => :app_start_command, :type_desc => 'COMMAND', :desc => 'Force the app to be started through this command' }, { :name => :app_support_kuria_protocol, :type => :boolean, :desc => 'Force the app to be recognized as a Kuria app', }, { :name => :spawn_method, :type_desc => 'NAME', :default => PlatformInfo.ruby_supports_fork? ? DEFAULT_SPAWN_METHOD : 'direct', :desc => 'The spawn method to use. Default: see docs' }, { :name => :direct_instance_request_address, :type => :hostname, :type_desc => 'HOST', :default => '127.0.0.1', :desc => "The address that Passenger binds to in order to allow sending\nHTTP requests to individual application processes.\nDefault: %DEFAULT%" }, { :name => :static_files_dir, :type => :path, :desc => "Specify the static files dir (Nginx engine\n" \ 'only)' }, { :name => :restart_dir, :type => :path, :desc => 'Specify the restart dir' }, { :name => :friendly_error_pages, :type => :boolean, :desc => 'Turn on friendly error pages' }, { :name => :custom_error_page, :type => :path, :desc => 'Path to html file to use for Passenger generated error pages' }, { :type => :boolean, :cli => '--no-friendly-error-pages', :cli_parser => lambda do \|options, value\| options[:friendly_error_pages] = false end, :desc => 'Turn off friendly error pages' }, { :name => :load_shell_envvars, :type => :boolean, # The Standalone mode is primarily used for serving a single app (except # when in mass deployment mode), so load_shell_envvars is disabled by # default. However, it's enabled by default in the Core, so we need to # explicitly set it to disabled here. :default => false, :desc => "Load shell startup files before loading\n" \ 'application' }, { :name => :preload_bundler, :type => :boolean, :default => false, :desc => "Tell Ruby to load the bundler gem before loading the application" }, { :name => :app_file_descriptor_ulimit, :type => :integer, :desc => "Set custom file descriptor ulimit for the\n" \ "application" }, { :name => :debugger, :type => :boolean, :desc => 'Enable debugger support' }, { :name => :envvars, :type => :map, :type_desc => 'NAME=VALUE', :default => {}, :cli => '--envvar', :cli_parser => lambda do \|options, value\| if value !~ /=.+/ abort "* ERROR: invalid --envvar format: #{value}" end key, real_value = value.split('=', 2) options[:envvars] \|\|= {} options[:envvars][key] = real_value end, :desc => 'Pass environment variable to application' } ] # Process management configuration options PROCESS_MANAGEMENT_CONFIG_SPECS = [ { :name => :max_pool_size, :type => :integer, :min => 1, :desc => "Maximum number of application processes.\n" \ "Default: #{DEFAULT_MAX_POOL_SIZE}" }, { :name => :min_instances, :type => :integer, :min => 0, :desc => "Minimum number of processes per\n" \ 'application. Default: 1' }, { :name => :pool_idle_time, :type => :integer, :type_desc => 'SECONDS', :desc => "Maximum time that processes may be idle.\n" \ "Default: #{DEFAULT_POOL_IDLE_TIME}" }, { :name => :max_preloader_idle_time, :type => :integer, :type_desc => 'SECONDS', :desc => "Maximum time that preloader processes may\n" \ "be idle. A value of 0 means that preloader\n" \ "processes never timeout. Default: #{DEFAULT_MAX_PRELOADER_IDLE_TIME}" }, { :name => :force_max_concurrent_requests_per_process, :type => :integer, :desc => "Force #{SHORT_PROGRAM_NAME} to believe that an\n" \ "application process can handle the given\n" \ "number of concurrent requests per process" }, { :name => :start_timeout, :type => :integer, :type_desc => 'SECONDS', :desc => "The maximum time an application process may\n" \ "take to start up, after which it will be killed\n" \ "with SIGKILL, and logged with an error.\nDefault: #{DEFAULT_START_TIMEOUT / 1000}" }, { :name => :concurrency_model, :type_desc => 'NAME', :desc => "The concurrency model to use, either\n" \ "'process' or 'thread' (Enterprise only).\n" \ "Default: #{DEFAULT_CONCURRENCY_MODEL}" }, { :name => :thread_count, :type => :integer, :desc => "The number of threads to use when using\n" \ "the 'thread' concurrency model (Enterprise\n" \ "only). Default: #{DEFAULT_APP_THREAD_COUNT}" }, { :name => :memory_limit, :type => :integer, :type_desc => 'MB', :desc => "Restart application processes that go over\n" \ "the given memory limit (Enterprise only)" }, { :name => :rolling_restarts, :type => :boolean, :desc => "Enable rolling restarts (Enterprise only)" }, { :name => :resist_deployment_errors, :type => :boolean, :desc => "Enable deployment error resistance\n" \ '(Enterprise only)' } ] # Request handling configuration options REQUEST_HANDLING_CONFIG_SPECS = [ { :name => :max_requests, :type => :integer, :min => 0, :desc => "Restart application processes that have handled\n" \ "the specified maximum number of requests" }, { :name => :max_request_time, :type => :integer, :type_desc => 'SECONDS', :min => 0, :desc => "Abort requests that take too much time\n" \ '(Enterprise only)' }, { :name => :max_request_queue_size, :type => :integer, :min => 0, :desc => "Specify request queue size. Default: #{DEFAULT_MAX_REQUEST_QUEUE_SIZE}" }, { :name => :sticky_sessions, :type => :boolean, :desc => 'Enable sticky sessions' }, { :name => :sticky_sessions_cookie_name, :type_desc => 'NAME', :desc => "Cookie name to use for sticky sessions.\n" \ "Default: #{DEFAULT_STICKY_SESSIONS_COOKIE_NAME}" }, { :name => :sticky_sessions_cookie_attributes, :type_desc => "'NAME1=VALUE1; NAME2'", :desc => "The attributes to use for the sticky session cookie.\n" \ "Default: #{DEFAULT_STICKY_SESSIONS_COOKIE_ATTRIBUTES}" }, { :name => :vary_turbocache_by_cookie, :type_desc => 'NAME', :desc => "Vary the turbocache by the cookie of the\n" \ 'given name' }, { :name => :turbocaching, :type => :boolean, :cli => nil }, { :type => :boolean, :cli => '--disable-turbocaching', :desc => 'Disable turbocaching', :cli_parser => lambda do \|options, value\| options[:turbocaching] = false end }, { :name => :old_routing, :type => :boolean, :desc => 'Revert to old routing algorithm' }, { :name => :unlimited_concurrency_paths, :type => :array, :type_desc => 'URI-PATH', :cli => '--unlimited-concurrency-path', :desc => "Specify URI path which supports unlimited\n" \ "concurrency. Specify multiple times for\n" \ "multiple paths", :default => [], :cli_parser => lambda do \|options, value\| options[:unlimited_concurrency_paths] \|\|= [] options[:unlimited_concurrency_paths] << value end }, { :name => :abort_websockets_on_process_shutdown, :type => :boolean, :cli => nil }, { :type => :boolean, :cli => '--no-abort-websockets-on-process-shutdown', :desc => "Do not abort WebSocket connections on\n" \ 'process restart', :cli_parser => lambda do \|options, value\| options[:abort_websockets_on_process_shutdown] = false end } ] # Nginx engine configuration options NGINX_ENGINE_CONFIG_SPECS = [ { :name => :nginx_bin, :type => :path, :type_desc => 'FILENAME', :desc => 'Nginx binary to use as core' }, { :name => :nginx_version, :type_desc => 'VERSION', :default => PREFERRED_NGINX_VERSION, :desc => "Nginx version to use as core.\n" \ "Default: #{PREFERRED_NGINX_VERSION}" }, { :name => :nginx_tarball, :type => :path, :type_desc => 'FILENAME', :desc => "If Nginx needs to be installed, then the\n" \ "given tarball will be used instead of\n" \ "downloading from the Internet" }, { :name => :nginx_config_template, :type => :path, :type_desc => 'FILENAME', :desc => "The template to use for generating the\n" \ 'Nginx config file' }, { :name => :debug_nginx_config, :type => :boolean, :desc => 'Print Nginx config template and exit' } ] # Advanced configuration options ADVANCED_CONFIG_SPECS = [ { :name => :disable_security_update_check, :type => :boolean, :desc => "Disable check for security updates" }, { :name => :security_update_check_proxy, :type_desc => 'NAME', :desc => "Use HTTP/SOCKS proxy for the security update check" }, { :name => :disable_anonymous_telemetry, :type => :boolean, :desc => "Disable anonymous telemetry collection" }, { :name => :anonymous_telemetry_proxy, :type_desc => 'NAME', :desc => "Use HTTP/SOCKS proxy for anonymous telemetry collection" }, { :name => :engine, :type_desc => 'NAME', :default => 'nginx', :desc => "Underlying HTTP engine to use. Available\n" \ "options: nginx (default), builtin" }, { :name => :log_level, :type => :integer, :default => DEFAULT_LOG_LEVEL, :desc => "Log level to use. Default: #{DEFAULT_LOG_LEVEL}" }, { :name => :disable_log_prefix, :type => :boolean, :desc => "Disable prefixing log statements with PID and channel." }, { :name => :admin_panel_url, :type => :string, :desc => 'Connect to an admin panel at the given connector URL' }, { :name => :admin_panel_auth_type, :type => :string, :desc => 'Authentication type to use when connecting to the admin panel' }, { :name => :admin_panel_username, :type => :string, :desc => 'Username to use when authenticating with the admin panel' }, { :name => :admin_panel_password, :type => :string, :desc => 'Password to use when authenticating with the admin panel' }, { :name => :auto, :type => :boolean, :default => !STDIN.tty? \|\| !STDOUT.tty?, :desc => "Run in non-interactive mode. Default when\n" \ 'stdin or stdout is not a TTY' }, { :name => :ctls, :type => :array, :type_desc => 'NAME=VALUE', :default => [], :cli_parser => lambda do \|options, value\| if value !~ /=.+/ abort "* ERROR: invalid --ctl format: #{value}" end options[:ctls] \|\|= [] options[:ctls] << value end }, { :name => :binaries_url_root, :type_desc => 'URL', :desc => "If Nginx needs to be installed, then the\n" \ "specified URL will be checked for binaries\n" \ 'prior to a local build' }, { :name => :runtime_check_only, :type => :boolean, :desc => "Quit after checking whether the\n" \ "#{PROGRAM_NAME} Standalone runtime files\n" \ 'are installed' }, { :name => :dont_install_runtime, :type => :boolean, :cli => '--no-install-runtime', :desc => 'Abort if runtime must be installed' }, { :name => :dont_compile_runtime, :type => :boolean, :cli => '--no-compile-runtime', :desc => 'Abort if runtime must be compiled' } ] CONFIG_SPECS = [ SERVER_CONFIG_SPEC, APPLICATION_LOADING_CONFIG_SPECS, PROCESS_MANAGEMENT_CONFIG_SPECS, REQUEST_HANDLING_CONFIG_SPECS, NGINX_ENGINE_CONFIG_SPECS, ADVANCED_CONFIG_SPECS ] # Maps configuration options to their default value. Automatically # set by code later in this file. # # To inspect the value of this array, run: # # ./dev/runner -r standalone/config_options_list -r pp \ # 'pp Standalone::CONFIG_DEFAULTS; nil' CONFIG_DEFAULTS = {} # Indexes all configuration specification items by name. # # To inspect the value of this array, run: # # ./dev/runner -r standalone/config_options_list -r pp \ # 'pp Standalone::CONFIG_NAME_INDEX; nil' CONFIG_NAME_INDEX = {} ############ # Apply transformations on the specification constants, e.g. set default values. make_default_type_desc_value = lambda do \|spec_item\| case spec_item[:type] when :string 'STRING' when :integer 'NUMBER' when :path 'PATH' when :array 'ARRAY' when :map 'MAP' when :hostname 'HOSTNAME' else nil end end make_default_cli_value = lambda do \|spec_item\| '--' + spec_item[:name].to_s.gsub('_', '-') end CONFIG_SPECS.each do \|spec\| spec.each do \|spec_item\| spec_item[:type] \|\|= :string spec_item[:type_desc] \|\|= make_default_type_desc_value.call(spec_item) if spec_item[:name] if !spec_item.key?(:cli) spec_item[:cli] = make_default_cli_value.call(spec_item) end if spec_item.key?(:default) CONFIG_DEFAULTS[spec_item[:name]] = spec_item[:default] end CONFIG_NAME_INDEX[spec_item[:name]] = spec_item end end end end end	24.89 KB	2025-11-20 11:36
📄 config_utils.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2014-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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 'ruby_core_enhancements' PhusionPassenger.require_passenger_lib 'standalone/config_options_list' module PhusionPassenger module Standalone module ConfigUtils extend self # Make methods available as class methods. def self.included(klass) # When included into another class, make sure that Utils # methods are made private. public_instance_methods(false).each do \|method_name\| klass.send(:private, method_name) end end class ConfigLoadError < StandardError end def global_config_file_path @global_config_file_path \|\|= File.join(PhusionPassenger.home_dir, 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) config_file = File.join(app_dir, "passenger-standalone.json") end if File.exist?(config_file) local_options = load_config_file(config_file) options.merge!(local_options) end end def load_config_file(filename) if !defined?(PhusionPassenger::Utils::JSON) PhusionPassenger.require_passenger_lib 'utils/json' end begin data = File.open(filename, "r:utf-8") do \|f\| f.read end rescue SystemCallError => e raise ConfigLoadError, "cannot load config file #{filename} (#{e})" end begin config = PhusionPassenger::Utils::JSON.parse(data) rescue => e raise ConfigLoadError, "cannot parse config file #{filename} (#{e})" end if !config.is_a?(Hash) raise ConfigLoadError, "cannot parse config file #{filename} (it does not contain an object)" end result = {} config_file_dir = File.dirname(File.absolute_logical_path(filename)) config.each_pair do \|key, 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 STDERR.puts "* WARNING: #{filename}: configuration key '#{key}' is not supported" result[key] = val end end result end 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 overridden # 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].nil? 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 \|\| type == :hostname 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 when :hostname begin resolve_hostname(value) rescue SocketError => e raise ConfigLoadError, "hostname #{value} cannot be resolved: #{e}" 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, :hostname "#{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, :hostname String when :integer Integer when :boolean nil else raise ArgumentError, "Cannot determine CLI switch type for #{spec_item[:type]}" end end 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 elsif spec_item[:type] == :hostname lambda do \|value\| begin options[spec_item[:name]] = resolve_hostname(value) rescue SocketError => e abort "* ERROR: the hostname passed to #{spec_item[:cli]}, #{value}, cannot be resolved: #{e}" end end else lambda do \|value\| options[spec_item[:name]] = value end end end def resolve_hostname(hostname) # We resolve the hostname into an IP address during configuration loading # because different components in the system (Nginx, Passenger core) may # resolve hostnames differently. If a hostname resolves to multiple addresses # (for example, to an IPv6 and an IPv4 address) then different components may # pick a different address as 'winner'. By resolving the hostname here, we # guarantee consistent behavior. # # Furthermore, `rails server` defaults to setting the hostname to 'localhost'. # But the user almost certainly doesn't explicitly want it to resolve to an IPv6 # address because most tools work better with IPv4 and because `http://[::1]:3000` # just looks weird. So we special case 'localhost' and resolve it to 127.0.0.1. if hostname.downcase == 'localhost' '127.0.0.1' else Socket.getaddrinfo(hostname, nil).first[3] end end end end # module Standalone end # module PhusionPassenger	12.19 KB	2025-11-20 11:36
📄 control_utils.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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. module PhusionPassenger module Standalone module ControlUtils extend self # Make methods available as class methods. def self.included(klass) # When included into another class, make sure that Utils # methods are made private. public_instance_methods(false).each do \|method_name\| klass.send(:private, method_name) end end def require_daemon_controller return if defined?(PhusionPassenger::DaemonController) PhusionPassenger.require_passenger_lib 'vendor/daemon_controller' end def warn_pid_file_not_found(options) if options[:pid_file] STDERR.puts "According to the PID file '#{options[:pid_file]}'," STDERR.puts "#{PROGRAM_NAME} Standalone doesn't seem to be running." else STDERR.puts "#{PROGRAM_NAME} Standalone doesn't seem to be running, " + "because its PID file" STDERR.puts "could not be found." end STDERR.puts STDERR.puts "If you know that #{PROGRAM_NAME} Standalone is running then one of these" STDERR.puts "might be the cause of this error:" STDERR.puts STDERR.puts " * The #{PROGRAM_NAME} Standalone instance that you want to stop isn't running" STDERR.puts " on port #{options[:port]}, but on another port. If this is the case then you" STDERR.puts " should specify the right port with --port." STDERR.puts " If the instance is listening on a Unix socket file instead of a TCP port," STDERR.puts " then please specify the PID file's filename with --pid-file." STDERR.puts " * The instance that you want to stop has stored its PID file in a non-standard" STDERR.puts " location. In this case please specify the right PID file with --pid-file." end end end end	3.08 KB	2025-11-20 11:36
📄 main.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2013-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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' module PhusionPassenger # Core of the `passenger` command (Passenger Standalone). Dispatches a subcommand to a specific class. module Standalone KNOWN_COMMANDS = [ ["start", "StartCommand"], ["stop", "StopCommand"], ["status", "StatusCommand"], ["version", "VersionCommand"] ] def self.run!(argv) if argv.empty? help exit end command_class, new_argv = lookup_command_class_by_argv(argv) if help_requested?(argv) help elsif version_requested?(argv) show_version elsif command_class command = command_class.new(new_argv) command.run else help abort end end def self.help puts "#{PROGRAM_NAME} Standalone, the easiest way to run web apps." puts puts "Available commands:" puts puts " passenger start Start #{PROGRAM_NAME} Standalone." puts " passenger stop Stop a #{PROGRAM_NAME} instance." puts " passenger status Show the status of a running #{PROGRAM_NAME} instance." puts puts "Run 'passenger <COMMAND> --help' for more information about each command." end private def self.help_requested?(argv) return argv.size == 1 && (argv[0] == "--help" \|\| argv[0] == "-h" \|\| argv[0] == "help") end def self.version_requested?(argv) return argv.size == 1 && (argv[0] == "--version" \|\| argv[0] == "-v") end def self.show_version command_class, new_argv = lookup_command_class_by_argv(["version"]) command_class.new(new_argv).run end def self.lookup_command_class_by_argv(argv) return nil if argv.empty? # Convert "passenger help <COMMAND>" to "passenger <COMMAND> --help". if argv.size == 2 && argv[0] == "help" argv = [argv[1], "--help"] end KNOWN_COMMANDS.each do \|props\| if argv[0] == props[0] command_class = lookup_command_class_by_class_name(props[1]) new_argv = argv[1 .. -1] return [command_class, new_argv] end end return nil end def self.lookup_command_class_by_class_name(class_name) base_name = class_name.gsub(/[A-Z]/) do \|match\| "_" + match[0..0].downcase end base_name.sub!(/^_/, '') base_name << ".rb" PhusionPassenger.require_passenger_lib("standalone/#{base_name}") return PhusionPassenger::Standalone.const_get(class_name) end end end # module PhusionPassenger	3.77 KB	2025-11-20 11:36
📁 start_command	-	2026-03-21 15:53
📄 start_command.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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' require 'socket' 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. module PhusionPassenger module Standalone class StartCommand < Command def run parse_options load_local_config_file load_env_config 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_one_or_more_log_files? 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) # If you add or change an option, make sure to update the following places too: # - src/ruby_supportlib/phusion_passenger/standalone/start_command/builtin_engine.rb, # function #build_daemon_controller_options # - resources/templates/standalone/config.erb OptionParser.new do \|opts\| 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:" ConfigUtils.add_option_parser_options_from_config_spec(opts, SERVER_CONFIG_SPEC, options) opts.separator "" opts.separator "Application loading options:" ConfigUtils.add_option_parser_options_from_config_spec(opts, APPLICATION_LOADING_CONFIG_SPECS, options) opts.separator "" opts.separator "Process management options:" ConfigUtils.add_option_parser_options_from_config_spec(opts, PROCESS_MANAGEMENT_CONFIG_SPECS, options) opts.separator "" opts.separator "Request handling options:" ConfigUtils.add_option_parser_options_from_config_spec(opts, REQUEST_HANDLING_CONFIG_SPECS, options) opts.separator "" opts.separator "Nginx engine options:" ConfigUtils.add_option_parser_options_from_config_spec(opts, NGINX_ENGINE_CONFIG_SPECS, options) opts.separator "" opts.separator "Advanced options:" ConfigUtils.add_option_parser_options_from_config_spec(opts, ADVANCED_CONFIG_SPECS, options) end end def load_local_config_file @local_options = ConfigUtils. load_local_config_file_from_app_dir_param!(@argv) end def load_env_config @env_options = ConfigUtils.load_env_config! end def remerge_all_options @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 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_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] 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[:nginx_tarball] && !@options_without_defaults[:nginx_version] abort "You specified --nginx-tarball. Please also specify which Nginx version the tarball contains using --nginx-version." 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[: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 \|\| (@options[:engine] == "nginx" && !@nginx_binary) install_runtime @agent_exe = PhusionPassenger.find_support_binary(AGENT_EXE) @nginx_binary = PhusionPassenger.find_support_binary(nginx_name) if @options[:engine] == "nginx" 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", "--engine", @options[:engine], "--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[:engine] == "nginx" if @options[:nginx_version] args << "--nginx-version" args << @options[:nginx_version] end if @options[:nginx_tarball] args << "--nginx-tarball" args << @options[:nginx_tarball] end 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, @local_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) ConfigUtils.find_pid_and_log_file(app_finder.execution_root, options) 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 "=============== #{PROGRAM_NAME} 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 command = [@agent_exe, "temp-dir-toucher", @working_dir, "--cleanup", "--daemonize", "--pid-file", "#{@working_dir}/temp_dir_toucher.pid", "--log-file", @options[:log_file]] command << "--user" << @options[:user] unless @options[:user].nil? command << "--nginx-pid" << @engine.pid.to_s if @options[:engine] == 'nginx' result = system(*command) 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 if PlatformInfo.os_name_simple != 'solaris' backward_arg = "-n #{backward}" end IO.popen("tail -f #{backward_arg} \"#{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 if should_watch_main_log_file? thread = Utils.create_thread_and_abort_on_exception do watch_log_file(@options[:log_file]) end @threads << thread @interruptable_threads << thread end end def should_watch_one_or_more_log_files? !@options[:daemonize] end def should_watch_main_log_file? if @options[:daemonize] false else begin stat = File.stat(@options[:log_file]) rescue Errno::ENOENT stat = nil end if stat stat.file? else true end end 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 if @options[:engine] == "nginx" && @options[:socket_file] begin File.delete(@options[:socket_file]) rescue Errno::ENOENT end end 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	19.48 KB	2025-11-20 11:36
📄 status_command.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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' PhusionPassenger.require_passenger_lib 'constants' PhusionPassenger.require_passenger_lib 'standalone/command' PhusionPassenger.require_passenger_lib 'standalone/config_utils' PhusionPassenger.require_passenger_lib 'standalone/control_utils' PhusionPassenger.require_passenger_lib 'ruby_core_enhancements' module PhusionPassenger module Standalone class StatusCommand < Command def run parse_options load_local_config_file load_env_config remerge_all_options find_pid_file create_controller begin running = @controller.running? pid = @controller.pid rescue SystemCallError, IOError running = false end if running puts "#{PROGRAM_NAME} Standalone is running on PID #{pid}, according to PID file #{@options[:pid_file]}" else puts "#{PROGRAM_NAME} Standalone is not running, according to PID file #{@options[:pid_file]}" end end private def self.create_option_parser(options) OptionParser.new do \|opts\| defaults = CONFIG_DEFAULTS nl = "\n" + ' ' * 37 opts.banner = "Usage: passenger status [OPTIONS] [APP DIR]\n" opts.separator "Shows the status of a running #{PROGRAM_NAME} Standalone instance." opts.separator "" opts.separator "Options:" opts.on("-p", "--port NUMBER", Integer, "The port number of the #{PROGRAM_NAME}#{nl}" + "instance. Default: #{defaults[:port]}") do \|value\| options[:port] = value end opts.on("--pid-file FILE", String, "PID file of the running #{PROGRAM_NAME}#{nl}" + "Standalone instance") do \|value\| options[:pid_file] = value end end end def load_local_config_file @local_options = ConfigUtils. load_local_config_file_from_app_dir_param!(@argv) end def load_env_config @env_options = ConfigUtils.load_env_config! end def remerge_all_options @options = ConfigUtils.remerge_all_config(@global_options, @local_options, @env_options, @parsed_options) end def execution_root @argv[0] \|\| Dir.logical_pwd end def find_pid_file ConfigUtils.find_pid_and_log_file(execution_root, @options) if !@options[:pid_file] if @options[:ignore_pid_not_found] exit else Standalone::ControlUtils.warn_pid_file_not_found(@options) exit 1 end end end def create_controller Standalone::ControlUtils.require_daemon_controller @controller = DaemonController.new( :identifier => "#{PROGRAM_NAME} Standalone engine", :start_command => "true", # Doesn't matter :ping_command => "true", # Doesn't matter :pid_file => @options[:pid_file], :log_file => "/dev/null" ) end end end end	4.26 KB	2025-11-20 11:36
📄 stop_command.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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' PhusionPassenger.require_passenger_lib 'constants' PhusionPassenger.require_passenger_lib 'standalone/command' PhusionPassenger.require_passenger_lib 'standalone/config_utils' PhusionPassenger.require_passenger_lib 'standalone/control_utils' PhusionPassenger.require_passenger_lib 'ruby_core_enhancements' module PhusionPassenger module Standalone class StopCommand < Command def run parse_options load_local_config_file load_env_config remerge_all_options find_pid_file create_controller begin running = @controller.running? rescue SystemCallError, IOError running = false end if running @controller.stop if @options[:engine] == "nginx" && @options[:socket_file] begin File.delete(@options[:socket_file]) rescue Errno::ENOENT end end else Standalone::ControlUtils.warn_pid_file_not_found(@options) exit 1 end end private def self.create_option_parser(options) OptionParser.new do \|opts\| defaults = CONFIG_DEFAULTS nl = "\n" + ' ' * 37 opts.banner = "Usage: passenger stop [OPTIONS] [APP DIR]\n" opts.separator "Stops a running #{PROGRAM_NAME} Standalone instance." opts.separator "" opts.separator "Options:" opts.on("-p", "--port NUMBER", Integer, "The port number of the #{PROGRAM_NAME}#{nl}" + "instance. Default: #{defaults[:port]}") do \|value\| options[:port] = value end opts.on("--pid-file FILE", String, "PID file of the running #{PROGRAM_NAME}#{nl}" + "Standalone instance") do \|value\| options[:pid_file] = value end opts.on("--ignore-pid-not-found", "-i", "Don't abort with an error if PID file cannot be found") do options[:ignore_pid_not_found] = true end opts.on("-t", "--timeout NUMBER", Integer, "How long in seconds to wait for the HTTP engine to#{nl}"+ "gracefully shutdown, before killing it.#{nl}" + "Default: #{defaults[:stop_timeout]}") do \|value\| options[:stop_timeout] = value end end end def load_local_config_file @local_options = ConfigUtils. load_local_config_file_from_app_dir_param!(@argv) end def load_env_config @env_options = ConfigUtils.load_env_config! end def remerge_all_options @options = ConfigUtils.remerge_all_config(@global_options, @local_options, @env_options, @parsed_options) end def execution_root @argv[0] \|\| Dir.logical_pwd end def find_pid_file ConfigUtils.find_pid_and_log_file(execution_root, @options) if !@options[:pid_file] if @options[:ignore_pid_not_found] exit else Standalone::ControlUtils.warn_pid_file_not_found(@options) exit 1 end end end def create_controller Standalone::ControlUtils.require_daemon_controller @controller = DaemonController.new( :identifier => "#{PROGRAM_NAME} Standalone engine", :start_command => "true", # Doesn't matter :ping_command => "true", # Doesn't matter :pid_file => @options[:pid_file], :log_file => "/dev/null", :stop_timeout => @options[:stop_timeout] ) end end end end	4.85 KB	2025-11-20 11:36
📄 version_command.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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 'standalone/command' PhusionPassenger.require_passenger_lib 'config/about_command' module PhusionPassenger module Standalone class VersionCommand < Command def run command = PhusionPassenger::Config::AboutCommand.new(['version']) command.run end end end end	1.58 KB	2025-11-20 11:36

Terminal