Perl脚本实时捕获外部程序输出、错误及退出码的实现需求

Alright, let's work through this problem. You need to capture every line of stdout and stderr from an external program in real-time, process each line before logging it, grab the exit code, and you can't install any extra Perl modules. Plus, IPC::Run wasn't giving you that real-time line-by-line output you need. Here's how to fix this with core Perl tools that come pre-installed.

The Core Perl Solution: IPC::Open3 + Select #

IPC::Open3 is a core Perl module (no extra installs needed) that lets you separate a child process's stdin, stdout, and stderr streams. The trick to real-time line capture is using select() to monitor both stdout and stderr handles at once—this prevents deadlocks that can happen if you only read one stream while the other fills up.

Here's a complete working example:

use strict;
use warnings;
use IPC::Open3;
use Symbol 'gensym';
use POSIX ':sys_wait_h'; # For WNOHANG constant

# Replace this with your actual external command
my $external_cmd = '/path/to/your/target/program';

# Create a symbol for stderr (open3 requires a glob for unhandled streams)
my $stderr_fh = gensym();

# Open pipes to the child process: stdin (unused here), stdout, stderr
my $child_pid = open3(my $stdin_fh, my $stdout_fh, $stderr_fh, $external_cmd);

# Close stdin since we don't need to send input to the child
close $stdin_fh;

# Map file descriptors to their handles and stream type for easy tracking
my %active_handles = (
    fileno($stdout_fh) => { fh => $stdout_fh, type => 'STDOUT' },
    fileno($stderr_fh) => { fh => $stderr_fh, type => 'STDERR' },
);

# Pre-open the log file once (better than opening/closing every line)
open my $log_fh, '>>', '/path/to/your/logfile.log' 
    or die "Failed to open log file: $!";

# Monitor handles until all streams are closed and child exits
while (keys %active_handles) {
    # Use select to wait for data on either stdout or stderr (0.1s timeout)
    my ($read_set) = select(my $read = '', undef, undef, 0.1);
    next unless $read_set;

    foreach my $fd (keys %active_handles) {
        next unless vec($read_set, $fd, 1); # Skip if no data on this handle

        my $handle_info = $active_handles{$fd};
        my $fh = $handle_info->{fh};
        my $stream_type = $handle_info->{type};

        # Read lines one at a time (real-time if child uses line buffering)
        while (my $line = <$fh>) {
            chomp $line;
            # Your custom line processing goes here!
            my $processed_line = sprintf("[%s] %s: %s", 
                $stream_type, scalar localtime(), $line);
            
            # Write processed line to log
            print $log_fh "$processed_line\n";
            flush $log_fh; # Ensure log writes happen immediately
        }

        # Remove the handle if it's closed (child finished writing to it)
        delete $active_handles{$fd} unless fileno($fh);
    }

    # Check if the child process has exited (without blocking)
    waitpid($child_pid, WNOHANG);
    last if $? != -1; # Exit loop if child is done
}

# Cleanup
close $log_fh;

# Extract the actual exit code from Perl's $? variable
my $exit_code = $? >> 8;
print "External program exited with code: $exit_code\n";

Key Details & Fixes for Real-Time Output #

1. Avoiding Deadlocks: Using select() ensures we never get stuck waiting on one stream while the other blocks the child process.
2. Line Buffering Issues: If your external program uses block buffering (common for compiled programs like C binaries), it won't flush lines to the pipe until the buffer is full. Fix this by wrapping your command with stdbuf (most Unix-like systems have this):

   my $external_cmd = 'stdbuf -oL /path/to/your/target/program';
   

   The -oL flag forces line buffering for stdout; add -eL if you need stderr line buffering too.
3. Log Flushing: The flush $log_fh call ensures processed lines are written to the log immediately, instead of being buffered in memory.
4. Exit Code Handling: Perl's $? variable holds the child process's exit status. Shifting right by 8 bits ($? >> 8) gives you the actual exit code (the lower 8 bits signal info).

Why IPC::Run Might Have Failed #

IPC::Run can buffer output by default, especially if you're using higher-level methods that wait for the process to finish before returning output. The manual approach with IPC::Open3 and select() gives you direct control over when and how you read each stream, ensuring real-time processing.

内容的提问来源于stack exchange，提问作者uldics