This is a simple class that solves the problem: "I'm reading from something that sends some input without a newline, and then waits for me to do something". (Common with programs that present interactive prompts, e.g. "tar" on solaris machines may present the prompt "Prepare volume #2 for /dev/rmt/0 and hit return:", with no newline, and wait for a return)

Sure, for the heavy stuff you could use Expect.pm, but this is for when that's overkill, and you'd like to do most reading through <FILEHANDLE>.

The code in "package main" below shows how to use this class. Basically, it lets you wrap a filehandle so that you can call <TIMEOUTFH> on the wrapped result and get lines as though every significant pause were an end-of-line.

This was posted in response to a SoPW post. The original post in that thread may also be used as an example where something like this is useful. However, as it's very likely generally useful in general, I thought I'd put it out here where it could be found.

package TimeOutHandle;
use Tie::Handle;
use IO::Select;
@ISA = qw(Tie::Handle);
sub TIEHANDLE 
{
  my ($class, $wrappedfh, $timeout) = @_;
  my ($buffer) = '';
  $timeout ||= 5;  # default five second timeout
  return bless [$wrappedfh, $timeout, \$buffer];
}
sub READLINE
{
  my $self = shift;
  my ($inputh, $timeout, $bufref) = @$self;
  if (length($$bufref)==0) {
    sysread $inputh,$$bufref,500;
    if (length($$bufref)==0) {return undef;}
  }
  if ($$bufref =~ s{^.*$/}{}) {return $&;}
  my $s = IO::Select->new();
  $s->add($inputh);
  my @ready = $s->can_read($timeout);
  while (@ready)
  {
    last unless 
      sysread $inputh,$$bufref,500,length($$bufref);
    if ($$bufref =~ s{^.*$/}{}) {return $&;}
    @ready = $s->can_read($timeout);
  }
  $$bufref =~ s/.+// or return undef;
  return $&;
}

package main;
# Test code for the above.

# feed me some data slowly
sub slowdata()
{
  print "a"; sleep 3; print "b"; sleep 6;
  print "c\nd"; sleep 2; print "e";
}

# given a filehandle, tell me what <> does.
# Also, give me when <> does it.
sub reportlines
{
  my $fh = shift;
  printf "%02d: __BEGIN__\n", time() % 100;
  while (<$fh>)
  { s/\n/\\n/s; printf "%02d: '$_'\n", time() % 100; }
  printf "%02d: __END__\n", time() % 100;
}

$|=1;
print "Regular filehandle:\n";
open (INDATA, '-|') || do {slowdata();exit();};
reportlines(*INDATA);

print "\n5 second timeout:\n";
open (INDATA, '-|') || do {slowdata();exit();};
tie *TIMEOUT5, 'TimeOutHandle', \*INDATA;
reportlines(*TIMEOUT5);

print "\n1 second timeout:\n";
open (INDATA, '-|') || do {slowdata();exit();};
tie *TIMEOUT1, 'TimeOutHandle', \*INDATA, 1;
reportlines(*TIMEOUT1);

print "\n10 second timeout:\n";
open (INDATA, '-|') || do {slowdata();exit();};
tie *TIMEOUT10, 'TimeOutHandle', \*INDATA, 10;
reportlines(*TIMEOUT10);

[download]

Replies are listed 'Best First'.
Re: Read a line with &lt;&gt; before \n
by zentara (Cardinal) on Feb 24, 2004 at 14:22 UTC
    This is an interesting snippet, but isn't this what IO::Select is designed to do?
    I'm not really a human, but I play one on earth. flash japh
[reply]
      Yes, and in fact it uses IO::Select internally.

      You could consider it a wrapper around IO::Select that lets you use the fairly comfortable perl idiom: 

      # open up a process that spits out prompts and occasionally
# suddenly spews screenfuls of data
while (<PROCESSOUTPUT>)
{
  chomp;
  if (/some prompt:/) {
    # kicked out because of the timeout
    # respond as appropriate
    ...
  }
  elsif (/first type of data/) {
    # kicked out because a newline was sent.
    ...
  }
  elsif (/second type of data/) {
    ...
  }
  ...
}

      [download]
      It's all about making the rest of your code more readable/useful. The thing is, you'd really like to read most of the program's output with <>, but you never know when the program will stop spewing data and suddenly hand you a prompt without a trailing newline. (such as Solaris's tar prompting you to change tapes) You'd rather not clutter up your main code with distinguishing between whether you got a newline or not.
[reply]
[d/l]

Back to Cool Uses for Perl