Otherwise it might be easier to open the pipe(s) with this line;

my $pid = open3(\*IN,\*OUT, 0, "/bin/bash -c $cmd");
[download]

This way the eof(OUT) check will return true when the shell completes the task and exits. No ctrl+c needed.

#!/usr/bin/perl
use warnings;
use strict;
use IPC::Open3;
$|=1;

my $pid=open3(\*IN,\*OUT,0,'ls -la');

#getresult 
while(<OUT>)
{
    print;
    if(eof(OUT))
    {
        goto GOLAST;
    }
}
GOLAST:

close IN;
close OUT;
[download]

Hi zentara


True, and I completely agree with what you said

"Running a bash shell thru IPC is useful when you want to send a series of commands to the shell, and keep it alive."

now I am sure that I am going in the right direction.

Well, yes I am shooting series of commands at a shell instance.

As of now I am using something like this:

foreach (@cmds)
{
  $result = `($cmd) 2>&1`;
}
[download]

I have found that each time I call a shell command using back ticks a new instance of shell is used.

All that I want to do is re-use the bash instance.

But then when I use IPC::Open3, I don't know how to capture the result directly I was forced to use while to loop through the result.

but I am getting lost inside while loop; unable to come out, which is stopping me from running the next command in the que.

mommy :(

Ok, now you are getting to the nitty-griity of your original problem. You need to realize that the shells created with IPC::Open3 use automatically generated pipes to communicate the data. Pipes act differently than you might expect, and it is sometimes requires some code trickery to read them in realtime. Otherwise, the pipe must be closed to force it to flush out all it's data.

So, your problem was

#getresult 
while(<OUT>){......}
[download]

Since OUT is connected to a pipe, you can never leave the loop until it closes, and it never closes with a bash shell (but it will with a simple command).

So, you need to get rid out the while(<OUT>) syntax, and switch to sysread. Something like this:

if( sysread( OUT, my $buffer, 2048 ) > 0 ){ print $buffer }
[download]

The above sucks 2k from the pipe, until there is 0 there. Be warned however, that this is not a general purpose solution to the problem. Each command can act differently, and there are a whole bunch of uncooperative commands that require a terminal to output to. These commands need a pseudo-tty ( see IO::Pty ) and can be very hard to deal with.

But for most commands, a combination of IO::Select and sysread will work. Here is a small example I wrote for Tk. Here, fileevent is Tk's version of IO::Select

#!/usr/bin/perl
use warnings;
use strict;
use Tk;
use IPC::Open3;
require Tk::ROText;

$|=1;

my $mw = new MainWindow;

my $entry=$mw->Entry(-width => 80)->pack;

$mw->Button(-text => 'Execute',
        -command => \&send_to_shell)->pack;

my $textwin =$mw->Scrolled('ROText',
       -width => 80,
       -bg =>'white',    
       -height => 24,
       )->pack;

$textwin->tagConfigure( 'err', -foreground => 'red' );

my $pid = open3( \*IN, \*OUT, \*ERR, '/bin/bash' ) or warn "$!\n";

$mw->fileevent( \*OUT, readable => \&read_stdout );
$mw->fileevent( \*ERR, readable => \&read_stderr );

MainLoop;

sub read_stdout {
    
    if( sysread( OUT, my $buffer, 1024 ) > 0 ){
       $textwin->insert( 'end', $buffer );
       $textwin->see('end');
      }
}

sub read_stderr {
    if( sysread(ERR, my $buffer, 1024 ) > 0 ){
      $textwin->insert( 'end', $buffer, 'err' );
      $textwin->see('end');
    }
}

    
sub send_to_shell {
   my $cmd= $entry->get();
   print IN "$cmd\n";
}
[download]

---

I'm not really a human, but I play one on earth. Cogito ergo sum a bum