subprocess leaves child living : Python

Hi, When I do a small program like

from subprocess import Popen
popen = Popen(["ping", "google.com"])
from time import sleep
sleep(100)

start it and kill it, the ping process lives on.
Is there a way to ensure that the ping process is always killed when the
python process is?
I can't use atexit, as ping then isn't killed when python is killed "in
the hard way"

Thomas Dybdahl Ahle schrieb:
> Hi, When I do a small program like
>
> from subprocess import Popen
> popen = Popen(["ping", "google.com"])
> from time import sleep
> sleep(100)
>
> start it and kill it, the ping process lives on.
> Is there a way to ensure that the ping process is always killed when the
> python process is?
> I can't use atexit, as ping then isn't killed when python is killed "in
> the hard way"
>
Calling popen.close() perhaps ?
You basically open a pipe, which spawns a shell and the command is then
started in there.
So, if your program quits, the spawned shell is still alive, only the
pipe is dead.

Den Tue, 05 Jun 2007 14:07:44 +0200 skrev Stefan Sonnenberg-Carstens:

> Thomas Dybdahl Ahle schrieb:
>> Hi, When I do a small program like
>>
>> from subprocess import Popen
>> popen = Popen(["ping", "google.com"]) from time import sleep
>> sleep(100)
>>
>> start it and kill it, the ping process lives on. Is there a way to
>> ensure that the ping process is always killed when the python process
>> is?
>> I can't use atexit, as ping then isn't killed when python is killed "in
>> the hard way"
>>
> Calling popen.close() perhaps ?
> You basically open a pipe, which spawns a shell and the command is then
> started in there.
> So, if your program quits, the spawned shell is still alive, only the
> pipe is dead.

Problem is - I can't do that when I get killed.
Isn't it possible to open processes in such a way like terminals? If I
kill the terminal, everything open in it will die too.

Thomas Dybdahl Ahle wrote:

> Problem is - I can't do that when I get killed.
> Isn't it possible to open processes in such a way like terminals? If I
> kill the terminal, everything open in it will die too.

On POSIX platform you can use signals and ``os.kill`` function.
Fo example:

<code>
import os, signal
from subprocess import Popen
from time import sleep

def handler(signum, frame):
print 'Signal handler called'
raise KeyboardInterrupt

signal.signal(signal.SIGTERM, handler)

try:
popen = Popen(["ping", "google.com"])
try:
sleep(100)
except KeyboardInterrupt:
pass
finally:
if popen.poll() is None:
print "killing process: %d" % popen.pid
os.kill(popen.pid, signal.SIGTERM)
</code>

--
HTH,
Rob

Den Tue, 05 Jun 2007 07:06:15 -0700 skrev Rob Wolfe:

> Thomas Dybdahl Ahle wrote:
>
>> Problem is - I can't do that when I get killed. Isn't it possible to
>> open processes in such a way like terminals? If I kill the terminal,
>> everything open in it will die too.
>
> On POSIX platform you can use signals and ``os.kill`` function. Fo
> example:
>
> <code>
> import os, signal
> from subprocess import Popen
> from time import sleep
>
> def handler(signum, frame):
> print 'Signal handler called'
> raise KeyboardInterrupt
>
> signal.signal(signal.SIGTERM, handler)
>
> try:
> popen = Popen(["ping", "google.com"]) try:
> sleep(100)
> except KeyboardInterrupt:
> pass
> finally:
> if popen.poll() is None:
> print "killing process: %d" % popen.pid os.kill(popen.pid,
> signal.SIGTERM)
> </code>

But you can't ever catch sigkill.
Isn't there a way to make sure the os kills the childprocess when the
parrent dies?

Thomas Dybdahl Ahle <lobais@> writes:

> But you can't ever catch sigkill.

There is no protection against sigkill.

> Isn't there a way to make sure the os kills the childprocess when the
> parrent dies?

If the parent dies suddenly without any notification childprocesses
become zombies and there is no way to avoid that.

--
HTH,
Rob

On Jun 5, 2007, at 3:01 PM, Rob Wolfe wrote:

> Thomas Dybdahl Ahle <lobais@> writes:
>
>> But you can't ever catch sigkill.
>
> There is no protection against sigkill.
>
>> Isn't there a way to make sure the os kills the childprocess when the
>> parrent dies?
>
> If the parent dies suddenly without any notification childprocesses
> become zombies and there is no way to avoid that.

Apologies for picking nits...

But actually *that* is an orphan process. When a parent process dies
and the child continues to run, the child becomes an orphan and is
adopted by init. Orphan processes can be cleaned up on most Unices
with 'init q' (or something very similar).

Zombies on the other hand, are those processes that have completed
execution but still have an entry in the process table. The cause of
zombies AFAIK, is a parent that has failed to call wait(2). To clean
up zombies, you can send a SIGCHLD signal to the parent process --
probably with 'kill -17' (but use 'kill -l' to find out what it is on
your system).

hth,
Michael
---
"I would rather use Java than Perl. And I'd rather be eaten by a
crocodile than use Java." — Trouser

Den Tue, 05 Jun 2007 22:01:44 +0200 skrev Rob Wolfe:

> Thomas Dybdahl Ahle <lobais@> writes:
>
>> But you can't ever catch sigkill.
>
> There is no protection against sigkill.
>
>> Isn't there a way to make sure the os kills the childprocess when the
>> parrent dies?
>
> If the parent dies suddenly without any notification childprocesses
> become zombies and there is no way to avoid that.

If I call "kill -9 pythonpid" on the python code you posted earlier, the
terminal running the script will continue pinging forever.
If it was a harder program like a chessengine or such, it would continue
consuming 100% cpu time.
Zombies would be fine to me.

Den Tue, 05 Jun 2007 15:46:39 -0500 skrev Michael Bentley:

> But actually *that* is an orphan process. When a parent process dies
> and the child continues to run, the child becomes an orphan and is
> adopted by init. Orphan processes can be cleaned up on most Unices with
> 'init q' (or something very similar).

Is it not possible to tell python that this process should not be adopted
by init, but die with its parrent?
Just like terminals seem to do it..

On Jun 5, 2007, at 4:17 PM, Thomas Dybdahl Ahle wrote:

> Den Tue, 05 Jun 2007 15:46:39 -0500 skrev Michael Bentley:
>
>> But actually *that* is an orphan process. When a parent process dies
>> and the child continues to run, the child becomes an orphan and is
>> adopted by init. Orphan processes can be cleaned up on most
>> Unices with
>> 'init q' (or something very similar).
>
> Is it not possible to tell python that this process should not be
> adopted
> by init, but die with its parrent?
> Just like terminals seem to do it..

Well, the way you posed the original question:

> from subprocess import Popen
> popen = Popen(["ping", "google.com"])
> from time import sleep
> sleep(100)

is really what adoption by init is designed to handle. Here you've
created a child but have not waited for its return value. Like a
good adoptive parent, init will wait(2) for the child.

I think if you really looked into it you'd find that the terminal had
called wait(2) before it was killed. Similarly, if you start a long-
running subprocess in python and wait for it to return -- killing the
parent will slaughter the child as well.

hth,
Michael
---
Let the wookie win.