ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent/lib/AnyEvent.pm
(Generate patch)

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.242 by root, Fri Jul 17 22:05:12 2009 UTC vs.
Revision 1.264 by root, Wed Jul 29 12:42:09 2009 UTC

1=head1 NAME 1=head1 NAME
2 2
3AnyEvent - provide framework for multiple event loops 3AnyEvent - the DBI of event loop programming
4 4
5EV, Event, Glib, Tk, Perl, Event::Lib, Qt and POE are various supported 5EV, Event, Glib, Tk, Perl, Event::Lib, Irssi, rxvt-unicode, IO::Async, Qt
6event loops. 6and POE are various supported event loops/environments.
7 7
8=head1 SYNOPSIS 8=head1 SYNOPSIS
9 9
10 use AnyEvent; 10 use AnyEvent;
11 11
… …
40=head1 INTRODUCTION/TUTORIAL 40=head1 INTRODUCTION/TUTORIAL
41 41
42This manpage is mainly a reference manual. If you are interested 42This manpage is mainly a reference manual. If you are interested
43in a tutorial or some gentle introduction, have a look at the 43in a tutorial or some gentle introduction, have a look at the
44L<AnyEvent::Intro> manpage. 44L<AnyEvent::Intro> manpage.
45
46=head1 SUPPORT
47
48There is a mailinglist for discussing all things AnyEvent, and an IRC
49channel, too.
50
51See the AnyEvent project page at the B<Schmorpforge Ta-Sa Software
52Repository>, at L<http://anyevent.schmorp.de>, for more info.
45 53
46=head1 WHY YOU SHOULD USE THIS MODULE (OR NOT) 54=head1 WHY YOU SHOULD USE THIS MODULE (OR NOT)
47 55
48Glib, POE, IO::Async, Event... CPAN offers event models by the dozen 56Glib, POE, IO::Async, Event... CPAN offers event models by the dozen
49nowadays. So what is different about AnyEvent? 57nowadays. So what is different about AnyEvent?
… …
368 376
369This watcher might use C<%SIG> (depending on the event loop used), 377This watcher might use C<%SIG> (depending on the event loop used),
370so programs overwriting those signals directly will likely not work 378so programs overwriting those signals directly will likely not work
371correctly. 379correctly.
372 380
381Example: exit on SIGINT
382
383 my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
384
385=head3 Signal Races, Delays and Workarounds
386
373Also note that many event loops (e.g. Glib, Tk, Qt, IO::Async) do not 387Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching
374support attaching callbacks to signals, which is a pity, as you cannot do 388callbacks to signals in a generic way, which is a pity, as you cannot do
375race-free signal handling in perl. AnyEvent will try to do it's best, but 389race-free signal handling in perl. AnyEvent will try to do it's best, but
376in some cases, signals will be delayed. The maximum time a signal might 390in some cases, signals will be delayed. The maximum time a signal might
377be delayed is specified in C<$AnyEvent::MAX_SIGNAL_LATENCY> (default: 10 391be delayed is specified in C<$AnyEvent::MAX_SIGNAL_LATENCY> (default: 10
378seconds). This variable can be changed only before the first signal 392seconds). This variable can be changed only before the first signal
379watcher is created, and should be left alone otherwise. Higher values 393watcher is created, and should be left alone otherwise. Higher values
380will cause fewer spurious wake-ups, which is better for power and CPU 394will cause fewer spurious wake-ups, which is better for power and CPU
381saving. All these problems can be avoided by installing the optional 395saving. All these problems can be avoided by installing the optional
382L<Async::Interrupt> module. 396L<Async::Interrupt> module. This will not work with inherently broken
383 397event loops such as L<Event> or L<Event::Lib> (and not with L<POE>
384Example: exit on SIGINT 398currently, as POE does it's own workaround with one-second latency). With
385 399those, you just have to suffer the delays.
386 my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
387 400
388=head2 CHILD PROCESS WATCHERS 401=head2 CHILD PROCESS WATCHERS
389 402
390You can also watch on a child process exit and catch its exit status. 403You can also watch on a child process exit and catch its exit status.
391 404
392The child process is specified by the C<pid> argument (if set to C<0>, it 405The child process is specified by the C<pid> argument (one some backends,
393watches for any child process exit). The watcher will triggered only when 406using C<0> watches for any child process exit, on others this will
394the child process has finished and an exit status is available, not on 407croak). The watcher will be triggered only when the child process has
395any trace events (stopped/continued). 408finished and an exit status is available, not on any trace events
409(stopped/continued).
396 410
397The callback will be called with the pid and exit status (as returned by 411The callback will be called with the pid and exit status (as returned by
398waitpid), so unlike other watcher types, you I<can> rely on child watcher 412waitpid), so unlike other watcher types, you I<can> rely on child watcher
399callback arguments. 413callback arguments.
400 414
… …
504Condition variables are similar to callbacks, except that you can 518Condition variables are similar to callbacks, except that you can
505optionally wait for them. They can also be called merge points - points 519optionally wait for them. They can also be called merge points - points
506in time where multiple outstanding events have been processed. And yet 520in time where multiple outstanding events have been processed. And yet
507another way to call them is transactions - each condition variable can be 521another way to call them is transactions - each condition variable can be
508used to represent a transaction, which finishes at some point and delivers 522used to represent a transaction, which finishes at some point and delivers
509a result. 523a result. And yet some people know them as "futures" - a promise to
524compute/deliver something that you can wait for.
510 525
511Condition variables are very useful to signal that something has finished, 526Condition variables are very useful to signal that something has finished,
512for example, if you write a module that does asynchronous http requests, 527for example, if you write a module that does asynchronous http requests,
513then a condition variable would be the ideal candidate to signal the 528then a condition variable would be the ideal candidate to signal the
514availability of results. The user can either act when the callback is 529availability of results. The user can either act when the callback is
… …
782 797
783 AnyEvent::Impl::Glib based on Glib, slow but very stable. 798 AnyEvent::Impl::Glib based on Glib, slow but very stable.
784 AnyEvent::Impl::Tk based on Tk, very broken. 799 AnyEvent::Impl::Tk based on Tk, very broken.
785 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse. 800 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
786 AnyEvent::Impl::POE based on POE, very slow, some limitations. 801 AnyEvent::Impl::POE based on POE, very slow, some limitations.
802 AnyEvent::Impl::Irssi used when running within irssi.
787 803
788=item Backends with special needs. 804=item Backends with special needs.
789 805
790Qt requires the Qt::Application to be instantiated first, but will 806Qt requires the Qt::Application to be instantiated first, but will
791otherwise be picked up automatically. As long as the main program 807otherwise be picked up automatically. As long as the main program
… …
865event module detection too early, for example, L<AnyEvent::AIO> creates 881event module detection too early, for example, L<AnyEvent::AIO> creates
866and installs the global L<IO::AIO> watcher in a C<post_detect> block to 882and installs the global L<IO::AIO> watcher in a C<post_detect> block to
867avoid autodetecting the event module at load time. 883avoid autodetecting the event module at load time.
868 884
869If called in scalar or list context, then it creates and returns an object 885If called in scalar or list context, then it creates and returns an object
870that automatically removes the callback again when it is destroyed. See 886that automatically removes the callback again when it is destroyed (or
887C<undef> when the hook was immediately executed). See L<AnyEvent::AIO> for
871L<Coro::BDB> for a case where this is useful. 888a case where this is useful.
889
890Example: Create a watcher for the IO::AIO module and store it in
891C<$WATCHER>. Only do so after the event loop is initialised, though.
892
893 our WATCHER;
894
895 my $guard = AnyEvent::post_detect {
896 $WATCHER = AnyEvent->io (fh => IO::AIO::poll_fileno, poll => 'r', cb => \&IO::AIO::poll_cb);
897 };
898
899 # the ||= is important in case post_detect immediately runs the block,
900 # as to not clobber the newly-created watcher. assigning both watcher and
901 # post_detect guard to the same variable has the advantage of users being
902 # able to just C<undef $WATCHER> if the watcher causes them grief.
903
904 $WATCHER ||= $guard;
872 905
873=item @AnyEvent::post_detect 906=item @AnyEvent::post_detect
874 907
875If there are any code references in this array (you can C<push> to it 908If there are any code references in this array (you can C<push> to it
876before or after loading AnyEvent), then they will called directly after 909before or after loading AnyEvent), then they will called directly after
… …
1041 1074
1042=cut 1075=cut
1043 1076
1044package AnyEvent; 1077package AnyEvent;
1045 1078
1079# basically a tuned-down version of common::sense
1080sub common_sense {
1046no warnings; 1081 # no warnings
1082 ${^WARNING_BITS} ^= ${^WARNING_BITS};
1047use strict qw(vars subs); 1083 # use strict vars subs
1084 $^H |= 0x00000600;
1085}
1086
1087BEGIN { AnyEvent::common_sense }
1048 1088
1049use Carp (); 1089use Carp ();
1050 1090
1051our $VERSION = 4.83; 1091our $VERSION = 4.881;
1052our $MODEL; 1092our $MODEL;
1053 1093
1054our $AUTOLOAD; 1094our $AUTOLOAD;
1055our @ISA; 1095our @ISA;
1056 1096
… …
1081 for reverse split /\s*,\s*/, 1121 for reverse split /\s*,\s*/,
1082 $ENV{PERL_ANYEVENT_PROTOCOLS} || "ipv4,ipv6"; 1122 $ENV{PERL_ANYEVENT_PROTOCOLS} || "ipv4,ipv6";
1083} 1123}
1084 1124
1085my @models = ( 1125my @models = (
1086 [EV:: => AnyEvent::Impl::EV::], 1126 [EV:: => AnyEvent::Impl::EV:: , 1],
1087 [Event:: => AnyEvent::Impl::Event::], 1127 [Event:: => AnyEvent::Impl::Event::, 1],
1088 [AnyEvent::Impl::Perl:: => AnyEvent::Impl::Perl::], 1128 [AnyEvent::Impl::Perl:: => AnyEvent::Impl::Perl:: , 1],
1089 # everything below here will not be autoprobed 1129 # everything below here will not (normally) be autoprobed
1090 # as the pureperl backend should work everywhere 1130 # as the pureperl backend should work everywhere
1091 # and is usually faster 1131 # and is usually faster
1092 [Glib:: => AnyEvent::Impl::Glib::], # becomes extremely slow with many watchers 1132 [Glib:: => AnyEvent::Impl::Glib:: , 1], # becomes extremely slow with many watchers
1093 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy 1133 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy
1134 [Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package
1094 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles 1135 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles
1095 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program 1136 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program
1096 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza 1137 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza
1097 [Wx:: => AnyEvent::Impl::POE::], 1138 [Wx:: => AnyEvent::Impl::POE::],
1098 [Prima:: => AnyEvent::Impl::POE::], 1139 [Prima:: => AnyEvent::Impl::POE::],
1099 # IO::Async is just too broken - we would need workarounds for its 1140 # IO::Async is just too broken - we would need workarounds for its
1100 # byzantine signal and broken child handling, among others. 1141 # byzantine signal and broken child handling, among others.
1101 # IO::Async is rather hard to detect, as it doesn't have any 1142 # IO::Async is rather hard to detect, as it doesn't have any
1102 # obvious default class. 1143 # obvious default class.
1103# [IO::Async:: => AnyEvent::Impl::IOAsync::], # requires special main program 1144# [0, IO::Async:: => AnyEvent::Impl::IOAsync::], # requires special main program
1104# [IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # requires special main program 1145# [0, IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # requires special main program
1105# [IO::Async::Notifier:: => AnyEvent::Impl::IOAsync::], # requires special main program 1146# [0, IO::Async::Notifier:: => AnyEvent::Impl::IOAsync::], # requires special main program
1106); 1147);
1107 1148
1108our %method = map +($_ => 1), 1149our %method = map +($_ => 1),
1109 qw(io timer time now now_update signal child idle condvar one_event DESTROY); 1150 qw(io timer time now now_update signal child idle condvar one_event DESTROY);
1110 1151
… …
1114 my ($cb) = @_; 1155 my ($cb) = @_;
1115 1156
1116 if ($MODEL) { 1157 if ($MODEL) {
1117 $cb->(); 1158 $cb->();
1118 1159
1119 1 1160 undef
1120 } else { 1161 } else {
1121 push @post_detect, $cb; 1162 push @post_detect, $cb;
1122 1163
1123 defined wantarray 1164 defined wantarray
1124 ? bless \$cb, "AnyEvent::Util::postdetect" 1165 ? bless \$cb, "AnyEvent::Util::postdetect"
… …
1130 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1171 @post_detect = grep $_ != ${$_[0]}, @post_detect;
1131} 1172}
1132 1173
1133sub detect() { 1174sub detect() {
1134 unless ($MODEL) { 1175 unless ($MODEL) {
1135 no strict 'refs';
1136 local $SIG{__DIE__}; 1176 local $SIG{__DIE__};
1137 1177
1138 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) { 1178 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) {
1139 my $model = "AnyEvent::Impl::$1"; 1179 my $model = "AnyEvent::Impl::$1";
1140 if (eval "require $model") { 1180 if (eval "require $model") {
… …
1157 } 1197 }
1158 } 1198 }
1159 } 1199 }
1160 1200
1161 unless ($MODEL) { 1201 unless ($MODEL) {
1162 # try to load a model 1202 # try to autoload a model
1163
1164 for (@REGISTRY, @models) { 1203 for (@REGISTRY, @models) {
1165 my ($package, $model) = @$_; 1204 my ($package, $model, $autoload) = @$_;
1205 if (
1206 $autoload
1166 if (eval "require $package" 1207 and eval "require $package"
1167 and ${"$package\::VERSION"} > 0 1208 and ${"$package\::VERSION"} > 0
1168 and eval "require $model") { 1209 and eval "require $model"
1210 ) {
1169 $MODEL = $model; 1211 $MODEL = $model;
1170 warn "AnyEvent: autoprobed model '$model', using it.\n" if $VERBOSE >= 2; 1212 warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1171 last; 1213 last;
1172 } 1214 }
1173 } 1215 }
1174 1216
1175 $MODEL 1217 $MODEL
… …
1247} 1289}
1248 1290
1249# default implementation for ->signal 1291# default implementation for ->signal
1250 1292
1251our $HAVE_ASYNC_INTERRUPT; 1293our $HAVE_ASYNC_INTERRUPT;
1294
1295sub _have_async_interrupt() {
1296 $HAVE_ASYNC_INTERRUPT = 1*(!$ENV{PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT}
1297 && eval "use Async::Interrupt 1.0 (); 1")
1298 unless defined $HAVE_ASYNC_INTERRUPT;
1299
1300 $HAVE_ASYNC_INTERRUPT
1301}
1302
1252our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO); 1303our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
1253our (%SIG_ASY, %SIG_ASY_W); 1304our (%SIG_ASY, %SIG_ASY_W);
1254our ($SIG_COUNT, $SIG_TW); 1305our ($SIG_COUNT, $SIG_TW);
1255 1306
1256sub _signal_exec { 1307sub _signal_exec {
… …
1264 $_->() for values %{ $SIG_CB{$_} || {} }; 1315 $_->() for values %{ $SIG_CB{$_} || {} };
1265 } 1316 }
1266 } 1317 }
1267} 1318}
1268 1319
1320# install a dummy wakeup watcher to reduce signal catching latency
1321sub _sig_add() {
1322 unless ($SIG_COUNT++) {
1323 # try to align timer on a full-second boundary, if possible
1324 my $NOW = AnyEvent->now;
1325
1326 $SIG_TW = AnyEvent->timer (
1327 after => $MAX_SIGNAL_LATENCY - ($NOW - int $NOW),
1328 interval => $MAX_SIGNAL_LATENCY,
1329 cb => sub { }, # just for the PERL_ASYNC_CHECK
1330 );
1331 }
1332}
1333
1334sub _sig_del {
1335 undef $SIG_TW
1336 unless --$SIG_COUNT;
1337}
1338
1339our $_sig_name_init; $_sig_name_init = sub {
1340 undef $_sig_name_init;
1341
1342 if (_have_async_interrupt) {
1343 *sig2num = \&Async::Interrupt::sig2num;
1344 *sig2name = \&Async::Interrupt::sig2name;
1345 } else {
1346 require Config;
1347
1348 my %signame2num;
1349 @signame2num{ split ' ', $Config::Config{sig_name} }
1350 = split ' ', $Config::Config{sig_num};
1351
1352 my @signum2name;
1353 @signum2name[values %signame2num] = keys %signame2num;
1354
1355 *sig2num = sub($) {
1356 $_[0] > 0 ? shift : $signame2num{+shift}
1357 };
1358 *sig2name = sub ($) {
1359 $_[0] > 0 ? $signum2name[+shift] : shift
1360 };
1361 }
1362};
1363
1364sub sig2num ($) { &$_sig_name_init; &sig2num }
1365sub sig2name($) { &$_sig_name_init; &sig2name }
1366
1269sub _signal { 1367sub _signal {
1270 my (undef, %arg) = @_; 1368 my (undef, %arg) = @_;
1271 1369
1272 my $signal = uc $arg{signal} 1370 my $signal = uc $arg{signal}
1273 or Carp::croak "required option 'signal' is missing"; 1371 or Carp::croak "required option 'signal' is missing";
1274 1372
1275 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1276
1277 if ($HAVE_ASYNC_INTERRUPT) { 1373 if ($HAVE_ASYNC_INTERRUPT) {
1278 # async::interrupt 1374 # async::interrupt
1279 1375
1280 $SIG_ASY{$signal} ||= do { 1376 $signal = sig2num $signal;
1281 my $asy = new Async::Interrupt 1377 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1378
1379 $SIG_ASY{$signal} ||= new Async::Interrupt
1282 cb => sub { undef $SIG_EV{$signal} }, 1380 cb => sub { undef $SIG_EV{$signal} },
1283 signal => $signal, 1381 signal => $signal,
1284 pipe => [$SIGPIPE_R->filenos], 1382 pipe => [$SIGPIPE_R->filenos],
1285 ;
1286 $asy->pipe_autodrain (0); 1383 pipe_autodrain => 0,
1287
1288 $asy
1289 }; 1384 ;
1290 1385
1291 } else { 1386 } else {
1292 # pure perl 1387 # pure perl
1388
1389 # AE::Util has been loaded in signal
1390 $signal = sig2name $signal;
1391 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1293 1392
1294 $SIG{$signal} ||= sub { 1393 $SIG{$signal} ||= sub {
1295 local $!; 1394 local $!;
1296 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1395 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1297 undef $SIG_EV{$signal}; 1396 undef $SIG_EV{$signal};
1298 }; 1397 };
1299 1398
1300 # can't do signal processing without introducing races in pure perl, 1399 # can't do signal processing without introducing races in pure perl,
1301 # so limit the signal latency. 1400 # so limit the signal latency.
1302 ++$SIG_COUNT; 1401 _sig_add;
1303 $SIG_TW ||= AnyEvent->timer (
1304 after => $MAX_SIGNAL_LATENCY,
1305 interval => $MAX_SIGNAL_LATENCY,
1306 cb => sub { }, # just for the PERL_ASYNC_CHECK
1307 );
1308 } 1402 }
1309 1403
1310 bless [$signal, $arg{cb}], "AnyEvent::Base::signal" 1404 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1311} 1405}
1312 1406
1313sub signal { 1407sub signal {
1314 # probe for availability of Async::Interrupt 1408 # probe for availability of Async::Interrupt
1315 if (!$ENV{PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT} && eval "use Async::Interrupt 0.6 (); 1") { 1409 if (_have_async_interrupt) {
1316 warn "AnyEvent: using Async::Interrupt for race-free signal handling.\n" if $VERBOSE >= 8; 1410 warn "AnyEvent: using Async::Interrupt for race-free signal handling.\n" if $VERBOSE >= 8;
1317 1411
1318 $HAVE_ASYNC_INTERRUPT = 1;
1319 $SIGPIPE_R = new Async::Interrupt::EventPipe; 1412 $SIGPIPE_R = new Async::Interrupt::EventPipe;
1320 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R->fileno, poll => "r", cb => \&_signal_exec); 1413 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R->fileno, poll => "r", cb => \&_signal_exec);
1321 1414
1322 } else { 1415 } else {
1323 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8; 1416 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
… …
1351} 1444}
1352 1445
1353sub AnyEvent::Base::signal::DESTROY { 1446sub AnyEvent::Base::signal::DESTROY {
1354 my ($signal, $cb) = @{$_[0]}; 1447 my ($signal, $cb) = @{$_[0]};
1355 1448
1356 undef $SIG_TW 1449 _sig_del;
1357 unless --$SIG_COUNT;
1358 1450
1359 delete $SIG_CB{$signal}{$cb}; 1451 delete $SIG_CB{$signal}{$cb};
1360 1452
1453 $HAVE_ASYNC_INTERRUPT
1454 ? delete $SIG_ASY{$signal}
1361 # delete doesn't work with older perls - they then 1455 : # delete doesn't work with older perls - they then
1362 # print weird messages, or just unconditionally exit 1456 # print weird messages, or just unconditionally exit
1363 # instead of getting the default action. 1457 # instead of getting the default action.
1364 undef $SIG{$signal} 1458 undef $SIG{$signal}
1365 unless keys %{ $SIG_CB{$signal} }; 1459 unless keys %{ $SIG_CB{$signal} };
1366} 1460}
1367 1461
1368# default implementation for ->child 1462# default implementation for ->child
1369 1463
1370our %PID_CB; 1464our %PID_CB;
1371our $CHLD_W; 1465our $CHLD_W;
1372our $CHLD_DELAY_W; 1466our $CHLD_DELAY_W;
1373our $WNOHANG; 1467our $WNOHANG;
1374 1468
1469sub _emit_childstatus($$) {
1470 my (undef, $rpid, $rstatus) = @_;
1471
1472 $_->($rpid, $rstatus)
1473 for values %{ $PID_CB{$rpid} || {} },
1474 values %{ $PID_CB{0} || {} };
1475}
1476
1375sub _sigchld { 1477sub _sigchld {
1478 my $pid;
1479
1480 AnyEvent->_emit_childstatus ($pid, $?)
1376 while (0 < (my $pid = waitpid -1, $WNOHANG)) { 1481 while ($pid = waitpid -1, $WNOHANG) > 0;
1377 $_->($pid, $?)
1378 for values %{ $PID_CB{$pid} || {} },
1379 values %{ $PID_CB{0} || {} };
1380 }
1381} 1482}
1382 1483
1383sub child { 1484sub child {
1384 my (undef, %arg) = @_; 1485 my (undef, %arg) = @_;
1385 1486
1386 defined (my $pid = $arg{pid} + 0) 1487 defined (my $pid = $arg{pid} + 0)
1387 or Carp::croak "required option 'pid' is missing"; 1488 or Carp::croak "required option 'pid' is missing";
1388 1489
1389 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1490 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1390 1491
1492 # WNOHANG is almost cetrainly 1 everywhere
1493 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/
1494 ? 1
1391 $WNOHANG ||= eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1495 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1392 1496
1393 unless ($CHLD_W) { 1497 unless ($CHLD_W) {
1394 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld); 1498 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld);
1395 # child could be a zombie already, so make at least one round 1499 # child could be a zombie already, so make at least one round
1396 &_sigchld; 1500 &_sigchld;
… …
1448 1552
1449our @ISA = AnyEvent::CondVar::Base::; 1553our @ISA = AnyEvent::CondVar::Base::;
1450 1554
1451package AnyEvent::CondVar::Base; 1555package AnyEvent::CondVar::Base;
1452 1556
1453use overload 1557#use overload
1454 '&{}' => sub { my $self = shift; sub { $self->send (@_) } }, 1558# '&{}' => sub { my $self = shift; sub { $self->send (@_) } },
1455 fallback => 1; 1559# fallback => 1;
1560
1561# save 300+ kilobytes by dirtily hardcoding overloading
1562${"AnyEvent::CondVar::Base::OVERLOAD"}{dummy}++; # Register with magic by touching.
1563*{'AnyEvent::CondVar::Base::()'} = sub { }; # "Make it findable via fetchmethod."
1564*{'AnyEvent::CondVar::Base::(&{}'} = sub { my $self = shift; sub { $self->send (@_) } }; # &{}
1565${'AnyEvent::CondVar::Base::()'} = 1; # fallback
1456 1566
1457our $WAITING; 1567our $WAITING;
1458 1568
1459sub _send { 1569sub _send {
1460 # nop 1570 # nop
… …
1551C<PERL_ANYEVENT_MODEL>. 1661C<PERL_ANYEVENT_MODEL>.
1552 1662
1553When set to C<2> or higher, cause AnyEvent to report to STDERR which event 1663When set to C<2> or higher, cause AnyEvent to report to STDERR which event
1554model it chooses. 1664model it chooses.
1555 1665
1666When set to C<8> or higher, then AnyEvent will report extra information on
1667which optional modules it loads and how it implements certain features.
1668
1556=item C<PERL_ANYEVENT_STRICT> 1669=item C<PERL_ANYEVENT_STRICT>
1557 1670
1558AnyEvent does not do much argument checking by default, as thorough 1671AnyEvent does not do much argument checking by default, as thorough
1559argument checking is very costly. Setting this variable to a true value 1672argument checking is very costly. Setting this variable to a true value
1560will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly 1673will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly
1561check the arguments passed to most method calls. If it finds any problems, 1674check the arguments passed to most method calls. If it finds any problems,
1562it will croak. 1675it will croak.
1563 1676
1564In other words, enables "strict" mode. 1677In other words, enables "strict" mode.
1565 1678
1566Unlike C<use strict>, it is definitely recommended to keep it off in 1679Unlike C<use strict> (or it's modern cousin, C<< use L<common::sense>
1567production. Keeping C<PERL_ANYEVENT_STRICT=1> in your environment while 1680>>, it is definitely recommended to keep it off in production. Keeping
1568developing programs can be very useful, however. 1681C<PERL_ANYEVENT_STRICT=1> in your environment while developing programs
1682can be very useful, however.
1569 1683
1570=item C<PERL_ANYEVENT_MODEL> 1684=item C<PERL_ANYEVENT_MODEL>
1571 1685
1572This can be used to specify the event model to be used by AnyEvent, before 1686This can be used to specify the event model to be used by AnyEvent, before
1573auto detection and -probing kicks in. It must be a string consisting 1687auto detection and -probing kicks in. It must be a string consisting
… …
1635 1749
1636When neither C<ca_file> nor C<ca_path> was specified during 1750When neither C<ca_file> nor C<ca_path> was specified during
1637L<AnyEvent::TLS> context creation, and either of these environment 1751L<AnyEvent::TLS> context creation, and either of these environment
1638variables exist, they will be used to specify CA certificate locations 1752variables exist, they will be used to specify CA certificate locations
1639instead of a system-dependent default. 1753instead of a system-dependent default.
1754
1755=item C<PERL_ANYEVENT_AVOID_GUARD> and C<PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT>
1756
1757When these are set to C<1>, then the respective modules are not
1758loaded. Mostly good for testing AnyEvent itself.
1640 1759
1641=back 1760=back
1642 1761
1643=head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE 1762=head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE
1644 1763
… …
2231 2350
2232This slightly arcane module is used to implement fast signal handling: To 2351This slightly arcane module is used to implement fast signal handling: To
2233my knowledge, there is no way to do completely race-free and quick 2352my knowledge, there is no way to do completely race-free and quick
2234signal handling in pure perl. To ensure that signals still get 2353signal handling in pure perl. To ensure that signals still get
2235delivered, AnyEvent will start an interval timer to wake up perl (and 2354delivered, AnyEvent will start an interval timer to wake up perl (and
2236catch the signals) with soemd elay (default is 10 seconds, look for 2355catch the signals) with some delay (default is 10 seconds, look for
2237C<$AnyEvent::MAX_SIGNAL_LATENCY>). 2356C<$AnyEvent::MAX_SIGNAL_LATENCY>).
2238 2357
2239If this module is available, then it will be used to implement signal 2358If this module is available, then it will be used to implement signal
2240catching, which means that signals will not be delayed, and the event loop 2359catching, which means that signals will not be delayed, and the event loop
2241will not be interrupted regularly, which is more efficient (And good for 2360will not be interrupted regularly, which is more efficient (And good for
2242battery life on laptops). 2361battery life on laptops).
2243 2362
2244This affects not just the pure-perl event loop, but also other event loops 2363This affects not just the pure-perl event loop, but also other event loops
2245that have no signal handling on their own (e.g. Glib, Tk, Qt). 2364that have no signal handling on their own (e.g. Glib, Tk, Qt).
2365
2366Some event loops (POE, Event, Event::Lib) offer signal watchers natively,
2367and either employ their own workarounds (POE) or use AnyEvent's workaround
2368(using C<$AnyEvent::MAX_SIGNAL_LATENCY>). Installing L<Async::Interrupt>
2369does nothing for those backends.
2246 2370
2247=item L<EV> 2371=item L<EV>
2248 2372
2249This module isn't really "optional", as it is simply one of the backend 2373This module isn't really "optional", as it is simply one of the backend
2250event loops that AnyEvent can use. However, it is simply the best event 2374event loops that AnyEvent can use. However, it is simply the best event
… …
2264 2388
2265=item L<JSON> and L<JSON::XS> 2389=item L<JSON> and L<JSON::XS>
2266 2390
2267This module is required when you want to read or write JSON data via 2391This module is required when you want to read or write JSON data via
2268L<AnyEvent::Handle>. It is also written in pure-perl, but can take 2392L<AnyEvent::Handle>. It is also written in pure-perl, but can take
2269advantage of the ulta-high-speed L<JSON::XS> module when it is installed. 2393advantage of the ultra-high-speed L<JSON::XS> module when it is installed.
2270 2394
2271In fact, L<AnyEvent::Handle> will use L<JSON::XS> by default if it is 2395In fact, L<AnyEvent::Handle> will use L<JSON::XS> by default if it is
2272installed. 2396installed.
2273 2397
2274=item L<Net::SSLeay> 2398=item L<Net::SSLeay>
… …
2341L<Glib>, L<Tk>, L<Event::Lib>, L<Qt>, L<POE>. 2465L<Glib>, L<Tk>, L<Event::Lib>, L<Qt>, L<POE>.
2342 2466
2343Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>, 2467Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>,
2344L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>, 2468L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>,
2345L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>, 2469L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>,
2346L<AnyEvent::Impl::POE>, L<AnyEvent::Impl::IOAsync>. 2470L<AnyEvent::Impl::POE>, L<AnyEvent::Impl::IOAsync>, L<Anyevent::Impl::Irssi>.
2347 2471
2348Non-blocking file handles, sockets, TCP clients and 2472Non-blocking file handles, sockets, TCP clients and
2349servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>. 2473servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.
2350 2474
2351Asynchronous DNS: L<AnyEvent::DNS>. 2475Asynchronous DNS: L<AnyEvent::DNS>.

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines