From: Jens Carlberg <jens.carlberg@...>
Date: 2011-04-14T17:28:16+09:00
Subject: Re: How do I trap Ctrl-C so it doesn't reach spawned threads?

------=_NextPart_000_00DB_01CBFA8E.9CB5EEE0
Content-Type: text/plain;
	charset="us-ascii"
Content-Transfer-Encoding: 7bit

I have now tried both fork and spawn, and my confusion have reached new
levels. :-)

Fork and ruby
=============
Worked as a charm. Too bad I need to use jruby due to JMX dependencies.


Fork and jruby
==============
Fork seems to be considered dangerous when used in jruby. I have found info
about enabling it, but are having very limited success in doing that.

I have started jirb two ways:

1. jirb -J-Djruby.fork.enabled=true

Results in "IRB::UnrecognizedSwitch: Unrecognized switch:
-J-Djruby.fork.enabled=true"

2. jruby -J-Djruby.fork.enabled=true -S jirb

Results in "NotImplementedError: fork is not available on this platform".

The jruby.fork.enabled property isn't listed when I do jruby --properties
either. Has it been removed?


Spawn and jruby
===============
1. Process.spawn("xeyes")
Do not protect the spawned process from Ctrl-C.

2. Process.spawn("xeyes", :pgroup=>true)
Gives the xeyes usage message; the option is used as a part of the command.
How do jruby separates options for the command and options for
Process.spawn?

Just to test that I read the Rdoc page for Process right:

3. spawn({"FOO"=>"BAR", "BAZ"=>nil}, "xeyes")
Errno::ENOENT: No such file or directory - {"FOO"=>"BAR", "BAZ"=>nil}


///Best regards, Jens Carlberg

-----Original Message-----
From: Charles Oliver Nutter [mailto:headius@headius.com] 
Sent: den 11 april 2011 01:32
To: ruby-talk@ruby-lang.org
Cc: Jens Carlberg
Subject: Re: How do I trap Ctrl-C so it doesn't reach spawned threads?

On Fri, Apr 8, 2011 at 2:53 AM, Jens Carlberg <jens.carlberg@ericsson.com>
wrote:
> Hi!
>
> I'm having trouble trapping Ctrl-C. I have a CLI that spawns processes I
would like to survive the CLI, but if I press Ctrl-C the spawns dies along
with the CLI. I have experimented with trap(INT), and have boiled down the
problem into a small example program. I run this on Linux.
...
> I don't understand the behaviour. The jruby version feels more consistent,
but is far away from what I need. The ruby version feels strange, but I
could handle my needs by spawning a dummy process if I didn't need jmx4r
(which as far as I understand requires jruby).
>
> 1. How is trapping of SIGINT supposed to work? How is the passing of
SIGINT supposed to work?
> 2. Why does it differs between ruby and jruby?
> 3. Anyone with a suggestion how to spawn processes not affected by a
SIGINT?

In MRI, I *believe* SIGINT is sent to the process that currently controls
the TTY, so in the case of system() it's sent to your program that's
running.

In JRuby, child processes don't usually share the TTY streams (JVM isolates
child process streams from the parent using pipes), so Ctrl-C is sent to
JRuby (the JVM itself, really, since we don't trap INT in JRuby and allow
JVM to handle it) and it shuts down taking the active child process with it.

Perhaps you can try to use posix_spawn or 1.9's "spawn"?

- Charlie

------=_NextPart_000_00DB_01CBFA8E.9CB5EEE0
Content-Type: application/x-pkcs7-signature; name="smime.p7s"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="smime.p7s"
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------=_NextPart_000_00DB_01CBFA8E.9CB5EEE0--