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
📄 instance.rb # encoding: utf-8 # 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 'constants' PhusionPassenger.require_passenger_lib 'platform_info' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' PhusionPassenger.require_passenger_lib 'utils/json' module PhusionPassenger module AdminTools class Instance STALE_TIMEOUT = 60 attr_reader :path, :state, :name, :server_software, :properties def initialize(path) @path = path # Possible states: # # * :good - Everything is good. But the Watchdog process that created # it might have died. In that case, the directory should be cleaned up. # Use `locked?` to check. # # * :not_finalized - The instance directory hasn't been finalized yet, # so we can't read any information from it. It is possible that the # process that has created it has died, i.e. that it will never # become finalized. In that case, the directory should be cleaned up. # Use `stale?` to check. # # * :structure_version_unsupported - The properties file advertised a # structure version that we don't support. We can't read any # information from it. # # * :corrupted - The instance directory is corrupted in some way. @state = nil reload_properties end def locked? if PlatformInfo.supports_flock? begin !File.open("#{@path}/lock", "r") do \|f\| f.flock(File::LOCK_EX \| File::LOCK_NB) end rescue Errno::ENOENT false end else # Solaris :-( # Since using fcntl locks in Ruby is a huge pain, # we'll fallback to checking the watchdog PID. watchdog_alive? end end def stale? stat = File.stat(@path) if stat.mtime < Time.now - STALE_TIMEOUT !locked? else false end end def watchdog_alive? process_is_alive?(@watchdog_pid) end def http_request(socket_path, request) sock = Net::BufferedIO.new(UNIXSocket.new("#{@path}/#{socket_path}")) begin request.exec(sock, "1.1", request.path) done = false while !done response = Net::HTTPResponse.read_new(sock) done = !response.kind_of?(Net::HTTPContinue) end response.reading_body(sock, request.response_body_permitted?) do # Nothing end ensure sock.close end return response end def watchdog_pid properties["watchdog_pid"] end # Returns the Core's PID, or nil if it is not running # or isn't finished initializing. def core_pid @core_pid \|\|= begin begin data = File.read("#{@path}/core.pid") if data.empty? nil else data.to_i end rescue Errno::ENOENT nil end end end def web_server_control_process_pid File.read("#{@path}/web_server_info/control_process.pid").to_i end def full_admin_password @full_admin_password \|\|= File.read("#{@path}/full_admin_password.txt") end def read_only_admin_password @read_only_admin_password \|\|= File.read("#{@path}/read_only_admin_password.txt") end def as_json json = properties json["instance_dir"]["path"] = path json["core_pid"] = core_pid json end private class CorruptedError < StandardError end def reload_properties @properties = nil @state = nil begin reload_properties_internal rescue CorruptedError @state = :corrupted end end def reload_properties_internal if !File.exist?("#{@path}/creation_finalized") @state = :unfinalized return end check(File.file?("#{@path}/creation_finalized")) properties = nil begin File.open("#{@path}/properties.json", "r") do \|f\| properties = Utils::JSON.parse(f.read) end rescue Errno::ENOENT raise CorruptedError rescue RuntimeError => e if e.message =~ /parse error/ raise CorruptedError else raise end end check(!properties.nil?) props = properties["instance_dir"] check(!props.nil?) major_version = props["major_version"] minor_version = props["minor_version"] check(major_version.is_a?(Integer)) check(minor_version.is_a?(Integer)) name = properties["name"] check(name.is_a?(String)) check(!name.empty?) server_software = properties["server_software"] check(server_software.is_a?(String)) check(!server_software.empty?) watchdog_pid = properties["watchdog_pid"] check(watchdog_pid.is_a?(Integer)) version_supported = major_version == PhusionPassenger::SERVER_INSTANCE_DIR_STRUCTURE_MAJOR_VERSION && minor_version >= PhusionPassenger::SERVER_INSTANCE_DIR_STRUCTURE_MIN_SUPPORTED_MINOR_VERSION if !version_supported @state = :structure_version_unsupported return end check(File.file?("#{@path}/lock")) check(File.directory?("#{@path}/agents.s")) check(File.directory?("#{@path}/apps.s")) @properties = properties @name = name @server_software = server_software @watchdog_pid = watchdog_pid @state = :good end def check(val) raise CorruptedError if !val end def process_is_alive?(pid) begin Process.kill(0, pid) return true rescue Errno::ESRCH return false rescue SystemCallError => e return true end end end end # module AdminTools end # module PhusionPassenger	7.26 KB	2025-11-20 11:36
📄 instance_registry.rb # encoding: utf-8 # 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. require 'fileutils' PhusionPassenger.require_passenger_lib 'admin_tools/instance' module PhusionPassenger module AdminTools class InstanceRegistry def initialize(paths = nil) @paths = [paths \|\| default_paths].flatten.uniq end def list(options = {}) options = { :clean_stale_or_corrupted => true }.merge(options) instances = [] @paths.each do \|path\| Dir["#{path}/passenger."].each do \|dir\| instance = Instance.new(dir) case instance.state when :good if instance.locked? instances << instance elsif options[:clean_stale_or_corrupted] cleanup(dir) end when :structure_version_unsupported next when :corrupted if !instance.locked? && options[:clean_stale_or_corrupted] cleanup(dir) end when :not_finalized if instance.stale? && options[:clean_stale_or_corrupted] cleanup(dir) end end end end instances end def find_by_name(name, options = {}) return list(options).find { \|instance\| instance.name == name } end def find_by_name_prefix(name, options = {}) prefix = /^#{Regexp.escape name}/ results = list(options).find_all { \|instance\| instance.name =~ prefix } if results.size <= 1 return results.first else return :ambiguous end end # :watchdog_pid: expected Integer. # # return: the matching instance, if found; nil otherwise. # def find_by_watchdog_pid(pid, options = {}) return list(options).detect { \|instance\| instance.watchdog_pid == pid } end private def default_paths if result = string_env("PASSENGER_INSTANCE_REGISTRY_DIR") return [result] end # On OSX, TMPDIR is set to a different value per-user. But Apache # is launched through Launchctl and runs without TMPDIR (and thus # uses the default /tmp). # # The RPM packages configure Apache and Nginx to use /var/run/passenger-instreg # as the instance registry dir. See https://github.com/phusion/passenger/issues/1475 # # systemd's PrivateTmp feature works like an inverted OSX, apache gets its own # TMPDIR and users use /tmp, however the path is often too long because socket paths can # only be up to 108 characters long. [string_env("TMPDIR"), "/tmp", "/var/run/passenger-instreg",Dir['/tmp/systemd-private--{httpd,nginx,apache2}.service-/tmp']].compact end def string_env(name) if (result = ENV[name]) && !result.empty? result else nil end end def cleanup(path) puts "*** Cleaning stale instance directory #{path}" begin FileUtils.chmod_R(0700, path) rescue nil FileUtils.remove_entry_secure(path) rescue SystemCallError => e puts " Warning: #{e}" end end end end # module AdminTools end # module PhusionPassenger	4.47 KB	2025-11-20 11:36
📄 memory_stats.rb # encoding: binary # 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 'platform_info/apache' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' module PhusionPassenger module AdminTools class MemoryStats # Information about a single process. class Process attr_accessor :pid attr_accessor :ppid attr_accessor :threads attr_accessor :vm_size # in KB attr_accessor :rss # in KB attr_accessor :cpu attr_accessor :name attr_accessor :private_dirty_rss # in KB def vm_size_in_mb return sprintf("%.1f MB", vm_size / 1024.0) end def rss_in_mb return sprintf("%.1f MB", rss / 1024.0) end def private_dirty_rss_in_mb if private_dirty_rss.is_a?(Numeric) return sprintf("%.1f MB", private_dirty_rss / 1024.0) else return "?" end end def to_a return [pid, ppid, vm_size_in_mb, private_dirty_rss_in_mb, rss_in_mb, name] end end # Returns a list of Apache processes, which may be the empty list if Apache is # not running. If the Apache executable name is unknown then nil will be returned. def apache_processes @apache_processes \|\|= begin if PlatformInfo.httpd processes = list_processes(:exe => PlatformInfo.httpd) if processes.empty? # On some Linux distros, the Apache worker processes # are called "httpd.worker" processes = list_processes(:exe => "#{PlatformInfo.httpd}.worker") end processes else nil end end end # Returns a list of Nginx processes, which may be the empty list if # Nginx is not running. def nginx_processes @nginx_processes \|\|= list_processes(:exe => "nginx") end # Returns a list of Phusion Passenger processes, which may be the empty list if # Phusion Passenger is not running. def passenger_processes @passenger_processes \|\|= list_processes(:match => /((^\| )Passenger\|(^\| )Rails:\|(^\| )Rack:\|wsgi-loader.py\|(.)PassengerAgent\|rack-loader.rb)/) end # Returns the sum of the memory usages of all given processes. # Returns a pair [usage, accurate]. +usage+ is the summed memory usage in KB, # and +accurate+ indicates whether this sum is accurate. This may be false # if some process's memory usage cannot be determined. def sum_memory_usage(processes) total = 0 if should_show_private_dirty_rss? accurate = true processes.each do \|p\| if p.private_dirty_rss.is_a?(Numeric) total += p.private_dirty_rss else accurate = true end end return [total, accurate] else processes.each do \|p\| total += p.rss end return [total, true] end end def platform_provides_private_dirty_rss_information? return os_name_simple == "linux" end # Returns whether root privileges are required in order to measure private dirty RSS. # Only meaningful if #platform_provides_private_dirty_rss_information? returns true. def root_privileges_required_for_private_dirty_rss? all_processes = (apache_processes \|\| []) + nginx_processes + passenger_processes return all_processes.any?{ \|p\| p.private_dirty_rss.nil? } end def should_show_private_dirty_rss? return platform_provides_private_dirty_rss_information? && (::Process.euid == 0 \|\| root_privileges_required_for_private_dirty_rss?) end # Determine the system's RAM usage, not including swap. # Returns a tuple [total, used] where both numbers are in KB, or nil # if the system's RAM usage cannot be determined. def system_ram_usage @total_system_ram \|\|= begin case os_name_simple when "linux" free_text = `free -k` free_text =~ %r{Mem:(.+)$} line = $1.strip total = line.split(/ +/).first.to_i free_text =~ %r{buffers/cache:(.+)$} line = $1.strip used = line.split(/ +/).first.to_i [total, used] when "macosx" vm_stat = `vm_stat` vm_stat =~ /page size of (\d+) bytes/ page_size = $1 vm_stat =~ /Pages free: +(\d+)/ free = $1 vm_stat =~ /Pages active: +(\d+)/ active = $1 vm_stat =~ /Pages inactive: +(\d+)/ inactive = $1 vm_stat =~ /Pages wired down: +(\d+)/ wired = $1 if page_size && free && active && inactive && wired page_size = page_size.to_i free = free.to_i page_size / 1024 active = active.to_i * page_size / 1024 inactive = inactive.to_i * page_size / 1024 wired = wired.to_i * page_size / 1024 used = active + wired [free + inactive + used, used] else nil end else `top` =~ /(\d+)(K\|M) Active, (\d+)(K\|M) Inact, (\d+)(K\|M) Wired,.?(\d+)(K\|M) Free/ if $1 && $2 && $3 && $4 && $5 && $6 && $7 && $8 to_kb = lambda do \|number, unit\| if unit == 'K' number.to_i else number.to_i 1024 end end active = to_kb.call($1, $2) inactive = to_kb.call($3, $4) wired = to_kb.call($5, $6) free = to_kb.call($7, $8) used = active + wired [free + inactive + used, used] else nil end end end end private def os_name_simple return PlatformInfo.os_name_simple end # Returns a list of Process objects that match the given search criteria. # # # Search by executable path. # list_processes(:exe => '/usr/sbin/apache2') # # # Search by executable name. # list_processes(:name => 'ruby1.8') # # # Search by process name. # list_processes(:match => 'Passenger FrameworkSpawner') def list_processes(options) if options[:exe] name = options[:exe].sub(/.\/(.)/, '\1') if os_name_simple == "linux" ps = "ps -C '#{name}'" else ps = "ps -A" options[:match] = Regexp.new(Regexp.escape(name)) end elsif options[:name] if os_name_simple == "linux" ps = "ps -C '#{options[:name]}'" else ps = "ps -A" options[:match] = Regexp.new(" #{Regexp.escape(options[:name])}") end elsif options[:match] ps = "ps -A" else raise ArgumentError, "Invalid options." end processes = [] case os_name_simple when "solaris" ps_output = `#{ps} -o pid,ppid,nlwp,vsz,rss,pcpu,comm` threads_known = true when "macosx" ps_output = `#{ps} -w -o pid,ppid,vsz,rss,%cpu,command` threads_known = false else ps_output = `#{ps} -w -o pid,ppid,nlwp,vsz,rss,%cpu,command` threads_known = true end list = force_binary(ps_output).split("\n") list.shift list.each do \|line\| line.gsub!(/^ /, '') line.gsub!(/ $/, '') p = Process.new if threads_known p.pid, p.ppid, p.threads, p.vm_size, p.rss, p.cpu, p.name = line.split(/ +/, 7) else p.pid, p.ppid, p.vm_size, p.rss, p.cpu, p.name = line.split(/ +/, 6) end p.name.sub!(/\Aruby: /, '') p.name.sub!(/ \(ruby\)\Z/, '') if p.name !~ /^ps/ && (!options[:match] \|\| p.name.match(options[:match])) # Convert some values to integer. [:pid, :ppid, :vm_size, :rss].each do \|attr\| p.send("#{attr}=", p.send(attr).to_i) end p.threads = p.threads.to_i if threads_known if platform_provides_private_dirty_rss_information? p.private_dirty_rss = determine_private_dirty_rss(p.pid) end processes << p end end return processes end # Returns the private dirty RSS for the given process, in KB. def determine_private_dirty_rss(pid) total = 0 File.read("/proc/#{pid}/smaps").split("\n").each do \|line\| line =~ /^(Private)_Dirty: +(\d+)/ if $2 total += $2.to_i end end if total == 0 return nil else return total end rescue Errno::EACCES, Errno::ENOENT, Errno::ESRCH return nil end if ''.respond_to?(:force_encoding) def force_binary(str) str.force_encoding('binary') end else def force_binary(str) str end end end end # module AdminTools end # module PhusionPassenger	10.4 KB	2025-11-20 11:36

Terminal