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
📁 crash_watch	-	2026-03-21 15:53
📁 daemon_controller	-	2026-03-21 15:53
📄 daemon_controller.rb # daemon_controller, library for robust daemon management # Copyright (c) 2010-2025 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 'tempfile' require 'fcntl' require 'socket' require 'pathname' require 'timeout' if Process.respond_to?(:spawn) require 'rbconfig' end PhusionPassenger.require_passenger_lib 'vendor/daemon_controller/lock_file' module PhusionPassenger # Main daemon controller object. See the README for an introduction and tutorial. class DaemonController ALLOWED_CONNECT_EXCEPTIONS = [Errno::ECONNREFUSED, Errno::ENETUNREACH, Errno::ETIMEDOUT, Errno::ECONNRESET, Errno::EINVAL, Errno::EADDRNOTAVAIL] SPAWNER_FILE = File.expand_path(File.join(File.dirname(__FILE__), "daemon_controller", "spawn.rb")) class Error < StandardError end class TimeoutError < Error end class AlreadyStarted < Error end class StartError < Error end class StartTimeout < TimeoutError end class StopError < Error end class StopTimeout < TimeoutError end class ConnectError < Error end class DaemonizationTimeout < TimeoutError end # Create a new DaemonController object. # # === Mandatory options # # [:identifier] # A human-readable, unique name for this daemon, e.g. "Sphinx search server". # This identifier will be used in some error messages. On some platforms, it will # be used for concurrency control: on such platforms, no two DaemonController # objects will operate on the same identifier on the same time. # # [:start_command] # The command to start the daemon. This must be a a String, e.g. # "mongrel_rails start -e production", or a Proc which returns a String. # # If the value is a Proc, and the +before_start+ option is given too, then # the +start_command+ Proc is guaranteed to be called after the +before_start+ # Proc is called. # # [:ping_command] # The ping command is used to check whether the daemon can be connected to. # It is also used to ensure that #start only returns when the daemon can be # connected to. # # The value may be a command string. This command must exit with an exit code of # 0 if the daemon can be successfully connected to, or exit with a non-0 exit # code on failure. # # The value may also be an Array which specifies the socket address of the daemon. # It must be in one of the following forms: # - [:tcp, host_name, port] # - [:unix, filename] # # The value may also be a Proc, which returns an expression that evaluates to # true (indicating that the daemon can be connected to) or false (failure). # If the Proc raises Errno::ECONNREFUSED, Errno::ENETUNREACH, Errno::ETIMEDOUT # Errno::ECONNRESET, Errno::EINVAL or Errno::EADDRNOTAVAIL then that also # means that the daemon cannot be connected to. # <b>NOTE:</b> if the ping command returns an object which responds to # <tt>#close</tt>, then that method will be called on it. # This makes it possible to specify a ping command such as # <tt>lambda { TCPSocket.new('localhost', 1234) }</tt>, without having to worry # about closing it afterwards. # Any exceptions raised by #close are ignored. # # [:pid_file] # The PID file that the daemon will write to. Used to check whether the daemon # is running. # # [:lock_file] # The lock file to use for serializing concurrent daemon management operations. # Defaults to "(filename of PID file).lock". # # [:log_file] # The log file that the daemon will write to. It will be consulted to see # whether the daemon has printed any error messages during startup. # # === Optional options # [:stop_command] # A command to stop the daemon with, e.g. "/etc/rc.d/nginx stop". If no stop # command is given (i.e. +nil+), then DaemonController will stop the daemon # by killing the PID written in the PID file. # # The default value is +nil+. # # [:restart_command] # A command to restart the daemon with, e.g. "/etc/rc.d/nginx restart". If # no restart command is given (i.e. +nil+), then DaemonController will # restart the daemon by calling #stop and #start. # # The default value is +nil+. # # [:before_start] # This may be a Proc. It will be called just before running the start command. # The before_start proc is not subject to the start timeout. # # [:start_timeout] # The maximum amount of time, in seconds, that #start may take to start # the daemon. Since #start also waits until the daemon can be connected to, # that wait time is counted as well. If the daemon does not start in time, # then #start will raise an exception. # # The default value is 15. # # [:stop_timeout] # The maximum amount of time, in seconds, that #stop may take to stop # the daemon. Since #stop also waits until the daemon is no longer running, # that wait time is counted as well. If the daemon does not stop in time, # then #stop will raise an exception. # # The default value is 15. # # [:log_file_activity_timeout] # Once a daemon has gone into the background, it will become difficult to # know for certain whether it is still initializing or whether it has # failed and exited, until it has written its PID file. Suppose that it # failed with an error after daemonizing but before it has written its PID file; # not many system administrators want to wait 15 seconds (the default start # timeout) to be notified of whether the daemon has terminated with an error. # # An alternative way to check whether the daemon has terminated with an error, # is by checking whether its log file has been recently updated. If, after the # daemon has started, the log file hasn't been updated for the amount of seconds # given by the :log_file_activity_timeout option, then the daemon is assumed to # have terminated with an error. # # The default value is 7. # # [:dont_stop_if_pid_file_invalid] # If the :stop_command option is given, then normally daemon_controller will # always execute this command upon calling #stop. But if :dont_stop_if_pid_file_invalid # is given, then daemon_controller will not do that if the PID file does not contain # a valid number. # # The default is false. # # [:daemonize_for_me] # Normally daemon_controller will wait until the daemon has daemonized into the # background, in order to capture any errors that it may print on stdout or # stderr before daemonizing. However, if the daemon doesn't support daemonization # for some reason, then setting this option to true will cause daemon_controller # to do the daemonization for the daemon. # # The default is false. # # [:keep_ios] # Upon spawning the daemon, daemon_controller will normally close all file # descriptors except stdin, stdout and stderr. However if there are any file # descriptors you want to keep open, specify the IO objects here. This must be # an array of IO objects. # # [:env] # This must be a Hash. The hash will contain the environment variables available # to be made available to the daemon. Hash keys must be strings, not symbols. def initialize(options) [:identifier, :start_command, :ping_command, :pid_file, :log_file].each do \|option\| if !options.has_key?(option) raise ArgumentError, "The ':#{option}' option is mandatory." end end @identifier = options[:identifier] @start_command = options[:start_command] @stop_command = options[:stop_command] @ping_command = options[:ping_command] @restart_command = options[:restart_command] @ping_interval = options[:ping_interval] \|\| 0.1 @pid_file = options[:pid_file] @log_file = options[:log_file] @before_start = options[:before_start] @start_timeout = options[:start_timeout] \|\| 15 @stop_timeout = options[:stop_timeout] \|\| 15 @log_file_activity_timeout = options[:log_file_activity_timeout] \|\| 7 @dont_stop_if_pid_file_invalid = options[:dont_stop_if_pid_file_invalid] @daemonize_for_me = options[:daemonize_for_me] @keep_ios = options[:keep_ios] \|\| [] @lock_file = determine_lock_file(options, @identifier, @pid_file) @env = options[:env] \|\| {} end # Start the daemon and wait until it can be pinged. # # Raises: # - AlreadyStarted - the daemon is already running. # - StartError - the start command failed. # - StartTimeout - the daemon did not start in time. This could also # mean that the daemon failed after it has gone into the background. def start @lock_file.exclusive_lock do start_without_locking end end # Connect to the daemon by running the given block, which contains the # connection logic. If the daemon isn't already running, then it will be # started. # # The block must return nil or raise Errno::ECONNREFUSED, Errno::ENETUNREACH, # Errno::ETIMEDOUT, Errno::ECONNRESET, Errno::EINVAL and Errno::EADDRNOTAVAIL # to indicate that the daemon cannot be # connected to. It must return non-nil if the daemon can be connected to. # Upon successful connection, the return value of the block will # be returned by #connect. # # Note that the block may be called multiple times. # # Raises: # - StartError - an attempt to start the daemon was made, but the start # command failed with an error. # - StartTimeout - an attempt to start the daemon was made, but the daemon # did not start in time, or it failed after it has gone into the background. # - ConnectError - the daemon wasn't already running, but we couldn't connect # to the daemon even after starting it. def connect connection = nil @lock_file.shared_lock do begin connection = yield rescue ALLOWED_CONNECT_EXCEPTIONS connection = nil end end if connection.nil? @lock_file.exclusive_lock do if !daemon_is_running? start_without_locking end connect_exception = nil begin connection = yield rescue ALLOWED_CONNECT_EXCEPTIONS => e connection = nil connect_exception = e end if connection.nil? # Daemon is running but we couldn't connect to it. Possible # reasons: # - The daemon froze. # - Bizarre security restrictions. # - There's a bug in the yielded code. if connect_exception raise ConnectError, "Cannot connect to the daemon: #{connect_exception} (#{connect_exception.class})" else raise ConnectError, "Cannot connect to the daemon" end else connection end end else connection end end # Stop the daemon and wait until it has exited. # # Raises: # - StopError - the stop command failed. # - StopTimeout - the daemon didn't stop in time. def stop @lock_file.exclusive_lock do begin Timeout.timeout(@stop_timeout, Timeout::Error) do kill_daemon if daemon_is_running? wait_until do !daemon_is_running? end end rescue Timeout::Error raise StopTimeout, "Daemon '#{@identifier}' did not exit in time" end end end # Restarts the daemon. Uses the restart_command if provided, otherwise # calls #stop and #start. def restart if @restart_command run_command(@restart_command) else stop start end end # Returns the daemon's PID, as reported by its PID file. Returns the PID # as an integer, or nil there is no valid PID in the PID file. # # This method doesn't check whether the daemon's actually running. # Use #running? if you want to check whether it's actually running. # # Raises SystemCallError or IOError if something went wrong during # reading of the PID file. def pid @lock_file.shared_lock do read_pid_file end end # Checks whether the daemon is still running. This is done by reading # the PID file and then checking whether there is a process with that # PID. # # Raises SystemCallError or IOError if something went wrong during # reading of the PID file. def running? @lock_file.shared_lock do daemon_is_running? end end # Checks whether ping Unix domain sockets is supported. Currently # this is supported on all Ruby implementations, except JRuby. def self.can_ping_unix_sockets? RUBY_PLATFORM != "java" end private def start_without_locking if daemon_is_running? raise AlreadyStarted, "Daemon '#{@identifier}' is already started" end save_log_file_information delete_pid_file begin started = false before_start Timeout.timeout(@start_timeout, Timeout::Error) do done = false spawn_daemon record_activity # We wait until the PID file is available and until # the daemon responds to pings, but we wait no longer # than @start_timeout seconds in total (including daemon # spawn time). # Furthermore, if the log file hasn't changed for # @log_file_activity_timeout seconds, and the PID file # still isn't available or the daemon still doesn't # respond to pings, then assume that the daemon has # terminated with an error. wait_until do if log_file_has_changed? record_activity elsif no_activity?(@log_file_activity_timeout) raise Timeout::Error, "Daemon seems to have exited" end pid_file_available? end wait_until(@ping_interval) do if log_file_has_changed? record_activity elsif no_activity?(@log_file_activity_timeout) raise Timeout::Error, "Daemon seems to have exited" end run_ping_command \|\| !daemon_is_running? end started = run_ping_command end result = started rescue DaemonizationTimeout, Timeout::Error => e start_timed_out if pid_file_available? kill_daemon_with_signal(true) end if e.is_a?(DaemonizationTimeout) result = :daemonization_timeout else result = :start_timeout end end if !result raise(StartError, differences_in_log_file \|\| "Daemon '#{@identifier}' failed to start.") elsif result == :daemonization_timeout raise(StartTimeout, differences_in_log_file \|\| "Daemon '#{@identifier}' didn't daemonize in time.") elsif result == :start_timeout raise(StartTimeout, differences_in_log_file \|\| "Daemon '#{@identifier}' failed to start in time.") else true end end def before_start if @before_start @before_start.call end end def spawn_daemon if @start_command.respond_to?(:call) run_command(@start_command.call) else run_command(@start_command) end end def kill_daemon if @stop_command if @dont_stop_if_pid_file_invalid && read_pid_file.nil? return end begin run_command(@stop_command) rescue StartError => e raise StopError, e.message end else kill_daemon_with_signal end end def kill_daemon_with_signal(force = false) pid = read_pid_file if pid if force Process.kill('SIGKILL', pid) else Process.kill('SIGTERM', pid) end end rescue Errno::ESRCH, Errno::ENOENT end def daemon_is_running? begin pid = read_pid_file rescue Errno::ENOENT # The PID file may not exist, or another thread/process # executing #running? may have just deleted the PID file. # So we catch this error. pid = nil end if pid.nil? false elsif check_pid(pid) true else delete_pid_file false end end def read_pid_file begin pid = File.read(@pid_file).strip rescue Errno::ENOENT return nil end if pid =~ /\A\d+\Z/ pid.to_i else nil end end def delete_pid_file File.unlink(@pid_file) rescue Errno::EPERM, Errno::EACCES, Errno::ENOENT # ignore end def check_pid(pid) Process.kill(0, pid) true rescue Errno::ESRCH false rescue Errno::EPERM # We didn't have permission to kill the process. Either the process # is owned by someone else, or the system has draconian security # settings and we aren't allowed to kill any process. Assume that # the process is running. true end def wait_until(sleep_interval = 0.1) while !yield sleep(sleep_interval) end end def wait_until_pid_file_is_available_or_log_file_has_changed while !(pid_file_available? \|\| log_file_has_changed?) sleep 0.1 end pid_file_is_available? end def wait_until_daemon_responds_to_ping_or_has_exited_or_log_file_has_changed while !(run_ping_command \|\| !daemon_is_running? \|\| log_file_has_changed?) sleep(@ping_interval) end run_ping_command end def record_activity @last_activity_time = Time.now end # Check whether there has been no recorded activity in the past +seconds+ seconds. def no_activity?(seconds) Time.now - @last_activity_time > seconds end def pid_file_available? File.exist?(@pid_file) && File.stat(@pid_file).size != 0 end # This method does nothing and only serves as a hook for the unit test. def start_timed_out end # This method does nothing and only serves as a hook for the unit test. def daemonization_timed_out end def save_log_file_information @original_log_file_stat = File.stat(@log_file) rescue nil @current_log_file_stat = @original_log_file_stat end def log_file_has_changed? if @current_log_file_stat stat = File.stat(@log_file) rescue nil if stat result = @current_log_file_stat.mtime != stat.mtime \|\| @current_log_file_stat.size != stat.size @current_log_file_stat = stat result else true end else false end end def differences_in_log_file if @original_log_file_stat && @original_log_file_stat.file? File.open(@log_file, 'r') do \|f\| f.seek(@original_log_file_stat.size, IO::SEEK_SET) diff = f.read.strip if diff.empty? nil else diff end end else nil end rescue Errno::ENOENT, Errno::ESPIPE # ESPIPE means the log file is a pipe. nil end def determine_lock_file(options, identifier, pid_file) if options[:lock_file] LockFile.new(File.expand_path(options[:lock_file])) else LockFile.new(File.expand_path(pid_file + ".lock")) end end def self.fork_supported? RUBY_PLATFORM != "java" && RUBY_PLATFORM !~ /win32/ end def self.spawn_supported? # Process.spawn doesn't work very well in JRuby. Process.respond_to?(:spawn) && RUBY_PLATFORM != "java" end def run_command(command) if should_capture_output_while_running_command? run_command_while_capturing_output(command) else run_command_without_capturing_output(command) end end def should_capture_output_while_running_command? if is_std_channel_chardev?(@log_file) false else begin real_log_file = Pathname.new(@log_file).realpath.to_s rescue SystemCallError real_log_file = nil end if real_log_file !is_std_channel_chardev?(real_log_file) else true end end end def is_std_channel_chardev?(path) path == "/dev/stdout" \|\| path == "/dev/stderr" \|\| path == "/dev/fd/1" \|\| path == "/dev/fd/2" \|\| path =~ %r(\A/proc/([0-9]+\|self)/fd/[12]\Z) end def run_command_while_capturing_output(command) # Create tempfile for storing the command's output. tempfile = Tempfile.new('daemon-output') tempfile.chmod(0666) tempfile_path = tempfile.path tempfile.close if self.class.fork_supported? \|\| self.class.spawn_supported? if Process.respond_to?(:spawn) options = { :in => "/dev/null", :out => tempfile_path, :err => tempfile_path, :close_others => true } @keep_ios.each do \|io\| options[io] = io end if @daemonize_for_me pid = Process.spawn(@env, ruby_interpreter, SPAWNER_FILE, command, options) else pid = Process.spawn(@env, command, options) end else pid = safe_fork(@daemonize_for_me) do ObjectSpace.each_object(IO) do \|obj\| if !@keep_ios.include?(obj) obj.close rescue nil end end STDIN.reopen("/dev/null", "r") STDOUT.reopen(tempfile_path, "w") STDERR.reopen(tempfile_path, "w") ENV.update(@env) exec(command) end end # run_command might be running in a timeout block (like # in #start_without_locking). begin interruptable_waitpid(pid) rescue Errno::ECHILD # Maybe a background thread or whatever waitpid()'ed # this child process before we had the chance. There's # no way to obtain the exit status now. Assume that # it started successfully; if it didn't we'll know # that later by checking the PID file and by pinging # it. return rescue Timeout::Error daemonization_timed_out # If the daemon doesn't fork into the background # in time, then kill it. begin Process.kill('SIGTERM', pid) rescue SystemCallError end begin Timeout.timeout(5, Timeout::Error) do begin interruptable_waitpid(pid) rescue SystemCallError end end rescue Timeout::Error begin Process.kill('SIGKILL', pid) interruptable_waitpid(pid) rescue SystemCallError end end raise DaemonizationTimeout end if $?.exitstatus != 0 raise StartError, File.read(tempfile_path).strip end else if @env && !@env.empty? raise "Setting the :env option is not supported on this Ruby implementation." elsif @daemonize_for_me raise "Setting the :daemonize_for_me option is not supported on this Ruby implementation." end cmd = "#{command} >\"#{tempfile_path}\"" cmd << " 2>\"#{tempfile_path}\"" unless PLATFORM =~ /mswin/ if !system(cmd) raise StartError, File.read(tempfile_path).strip end end ensure File.unlink(tempfile_path) rescue nil end def run_command_without_capturing_output(command) if self.class.fork_supported? \|\| self.class.spawn_supported? if Process.respond_to?(:spawn) options = { :in => "/dev/null", :out => :out, :err => :err, :close_others => true } @keep_ios.each do \|io\| options[io] = io end if @daemonize_for_me pid = Process.spawn(@env, ruby_interpreter, SPAWNER_FILE, command, options) else pid = Process.spawn(@env, command, options) end else pid = safe_fork(@daemonize_for_me) do ObjectSpace.each_object(IO) do \|obj\| if !@keep_ios.include?(obj) obj.close rescue nil end end STDIN.reopen("/dev/null", "r") ENV.update(@env) exec(command) end end # run_command might be running in a timeout block (like # in #start_without_locking). begin interruptable_waitpid(pid) rescue Errno::ECHILD # Maybe a background thread or whatever waitpid()'ed # this child process before we had the chance. There's # no way to obtain the exit status now. Assume that # it started successfully; if it didn't we'll know # that later by checking the PID file and by pinging # it. return rescue Timeout::Error daemonization_timed_out # If the daemon doesn't fork into the background # in time, then kill it. begin Process.kill('SIGTERM', pid) rescue SystemCallError end begin Timeout.timeout(5, Timeout::Error) do begin interruptable_waitpid(pid) rescue SystemCallError end end rescue Timeout::Error begin Process.kill('SIGKILL', pid) interruptable_waitpid(pid) rescue SystemCallError end end raise DaemonizationTimeout end if $?.exitstatus != 0 raise StartError, "Daemon '#{@identifier}' failed to start." end else if @env && !@env.empty? raise "Setting the :env option is not supported on this Ruby implementation." elsif @daemonize_for_me raise "Setting the :daemonize_for_me option is not supported on this Ruby implementation." end if !system(command) raise StartError, "Daemon '#{@identifier}' failed to start." end end end def run_ping_command if @ping_command.respond_to?(:call) begin value = @ping_command.call if value.respond_to?(:close) value.close rescue nil end value rescue ALLOWED_CONNECT_EXCEPTIONS false end elsif @ping_command.is_a?(Array) type, args = @ping_command if self.class.can_ping_unix_sockets? case type when :tcp hostname, port = args sockaddr = Socket.pack_sockaddr_in(port, hostname) ping_tcp_socket(sockaddr) when :unix socket_domain = Socket::Constants::AF_LOCAL sockaddr = Socket.pack_sockaddr_un(args[0]) ping_socket(socket_domain, sockaddr) else raise ArgumentError, "Unknown ping command type #{type.inspect}" end else case type when :tcp hostname, port = args ping_socket(hostname, port) when :unix raise "Pinging Unix domain sockets is not supported on this Ruby implementation" else raise ArgumentError, "Unknown ping command type #{type.inspect}" end end else system(@ping_command) end end if !can_ping_unix_sockets? require 'java' def ping_socket(host_name, port) channel = java.nio.channels.SocketChannel.open begin address = java.net.InetSocketAddress.new(host_name, port) channel.configure_blocking(false) if channel.connect(address) return true end deadline = Time.now.to_f + 0.1 done = false while true begin if channel.finish_connect return true end rescue java.net.ConnectException => e if e.message =~ /Connection refused/i return false else throw e end end # Not done connecting and no error. sleep 0.01 if Time.now.to_f >= deadline return false end end ensure channel.close end end else def ping_socket(socket_domain, sockaddr) begin socket = Socket.new(socket_domain, Socket::Constants::SOCK_STREAM, 0) begin socket.connect_nonblock(sockaddr) rescue Errno::ENOENT, Errno::EINPROGRESS, Errno::EAGAIN, Errno::EWOULDBLOCK if select(nil, [socket], nil, 0.1) begin socket.connect_nonblock(sockaddr) rescue Errno::EISCONN rescue Errno::EINVAL if RUBY_PLATFORM =~ /freebsd/i raise Errno::ECONNREFUSED else raise end end else raise Errno::ECONNREFUSED end end true rescue Errno::ECONNREFUSED, Errno::ENOENT false ensure socket.close if socket end end def ping_tcp_socket(sockaddr) begin ping_socket(Socket::Constants::AF_INET, sockaddr) rescue Errno::EAFNOSUPPORT ping_socket(Socket::Constants::AF_INET6, sockaddr) end end end def ruby_interpreter if defined?(RbConfig) rb_config = RbConfig::CONFIG else rb_config = Config::CONFIG end File.join( rb_config['bindir'], rb_config['RUBY_INSTALL_NAME'] ) + rb_config['EXEEXT'] end def safe_fork(double_fork) pid = fork if pid.nil? begin if double_fork pid2 = fork if pid2.nil? Process.setsid yield end else yield end rescue Exception => e message = "*** Exception #{e.class} " << "(#{e}) (process #{$$}):\n" << "\tfrom " << e.backtrace.join("\n\tfrom ") STDERR.write(e) STDERR.flush exit! ensure exit!(0) end else if double_fork Process.waitpid(pid) rescue nil pid else pid end end end if RUBY_VERSION < "1.9" def interruptable_waitpid(pid) Process.waitpid(pid) end else # On Ruby 1.9, Thread#kill (which is called by timeout.rb) may # not be able to interrupt Process.waitpid. So here we use a # special version that's a bit less efficient but is at least # interruptable. def interruptable_waitpid(pid) result = nil while !result result = Process.waitpid(pid, Process::WNOHANG) sleep 0.01 if !result end result end end end end # module PhusionPassenger	30.27 KB	2025-11-20 11:36

Terminal