/ 
IO-Async-0.19
River stage three • 121 direct dependents • 154 total dependents
/ IO::Async::Loop

NAME

IO::Async::Loop - core loop of the IO::Async framework

SYNOPSIS

use IO::Async::Loop;

my $loop = IO::Async::Loop->new();

$loop->enqueue_timer(
   delay => 10,
   code  => sub { print "10 seconds have passed\n" },
);

$loop->add( IO::Async::Stream->new(
   read_handle => \*STDIN,

   on_read => sub {
      my ( $self, $buffref, $closed ) = @_;

      if( $$buffref =~ s/^(.*)\n// ) {
         print "You typed a line $1\n";
         return 1;
      }

      return 0;
   },
);

$loop->loop_forever();

DESCRIPTION

This module provides an abstract class which implements the core loop of the IO::Async framework. Its primary purpose is to store a set of IO::Async::Notifier objects or subclasses of them. It handles all of the lower-level set manipulation actions, and leaves the actual IO readiness testing/notification to the concrete class that implements it. It also provides other functionallity such as signal handling, child process managing, and timers.

See also the two bundled Loop subclasses:

IO::Async::Loop::Select
IO::Async::Loop::IO_Poll

Or other subclasses that may appear on CPAN which are not part of the core IO::Async distribution.

MAGIC CONSTRUCTOR

$loop = IO::Async::Loop->new()

This function attempts to find a good subclass to use, then calls its constructor. It works by making a list of likely candidate classes, then trying each one in turn, requireing the module then calling its new method. If either of these operations fails, the next subclass is tried. If no class was successful, then an exception is thrown.

The list of candidates is formed from the following choices, in this order:

  • $ENV{IO_ASYNC_LOOP}

    If this environment variable is set, it should contain a comma-separated list of subclass names. These names may or may not be fully-qualified; if a name does not contain :: then it will have IO::Async::Loop:: prepended to it. This allows the end-user to specify a particular choice to fit the needs of his use of a program using IO::Async.

  • $IO::Async::Loop::LOOP

    If this scalar is set, it should contain a comma-separated list of subclass names. These may or may not be fully-qualified, as with the above case. This allows a program author to suggest a loop module to use.

    In cases where the module subclass is a hard requirement, such as GTK programs using Glib, it would be better to use the module specifically and invoke its constructor directly.

  • $^O

    The module called IO::Async::Loop::$^O is tried next. This allows specific OSes, such as the ever-tricky MSWin32, to provide an implementation that might be more efficient than the generic ones, or even work at all.

  • IO_Poll and Select

    Finally, if no other choice has been made by now, the built-in IO_Poll module is chosen. This should always work, but in case it doesn't, the Select module will be chosen afterwards as a last-case attempt. If this also fails, then the magic constructor itself will throw an exception.

METHODS

$loop->add( $notifier )

This method adds another notifier object to the stored collection. The object may be a IO::Async::Notifier, or any subclass of it.

$loop->remove( $notifier )

This method removes a notifier object from the stored collection.

$loop->attach_signal( $signal, $code )

This method adds a new signal handler to watch the given signal.

$signal

The name of the signal to attach to. This should be a bare name like TERM.

$code

A CODE reference to the handling callback.

Attaching to SIGCHLD is not recommended because of the way all child processes use it to report their termination. Instead, the watch_child method should be used to watch for termination of a given child process. A warning will be printed if SIGCHLD is passed here, but in future versions of IO::Async this behaviour may be disallowed altogether.

See also POSIX for the SIGname constants.

$loop->detach_signal( $signal )

This method removes the signal handler for the given signal.

$signal

The name of the signal to attach to. This should be a bare name like TERM.

$loop->enable_childmanager

This method enables the child manager, which allows use of the watch_child() methods without a race condition.

The child manager will be automatically enabled if required; so this method does not need to be explicitly called for other *_child() methods.

$loop->disable_childmanager

This method disables the child manager.

$loop->watch_child( $pid, $code )

This method adds a new handler for the termination of the given child PID.

Because the process represented by $pid may already have exited by the time this method is called, the child manager should already have been enabled before it was fork()ed, by calling enable_childmanager. If this is not done, then a SIGCHLD signal may have been missed, and the exit of this child process will not be reported.

$pid = $loop->detach_child( %params )

This method creates a new child process to run a given code block. For more detail, see the detach_child() method on the IO::Async::ChildManager class.

$code = $loop->detach_code( %params )

This method creates a new detached code object. It is equivalent to calling the IO::Async::DetachedCode constructor, passing in the given loop. See the documentation on this class for more information.

$loop->spawn_child( %params )

This method creates a new child process to run a given code block or command. For more detail, see the detach_child() method on the IO::Async::ChildManager class.

$loop->open_child( %params )

This method creates a new child process to run the given code block or command, and attaches filehandles to it that the parent will watch. For more detail, see the open_child() method on the IO::Async::ChildManager class.

$loop->run_child( %params )

This method creates a new child process to run the given code block or command, captures its STDOUT and STDERR streams, and passes them to the given continuation. For more detail see the run_child() method on the IO::Async::ChildManager class.

$id = $loop->enqueue_timer( %params )

This method installs a callback which will be called at the specified time. The time may either be specified as an absolute value (the time key), or as a delay from the time it is installed (the delay key).

The returned $id value can be used to identify the timer in case it needs to be cancelled by the cancel_timer() method. Note that this value may be an object reference, so if it is stored, it should be released after it has been fired or cancelled, so the object itself can be freed.

The %params hash takes the following keys:

time => NUM

The absolute system timestamp to run the event.

delay => NUM

The delay after now at which to run the event.

now => NUM

The time to consider as now; defaults to time() if not specified.

code => CODE

CODE reference to the continuation to run at the allotted time.

If the Time::HiRes module is loaded, then it is used to obtain the current time which is used for the delay calculation. If this behaviour is required, the Time::HiRes module must be loaded before IO::Async::Loop:

use Time::HiRes;
use IO::Async::Loop;

$loop->cancel_timer( $id )

Cancels a previously-enqueued timer event by removing it from the queue.

$newid = $loop->requeue_timer( $id, %params )

Reschedule an existing timer, moving it to a new time. The old timer is removed and will not be invoked.

The %params hash takes the same keys as enqueue_timer(), except for the code argument.

The requeue operation may be implemented as a cancel + enqueue, which may mean the ID changes. Be sure to store the returned $newid value if it is required.

$loop->resolve( %params )

This method performs a single name resolution operation. It uses an internally-stored IO::Async::Resolver object. For more detail, see the resolve() method on the IO::Async::Resolver class.

$loop->connect( %params )

This method performs a non-blocking connect operation. It uses an internally-stored IO::Async::Connector object. For more detail, see the connect() method on the IO::Async::Connector class.

$loop->listen( %params )

This method sets up a listening socket. It uses an internally-stored IO::Async::Listener object. For more detail, see the listen() method on the IO::Async::Listener class.

$count = $loop->loop_once( $timeout )

This method performs a single wait loop using the specific subclass's underlying mechanism. If $timeout is undef, then no timeout is applied, and it will wait until an event occurs. The intention of the return value is to indicate the number of callbacks that this loop executed, though different subclasses vary in how accurately they can report this. See the documentation for this method in the specific subclass for more information.

$loop->loop_forever()

This method repeatedly calls the loop_once method with no timeout (i.e. allowing the underlying mechanism to block indefinitely), until the loop_stop method is called from an event callback.

$loop->loop_stop()

This method cancels a running loop_forever, and makes that method return. It would be called from an event callback triggered by an event that occured within the loop.

OS ABSTRACTIONS

Because the Magic Constructor searches for OS-specific subclasses of the Loop, several abstractions of OS services are provided, in case specific OSes need to give different implementations on that OS.

( $S1, $S2 ) = $loop->socketpair( $family, $socktype, $proto )

An abstraction of the socketpair() syscall, where any argument may be missing (or given as undef).

If $family is not provided, a suitable value will be provided by the OS (likely AF_UNIX on POSIX-based platforms). If $socktype is not provided, then SOCK_STREAM will be used.

( $rd, $wr ) = $loop->pipepair()

An abstraction of the pipe() syscall, which returns the two new handles.

( $rdA, $wrA, $rdB, $wrB ) = $loop->pipequad()

This method is intended for creating two pairs of filehandles that are linked together, suitable for passing as the STDIN/STDOUT pair to a child process. After this function returns, $rdA and $wrA will be a linked pair, as will $rdB and $wrB.

On platforms that support socketpair(), this implementation will be preferred, in which case $rdA and $wrB will actually be the same filehandle, as will $rdB and $wrA. This saves a file descriptor in the parent process.

When creating a IO::Async::Stream or subclass of it, the read_handle and write_handle parameters should always be used.

my ( $childRd, $myWr, $myRd, $childWr ) = $loop->pipequad();

$loop->open_child(
   stdin  => $childRd,
   stdout => $childWr,
   ...
);

my $str = IO::Async::Stream->new(
   read_handle  => $myRd,
   write_handle => $myWr,
   ...
);
$loop->add( $str );

AUTHOR

Paul Evans <leonerd@leonerd.org.uk>