To achieve the ability for Python programs to automatically re-run after being forced to shut down by a remote host, there are several approaches we can take, but one of the most straightforward and commonly used is to incorporate operating system-level tools or scripts. On a Linux system, we can use thecronjob orsystemdservice to accomplish this; on Windows systems, you can use theMission planning process. But here, to provide a cross-platform, more flexible solution, we can write a simple Python script to monitor the main program and restart it when it detects that the main program has been shut down.
1. Python is used.subprocessExample of a module to start and monitor the main program
1.1 Examples of scripts
The following is an example of a Python script that will monitor another Python program (e.g.main_program.py) run status and restarts it when it exits. This monitoring script uses Python'ssubprocessmodule to start and monitor the main program, andto periodically check if the main program is still running.
import subprocess
import time
def run_main_program():: # Start the main program.
# Start the main program
print("Starting main_program.py...")
try.
# Use the startup main program to ensure that its PID is captured
process = (['python', 'main_program.py'])
# Wait for the main program to finish
()
print("main_program.py has exited. Restarting...")
except Exception as e: print(f "An error occurred:")
print(f "An error occurred: {e}. Trying to restart main_program.py...")
if __name__ == "__main__": while True: __name__ == "__main__".
while True: run_main_program()
run_main_program()
# Wait for some time before restarting (e.g. every 5 minutes)
(300) # 300 seconds = 5 minutes
# Note: We need to replace 'main_program.py' with the name of our main program file.
# Also, make sure that this monitor script is in the same directory as the main program, or provide the full path to.
1.2 Description
（1）main program file: We will need to set themain_program.pyReplace it with the name of the Python program file that we want to monitor and restart automatically.
（2）error handling: The above script includes basic error handling so that if the main program fails to start it can output an error message and attempt to restart.
（3）restart interval：(300)The wait time between reboots is set to 5 minutes. We can adjust this value as needed.
（4）Cross-platform compatibility: This script should work on both Linux and Windows, as long as the Python environment is set up and themain_program.pyis executable.
1.3 Attention
(1) If the main program exits frequently because of an exception or error, simply restarting it may not be the best way to solve the problem. In this case, we should first investigate and fix the error in the main program.
(2) This script runs in an infinite loop until we stop it manually. In a production environment, we may want to use a more robust service management tool (such as systemd or Windows Services) to manage it.
For those who need a more advanced solution to the problem of automatically re-running processes after a Python program is forced to shut down by a remote host, we can consider using a daemon management tool likesupervisor, or write more complex retry logic combined with exception handling. Both approaches are described in detail below:
2. Usesupervisorartifact
supervisoris a daemon management tool written in Python that monitors our applications and automatically restarts them in case of a crash or abnormal exit. This approach is suitable for production environments as it provides a more stable and reliable monitoring and restarting mechanism.
Steps:
（1）Installation of supervisor：
Run the following command at the command line to install supervisor (for Linux, for example):
sudo apt-get install supervisor # Debian/Ubuntu
sudo yum install supervisor # CentOS/RHEL
（2）Configuring the supervisor：
Create a configuration file (e.g.), and specify in it the details of the Python application to be monitored. The configuration file is usually located in the/etc/supervisor//directory. An example of a configuration file is shown below:
[program:myapp]
command = python /path/to/your/
directory = /path/to/your/app
user = your_username
autostart = true
autorestart = true
startsecs = 5
stopwaitsecs = 600
environment = ENV_VAR_1=value, ENV_VAR_2=value
Set the values accordingly to the actual path and needs of our application.
（3）Start the supervisor：
Run the following command to start supervisor and re-read the configuration file:
sudo supervisorctl reread
sudo supervisorctl update
（4）Monitor and manage applications：
Use the following commands to monitor and manage applications managed by supervisor:
sudo supervisorctl status
sudo supervisorctl tail -f myapp
sudo supervisorctl restart myapp
sudo supervisorctl stop myapp
3. Write complex retry logic combined with exception handling
If we don't want to use additional tools, we can write more complex retry logic and exception handling mechanisms in Python scripts. This approach is more flexible, but may require more code and logic to ensure stability and reliability.
Sample code:
import time
import random
def remote_task().
"""Simulates interaction with a remote host, may throw an exception due to connection closure""""
# Randomly simulate success and failure
if ([True, False]).
print("Task executed successfully.")
else: raise ConnectionError([True, False])
raise ConnectionError("Connection to remote host failed")
def run_task(): max_retries = 5
max_retries = 5 # Maximum number of retries.
retry_interval = 5 # retry interval (seconds)
retries = 0
while retries < max_retries.
max_retries: # retries = 0 while retries < max_retries.
remote_task()
break # Jump out of loop on success
except ConnectionError as e: print(e)
print(e)
print(f "Trying to reconnect... (Retries remaining: {max_retries - retries - 1})")
(retry_interval)
retries += 1
if retries == max_retries.
print("Maximum number of retries reached, task execution failed.")
if __name__ == "__main__".
run_task()
In this example, we define aremote_taskfunction to simulate interaction with the remote host and may throw theConnectionErrorException.run_taskfunction is responsible for running in a loopremote_task, and is captured in theConnectionErrorThe maximum number of retries and the retry interval are set.
summarize
For scenarios that require a more advanced solution, it is recommended to use thesupervisorand other daemon management tools, as they provide a more stable and reliable monitoring and restarting mechanism. However, writing complex retry logic and exception handling mechanisms is also a viable option if we wish to implement similar functionality without introducing additional tools.