def update_wakeup_handler(self, ev=None, disconnected=False):
if disconnected:
self.connected = False
signal.pthread_kill(threading.main_thread().ident, signal.SIGWINCH)
elif self.connected is None:
self.connected = True
self._updates.append(ev)
def server():
config_ui_thread = Thread(target=config_ui,
args=["", "./piman.yaml", "./hosts.csv"],
name="config_ui")
config_ui_thread.start()
tftp_thread = Thread(target=tftp.do_tftpd,
args=[data_dir, ip, tftp_port],
name="tftpd")
tftp_thread.start()
dhcp_thread = Thread(
target=dhcp.do_dhcp,
args=[mac_ip_file, subnet_mask, ip, lease_time, interface],
name="dhcpd")
dhcp_thread.start()
tcp_thread = Thread(target=tcp.do_tcp,
args=[data_dir, tcp_port, ip],
name="tcp")
tcp_thread.start()
ntp_thread = Thread(target=ntpserver.do_ntp())
ntp_thread.start()
dns_thread = Thread(target=dns.start())
dns_thread.start()
signal.pthread_kill(config_ui_thread.ident, 15) # 15 = sigterm
signal.pthread_kill(tftp_thread.ident, 15)
signal.pthread_kill(dhcp_thread.ident, 15)
signal.pthread_kill(tcp_thread.ident, 15)
signal.pthread_kill(dns_thread, 15)
def _signal_int(self, signum, frame):
"""Signal handler for SIGINT - Ctrl+C may have been pressed."""
self.send_signal(signal.CTRL_C_EVENT if xp.ON_WINDOWS else signum)
if self.proc is not None and self.proc.poll() is not None:
self._restore_sigint(frame=frame)
if xt.on_main_thread() and not xp.ON_WINDOWS:
signal.pthread_kill(threading.get_ident(), signal.SIGINT)
def image_set_pixbuf_thread(self):
while True:
image = self.thread_queue.get()
log.debug('pixbuf_proc [thread]: {}', image.path)
self.image_set_pixbuf_proc(image)
self.thread_results.append(image)
signal.pthread_kill(*self.thread_kill)
def shutdown(self, signum, frame):
for worker in self.worker_list:
worker.stop_worker()
# kill the current thread for prevent server reload blocking
current_thread_id = threading.current_thread().ident
signal.pthread_kill(current_thread_id, signal.SIGKILL)
def interruption():
inter_iter = iter(self._interruptions)
while not self._interrupt_event.is_set():
inter = self._last_attempt = next(inter_iter,
self._last_attempt)
log.log(self._log_level, inter.message)
if inter.before_interrupt is not None:
try:
inter.before_interrupt()
except Exception:
log.warning(
"Swallowing the error raised by `before_interrupt` hook: %s",
inter.before_interrupt,
exc_info=True)
try:
if inter.interrupt == 'thread':
if isinstance(inter.sig, (type(None), BaseException)):
exc = TimeoutError(
inter.message
) if inter.sig is None else inter.sig
raise_in_thread(inter.id, exc)
else:
# _thread.interrupt_main()
signal.pthread_kill(inter.id, inter.sig)
elif inter.interrupt == 'process':
os.kill(inter.id, inter.sig)
except Exception:
raise
finally:
self._interrupt_event.wait(
inter.wait
) # retry every second if interruption didn't work
async def wrapper(*args, **kwargs):
try:
ret = await f(*args, **kwargs)
except Exception:
logging.exception('Aborting on error')
signal.pthread_kill(threading.get_ident(), signal.SIGUSR1)
else:
return ret
def stop_loop():
now = time.time()
io_loop = tornado.ioloop.IOLoop.instance()
if now < deadline and (io_loop._callbacks or io_loop._timeouts):
io_loop.add_timeout(now + 1, stop_loop)
else:
io_loop.stop()
logger.info('...Shutdown...')
signal.pthread_kill(threading.current_thread().ident, 9)
def interrupt_main():
import os
if os.name == 'nt':
from _thread import interrupt_main
interrupt_main()
else:
import signal
import threading
signal.pthread_kill(threading.main_thread().ident, signal.SIGINT)
def stop_loop():
now = time.time()
io_loop = tornado.ioloop.IOLoop.instance()
if now < deadline and (io_loop._callbacks or io_loop._timeouts):
io_loop.add_timeout(now + 1, stop_loop)
else:
io_loop.stop()
logger.info('...Shutdown...')
signal.pthread_kill(threading.current_thread().ident, 9)
def _onItemFini(self):
if self.isfini:
return
self.printf('connection closed...')
self.fini()
if self.loopthread is not None and self.finikill:
signal.pthread_kill(self.loopthread, signal.SIGINT)
def stop(self):
self._alive = False
self._wsserver.shutdown()
self._wsth.join()
self._sserver.shutdown()
self._sth.join()
try:
signal.pthread_kill(self._myid, signal.SIGINT)
except Exception:
pass
def stop(self):
self._alive = False
self._wsserver.shutdown()
self._wsth.join()
self._sserver.shutdown()
self._sth.join()
try:
signal.pthread_kill(self._myid, signal.SIGINT)
except Exception:
pass
async def command(client, message):
for client_ in CLIENTS.values():
await client_.disconnect()
await client.message_create(message.channel,
'Clients stopped, stopping process.')
KOKORO.stop()
thread_id = main_thread().ident
signal.pthread_kill(thread_id, signal.SIGKILL)
def alarm_timeout_handler(signum, frame):
LOG.warn('Process timed out after %0.f seconds', timeout)
signal.signal(signal.SIGALRM, signal.SIG_DFL)
signal.alarm(0)
if six.PY3:
signal.pthread_kill(threading.main_thread().ident,
signal.SIGTERM)
else:
sys.exit(1)
def interrupt():
if sys.platform == "win32":
# pthread_kill is Windows only
from _thread import interrupt_main
interrupt_main()
else:
import signal
signal.pthread_kill(main_thread, signal.SIGINT)
def test_signal_delivery(signal_handler):
dummy = DummyComponent()
signal_handler.register('dummy', dummy)
signal_handler.start()
sleep(1) # just enough time to get started
signal.pthread_kill(threading.get_ident(), signal.SIGUSR1)
sleep(1) # signal delivery lapse
assert (dummy._stopped)
def handle(self):
LOG.info('Request received')
self.request.recv(0)
LOG.info('Sending %i bytes', len(data))
self.request.sendall(data)
LOG.info('Killing server')
if six.PY3:
signal.pthread_kill(threading.main_thread().ident,
signal.SIGTERM)
else:
sys.exit(0)
def interruption():
log.log(log_level, self.message)
if before_interrupt is not None:
before_interrupt()
if interrupt == 'thread':
if isinstance(self.sig, (type(None), BaseException)):
raise_in_thread(self.ident, TimeoutError(self.message) if self.sig is None else self.sig)
else:
# _thread.interrupt_main()
signal.pthread_kill(self.ident, self.sig)
elif interrupt == 'process':
os.kill(self.ident, self.sig)
def interrupt_if_cancelling() -> None:
# We need to copy the context into this thread, since context is a
# thread local.
with prefect.context(context):
flow_run_id = prefect.context["flow_run_id"]
while True:
exiting_context = done.wait(
prefect.config.cloud.check_cancellation_interval)
try:
self.logger.debug("Checking flow run state...")
flow_run_info = self.client.get_flow_run_info(
flow_run_id)
except Exception:
self.logger.warning("Error getting flow run info",
exc_info=True)
continue
if not flow_run_info.state.is_running():
self.logger.warning(
"Flow run is no longer in a running state; the current state is: %r",
flow_run_info.state,
)
if isinstance(flow_run_info.state, Cancelling):
self.logger.info(
"Flow run has been cancelled, cancelling active tasks"
)
nonlocal cancelling
nonlocal flow_run_version
cancelling = True
flow_run_version = flow_run_info.version
# If not already leaving context, raise KeyboardInterrupt in the main thread
if not exiting_context:
if hasattr(signal, "raise_signal"):
# New in python 3.8
signal.raise_signal(
signal.SIGINT) # type: ignore
else:
if os.name == "nt":
# This doesn't actually send a signal, so it will only
# interrupt the next Python bytecode instruction - if the
# main thread is blocked in a c extension the interrupt
# won't be seen until that returns.
from _thread import interrupt_main
interrupt_main()
else:
signal.pthread_kill(
threading.main_thread().ident,
signal.SIGINT # type: ignore
)
break
elif exiting_context:
break
def command_line_interface(self):
"Método que lee instrucciones desde la línea de comandos"
while True:
try:
text = input()
except EOFError:
signal.pthread_kill(threading.main_thread().ident, signal.SIGTERM)
return
splitted = text.split(' ')
if len(splitted) == 1:
self.command_handler(splitted[0], None)
elif len(splitted) > 1:
self.command_handler(splitted[0], splitted[1])
def interruption():
nonlocal message
if message is None:
desc = 'current' if ident is None else 'main' if ident == 0 else self.ident
message = "Interrupting {} {} after {}s timeout.".format(interrupt, desc, timeout_secs)
log.log(log_level, message)
if before_interrupt is not None:
before_interrupt()
if interrupt == 'thread':
# _thread.interrupt_main()
signal.pthread_kill(self.ident, sig)
elif interrupt == 'process':
os.kill(self.ident, sig)
def move(self, event, task):
if event.direction == 'enter' and self.position[0] == 1:
task.ctrl_queue.send_pyobj(['QUIT'])
if event.direction == 'enter':
signal.pthread_kill(main_thread().ident, signal.SIGINT)
delta = super().move(event, task)
if event.direction == 'up':
task.renderer = self.main
task.transition = partial(
task.screen.slide_to, direction='down', duration=0.5)
elif delta != (0, 0):
self.update_text()
task.transition = partial(
task.screen.slide_to,
direction='left' if delta == (1, 0) else 'right', duration=0.5)
return delta
def handler(self, signum, frame):
self.release()
self.interrupted = True
print("\nCTRL+C has been catched... Shutting down server...")
if tcpserver.tcp_server:
tcpserver.tcp_server.shutdown()
tcpserver.tcp_server.server_close()
tcpserver.tcp_server = None
if tcpserver.tcp_server_thread:
# print(tcpserver.tcp_server_thread.is_alive())
tcpserver.tcp_server_thread = None
signal.pthread_kill(threading.get_ident(), signal.SIGTERM)
def test_config_reading():
"""Test reading the config."""
with NamedTemporaryFile('w', delete=False) as the_file:
fname = the_file.name
try:
with patch.object(YAMLConfig, 'read_config') as rc:
assert rc.call_count == 0
yconf = YAMLConfig(fname)
time.sleep(.1)
assert rc.call_count == 1
the_file.write(test_yaml1)
the_file.flush()
the_file.close()
time.sleep(.1)
assert rc.call_count == 2
signal.pthread_kill(get_ident(), signal.SIGUSR1)
time.sleep(.1)
assert rc.call_count == 3
os.remove(fname)
signal.pthread_kill(get_ident(), signal.SIGUSR1)
time.sleep(.1)
yconf.close()
finally:
yconf.close()
try:
os.remove(fname)
except FileNotFoundError:
pass
expected = yaml.safe_load(test_yaml1)
with NamedTemporaryFile('w', delete=False) as the_file:
fname = the_file.name
try:
yconf = YAMLConfig(fname)
time.sleep(.1)
the_file.write(test_yaml1)
the_file.flush()
the_file.close()
time.sleep(.1)
assert yconf.config == expected
finally:
yconf.close()
try:
os.remove(fname)
except FileNotFoundError:
pass
def move(self, event, task):
x, y = self.position
if event.direction == 'enter':
if x == 1:
subprocess.call(['sudo', '-n', 'reboot'])
elif x == 2:
subprocess.call(['sudo', '-n', 'poweroff'])
signal.pthread_kill(main_thread().ident, signal.SIGINT)
delta = super().move(event, task)
if event.direction == 'up':
task.switch_to(task.renderers['main'],
transition='slide',
direction='down',
duration=0.5)
elif delta != (0, 0):
self.update_text()
return delta
def update_devices(self):
devices = self.enumerate_keyboard_event_devices()
with self._map_lock:
for device in self._map.keys():
if device not in devices:
if self._map[device].is_alive():
signal.pthread_kill(self._map[device].get_native_id(), signal.SIGKILL)
self._map[device].join()
del self._map[device]
if is_verbose:
print(f'Killed Alt+Shift Thread for {device}')
show_threads()
for device in devices:
if device not in self._map:
thread = self._map[device] = AltShiftNotify(device, self)
thread.start()
if is_verbose:
print(f'Started Alt+Shift Thread for {device}')
show_threads()
def commit(self):
"""
Multicast the result of the current node
:return: result
"""
result = self.valid_block()
if result:
self.status[3][0].add(self.node_identifier)
else:
self.status[3][1].add(self.node_identifier)
data = {
'result': result,
'phase': 2,
'index': self.current_block.get('index')
}
sign = rsa.sign(str(data).encode('utf8'), self.prikey, 'SHA-1')
headers = {'Connection': 'close', 'Content-Type': 'application/json'}
web_chain_len = len(self.chain)
for node in self.nodes:
url = 'http://' + self.nodes[node][0] + '/consensus' # idx 0 = addr
print("commit: from", self.node_identifier, "to", url)
cdata = rsa.encrypt(str(data).encode('utf8'),
self.nodes[node][1]) # idx 1 = pubkey
fdata = {
'data': list(cdata),
'sign': list(sign),
'id': self.node_identifier
}
jdata = json.dumps(fdata)
threading.Thread(target=self.block_thread,
args=(url, headers, jdata)).start()
self.send2web(web_chain_len, 2, node, str(data['result']))
self.is_block = False
print("commit thread_id : " + str(self.thread_id))
signal.pthread_kill(self.thread_id, signal.SIGUSR1)
return result
async def test_keyboard_interrupt_teardown():
asyncio_loop_closed = trio.Event()
async def work_in_trio_no_matter_what(*,
task_status=trio.TASK_STATUS_IGNORED
):
await trio_asyncio.aio_as_trio(work_in_asyncio)()
try:
# KeyboardInterrupt won't cancel this coroutine thanks to the shield
with trio.CancelScope(shield=True):
task_status.started()
await asyncio_loop_closed.wait()
finally:
# Hence this call will be exceuted after run_asyncio_loop is cancelled
with pytest.raises(RuntimeError):
await trio_asyncio.aio_as_trio(work_in_asyncio)()
async def work_in_asyncio():
await asyncio.sleep(0)
async def run_asyncio_loop(nursery,
*,
task_status=trio.TASK_STATUS_IGNORED):
with trio.CancelScope() as cancel_scope:
try:
async with trio_asyncio.open_loop():
# Starting a coroutine from here make it inherit the access
# to the asyncio loop context manager
await nursery.start(work_in_trio_no_matter_what)
task_status.started(cancel_scope)
await trio.sleep_forever()
finally:
asyncio_loop_closed.set()
import signal
import threading
with pytest.raises(KeyboardInterrupt):
with pytest.warns(RuntimeWarning):
async with trio.open_nursery() as nursery:
await nursery.start(run_asyncio_loop, nursery)
# Trigger KeyboardInterrupt that should propagate accross the coroutines
signal.pthread_kill(threading.get_ident(), signal.SIGINT)
def kill_sender_reciever(thread1, thread2=None):
'''
kill sender reciever and TorrentDHT socket when there is
continuous bootstrap.
'''
identification = thread1.ident
try:
signal.pthread_kill(identification, 2)
except ProcessLookupError:
pass
# take some time to kill reciever thread
if thread2 is None:
return
identification = thread2.ident
try:
signal.pthread_kill(identification, 2)
except ProcessLookupError:
pass
def on_key_press(self, symbol: int, modifiers: int):
# Just kill the program I don't care how
if symbol == Keymap.Esc.value:
arcade.close_window()
signal.pthread_kill(threading.current_thread().ident,
signal.SIGKILL)
# Forward
if symbol == Keymap.W.value:
self.movement_values[0] = True
if symbol == Keymap.Up.value:
self.movement_values[1] = True
# Reverse
if symbol == Keymap.S.value:
self.movement_values[2] = True
if symbol == Keymap.Down.value:
self.movement_values[3] = True
def interruption():
log.log(log_level, self.message)
if before_interrupt is not None:
before_interrupt()
while not self.interrupt_event.is_set():
try:
if interrupt == 'thread':
if isinstance(self.sig, (type(None), BaseException)):
exc = TimeoutError(
self.message) if self.sig is None else self.sig
raise_in_thread(self.ident, exc)
else:
# _thread.interrupt_main()
signal.pthread_kill(self.ident, self.sig)
elif interrupt == 'process':
os.kill(self.ident, self.sig)
except Exception:
raise
finally:
self.interrupt_event.wait(
1) # retry every second if interruption didn't work
def closeEvent(self, event):
# Call Parent (QMainWindow).close()
super(MainWindow, self).closeEvent(event)
print(self.t_child_saveImages.ident)
print(self.t_child_runServer.ident)
print(self.t_grandchild_list)
# Afterwards Process - Removal of Files
shutil.rmtree('./S_CameraVision/Images')
os.mkdir('./S_CameraVision/Images')
shutil.rmtree('./S_CameraVision/Images_Box/Filtered')
os.mkdir('./S_CameraVision/Images_Box/Filtered')
shutil.rmtree('./S_CameraVision/Images_Box/Robot')
os.mkdir('./S_CameraVision/Images_Box/Robot')
shutil.rmtree('./S_CameraVision/Images_Box/Sticker')
os.mkdir('./S_CameraVision/Images_Box/Sticker')
# Afterwards Process - Killing normal threads
for t_grandchild in self.t_grandchild_list:
signal.pthread_kill(t_grandchild.ident, signal.SIGKILL)
# TODO: Unreached... Why?
signal.pthread_kill(self.t_child_saveImages.ident, signal.SIGKILL)
signal.pthread_kill(self.t_child_runServer.ident, signal.SIGKILL)
def update_wakeup_handler(self, ev=None, disconnected=False): if disconnected: self.connected = False signal.pthread_kill(threading.main_thread().ident, signal.SIGWINCH) elif self.connected is None: self.connected = True self._updates.append(ev)
def handle_sigint(sig, frame):
for thread in threads:
signal.pthread_kill(thread.ident, signal.SIGINT)
sys.exit(0)
import time
def countdown(n):
while n > 0:
print('T-minus', n)
n -= 1
time.sleep(1)
from threading import Thread
import threading
import signal
# t = Thread(target=countdown, args=(5,))
# t.start()
# t.join()
# print "ok"
# threads = [Thread(target=countdown, args=(i,)) for i in range(3,5)]
# [t.start() for t in threads]
# [t.join() for t in threads]
# print "ok"
threading.get_ident()
aa = Thread(target=countdown, args=(30,))
aa.start()
aa.ident
signal.pthread_kill(aa.ident, 1)
aa.is_alive()
print("ok")
def interrupt_main():
signal.pthread_kill(main_thread, signal.SIGINT)
def run(self):
game.run()
signal.pthread_kill(main_thread_id, signal.SIGQUIT)
def signal_raise(signum):
# Use pthread_kill to make sure we're actually using the wakeup fd on
# Unix
signal.pthread_kill(threading.get_ident(), signum)