def kill_proc_tree(pid, including_parent=True, timeout=5):
try:
parent = Process(pid)
except NoSuchProcess:
return
children = parent.children(recursive=True)
for child in children:
if verbose.kill:
print("killing {}".format(child.pid))
try:
child.kill()
child.terminate()
except NoSuchProcess:
pass
gone, still_alive = wait_procs(children, timeout=timeout)
if including_parent:
try:
if verbose.kill:
print("killing {}".format(parent.pid))
parent.kill()
parent.terminate()
try:
parent.wait(timeout)
except TimeoutExpired:
print("timeout expired, process may still be around: {}".format(parent.pid))
except NoSuchProcess:
pass
def run():
args = parse_the_args()
if args.run_setup:
log.debug('Running FSM Setup')
fsm_setup()
elif args.start_in_background:
if os.name == 'NT':
python = 'python'
else:
python = 'python3'
commands = [python, 'start.py']
if len(sys.argv) > 1:
commands.extend(sys.argv[1:])
process = Popen(commands, stdout=DEVNULL, stderr=DEVNULL)
with open('fsm.pid', 'w+') as pid_file:
pid_file.write(str(process.pid))
elif args.stop:
with open('fsm.pid') as pid_file:
pid = int(pid_file.read())
p = Process(pid)
p.terminate()
else:
main(args)
def _kill(process: psutil.Process, timeout=5) -> bool:
"""Attempts to kill the process in a fail-safe manner and returns status
Tries to terminate the process first and waits for it for the given timeout.
If termination fails - attempts to kill the process instead and wait for it to die.
Args:
process(Process): the process that is to be killed
timeout(int): the timeout to wait after each terminate/kill attempt
Returns:
obj(bool): True if the process has been killed/terminated,
False if the process is still running after this method returns
"""
if not process.is_running():
return True
try:
process.terminate()
try:
process.wait(timeout)
return True
except:
process.kill()
try:
process.wait(timeout)
return True
except:
pass
except:
pass
return not process.is_running()
def Terminate(self):
"""Terminate the process"""
info('ProcessManager::Terminate Name:' + self.Name + ' PID:' +
str(self.Pid))
try:
process = Process(self.Pid)
process.terminate()
except Exception as ex:
error('ProcessInfo::Terminate failed Name:' + self.Name + ' PID:' +
str(self.Pid) + ' Exception:' + str(ex))
return False
return True
def stop_diamond(conf_path):
config_file = os.path.join(conf_path, CONFIG_NAME)
pid = get_pid(config_file)
if pid:
diamond_process = Process(pid)
diamond_process.terminate()
diamond_process.wait(timeout=DEFAULT_TIMEOUT)
if diamond_process.is_running():
raise exceptions.NonRecoverableError("Diamond couldn't be killed")
else:
raise exceptions.NonRecoverableError('Failed reading diamond pid file')
def safe_stop(proc: psutil.Process, kill: bool = False) -> None:
"""Do not crash on already stopped process.
:param proc: target process
:type proc: psutil.Process
:param kill: use SIGKILL instead of SIGTERM
:type kill: bool
"""
with contextlib.suppress(psutil.NoSuchProcess):
if kill:
proc.kill()
proc.terminate()
async def _close_process(self, proc: psutil.Process):
try:
proc.terminate()
await asyncio.sleep(1)
try:
if proc.status() != psutil.STATUS_ZOMBIE:
proc.kill()
except Exception:
pass
except Exception:
pass
try:
proc.wait(timeout=0)
except Exception:
pass
def get_as_item(p: Process, *extra_actions):
"""Return an item - ready to be appended to the items list and be rendered by Albert.
if Process is not a valid object (.name or .cmdline raise an exception) then return None
"""
name_field = cmdline(p)
if not name_field:
return None
try:
actions = [
v0.FuncAction("Terminate", lambda: p.terminate()),
v0.FuncAction("Kill", lambda: p.kill()),
v0.ClipAction("Get PID", f"{p.pid}"),
v0.FuncAction(
"Terminate matching names",
lambda name=p.name(): kill_by_name(name, signal=signal.SIGTERM
),
),
v0.FuncAction("Kill matching names",
lambda name=p.name(): kill_by_name(name)),
]
actions = [*extra_actions, *actions]
return v0.Item(
id=__title__,
icon=icon_path,
text=name_field,
subtext="",
completion=p.name(),
actions=actions,
)
except psutil.NoSuchProcess:
return None
def terminateOldListener():
# Assume the listener hasn't been terminated
terminated = False
# Check the PID in the run.txt file to see if it's an active python process and if so shut it down
with open("Data/run.txt", 'r') as check:
strpid = check.readline()
if strpid != "":
try:
process = Process(int(strpid))
if process.name() == "python.exe" or process.name() == "pythonw.exe":
process.terminate()
terminated = True
except NoSuchProcess:
pass
return terminated
def _terminate_server(self):
"""."""
last_print = None
while True:
if self._num_connections > 0 and\
(last_print is None or
last_print != self._num_connections):
last_print = self._num_connections
print('Waiting to close {0} pending connections.'.format(
self._num_connections))
if self._num_connections == 0 and\
self._list_connection.empty():
print('Terminating server.')
pid = getpid()
proc = Process(pid)
proc.terminate()
break
def killProcs(PID):
#try:
p = Process(PID)
#try:
while len(p.children()) > 0:
try:
child = p.children()[0]
while len(child.children()) > 0:
print len(child.children()), child
child = child.children()[0]
print "kill"
child.terminate()
print "Restart"
except:
pass
try:
p.terminate()
except:
pass
def stop_diamond(conf_path):
config_file = os.path.join(conf_path, CONFIG_NAME)
pid = get_pid(config_file)
if pid:
need_kill = True
try:
diamond_process = Process(pid)
diamond_process.terminate()
diamond_process.wait(timeout=DEFAULT_TIMEOUT)
need_kill = diamond_process.is_running()
except Error:
pass
if need_kill:
call(["sudo", "kill", str(pid)])
# diamond deletes the pid file, even if killed
for _ in range(DEFAULT_TIMEOUT):
pid = get_pid(config_file)
if not pid:
return
sleep(1)
else:
raise exceptions.NonRecoverableError('Failed reading diamond pid file')
def stop_diamond(conf_path):
config_file = os.path.join(conf_path, CONFIG_NAME)
pid = get_pid(config_file)
if pid:
need_kill = True
try:
diamond_process = Process(pid)
diamond_process.terminate()
diamond_process.wait(timeout=DEFAULT_TIMEOUT)
need_kill = diamond_process.is_running()
except Error:
pass
if need_kill:
call(["sudo", "kill", str(pid)])
# diamond deletes the pid file, even if killed
for _ in range(DEFAULT_TIMEOUT):
pid = get_pid(config_file)
if not pid:
return
sleep(1)
else:
raise exceptions.NonRecoverableError('Failed reading diamond pid file')
def stop(self):
"""
Stop the Elasticsearch server.
:rtype : ElasticsearchRunner
:return: The instance called on.
"""
if self.is_running():
server_proc = Process(self.es_state.server_pid)
server_proc.terminate()
server_proc.wait()
if process_exists(self.es_state.server_pid):
logging.warn('Failed to stop Elasticsearch server process PID %d ...' % self.es_state.server_pid)
# delete transient directories
if 'path' in self.es_config:
if 'log' in self.es_config['path']:
log_path = self.es_config['path']['log']
logging.info('Removing transient log path %s ...' % log_path)
rmtree(log_path)
if 'data' in self.es_config['path']:
data_path = self.es_config['path']['data']
logging.info('Removing transient data path %s ...' % data_path)
rmtree(data_path)
# delete temporary config file
if os.path.exists(self.es_state.config_fn):
logging.info('Removing transient configuration file %s ...' % self.es_state.config_fn)
os.remove(self.es_state.config_fn)
self.es_state = None
self.es_config = None
else:
logging.warn('Elasticsearch is not running ...')
return self
def kill_process(max_retry,
p_instance: psutil.Process,
p_name,
kill_process_retry_interval: int = 60):
if not p_instance:
return
count: int = 0
while psutil.Process(p_instance.pid).status() != psutil.STATUS_ZOMBIE:
p_instance.terminate()
time.sleep(kill_process_retry_interval)
if count % kill_process_retry_interval == 0:
print(f'terminating process: {p_name}')
count += 1
if count > max_retry:
print(
f'reach max limitation of retries and failed to terminate process: {p_name}'
)
return
# clear the zombie
p_instance.kill()
p_instance = None
print(f'{p_name} is terminated')
def stop(**kwargs):
lock = PIDLockFile(os.path.join(RAMMON_PATH, "rammon.pid"))
if try_systemd_stop():
logger.info("Stopping rammon daemon with systemd...")
if lock.is_locked():
try:
proc = Process(lock.read_pid())
proc.terminate()
try:
proc.wait(1)
except TimeoutExpired:
print("Rammon did not stop gracefully, killing it...")
proc.kill()
lock.break_lock()
logger.info("Rammon stopped successfully")
except NoSuchProcess:
logger.warning(
"Rammon was already stopped, but had not stopped cleanly.\n"
"Breaking pidfile lock...")
lock.break_lock()
else:
logger.error("Rammon is already stopped")
sys.exit(1)
def terminate(process: psutil.Process) -> None:
process.terminate()
https://stackoverflow.com/questions/47818822/can-i-use-tensorboard-with-google-colab
For some reason, soemtimes you need to wait ~30 seconds and/or run this code twice for Tensorboard to successfully
be piped through to a public url.
'''
port = 8008
# Close tensorboard port if it's already hosting something else
port_out = subprocess.Popen(f'sudo lsof -i :{port}',
shell=True,
stdout=subprocess.PIPE)
port_out = [j.decode('utf-8') for j in port_out.stdout.readlines()][1::]
pids_on_port = [int(i.split(' ')[1]) for i in port_out if len(i) > 1]
for pid in pids_on_port:
p = Process(pid)
p.terminate()
LOG_DIR = '../../models/logs/20210122-204141'
# Define commands to initialize tensorboard + ngrok, then set up a tunnerl
cmd_str_tb = f'tensorboard --logdir {LOG_DIR} --host 0.0.0.0 --port {port} &'
cmd_str_ngrok = f'~/ngrok http {port} &'
cmd_str_pipe = 'curl -s http://localhost:4040/api/tunnels'
# Run commands
subprocess.Popen(cmd_str_tb, shell=True, stdout=subprocess.PIPE)
subprocess.Popen(cmd_str_ngrok, shell=True, stdout=subprocess.PIPE)
cmd_out = subprocess.Popen(cmd_str_pipe,
shell=True,
stdout=subprocess.PIPE)
while pid_exists(PID):
proc = Process(PID)
timeout = 5
try:
print(f"[{timeout} seconds] Trying to kill process PID: {PID}")
proc.kill()
proc.wait(timeout)
except:
pass
finally:
if pid_exists(PID):
try:
print(
f"[{timeout} seconds] Trying to kill process PID: {PID}"
)
proc.terminate()
proc.wait(timeout)
except:
print(f"Process is out of controll PID: {PID}")
if stderr is not None:
stdout.close()
if not args.leave:
from shutil import rmtree
rmtree(work_dir)
print("deleted: {}".format(work_dir))
else:
print("datadir not deleted: {}".format(work_dir))
exit(RETCODE)
def terminate_process_group(pid):
'''Send sigterm to a process id and its children'''
p = Process(pid)
for child in p.children(recursive=True):
child.terminate()
p.terminate()
def _stop_worker_process(self, process: psutil.Process):
""" Terminate a new worker node and remove it from the process pool. """
process.terminate()
process.wait(timeout=60)
self.job_queue_size -= 1
self._processes.remove(process)
def _stop_worker_process(self, process: psutil.Process):
""" Terminate a new worker node and remove it from the process pool. """
process.terminate()
self._processes.remove(process)
def Terminate(self):
p = Process(self.pid)
return p.terminate()
