G'day techman2006,

Take a look at "perlop: Quote-Like Operators". Under qx/STRING/ (aka `STRING`), you'll find information on how to check for problems with whatever command you're running.

Also, in "perlvar: Error Variables", under $CHILD_ERROR (aka $?), you'll see how to get the status of such commands.

For running a simple tar command, IPC::Open3 doesn't seem appropriate; however, if you have more complex usage, an explanation of this would lead to a more informed answer.

G'day Ken,

Thanks for the references. Let me try to explain the problem on which I am working.

I need to scan a set of directory and based on certain criteria I may need to perform a tar operation. Once the operation is successful I need to update some entries in DB( a SQLite DB).

Now the issue is say an user use Ctrl-C to abort the program. As it may come while DB operations going on it will result into a inconsistent state of DB (which need to be avoided). As if the program run again the flow will be decided based on the entries in DB.

So there are two ways to handle such case

1. Catch all such signals and let the program run

2. Catch such signals and handle the condition gracefully.

So I am thinking to take approach 2 for the same. So I was thinking how to achieve the same. Any example with this reference will be great help.

Hope this will help.

"perlipc: Signals" explains how to trap and handle signals.

There's quite a few examples, including $SIG{INT} which is what you want for Ctrl-C.

Make sure you read down to the caveat: "Be careful: qx(), system(), and some modules for calling external commands ..." - this also has example code.

-- Ken

Hi, I'm not completely sure of what you are doing, but if you need to watch the tar command running, to check for an abort situation, I will point out 1 significant difference between backticks and IPC::Open3. Backticks will stop processing of your main script until the backtick completes, necessitating watching signals and return codes. Whereas IPC::Open3 will allow you to use select or IO::Select to watch the returns coming in, and even separate the stdout and stderr of the command.

Just to demonstrate this capability of IPC::Open3, look at this:

#!/usr/bin/perl
use warnings;
use strict;
use IPC::Open3;
use IO::Select;

my $pid = open3(\*WRITE, \*READ,\*ERROR,"/bin/bash");

my $sel = new IO::Select();

$sel->add(\*READ);
$sel->add(\*ERROR);

my($error,$answer)=('','');

while(1){

 print "Enter command\n";
 chomp(my $query = <STDIN>);
 
 #send query to bash
 print WRITE "$query\n";

 foreach my $h ($sel->can_read)
 {
   my $buf = '';
   if ($h eq \*ERROR)
   {
     sysread(ERROR,$buf,4096);
     if($buf){print "ERROR-> $buf\n"}
   }
   else
   {
     sysread(READ,$buf,4096);
     if($buf){print "$query = $buf\n"}
   }
 }
}

waitpid($pid, 1);
# It is important to waitpid on your child process,  
# otherwise zombies could be created.
[download]

Also, since you are working with tar, you may consider using Archive::Tar(CORE module) instead of command-lining it. That might make your error-handling dramatically more straight-forward.