Process started by script does not receive SIGINT

Question

I am on Ubuntu 16.04.5 LTS (AWS)

I am creating a python process via this command: nohup python -u main.py > nohup.out 2>&1 &

I would like to send a ctrl-c/SIGINT to the process, so I send kill -2 <pid>.

When I start the process from my terminal, this works fine, the program receives the keyboard interrupt and closes gracefully.

When I start the process via a .sh script or via another bash process (e.g. bash -c 'nohup python -u main.py > nohup.out 2>&1 &'). (I believe both methods start the process in the same way), the process does not receive the SIGINT when I send it.

SIGTERM (default kill) works normally and closes the process, but does not let the process close gracefully, but I need.

What's happening?

Answer 1

No, they're not started in the same way. Since bash is running scripts with the job control turned off, the background mode of the commands started with & from a script is just "faked" by letting them ignore SIGINT and SIGQUIT and redirecting their input from /dev/null.

See my answer here (with references to the standard describing this).

In your case this also means the main.py isn't setting any handler for SIGINT in order to do a "graceful" exit, but it's just forcefully killed by a Control-C or kill -2 when run from an interactive shell. If it did set a handler, that handler would've also overridden the SIG_IGN disposition of SIGINT set by the parent shell when run from a script.

Answer 2

Job control is enabled by default, but it's usually disabled in scripts.

When job control is disabled, bash makes processes, that it starts asynchronously (... &), ignore SIGINT:

When job control is not in effect, asynchronous commands ignore SIGINT and SIGQUIT in addition to these inherited handlers.

a.py:

import signal
print('getsignal()', signal.getsignal(signal.SIGINT))
print('SIG_IGN?', signal.getsignal(signal.SIGINT) == signal.SIG_IGN)

$ echo $-
smi (job control is enabled)

$ python a.py &
getsignal() <built-in function default_int_handler>
SIG_IGN? False
[1]+  Done                       python a.py

$ bash -c 'echo $-; python a.py &'
hBc (job control is not enabled)
getsignal() 1
SIG_IGN? True

Let's take a more long-running process and try to kill it:

b.py:

import signal
import time
import sys

print('getsignal()', signal.getsignal(signal.SIGINT))
print('SIG_IGN?', signal.getsignal(signal.SIGINT) == signal.SIG_IGN)

if len(sys.argv) > 1 and sys.argv[1] == 'reset-sigint':
    signal.signal(signal.SIGINT, signal.SIG_DFL)

    print('getsignal()', signal.getsignal(signal.SIGINT))
    print('SIG_IGN?', signal.getsignal(signal.SIGINT) == signal.SIG_IGN)

while True:
    print('.', end='', flush=True)
    time.sleep(2)

$ python e.py &
[1] 245
getsignal() <built-in function default_int_handler>
SIG_IGN? False
..........
$ echo "ibase=16; obase=2; $(ps -p `pgrep python` -o ignored=)" | bc
1000000000001000000000000
$ pkill -2 python
Traceback (most recent call last):
  File "//e.py", line 16, in <module>
    time.sleep(2)
KeyboardInterrupt
[1]+  Interrupt               python e.py

$ bash -c 'python e.py &'
getsignal() 1
SIG_IGN? True
......
$ echo "ibase=16; obase=2; $(ps -p `pgrep python` -o ignored=)" | bc
1000000000001000000000110
$ pkill -2 python
...
$ pkill python

$ bash -c 'python e.py reset-sigint &'
getsignal() 1
SIG_IGN? True
getsignal() 0
SIG_IGN? False
...
$ echo "ibase=16; obase=2; $(ps -p `pgrep python` -o ignored=)" | bc
1000000000001000000000100
$ pkill -2 python