NAME¶

IPC::System::Simple - Run commands simply, with detailed diagnostics

SYNOPSIS¶

  use IPC::System::Simple qw(system systemx capture capturex);
  system("some_command");        # Command succeeds or dies!
  system("some_command",@args);  # Succeeds or dies, avoids shell if @args
  systemx("some_command",@args); # Succeeds or dies, NEVER uses the shell
  # Capture the output of a command (just like backticks). Dies on error.
  my $output = capture("some_command");
  # Just like backticks in list context.  Dies on error.
  my @output = capture("some_command");
  # As above, but avoids the shell if @args is non-empty
  my $output = capture("some_command", @args);
  # As above, but NEVER invokes the shell.
  my $output = capturex("some_command", @args);
  my @output = capturex("some_command", @args);

DESCRIPTION¶

Calling Perl's in-built "system()" function is easy, determining if it was successful is hard. Let's face it, $? isn't the nicest variable in the world to play with, and even if you do check it, producing a well-formatted error string takes a lot of work.

"IPC::System::Simple" takes the hard work out of calling external commands. In fact, if you want to be really lazy, you can just write:

    use IPC::System::Simple qw(system);

and all of your "system" commands will either succeed (run to completion and return a zero exit value), or die with rich diagnostic messages.

The "IPC::System::Simple" module also provides a simple replacement to Perl's backticks operator. Simply write:

    use IPC::System::Simple qw(capture);

and then use the "capture()" command just like you'd use backticks. If there's an error, it will die with a detailed description of what went wrong. Better still, you can even use "capturex()" to run the equivalent of backticks, but without the shell:

    use IPC::System::Simple qw(capturex);
    my $result = capturex($command, @args);

If you want more power than the basic interface, including the ability to specify which exit values are acceptable, trap errors, or process diagnostics, then read on!

ADVANCED SYNOPSIS¶

  use IPC::System::Simple qw(
    capture capturex system systemx run runx $EXITVAL EXIT_ANY
  );
  # Run a command, throwing exception on failure
  run("some_command");
  runx("some_command",@args);  # Run a command, avoiding the shell
  # Do the same thing, but with the drop-in system replacement.
  system("some_command");
  systemx("some_command", @args);
  # Run a command which must return 0..5, avoid the shell, and get the
  # exit value (we could also look at $EXITVAL)
  my $exit_value = runx([0..5], "some_command", @args);
  # The same, but any exit value will do.
  my $exit_value = runx(EXIT_ANY, "some_command", @args);
  # Capture output into $result and throw exception on failure
  my $result = capture("some_command"); 
  # Check exit value from captured command
  print "some_command exited with status $EXITVAL\n";
  # Captures into @lines, splitting on $/
  my @lines = capture("some_command"); 
  # Run a command which must return 0..5, capture the output into
  # @lines, and avoid the shell.
  my @lines  = capturex([0..5], "some_command", @args);

ADVANCED USAGE¶

    use IPC::System::Simple qw(run);
    run("cat *.txt");           # Execute command via the shell
    run("cat","/etc/motd");     # Execute command without shell

    use IPC::System::Simple qw(system);
    system("cat *.txt");  # system now succeeds or dies!

    use IPC::System::Simple qw(capture);
    # Capture text while invoking the shell.
    my $file  = capture("cat /etc/motd");
    my @lines = capture("cat /etc/passwd");

    # Capture text while avoiding the shell.
    my $file  = capture("cat", "/etc/motd");
    my @lines = capture("cat", "/etc/passwd");

    systemx($cmd, @args);

    eval {
        run("cat *.txt");
    };
    if ($@) {
        print "Something went wrong - $@\n";
    }

        use IPC::System::Simple qw(run system capture EXIT_ANY);
        run( [0..5], "cat *.txt");             # Exit values 0-5 are OK
        system( [0..5], "cat *.txt");          # This works the same way
        my @lines = capture( EXIT_ANY, "cat *.txt"); # Any exit is fine.

        my $exit_value = run( [0..5], "cat *.txt");
        # OR:
        my $exit_value = system( [0..5] "cat *.txt");
        print "Program exited with value $exit_value\n";

        use IPC::System::Simple qw(capture $EXITVAL EXIT_ANY);
        my @enemies_defeated = capture(EXIT_ANY, "defeat_evil", "/dev/mordor");
        print "Program exited with value $EXITVAL\n";

DIAGNOSTICS¶

"%s" failed to start: "%s"

The command specified did not even start. It may not exist, or you may not have permission to use it. The reason it could not start (as determined from $!) will be provided.

"%s" unexpectedly returned exit value %d

The command ran successfully, but returned an exit value we did not expect. The value returned is reported.

"%s" died to signal "%s" (%d) %s

The command was killed by a signal. The name of the signal will be reported, or "UNKNOWN" if it cannot be determined. The signal number is always reported. If we detected that the process dumped core, then the string "and dumped core" is appended.

IPC::System::Simple::%s called with no arguments

You attempted to call "run" or "capture" but did not provide any arguments at all. At the very lease you need to supply a command to run.

IPC::System::Simple::%s called with no command

You called "run" or "capture" with a list of acceptable exit values, but no actual command.

IPC::System::Simple::%s called with tainted argument "%s"

You called "run" or "capture" with tainted (untrusted) arguments, which is almost certainly a bad idea. To untaint your arguments you'll need to pass your data through a regular expression and use the resulting match variables. See "Laundering and Detecting Tainted Data" in perlsec for more information.

IPC::System::Simple::%s called with tainted environment $ENV{%s}

You called "run" or "capture" but part of your environment was tainted (untrusted). You should either delete the named environment variable before calling "run", or set it to an untainted value (usually one set inside your program). See "Cleaning Up Your Path" in perlsec for more information.

Error in IPC::System::Simple plumbing: "%s" - "%s"

Implementing the "capture" command involves dark and terrible magicks involving pipes, and one of them has sprung a leak. This could be due to a lack of file descriptors, although there are other possibilities.

If you are able to reproduce this error, you are encouraged to submit a bug report according to the "Reporting bugs" section below.

Internal error in IPC::System::Simple: "%s"

You've found a bug in "IPC::System::Simple". Please check to see if an updated version of "IPC::System::Simple" is available. If not, please file a bug report according to the "Reporting bugs" section below.

IPC::System::Simple::%s called with undefined command

You've passed the undefined value as a command to be executed. While this is a very Zen-like action, it's not supported by Perl's current implementation.

DEPENDENCIES¶

This module depends upon Win32::Process when used on Win32 system. "Win32::Process" is bundled as a core module in ActivePerl 5.6 and above.

There are no non-core dependencies on non-Win32 systems.

COMPARISON TO OTHER APIs¶

Perl provides a range of in-built functions for handling external commands, and CPAN provides even more. The "IPC::System::Simple" differentiates itself from other options by providing:

Extremely detailed diagnostics

The diagnostics produced by "IPC::System::Simple" are designed to provide as much information as possible. Rather than requiring the developer to inspect $?, "IPC::System::Simple" does the hard work for you.

If an odd exit status is provided, you're informed of what it is. If a signal kills your process, you are informed of both its name and number. If tainted data or environment prevents your command from running, you are informed of exactly which data or environmental variable is tainted.

Exceptions on failure

"IPC::System::Simple" takes an aggressive approach to error handling. Rather than allow commands to fail silently, exceptions are thrown when unexpected results are seen. This allows for easy development using a try/catch style, and avoids the possibility of accidentally continuing after a failed command.

Easy access to exit status

The "run", "system" and "capture" commands all set $EXITVAL, making it easy to determine the exit status of a command. Additionally, the "system" and "run" interfaces return the exit status.

Consistent interfaces

When called with multiple arguments, the "run", "system" and "capture" interfaces never invoke the shell. This differs from the in-built Perl "system" command which may invoke the shell under Windows when called with multiple arguments. It differs from the in-built Perl backticks operator which always invokes the shell.

BUGS¶

When "system" is exported, the exotic form "system { $cmd } @args" is not supported. Attemping to use the exotic form is a syntax error. This affects the calling package only. Use "CORE::system" if you need it, or consider using the autodie module to replace "system" with lexical scope.

Core dumps are only checked for when a process dies due to a signal. It is not believed there are any systems where processes can dump core without dying to a signal.

"WIFSTOPPED" status is not checked, as perl never spawns processes with the "WUNTRACED" option.

Signals are not supported under Win32 systems, since they don't work at all like Unix signals. Win32 signals cause commands to exit with a given exit value, which this modules does capture.

FEEDBACK¶

If you find this module useful, please consider rating it on the CPAN Ratings service at <http://cpanratings.perl.org/rate/?distribution=IPC-System-Simple> .

The module author loves to hear how "IPC::System::Simple" has made your life better (or worse). Feedback can be sent to <pjf@perltraining.com.au>.

SEE ALSO¶

autodie uses "IPC::System::Simple" to provide succeed-or-die replacements to "system" (and other built-ins) with lexical scope.

POSIX, IPC::Run::Simple, perlipc, perlport, IPC::Run, IPC::Run3, Win32::Process

AUTHOR¶

Paul Fenwick <pjf@cpan.org>

COPYRIGHT AND LICENSE¶

Copyright (C) 2006-2008 by Paul Fenwick

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.6.0 or, at your option, any later version of Perl 5 you may have available.