def test_sigwaitinfo(self):
# Issue #25277: The sleep is a weak synchronization between the parent
# and the child process. If the sleep is too low, the test hangs on
# slow or highly loaded systems.
self.sleep_time = 2.0
signum = signal.SIGUSR1
pid = os.getpid()
old_handler = signal.signal(signum, lambda *args: None)
self.addCleanup(signal.signal, signum, old_handler)
code = '\n'.join((
'import os, time',
'pid = %s' % os.getpid(),
'signum = %s' % int(signum),
'sleep_time = %r' % self.sleep_time,
'time.sleep(sleep_time)',
'os.kill(pid, signum)',
))
t0 = time.monotonic()
proc = self.subprocess(code)
with kill_on_error(proc):
# parent
signal.sigwaitinfo([signum])
dt = time.monotonic() - t0
self.assertEqual(proc.wait(), 0)
self.assertGreaterEqual(dt, self.sleep_time)
def test_sigwaitinfo(self):
signum = signal.SIGUSR1
pid = os.getpid()
old_handler = signal.signal(signum, lambda *args: None)
self.addCleanup(signal.signal, signum, old_handler)
code = '\n'.join((
'import os, time',
'pid = %s' % os.getpid(),
'signum = %s' % int(signum),
'sleep_time = %r' % self.sleep_time,
'time.sleep(sleep_time)',
'os.kill(pid, signum)',
))
t0 = time.monotonic()
proc = self.subprocess(code)
with kill_on_error(proc):
# parent
signal.sigwaitinfo([signum])
dt = time.monotonic() - t0
self.assertEqual(proc.wait(), 0)
self.assertGreaterEqual(dt, self.sleep_time)
def test_sigwaitinfo(self):
# Issue #25277: The sleep is a weak synchronization between the parent
# and the child process. If the sleep is too low, the test hangs on
# slow or highly loaded systems.
self.sleep_time = 2.0
signum = signal.SIGUSR1
pid = os.getpid()
old_handler = signal.signal(signum, lambda *args: None)
self.addCleanup(signal.signal, signum, old_handler)
code = '\n'.join((
'import os, time',
'pid = %s' % os.getpid(),
'signum = %s' % int(signum),
'sleep_time = %r' % self.sleep_time,
'time.sleep(sleep_time)',
'os.kill(pid, signum)',
))
t0 = time.monotonic()
proc = self.subprocess(code)
with kill_on_error(proc):
# parent
signal.sigwaitinfo([signum])
dt = time.monotonic() - t0
self.assertEqual(proc.wait(), 0)
self.assertGreaterEqual(dt, self.sleep_time)
def main(args, gdrive_client):
bind_addr = to_addr(args.bind)
transcoder_addr = to_addr(args.transcoder)
devwatch_addr = to_addr(args.devwatch)
daemon = JobQueueDaemon(["q_import", "q_upload"])
daemon.active_imports = {}
daemon.active_transcodes = {}
daemon.add_executor("q_import", ImportExecutor, args.output_dir,
transcoder_addr, daemon)
daemon.add_executor("q_upload", UploadExecutor, gdrive_client,
args.gdrive_root, args.output_dir, devwatch_addr,
daemon)
daemon.add_server(socketserver.TCPServer(bind_addr, ImportRequestHandler))
daemon.start()
logging.info("Started")
try:
sig = signal.sigwaitinfo({signal.SIGINT}) # TODO handle sigterm
except KeyboardInterrupt:
sig = signal.SIGINT
finally:
sig = signal.Signals(sig.si_signo)
logging.info("Shutting down after %s", sig.name)
daemon.shutdown()
def main(args):
bind_addr = to_addr(args.bind)
importer_addr = to_addr(args.importer)
# TODO check mount privilege
daemon = JobQueueDaemon(["q_import"])
udev_context = pyudev.Context()
daemon.add_executor(None,
DevwatchExecutor,
udev_context,
daemon,
daemon.job_queues["q_import"],
udev_filter="block",
event_filter=check_match)
daemon.add_executor("q_import", ImportExecutor, importer_addr)
daemon.add_server(socketserver.TCPServer(bind_addr,
DevwatchRequestHandler))
daemon.start()
logging.info("Started")
try:
sig = signal.sigwaitinfo({signal.SIGINT}) # TODO handle sigterm
except KeyboardInterrupt:
sig = signal.SIGINT
finally:
sig = signal.Signals(sig.si_signo)
logging.info("Shutting down after %s", sig.name)
daemon.shutdown()
def test_sigwaitinfo(self):
# Issue #25277, #25868: give a few miliseconds to the parent process
# between os.write() and signal.sigwaitinfo() to works around a race
# condition
self.sleep_time = 0.100
signum = signal.SIGUSR1
pid = os.getpid()
old_handler = signal.signal(signum, lambda *args: None)
self.addCleanup(signal.signal, signum, old_handler)
rpipe, wpipe = os.pipe()
code = '\n'.join((
'import os, time',
'pid = %s' % os.getpid(),
'signum = %s' % int(signum),
'sleep_time = %r' % self.sleep_time,
'rpipe = %r' % rpipe,
'os.read(rpipe, 1)',
'os.close(rpipe)',
'time.sleep(sleep_time)',
'os.kill(pid, signum)',
))
t0 = time.monotonic()
proc = self.subprocess(code, pass_fds=(rpipe, ))
os.close(rpipe)
with kill_on_error(proc):
# sync child-parent
os.write(wpipe, b'x')
os.close(wpipe)
# parent
signal.sigwaitinfo([signum])
dt = time.monotonic() - t0
self.assertEqual(proc.wait(), 0)
self.assertGreaterEqual(dt, self.sleep_time)
def test_sigwaitinfo(self):
# Issue #25277, #25868: give a few milliseconds to the parent process
# between os.write() and signal.sigwaitinfo() to works around a race
# condition
self.sleep_time = 0.100
signum = signal.SIGUSR1
pid = os.getpid()
old_handler = signal.signal(signum, lambda *args: None)
self.addCleanup(signal.signal, signum, old_handler)
rpipe, wpipe = os.pipe()
code = '\n'.join((
'import os, time',
'pid = %s' % os.getpid(),
'signum = %s' % int(signum),
'sleep_time = %r' % self.sleep_time,
'rpipe = %r' % rpipe,
'os.read(rpipe, 1)',
'os.close(rpipe)',
'time.sleep(sleep_time)',
'os.kill(pid, signum)',
))
t0 = time.monotonic()
proc = self.subprocess(code, pass_fds=(rpipe,))
os.close(rpipe)
with kill_on_error(proc):
# sync child-parent
os.write(wpipe, b'x')
os.close(wpipe)
# parent
signal.sigwaitinfo([signum])
dt = time.monotonic() - t0
self.assertEqual(proc.wait(), 0)
self.assertGreaterEqual(dt, self.sleep_time)
def test_sigwaitinfo(self):
signum = signal.SIGUSR1
pid = os.getpid()
old_handler = signal.signal(signum, lambda *args: None)
self.addCleanup(signal.signal, signum, old_handler)
t0 = time.monotonic()
child_pid = os.fork()
if child_pid == 0:
# child
try:
self._sleep()
os.kill(pid, signum)
finally:
os._exit(0)
else:
# parent
signal.sigwaitinfo([signum])
dt = time.monotonic() - t0
os.waitpid(child_pid, 0)
self.assertGreaterEqual(dt, self.sleep_time)
def main():
# Check python version
if (sys.version_info[0] < 3):
log("You are trying to use Python version {}.{}.{}".format(
sys.version_info[0], sys.version_info[1], sys.version_info[2]))
log("ANT requires Python 3.0+.")
return
# Check if this is root user
thisUid = os.getuid()
if thisUid != 0:
log("You(uid={}) are not root user. Please try it again on root.".
format(thisUid))
return
# Parse option arguments
parser = argparse.ArgumentParser(description="ANT options.")
parser.add_argument("--debug-appcore",
"-dac",
dest="debugappcore",
action="store_true",
help="Debug Appcore Manager")
parser.add_argument("--debug-apps",
"-da",
dest="debugapps",
action="store_true",
help="Debug Apps")
args = parser.parse_args()
# Register signal handlers
signal.signal(signal.SIGCHLD, signal_handler)
signal.signal(signal.SIGINT, signal_handler)
# Initialize Completed
log("args: {}".format(args))
on_did_initialize(args)
# Wait for signals
while True:
siginfo = signal.sigwaitinfo({signal.SIGCHLD, signal.SIGINT})
if siginfo.si_signo == signal.SIGCHLD:
# Child daemon process is dead
on_did_dead_deamon(siginfo.si_pid)
elif siginfo.si_signo == signal.SIGINT:
# Halt ANT triggered by user
on_did_halt_by_user()
return
def main(args):
bind_addr = to_addr(args.bind)
importer_addr = to_addr(args.importer)
daemon = JobQueueDaemon(["q_transcode_accept", "q_transcode_finished"])
report_queue = daemon.job_queues["q_transcode_finished"]
daemon.add_executor("q_transcode_accept", TranscodeExecutor, report_queue)
daemon.add_executor("q_transcode_finished", ResultReporter, importer_addr)
daemon.add_server(
socketserver.TCPServer(bind_addr, TranscodeRequestHandler))
daemon.start()
logging.info("Started")
try:
sig = signal.sigwaitinfo({signal.SIGINT}) # TODO handle sigterm
except KeyboardInterrupt:
sig = signal.SIGINT
finally:
sig = signal.Signals(sig.si_signo)
logging.info("Shutting down after %s", sig.name)
daemon.shutdown()
#!/usr/bin/python3
import os
import signal
# signal id -> signal name
SIGNALS_TO_NAMES_DICT = dict((getattr(signal, n), n) \
for n in dir(signal) if n.startswith('SIG') and '_' not in n )
print("My PID is %d, you can stop me with SIGUSR1" % os.getpid())
while True:
info = signal.sigwaitinfo(range(1, signal.NSIG))
if info.si_signo == signal.SIGUSR1:
print("Received deadly signal %r" % (SIGNALS_TO_NAMES_DICT[info.si_signo]))
break
else:
print("Received signal %r" % (SIGNALS_TO_NAMES_DICT[info.si_signo]))
def wait_func(signum):
signal.sigwaitinfo([signum])
import signal, sys
from time import sleep
def terminated(signum, frame):
pass
signal.signal(signal.SIGTERM, terminated)
signal.signal(signal.SIGINT, terminated)
while True:
siginfo = signal.sigwaitinfo({signal.SIGINT, signal.SIGTERM})
with open("terminated.txt", "w") as f:
f.write("Process terminated by %d\n" % siginfo.si_pid)
sys.exit(0)
print(f'Updated {self.__pid_file} to {os.getpid()}')
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Subscription service for Alt+Shift language switch')
parser.add_argument('--pid-file', '-p', type=pathlib.Path, default=pathlib.Path('/var/run/alt-shift-notify/service.pid'))
parser.add_argument('--verbose', dest='verbose', action='store_true')
args = parser.parse_args()
if not args.pid_file.is_absolute():
args.pid_file = pathlib.Path(pathlib.Path.cwd(), args.pid_file)
pid_file = args.pid_file
if args.verbose:
is_verbose = True
context = pyudev.Context()
manager = KeyboardThreadManager(context)
threading.current_thread().name = 'SubscriberThread'
signal.pthread_sigmask(signal.SIG_BLOCK, [signal.SIGUSR1, signal.SIGUSR2])
pid_file_creator = PIDFileCreator(pid_file=pid_file)
pid_file_creator.start()
while True:
received = signal.sigwaitinfo([signal.SIGUSR1, signal.SIGUSR2, signal.SIGINT, signal.SIGTERM])
if received.si_signo == signal.SIGUSR1:
if is_verbose:
print(f'Adding subscriber: {received.si_pid}')
subscriber_list.add(received.si_pid)
elif received.si_signo == signal.SIGUSR2:
if is_verbose:
print(f'Removing subscriber: {received.si_pid}')
subscriber_list.remove(received.si_pid)
elif received.si_signo == signal.SIGTERM or received.si_signo == signal.SIGINT:
sys.exit(0)
config['Node']['Nodes'][
f'node_{j1}'] = f'https://go.tvbit.local:82{j1}6'
with open(f'config_{j}.json', 'w') as f:
json.dump(config, f)
servers.append(create_server(f'out-{j}.log', f'config_{j}.json', j))
else:
servers.append(create_server('out.log', args.config, 0))
print('servers', servers)
t = threading.Thread(target=read_commands, args=(servers, ), daemon=True)
t.start()
signal.signal(signal.SIGUSR1, signal_handler)
ready = set()
while True:
try:
siginfo = signal.sigwaitinfo([signal.SIGUSR1])
print('signal received', siginfo)
for s in servers:
if s[0] == siginfo.si_pid:
ready.add(siginfo.si_pid)
if len(ready) == len(servers):
print('all servers ready')
for s in servers:
s[1].put('proceed')
except KeyboardInterrupt:
for s in servers:
s[1].put('stop')
s[1].join()
break
def wait_func(signum):
signal.sigwaitinfo([signum])
#!/usr/local/Caskroom/miniconda/base/envs/cybersecurity/bin/python
import signal, sys
from time import sleep
def terminated(signum, frame):
pass
#catching any commands throwing SIGTERM, SIGINT, kill etc
#if a process attemted to kill this process we can log what sent the signal
#SIGKILL is an uncatchable signal (will not work with this)
signal.signal(signal.SIGTERM, terminated)
signal.signal(signal.SIGINT, terminated)
while True:
#only availabe on UNIX (signal.sigwait)
siginfo = signal.sigwaitinfo((signal.SIGINT, signal.SIGTERM))
with open("terminated.txt", "w") as f:
f.write(f"Process terminated by {siginfo.si_pid}\n")
sys.exit(0)
def run(self, wanted_interfaces, log_filename_by_process=None):
"""fork processes for each wanted interface
This function returns for the child processes (i.e.: they may continue using stdin/stdout).
The parent process (the interface manager) stays alive and never returns.
"""
if not self.run_and_stop_interfaces(
wanted_interfaces,
log_filename_by_process=log_filename_by_process):
# we are a managed interface process - simply return
return
# we are the manager
# Ignore all signals that we want to listen for, but store their previous handlers.
original_signal_handlers = {}
for one_signal in {
signal.SIGUSR1,
signal.SIGHUP,
signal.SIGTERM,
signal.SIGCHLD,
}:
# The signal handler signal.SIG_IGN is not appropriate: it would prevent "sigwaitinfo"
# below from capturing these signals.
original_signal_handlers[one_signal] = signal.signal(
one_signal, lambda *args: None)
should_finish = False
while not should_finish:
try:
signal_info = signal.sigwaitinfo(set(original_signal_handlers))
except KeyboardInterrupt:
self.logger.info("Received CTRL-C")
should_finish = True
continue
if signal_info.si_signo == signal.SIGTERM:
self.logger.info("Received termination signal")
should_finish = True
elif signal_info.si_signo == signal.SIGCHLD:
# a child process signals its termination
matched_specs = {
spec
for spec, pid in self.running_interface_processes.items()
if pid == signal_info.si_pid
}
for spec in matched_specs:
self.logger.info(
"A child signals its termination: %d %s",
signal_info.si_pid,
spec,
)
self.running_interface_processes.pop(spec)
# in any case: retrieve its result (otherwise it will end up as a zombie)
os.waitpid(signal_info.si_pid, os.WNOHANG)
if not self.running_interface_processes:
self.logger.info(
"All child processes are gone. Going home, too.")
should_finish = True
elif signal_info.si_signo == signal.SIGUSR1:
# print all currently running processes
for spec, pid in self.running_interface_processes.items():
print("{:d}\t{}".format(pid, spec))
elif signal_info.si_signo == signal.SIGHUP:
# Parse the wanted set of interfaces from a given text file and update the list of
# running processes appropriately.
raise NotImplementedError(
"The 'update interfaces from file' feature is not supported, yet."
)
else:
raise NotImplementedError("Received unknown signal")
# kill all child processes
self.run_and_stop_interfaces(set())
sys.exit(0)
