By catching the SIGINT handler, you are preventing the default behaviour, which is to quit the process. When you use Ctrl+C the second time, the process dies because server.close throws an uncaught exception. Just add a process.exit() to the end of your SIGINT handler to quit the process gracefully.
The accepted answer was mainly focused on OP’s question of In Node.js servers, is there any difference between catching SIGTERM vs catching SIGINT? Am I able to trap both signals and prevent exit? I landed here because I want to know the differences between them. So here is a bit of more clarifications. From https://en.wikipedia.org/wiki/Unix_signal … Read more
Use signal handlers: import asyncio from signal import SIGINT, SIGTERM async def main_coro(): try: await awaitable() except asyncio.CancelledError: do_cleanup() if __name__ == “__main__”: loop = asyncio.get_event_loop() main_task = asyncio.ensure_future(main_coro()) for signal in [SIGINT, SIGTERM]: loop.add_signal_handler(signal, main_task.cancel) try: loop.run_until_complete(main_task) finally: loop.close()
Somebody in the #python IRC-Channel (Freenode) helped me by pointing out the preexec_fn parameter of subprocess.Popen(…): If preexec_fn is set to a callable object, this object will be called in the child process just before the child is executed. (Unix only) Thus, the following code solves the problem (UNIX only): import subprocess import signal def … Read more
The python signal handlers do not seem to be real signal handlers; that is they happen after the fact, in the normal flow and after the C handler has already returned. Thus you’d try to put your quit logic within the signal handler. As the signal handler runs in the main thread, it will block … Read more
^C sends a SIGINT to all the processes in the foreground process group. To do the equivalent with kill, you should send the signal to the process group (OS-level concept): kill -SIGINT -<pid> or to the job (shell-level concept, the pipeline ended with &): kill -SIGINT %
No, by default, most signals cause an immediate, abnormal exit of your program. However, you can easily change the default behavior for most signals. This code shows how to make a signal exit your program normally, including calling all the usual destructors: #include <iostream> #include <signal.h> #include <unistd.h> #include <cstring> #include <atomic> std::atomic<bool> quit(false); // … Read more
I have done some research around this topic, which turned out to be more popular than I anticipated. KindDragon’s reply was one of the pivotal points. I wrote a longer blog post on the topic and created a working demo program, which demonstrates using this type of system to close a command line application in … Read more
signal isn’t the most reliable way as it differs in implementations. I would recommend using sigaction. Tom’s code would now look like this : #include <signal.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> void my_handler(int s){ printf(“Caught signal %d\n”,s); exit(1); } int main(int argc,char** argv) { struct sigaction sigIntHandler; sigIntHandler.sa_handler = my_handler; sigemptyset(&sigIntHandler.sa_mask); sigIntHandler.sa_flags = 0; … Read more