Subproccess exits when parent python script stopped by systemd - subprocess

Question

I am new to python and wanted to get familiar, so I created a python script that uses Popen from subprocess to execute a bash script. The bash script sets up an environment for, and executes a c++ program to run in the background.
The intended use is to run the python script as a service that watches for the C++ process, and if the C++ process exits, run the bash startup script again.
Everything runs as intended if I start the python script from the command line (./proc_watchdog.py), and then ctr+c, the C++ process will continue running.
If I then execute the the python script using systemd, systemd start pythonscript.service and then stop it systemd stop pythonscript.service, the C++ program exits.
The .service file:
[Unit]
Description=RustDedicated watchdog service
StartLimitIntervalSec=0
[Service]
Type=simple
Restart=always
RestartSec=1
User=scriptuser
ExecStart=/path/to/C++_Prog_Dir/proc_watchdog.py
[Install]
WantedBy=multi-user.target
The python script:
#!/usr/bin/python3
import subprocess as sp
import os
import psutil
import time
backgroundProc = "Procname"
def processWatchdog():
waitCount = 0;
while True:
procList = []
for proc in psutil.process_iter():
procList.append(proc.as_dict(attrs=['name']))
found = 0
for pname in procList:
if backgroundProc == pname['name']:
print("Process running")
found = 1
if found == 0:
print("Process not found...")
waitCount += 1
if waitCount == 3:
p = sp.Popen(["/path/to/C++_Prog_Dir/start.sh"])
print("Restarting")
p.wait()
waitCount = 0
print("Restarted")
time.sleep(2)
if __name__ == '__main__':
processWatchdog()
Bash script example:
#!/bin/bash
./c++_process &>> /dev/null &
exit 0
Can anyone help me understand why the python script would behave differently for each of the ways it gets executed?

Answer 1

Do supervision properly have the parent wait on the child. When the child exits, restart it. This is what DJB's daemontools does.
Change your script from:
./c++_process &>> /dev/null &
to:
exec ./c++_process &>> /dev/null
Then your watch dog will be alerted immediately when p.wait() returns that it has to restart the program as it had exited. With that your watch dog can be reduced to:
import subprocess as sp
import time
def processWatchdog():
while True:
p = sp.Popen(["/path/to/C++_Prog_Dir/start.sh"])
p.wait()
time.sleep(2)
if __name__ == '__main__':
processWatchdog()
Which simply restarts the program with a 2 second delay.