NAME

Mojo::IOLoop::ForkCall - (DEPRECATED) run blocking functions asynchronously by forking

SYNOPSIS

 use Mojo::IOLoop::ForkCall
 my $fc = Mojo::IOLoop::ForkCall->new;
 $fc->run(
   \&expensive_function,
   ['arg', 'list'],
   sub { my ($fc, $err, @return) = @_; ... }
 );
 $fc->ioloop->start unless $fc->ioloop->is_running;

DESCRIPTION

DEPRECATED!

This module is deprecated in favor of the Mojolicious core module Mojo::IOLoop::Subprocess, which was inspired by this module. While the author does not intend to remove this module from CPAN it will certainly receive less effort and new code should use the core module. Possibly in the future this will just be an alias to that core module.

Asynchronous programming can be benefitial for performance, however not all functions are written for nonblocking interaction and external processes almost never are. Still, all is not lost.

By forking the blocking call into a new process, the main thread may continue to run non-blocking, while the blocking call evaluates. Mojo::IOLoop::ForkCall manages the forking and will emit an event (or execute a callback) when the forked process completes. Return values are serialized and sent from the child to the parent via an appropriate pipe for your platform.

This module is heavily inspired by AnyEvent::Util's "fork_call".

For simple cases in a Mojolicious web app, a helper is also available in Mojolicious::Plugin::ForkCall.

WARNINGS

Some platforms do not fork well, some platforms don't pipe well. This module and the libraries it relies on do their best to smooth over these differences. Still some attention should be paid to platform specific usage, especially on Windows. Efficiency/performance on Windows is not likely to be very good.

N.B. There was previously a warning about using event-based programming in the child. As of version 0.10, this warning is lifted as the child process will reset the singleton loop, as well as the loop refered to in the ForkCall instance. Still, use with caution, and no running with scissors!

EVENTS

This module inherits all events from Mojo::EventEmitter and implements the following addtional ones.

error

 $fc->on( error => sub { my ($fc, $err) = @_; } );

Emitted in the parent when the parent process encounters an error. Fatal if not handled.

finish

 $fc->on( finish => sub {
   my ($fc, $err, @return_values) = @_;
   ...
 });

Emitted in the parent process once the child process completes and sends its results. The callback is passed the ForkCall instance, any error, then all deserialized results from the child. Note that this event is called for each "run" completion; to schedule a callback for a single call, pass the callback to "run" itself.

spawn

 $fc->on( spawn => sub { my ($fc, $child_pid) = @_; ... } );

Emitted in the parent process when a child process is spawned. The callback is passed the ForkCall instance and the child pid.

ATTRIBUTES

This module inherits all attributes from Mojo::EventEmitter and implements the following additional ones.

ioloop

The Mojo::IOLoop instance which is used internally. Defaults to "Mojo::IOLoop->singleton".

serializer

A code reference to serialize the results of the child process to send to the parent. Note that as this code reference is called in the child, some care should be taken when setting it to something other than the defaults. Defaults to "\&Storable::freeze".

The code reference will be passed a single array reference. The first argument will be any error or undef if no error occured. If there was no error, the remaining elements of the array will be the values returned by the job (evaluated in list context).

deserializer

A code reference used to deserialize the results of the child process. Defaults to "\&Storable::thaw". This should be the logical inverse of the "serializer".

weaken

If true, the reference to the ForkCall object will be weakened in the internals to prevent a possible memory leak should the child process never close. In this case, if you do not maintain a reference to the ForkCall object, the first argument to the callback will be undef. Additionally, the finish event may not be emitted. Defaults to false. Do not use this unless you know what you are doing and why!

METHODS

This module inherits all METHODS from Mojo::EventEmitter and implements the following additional ones.

run

 my $fc = Mojo::IOLoop::ForkCall->new;
 $fc = $fc->run(
   sub { my @args = @_; ... return @res },
   \@args,
   sub { my ($fc, $err, @return_values) = @_; ... }
 );

Takes a code reference (required) which is the job to be run on the child. If the next argument is an array reference, these will be passed to the child job. If the last argument is a code reference, it will be called immediately before the finish event is emitted, its arguments are the same as the "finish" event.

EXPORTED FUNCTIONS

Upon request this module exports the following functions.

fork_call

 fork_call { my @args = @_; child code; return @res } @args, sub { my @res = @_; parent callback }

This function is a drop-in replacement for AnyEvent::Util's "fork_call", with the exception of the fork limiting/queueing that that function provides. Because it is attempting to mimic that function the api is different to that provided by the OO interface descibed above. This function is provided for ease of porting from AnyEvent's function; for new code, please use the OO syntax.

The function takes a block to be performed in the child, a list of arguments to pass to the block, and a callback to be run on completion. Note that the callback is required and that the arguments are given as a list, not an arrayreference (unlike the OO style). The callback will receive the deserialized return values from the child block as @_. Any error will be available in $@.

The underlying ForkCall object will use its default attributes. The return value is the created ForkCall instance.

WARNING: In Perl versions before 5.14, if the parent callback dies, the exception is silently ignored. This is a limitation in those Perl interpreters and was fixed in 5.14. Yet another reason to use the object-oriented interface, which does not suffer from this limitation!

FUTURE WORK

•: Investigate hooking into the "timeout" in Mojo::IOLoop::Stream event to kill runaway children.

KNOWN ISSUES

•: Although in concept this module works on windows, in practical cases running real-world apps with this module on windows might spectularly crash. This is unfortunately not solvable from the Perl level and must be addressed in the C level interpreter code. The good news is that recent interpreters seem not to be having this issue. See <https://github.com/jberger/Mojo-IOLoop-ForkCall/issues/5>.

SOURCE REPOSITORY

<http://github.com/jberger/Mojo-IOLoop-ForkCall>

AUTHOR

Joel Berger, <joel.a.berger@gmail.com>

CONTRIBUTORS

Dan Book (Grinnz)

COPYRIGHT AND LICENSE

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.