$| = 1; select(PIPE);
is wrong. It sets autoflush for the previously select handle, not PIPE. It should be
my $old_sel = select(PIPE); $|=1; select($old_sel);
or the more readable
use IO::Handle qw( ); PIPE->autoflush(1);

Now that won't fix your problem. Since you proceed to close the pipe after every print, everything is being flushed even though you fail to turn on autoflush. However, once you fix autoflush, you won't have any reason to keep reopening and closing the pipe.

Now, I'm quite curious as to what you use <PIPE> to read from the pipe (with $/ left to its default) when the data sent over the pipe doesn't contains any newlines.

I wan't sure about the autoflush, but I've tried it with and without all to no avail. Out of interest, wouldn't

select(PIPE); $| = 1;
[download]

work? fwiw as it's in a loop, wouldn't the second iteration turn it on?
I digress...
I don't understand your last paragraph. Could you explain it please?

It would work, but print statements without a file handle will now go into the PIPE instead of to STDOUT. That's probably not what you want to do, and I don't like using select that way (spooky action at a distance). That's why you should have a second select to re-select the currently selected handle.

I don't understand your last paragraph. Could you explain it please?

<FILE> reads until end of line, but your data doesn't contain lines.

Nothing else is reading the pipe. No backups are running. I haven't tried the \n, but will do in a bit as I'm clutchig at straws :) No nfs is involved. (The grandparent directory is exported, fwiw)

while (1) {
   ...
    open FH, "<pipe";
    my $data = <FH>;
    close FH
  ...
}
[download]

Well with some ideas from above, I have tried:

local $/;
open PIPE, "<$pipe";
my $data = <PIPE>;
close PIPE;
[download]

Which didn't work, I'm still missing some messages. So, assuming the problem is with buffered IO, I thought I'd try:

    open FH, "<$config->{'pipe'}";
    my $data;
    while (sysread FH, my $buf, 2048) {
        $data .= $buf;
    }
    close FH;
[download]

Which is also not working. I am stumped. I could open the pipe out of the loop, but then it wouldn't block on the open and I'd rather not sleep to simulate that. Any ideas?

I think you're better off using a socket based approach. Then you'll have a separate file handle for every connection. By closing and re-opening the pipe you introduce a race condition and (at the very least) run the risk of causing SIGPIPE signals to be sent to the client processes. (And maybe this is what is happening since your clients are logging the message being sent before writing it to the pipe.)

That said, does this work for you?

open FH, "<pipe" or die "open failed; $!\n";
my $buf;
while (1) {
  my $nr = sysread(FH, $buf, 1024, length($buf));
  while ($buf =~ s/^(.*?)\n//) {
    process_line($1);
  }
  sleep(1);
}
close(FH);
[download]

I haven't yet found out how to make the sysread call blocking, but if I do I'll let you know.

Best

Casiano

open(RW, "+<pipe") or die "unable to open pipe: $!\n";
open(FH, "<pipe") or die "open pipe: $!\n";
while (<FH>) {
    # process line
}
[download]

Thanks everyone for your help. I finally cracked it yesterday. The trick is to open the pipe for read/write, bypass perlio and have a blocking read. The code below shows how it's done. I could possibly have moved to sockets, but pipes are as old as the hills so it should be possible to use them and on top of that the writer could be a bash script. Having said that, I did find out how to have bash write to a socket...

# Non blocking open
open (FH, "+<", $config->{'pipe'} ) || die "Unable to open $config->{'
+pipe'}";

my $rin = '';
my $rout = '';
vec( $rin, fileno(FH), 1) = 1; # No, I have no idea either

# Loop forever.
while (1) {

    # Wait for the pipe to change status
    my $nfound = select( $rout = $rin, undef, undef, undef ); # blocki
+ng select

    my $data;
    # Non blocking select only returns a value while there is somethin
+g in the pipe
    while ( select( $rout = $rin, undef, undef, 0 ) ) {
        sysread FH, my $buf, 2048;
        $data .= $buf;
    }

    Log( { logfile => $log_file, text => 'trace: START: '. ( $data || 
+'$data no val' ) }) if TRACE;

    # 9/4/8 A request is C,DIR,1ROSE
    # Multiple requests can come through on one read ie C,FOO,1ROSEC,B
+AR,1ROSE
    for ( split /ROSE/, $data ? $data : '' ) {
        if ( /^RELOAD/ ) {
            # Reread the config file
            Log({logfile=>$log_file, text=> qq{RELOAD: Reloading confi
+g}});
            load_config();
        }
        else {
            process_input( { data => $_ } ) if $_;
        }
    }

} # while 1
[download]

"ROSE" has got to be the weirdest line ending I've ever seen.

I took the liberty of cleaning up your code a bit.

• I fixed a bug where a single message could be considered two.
• I eliminated the select which needlessly served to empty the pipe.
• I replaced split since you have a record terminator rather than a record separator.

# Non blocking open
open (FH, "+<", $config->{'pipe'} ) || die "Unable to open $config->{'
+pipe'}";

my $buf = '';

# Loop forever.
while (1) {
    my $rv = sysread( FH, $buf, 2048, length($buf) );
    die("Error reading from pipe: $!\n") if !defined($rv);

    # 9/4/8 A request is C,DIR,1ROSE
    # Multiple requests can come through on one read ie C,FOO,1ROSEC,B
+AR,1ROSE
    while ($buf =~ s/(.*?ROSE)//s) {
       my $rec = $1;
       Log( { logfile => $log_file, text => "trace: START: $rec" }) if
+ TRACE;

        if ( $rec =~ /^RELOAD,/ ) {
            # Reread the config file
            Log({logfile=>$log_file, text=> qq{RELOAD: Reloading confi
+g}});
            load_config();
        }
        else {
            process_input( { data => $rec } );
        }
    }

} # while 1
[download]