NAME

Venus::Process - Process Class

ABSTRACT

Process Class for Perl 5

SYNOPSIS

package main;

use Venus::Process;

my $parent = Venus::Process->new;

my $process = $parent->fork;

if ($process) {
  # do something in forked process ...
  $process->exit;
}
else {
  $parent->wait(-1);
}

# $parent->exit;

DESCRIPTION

This package provides methods for handling and forking processes.

INHERITS

This package inherits behaviors from:

Venus::Kind::Utility

INTEGRATES

This package integrates behaviors from:

Venus::Role::Accessible

Venus::Role::Explainable

METHODS

This package provides the following methods:

chdir

chdir(Str $path) (Process)

The chdir method changes the working directory the current process is opreting within.

Since 0.06

chdir example 1

# given: synopsis;

my $chdir = $parent->chdir;

# 1

chdir example 2

# given: synopsis;

my $chdir = $parent->chdir('/tmp');

# 1

chdir example 3

# given: synopsis;

my $chdir = $parent->chdir('/xyz');

# Exception!

check

check(Int $pid) (Int, Int)

The check method does a non-blocking "waitpid" operation and returns the wait status. In list context, returns the specified process' exit code (if terminated).

Since 0.06

check example 1

package main;

use Venus::Process;

my $parent = Venus::Process->new;

my ($process, $pid) = $parent->fork;

if ($process) {
  # do something in forked process ...
  $process->exit;
}

my $check = $parent->check($pid);

# 0

check example 2

package main;

use Venus::Process;

my $parent = Venus::Process->new;

my ($process, $pid) = $parent->fork;

if ($process) {
  # do something in forked process ...
  $process->exit;
}

my ($check, $status) = $parent->check('00000');

# (-1, -1)

check example 3

package main;

use Venus::Process;

my $parent = Venus::Process->new;

my ($process, $pid) = $parent->fork(sub{
  $_->exit(1);
});

if ($process) {
  # do something in forked process ...
  $process->exit;
}

my ($check, $status) = $parent->check($pid);

# ($pid, 1)

daemon

daemon() (Process)

The daemon method detaches the process from controlling terminal and runs it in the background as system daemon. This method internally calls "disengage" and "setsid", and attempts to change the working directory to the root directory.

Since 0.06

daemon example 1

# given: synopsis;

my $daemon = $parent->daemon; # exits parent immediately

# do something in forked process ...

# $daemon->exit;

disengage

disengage() (Process)

The disengage method limits the interactivity of the process by changing the working directory to the root directory and redirecting its standard file descriptors from and to /dev/null or the OS equivalent. These state changes can be undone by calling the "engage" method.

Since 0.06

disengage example 1

# given: synopsis;

$process = $parent->disengage;

# bless({...}, 'Venus::Process')

engage

engage() (Process)

The engage method ensures the interactivity of the process by changing the working directory to the directory used to launch the process, and by redirecting/returning its standard file descriptors from and to their defaults. This method effectively does the opposite of the "disengage" method.

Since 0.06

engage example 1

# given: synopsis;

$process = $parent->engage;

# bless({...}, 'Venus::Process')

exit

exit(Int $status) (Int)

The exit method exits the program immediately.

Since 0.06

exit example 1

# given: synopsis;

my $exit = $parent->exit;

# 0

exit example 2

# given: synopsis;

my $exit = $parent->exit(1);

# 1

fork

fork(Str | CodeRef $code, Any @args) (Process, Int)

The fork method calls the system "fork" function and create a new process running the same program at the same point (or call site). This method return a newVenus::Process object representing the child process within the child process (or fork), and returns undef to the parent (or originating) process. In list context, this method returns both the process and PID (or process ID) of the child process. If a callback or argument is provided it will be executed in the child process.

Since 0.06

fork example 1

# given: synopsis;

$process = $parent->fork;

# if ($process) {
#   # do something in forked process ...
#   $process->exit;
# }
# else {
#   # do something in the parent process ...
#   $parent->wait(-1);
# }

# bless({...}, 'Venus::Process')

fork example 2

# given: synopsis;

my $pid;

($process, $pid) = $parent->fork;

# if ($process) {
#   # do something in forked process ...
#   $process->exit;
# }
# else {
#   # do something in the parent process ...
#   $parent->wait($pid);
# }

# bless({...}, 'Venus::Process')

fork example 3

# given: synopsis;

my $pid;

($process, $pid) = $parent->fork(sub{
  $$_{started} = time;
});

# if ($process) {
#   # do something in forked process ...
#   $process->exit;
# }
# else {
#   # do something in the parent process ...
#   $parent->wait($pid);
# }

# bless({...}, 'Venus::Process')

forks

forks(Str | CodeRef $code, Any @args) (Process, ArrayRef[Int])

The forks method creates multiple forks by calling the "fork" method "n" times based on the count specified. As with the singular "fork" method, this method return a new Venus::Process object representing the child process within the child process (or fork), and returns undef to the parent (or originating) process. In list context, this method returns both the process and an arrayref of PID values (or process IDs) for each of the child processes created. If a callback or argument is provided it will be executed in each child process.

Since 0.06

forks example 1

# given: synopsis;

$process = $parent->forks(5);

# if ($process) {
#   # do something in (each) forked process ...
#   $process->exit;
# }
# else {
#   # do something in the parent process ...
#   $parent->wait(-1);
# }

# bless({...}, 'Venus::Process')

forks example 2

# given: synopsis;

my $pids;

($process, $pids) = $parent->forks(5);

# if ($process) {
#   # do something in (each) forked process ...
#   $process->exit;
# }
# else {
#   # do something in the parent process ...
#   $parent->wait($_) for @$pids;
# }

# in the parent process

# (undef, $pids)

forks example 3

# given: synopsis;

my $pids;

($process, $pids) = $parent->forks(5, sub{
  my ($fork, $pid, $iteration) = @_;
  # $iteration is the fork iteration index
  $fork->exit;
});

# if ($process) {
#   # do something in (each) forked process ...
#   $process->exit;
# }
# else {
#   # do something in the parent process ...
#   $parent->wait($_) for @$pids;
# }

# in the child process

# bless({...}, 'Venus::Process')

kill

kill(Str $signal, Int @pids) (Int)

The kill method calls the system "kill" function which sends a signal to a list of processes and returns truthy or falsy. Note: A truthy result doesn't necessarily mean all processes were successfully signalled.

Since 0.06

kill example 1

# given: synopsis;

if ($process = $parent->fork) {
  # do something in forked process ...
  $process->exit;
}

my $kill = $parent->kill('term', $process->value);

# 1

setsid

setsid() (Int)

The setsid method calls the "setsid" in POSIX function and sets the process group identifier of the current process.

Since 0.06

setsid example 1

# given: synopsis;

my $setsid = $parent->setsid;

# 1

stderr

stderr(Str $path) (Process)

The stderr method redirects STDERR to the path provided, typically /dev/null or some equivalent. If called with no arguments STDERR will be restored to its default.

Since 0.06

stderr example 1

# given: synopsis;

$process = $parent->stderr;

# bless({...}, 'Venus::Process')

stdin

stdin(Str $path) (Process)

The stdin method redirects STDIN to the path provided, typically /dev/null or some equivalent. If called with no arguments STDIN will be restored to its default.

Since 0.06

stdin example 1

# given: synopsis;

$process = $parent->stdin;

# bless({...}, 'Venus::Process')

stdout

stdout(Str $path) (Process)

The stdout method redirects STDOUT to the path provided, typically /dev/null or some equivalent. If called with no arguments STDOUT will be restored to its default.

Since 0.06

stdout example 1

# given: synopsis;

$process = $parent->stdout;

# bless({...}, 'Venus::Process')

trap

trap(Str $name, Str | CodeRef $expr) (Process)

The trap method registers a process signal trap (or callback) which will be invoked whenever the current process receives that matching signal. The signal traps are globally installed and will overwrite any preexisting behavior. Signal traps are inherited by child processes (or forks) but can be overwritten using this method, or reverted to the default behavior by using the "untrap" method.

Since 0.06

trap example 1

# given: synopsis;

$parent = $parent->trap(term => sub{
  die 'Something failed!';
});

# bless({...}, 'Venus::Process')

untrap

untrap(Str $name) (Process)

The untrap method restores the process signal trap specified to its default behavior. If called with no arguments, restores all signal traps overwriting any user-defined signal traps in the current process.

Since 0.06

untrap example 1

# given: synopsis;

$parent->trap(chld => 'ignore');

$parent->trap(term => sub{
  die 'Something failed!';
});

$parent = $parent->untrap('term');

# bless({...}, 'Venus::Process')

untrap example 2

# given: synopsis;

$parent->trap(chld => 'ignore');

$parent->trap(term => sub{
  die 'Something failed!';
});

$parent = $parent->untrap;

# bless({...}, 'Venus::Process')

wait

wait(Int $pid) (Int, Int)

The wait method does a blocking "waitpid" operation and returns the wait status. In list context, returns the specified process' exit code (if terminated).

Since 0.06

wait example 1

package main;

use Venus::Process;

my $parent = Venus::Process->new;

my ($process, $pid) = $parent->fork;

if ($process) {
  # do something in forked process ...
  $process->exit;
}

my $check = $parent->wait($pid);

# 0

wait example 2

package main;

use Venus::Process;

my $parent = Venus::Process->new;

my ($process, $pid) = $parent->fork;

if ($process) {
  # do something in forked process ...
  $process->exit;
}

my ($check, $status) = $parent->wait('00000');

# (-1, -1)

wait example 3

package main;

use Venus::Process;

my $parent = Venus::Process->new;

my ($process, $pid) = $parent->fork(sub{
  $_->exit(1);
});

if ($process) {
  # do something in forked process ...
  $process->exit;
}

my ($check, $status) = $parent->wait($pid);

# ($pid, 1)

work

work(Str | CodeRef $code, Any @args) (Int)

The work method forks the current process, runs the callback provided in the child process, and immediately exits after. This method returns the PID of the child process. It is recommended to install an "alarm" in the child process (i.e. callback) to avoid creating zombie processed in situations where the parent process might exit before the child process is done working.

Since 0.06

work example 1

# given: synopsis;

my $pid = $parent->work(sub{
  my ($process) = @_;
  # do something in forked process ...
  $process->exit;
});

# $pid

AUTHORS

Cpanery, cpanery@cpan.org

LICENSE

Read the "license" file.

To install Venus, copy and paste the appropriate command in to your terminal.

cpanm

cpanm Venus

CPAN shell

perl -MCPAN -e shell
install Venus

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

ABSTRACT

SYNOPSIS

DESCRIPTION

INHERITS

INTEGRATES

METHODS

chdir

check

daemon

disengage

engage

exit

fork

forks

kill

setsid

stderr

stdin

stdout

trap

untrap

wait

work

AUTHORS

LICENSE

Module Install Instructions