IPC::Cmd allows you to run commands, interactively if desired,
platform independent but have them still work.
This module implements a FIFO queuing infrastructure, using a directory
as the communications and storage media. No daemon process is required
to manage the queue; all communication takes place via the filesystem.
IPC::MM provides an interface to Ralf Engelschall's mm library, allowing
memory to be shared between multiple processes in a relatively
convenient way.
IPC::MM provides methods to create and destroy shared memory segments and
to access data structures within those shared memory segments, as well
as miscellaneous methods. Additionally, it provides a tied interface
for scalars and hashes.
IPC::MMA provides an interface to Ralf Engelschall's mm library, allowing
memory to be shared between multiple processes in a relatively
convenient way.
IPC::MMA is a superset of Arthur Choung's IPC::MM module, adding arrays and
allowing any Perl scalar to be used as a hash/BTree key rather than just C
strings. IPC::MMA hashes are like IPC::MM BTrees in that they return keys in
sorted order ineach, keys, and next operations.
An IPC::MMA array can store data in any of six ways, including general-purpose
scalars, signed or unsigned integers, floating-point numbers, fixed-length
strings/records, and booleans at one bit per array element.
This module allows you to alias a lexical variable to another variable
(package or lexical). You will receive a fatal error if you try
aliasing a scalar to something that is not a scalar etc.
LV makes lvalue subroutines easy and practical to use. It's inspired by the
lvalue module which is sadly problematic because of the existence of another
module on CPAN called Lvalue. (They can get confused on file-systems that have
case-insensitive file names.)
LV comes with three different implementations, based on Variable::Magic,
Sentinel and tie; it will choose and use the best available one. You can force
LV to pick a particular implementation using:
$ENV{PERL_LV_IMPLEMENTATION} = 'Magic'; # or 'Sentinel' or 'Tie'
The tie implementation is the slowest, but will work on Perl 5.6 with only core
modules.
This module provides a simple API for publishing messages to channels
and for subscribing to them.
When a message is published on a channel, all subscribers currently in
that channel will get it on their next "get" or "get_all" call.
Currently, it offers three backends: "DBM_Deep" for on-disk storage,
"Memcached" for possibly multi-host storage, and "PlainHash" for
single-process storage.
IPC::Run allows you run and interact with child processes, files, pipes,
and pseudo-ttys. Both event-loop and procedural techniques are
supported and may be mixed. Likewise, functional and OO API styles are
both supported and may be mixed.
IPC::Shareable allows you to tie a variable to shared memory making it
easy to share the contents of that variable with other Perl processes.
Currently either scalars or hashes can be tied; tying of arrays remains
a work in progress. However, the variable being tied may contain
arbitrarily complex data structures - including references to arrays,
hashes of hashes, etc. See the "REFERENCES" entry in this man page below
for more information.
IPC::ShellCmd comes from the nth time I've had to implement a select loop and
wanted appropriate sudo/su privilege magic, environment variables that are set
in the child, working directories set etc.
It aims to provide a reasonable interface for setting up command execution
environment (working directory, environment variables, stdin, stdout and stderr
redirection if necessary), but allowing for ssh and sudo and magicking in the
appropriate shell quoting.
It tries to be flexible about how you might want to capture output, exit status
and other such, but in such a way as it's hopefully easy to understand and make
it work.
Setup method calls are chain-able in a File::Find::Rule kind of a way.