Terminating a program within a time frame through python

Question

I'm running a fortran code from a python script which sometimes takes a while to run. Thus I'm limiting the run time with a code taken from this link:

def timeout(func, args=(), kwargs={}, timeout_duration=15, default=1):
    import signal

    class TimeoutError(Exception):
        pass

    def handler(signum, frame):
        raise TimeoutError()

    # set the timeout handler
    signal.signal(signal.SIGALRM, handler) 
    signal.alarm(timeout_duration)
    try:
        result = func(*args, **kwargs)
    except TimeoutError as exc:
        result = default
    finally:
        signal.alarm(0)

    return result

I'm basically putting another function (partly below) in to this one (above) to run fortran code as:

subprocess.check_output('./../bin/SPhenoUMSSM ../UMSSM/LH_out_'+mod+' > SPheno_log_'+mod, shell=True)

However I realised that when fortran code takes more than 15 seconds, which is the boundary in timeout function, it leaves in the core and executes other one in the for loop which creates dump in my cores. In order to prevent that, I wanted to use subprocess.popen() since it gives me pid to terminate the job in the core, but I need to wait for the process to be executed as well, like subprocess.check_output() does. Thus I was wondaring if there is a way to combine popen and check_output properties to wait until job is done within 15 seconds and if its not just terminates that.

score 1 · Accepted Answer · edited Sep 30 '16 at 16:16

Not the most sophisticated piece of code in the world but it may be useful.

import subprocess, time
x = subprocess.Popen(['sleep', '15'])
polling = None
i = 0
while polling == None:
    time.sleep(1)
    polling = x.poll()
    i +=1
    if i > 15: break
if polling == None:
    try:
        x.kill()
        print "Time out - process terminated" # process terminated by kill command
    except OSError:
        print "Process completed on time" # process terminated between poll and kill commands
    except Exception as e:
        print "Error "+str(e) # kill command failed due to another exception "e"
else:
    print "Process Completed after "+str(i)+" seconds"

Edit: Problems with kill not appearing to function.
Try using os.kill(x.pid, signal.SIGKILL) rather than SIGTERM.
I believe that SIGTERM asks the process to close down cleanly, rather than terminate immediately. Not knowing what drives the fortran script, it's difficult to know what the terminate signal does. Perhaps the code is doing something.
For example:
if I ran a shell script as follows:

#!/bin/bash
trap "echo signal" 15
sleep 30

and sent it kill -15 pid_number, it would not print "signal" until the sleep had terminated after 30 seconds, whereas if I issued kill -9 pid_number it would terminate immediately with nothing printed out.

The short answer, is I don't know but I suspect that the answer lies within the script running the fortran code.

EDIT:

Note: In order to successfully run x.kill() or os.kill() or subprocess.call('kill '+ str(x.pid), shell=True), shell option in x needs to be False. Thus one can use

import shlex
args = shlex.split(ARGS HERE) 
x = subprocess.Popen(args) # shell=False is default

But also note that if you want to write the output to a log file by using ... >& log_file it wont work since >& is not an valid argument for your script but for your shell environment. Thus one needs to use only arguments that are valid for the script that python runs.

Interestingly sometimes it works perfectly fine but sometimes it just leaves the program in the background and prints terminated. I tried x.terminate() as well but ended up with the same result. Do you know why it might happen? — jackaraz, Sep 29 '16 at 15:02
No idea I'm afraid. The documentation does not have any caveats that I can see. However I do not know how your fortran code functions, your OS or indeed, how you have implemented the above code. I would take out the `try` statement and see if you get an error from the `kill()` command which points you in the right direction. — Rolf of Saxony, Sep 29 '16 at 15:27
Another thought, too late for an edit. Try `poll()` again after the `kill()` just to double check. — Rolf of Saxony, Sep 29 '16 at 15:34
I'm actually running it without try since the beginning and didnt get any error messages. tried `os.kill(PID, signal.SIGTERM)`, `process = psutil.Process(PID) process.terminate()`, didnt worked as well. Actually I got an error with `os.kill` about str object which I do not understand where it found str. my OS is Ubuntu 14.04, python 2.7.6 — jackaraz, Sep 29 '16 at 16:27
Thanks a lot, I tried it and figured that the problem occurs due to `shell=True` option. `Popen` terminates shell but not the script inside it. Thus `shell=True` option needs to be False to execute such a command successfully. But in this situation `... > log_file` doesn't work somehow probably because its not an argument required by the code. — jackaraz, Sep 30 '16 at 14:09

ApolloFortyNine · Answer 2 · 2016-09-26T15:38:18.560

0

There's a timeout argument on check_output, just set it to 15 seconds.

try:
  subprocess.check_output(['arg1', 'arg2'], timeout=15)
except:
  print("Timed out")

Documentation here https://docs.python.org/3/library/subprocess.html#subprocess.check_output

check_output returns the output as well, so if you care about it just store the result.

There's also a wait function that's useful for more complicated use cases. Both check_output and wait block until the process finishes, or until the timeout is reached.

edited Sep 26 '16 at 15:38

answered Sep 26 '16 at 15:32

ApolloFortyNine

570
2
7

unfortunately I'm using Python 2.7.6, `timeout` update is for vers 3.3 – jackaraz Sep 26 '16 at 15:51
You should stop unless your company is forcing it upon you, Python 2 is at EOL and will be fully dead in 2020. A simple Google revealed this though: http://stackoverflow.com/questions/3733270/python-subprocess-timeout – ApolloFortyNine Sep 26 '16 at 17:34

score 0 · Answer 3 · answered Nov 18 '16 at 17:43

Additional answer to the one above, shell has an internal timeout command as well so it can be used as follows;

timeout <TIME IN SEC> ./blabla > log_file

I'm using it in python as follows;

try:
    check_output('timeout --signal=SIGKILL 12 ./<COMMAND> > log', shell=True)
    flag = 0
except:
    flag = 1

Thus one can check if flag is 1 or 0 to understand what happened to the job. Note that --signal=SIGKILL is just written Killed at the end of the run if its terminated. For more signal options one can check kill -l.

Terminating a program within a time frame through python

3 Answers3

Linked