Provided by: libmojo-ioloop-readwriteprocess-perl_0.32-1_all 
NAME
Mojo::IOLoop::ReadWriteProcess::Session - Session manager for handling child processes.
SYNOPSIS
use Mojo::IOLoop::ReadWriteProcess::Session;
use Mojo::IOLoop::ReadWriteProcess qw(process);
my $session = process()->session; # or Mojo::IOLoop::ReadWriteProcess::Session->singleton
$session->enable; # Modifies your SIG_CHLD
$session->on(collected => sub { warn "Process ".(shift->pid)." collected! "});
$session->on(collected_orphan => sub { warn "Orphan process collected! "});
$session->enable_subreaper(); # Mark the current process as subreaper
$session->disable_subreaper(); # Disable subreaper
$session->reset(); # Resets events and clear the process tables
$session->clean(); # Stop all processes that result as running and reset
DESCRIPTION
Mojo::IOLoop::ReadWriteProcess::Session is a session manager for the collected processes
EVENTS
Mojo::IOLoop::ReadWriteProcess::Session inherits all events from Mojo::EventEmitter and
can emit the following new ones.
SIG_CHLD
$session->on(SIG_CHLD => sub {
my ($self) = @_;
...
});
Emitted when we receive SIG_CHLD.
collected
$session->on(collected => sub {
my ($self, $process) = @_;
...
});
Emitted when child process is collected and it's return status is available.
protect
$session->on(protect => sub {
my ($self, $detail) = @_;
my ($cb, $signal) = @$detail;
...
});
Emitted when protected callbacks are fired.
collected_orphan
$session->on(collected_orphan => sub {
my ($self, $process) = @_;
$process->pid;
$process->exit_status;
...
});
Emitted when child process is collected and it's exit status is available. Note: here are
collected processes that weren't created with Mojo::IOLoop::ReadWriteProcess.
register
$session->on(register => sub {
my ($self, $process) = @_;
$process->pid;
$process->exit_status;
...
});
Emitted when a process is registering to a session.
ATTRIBUTES
Mojo::IOLoop::ReadWriteProcess::Session inherits all attributes from Mojo::EventEmitter
and implements the following new ones.
subreaper
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
session->enable_subreaper;
my $process = Mojo::IOLoop::ReadWriteProcess->new(code => sub { print "Hello ".$_[1] }, args => "User" );
$process->start();
$process->on( stop => sub { shift()->disable_subreaper } );
$process->stop();
# The process will print "Hello User"
Mark the current process (not the child) as subreaper on start. It's on invoker behalf to
disable subreaper when process stops, as it marks the current process and not the child.
collect_status
Defaults to 1, If enabled it will automatically collect the status of the children
process. Disable it in case you want to manage your process child directly, and do not
want to rely on automatic collect status. If you won't overwrite your "SIGCHLD" handler,
the "SIG_CHLD" event will be still emitted.
handler()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
session->handler(sub {});
Default handler for SIG_CHLD processing, used when "disable()" is invoked.
METHODS
Mojo::IOLoop::ReadWriteProcess::Session inherits all methods from Mojo::EventEmitter and
implements the following new ones.
enable()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
session->enable();
Sets the SIG_CHLD handler.
disable()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
session->disable();
Disables the SIG_CHLD handler and reset with the previous one.
enable_subreaper()
use Mojo::IOLoop::ReadWriteProcess qw(process);
my $p = process()->enable_subreaper;
# or
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
session->enable_subreaper;
Mark the current process (not the child) as subreaper. This is used typically if you want
to mark further children as subreapers inside other forks.
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
my $master_p = process(
sub {
my $p = shift;
$p->enable_subreaper;
process(sub { sleep 4; exit 1 })->start();
process(
sub {
sleep 4;
process(sub { sleep 1; })->start();
})->start();
process(sub { sleep 4; exit 0 })->start();
process(sub { sleep 4; die })->start();
my $manager
= process(sub { sleep 2 })->subreaper(1)->start();
sleep 1 for (0 .. 10);
$manager->stop;
return session->all->size;
});
$master_p->subreaper(1);
$master_p->on(collect_status => sub { $status++ });
$master_p->on(stop => sub { shift()->disable_subreaper });
$master_p->start();
session->all->size();
....
disable_subreaper()
use Mojo::IOLoop::ReadWriteProcess qw(process);
my $p = process()->disable_subreaper;
Unset the current process as subreaper.
prctl()
use Mojo::IOLoop::ReadWriteProcess qw(process);
my $p = process();
$p->prctl($option, $arg2, $arg3, $arg4, $arg5);
Internal function to execute and wrap the prctl syscall, accepts the same arguments as
prctl.
reset()
use Mojo::IOLoop::ReadWriteProcess qw(session);
session->reset;
Wipe the process tables.
clean()
use Mojo::IOLoop::ReadWriteProcess qw(session);
session->clean;
Wipe the process tables, but before attempt to stop running procesess.
all()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
my $collection = session->all;
$collection->size;
Returns a Mojo::Collection of Mojo::IOLoop::ReadWriteProcess that belongs to a session.
all_orphans()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
my $collection = session->all_orphans;
$collection->size;
Returns a Mojo::Collection of Mojo::IOLoop::ReadWriteProcess of orphaned processes that
belongs to a session. They are automatically turned into a
Mojo::IOLoop::ReadWriteProcess, also if processes were created by "fork()".
all_processes()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
my $collection = session->all_processes;
$collection->size;
Returns a Mojo::Collection of all Mojo::IOLoop::ReadWriteProcess known processes that
belongs to a session.
contains()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
my $collection = session->contains(13443);
$collection->size;
Returns true if the pid is contained in any of the process tables.
resolve()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
my $process = session->resolve(12233);
Returns the Mojo::IOLoop::ReadWriteProcess process identified by its pid if belongs to the
process table.
orphan()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
my $process = session->orphan(12233);
Returns the Mojo::IOLoop::ReadWriteProcess process identified by its pid if belongs to the
process table of unknown processes.
register()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
my $process = session->register('pid' => Mojo::IOLoop::ReadWriteProcess->new);
Register the Mojo::IOLoop::ReadWriteProcess process to the session.
unregister()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
my $process = session->unregister(123342);
Unregister the corresponding Mojo::IOLoop::ReadWriteProcess with the given pid.
collect()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
my $process = session->collect(123342 => 0 => undef);
Collect the status for the given pid.
protect()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
use POSIX;
my $return = session->protect(sub { print "Hello World\n" });
session->protect(sub { print "Hello World\n" } => SIGTERM);
Try to protect the execution of the callback from signal interrupts.
EXPORTS
session()
use Mojo::IOLoop::ReadWriteProcess::Session qw(session);
session->enable_subreaper;
Returns the Mojo::IOLoop::ReadWriteProcess::Session singleton.
DEBUGGING
You can set the MOJO_EVENTEMITTER_DEBUG environment variable to get some advanced
diagnostics information printed to STDERR.
MOJO_EVENTEMITTER_DEBUG=1
Also, you can set MOJO_PROCESS_DEBUG environment variable to get diagnostics about the
process execution.
MOJO_PROCESS_DEBUG=1
LICENSE
Copyright (C) Ettore Di Giacinto.
This library is free software; you can redistribute it and/or modify it under the same
terms as Perl itself.
AUTHOR
Ettore Di Giacinto <edigiacinto@suse.com>
perl v5.34.0 2022-02-2Mojo::IOLoop::ReadWriteProcess::Session(3pm)