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.297 by root, Thu Nov 19 01:55:57 2009 UTC vs.
Revision 1.316 by root, Mon Mar 15 18:51:30 2010 UTC

… …
402correctly. 402correctly.
403 403
404Example: exit on SIGINT 404Example: exit on SIGINT
405 405
406 my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 }); 406 my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
407
408=head3 Restart Behaviour
409
410While restart behaviour is up to the event loop implementation, most will
411not restart syscalls (that includes L<Async::Interrupt> and AnyEvent's
412pure perl implementation).
413
414=head3 Safe/Unsafe Signals
415
416Perl signals can be either "safe" (synchronous to opcode handling) or
417"unsafe" (asynchronous) - the former might get delayed indefinitely, the
418latter might corrupt your memory.
419
420AnyEvent signal handlers are, in addition, synchronous to the event loop,
421i.e. they will not interrupt your running perl program but will only be
422called as part of the normal event handling (just like timer, I/O etc.
423callbacks, too).
407 424
408=head3 Signal Races, Delays and Workarounds 425=head3 Signal Races, Delays and Workarounds
409 426
410Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching 427Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching
411callbacks to signals in a generic way, which is a pity, as you cannot 428callbacks to signals in a generic way, which is a pity, as you cannot
… …
486 503
487=head2 IDLE WATCHERS 504=head2 IDLE WATCHERS
488 505
489 $w = AnyEvent->idle (cb => <callback>); 506 $w = AnyEvent->idle (cb => <callback>);
490 507
491Sometimes there is a need to do something, but it is not so important 508Repeatedly invoke the callback after the process becomes idle, until
492to do it instantly, but only when there is nothing better to do. This 509either the watcher is destroyed or new events have been detected.
493"nothing better to do" is usually defined to be "no other events need
494attention by the event loop".
495 510
496Idle watchers ideally get invoked when the event loop has nothing 511Idle watchers are useful when there is a need to do something, but it
497better to do, just before it would block the process to wait for new 512is not so important (or wise) to do it instantly. The callback will be
498events. Instead of blocking, the idle watcher is invoked. 513invoked only when there is "nothing better to do", which is usually
514defined as "all outstanding events have been handled and no new events
515have been detected". That means that idle watchers ideally get invoked
516when the event loop has just polled for new events but none have been
517detected. Instead of blocking to wait for more events, the idle watchers
518will be invoked.
499 519
500Most event loops unfortunately do not really support idle watchers (only 520Unfortunately, most event loops do not really support idle watchers (only
501EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent 521EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
502will simply call the callback "from time to time". 522will simply call the callback "from time to time".
503 523
504Example: read lines from STDIN, but only process them when the 524Example: read lines from STDIN, but only process them when the
505program is otherwise idle: 525program is otherwise idle:
… …
949You should check C<$AnyEvent::MODEL> before adding to this array, though: 969You should check C<$AnyEvent::MODEL> before adding to this array, though:
950if it is defined then the event loop has already been detected, and the 970if it is defined then the event loop has already been detected, and the
951array will be ignored. 971array will be ignored.
952 972
953Best use C<AnyEvent::post_detect { BLOCK }> when your application allows 973Best use C<AnyEvent::post_detect { BLOCK }> when your application allows
954it,as it takes care of these details. 974it, as it takes care of these details.
955 975
956This variable is mainly useful for modules that can do something useful 976This variable is mainly useful for modules that can do something useful
957when AnyEvent is used and thus want to know when it is initialised, but do 977when AnyEvent is used and thus want to know when it is initialised, but do
958not need to even load it by default. This array provides the means to hook 978not need to even load it by default. This array provides the means to hook
959into AnyEvent passively, without loading it. 979into AnyEvent passively, without loading it.
980
981Example: To load Coro::AnyEvent whenever Coro and AnyEvent are used
982together, you could put this into Coro (this is the actual code used by
983Coro to accomplish this):
984
985 if (defined $AnyEvent::MODEL) {
986 # AnyEvent already initialised, so load Coro::AnyEvent
987 require Coro::AnyEvent;
988 } else {
989 # AnyEvent not yet initialised, so make sure to load Coro::AnyEvent
990 # as soon as it is
991 push @AnyEvent::post_detect, sub { require Coro::AnyEvent };
992 }
960 993
961=back 994=back
962 995
963=head1 WHAT TO DO IN A MODULE 996=head1 WHAT TO DO IN A MODULE
964 997
… …
1114package AnyEvent; 1147package AnyEvent;
1115 1148
1116# basically a tuned-down version of common::sense 1149# basically a tuned-down version of common::sense
1117sub common_sense { 1150sub common_sense {
1118 # from common:.sense 1.0 1151 # from common:.sense 1.0
1119 ${^WARNING_BITS} = "\xfc\x3f\xf3\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x03"; 1152 ${^WARNING_BITS} = "\xfc\x3f\x33\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x00";
1120 # use strict vars subs 1153 # use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1121 $^H |= 0x00000600; 1154 $^H |= 0x00000600;
1122} 1155}
1123 1156
1124BEGIN { AnyEvent::common_sense } 1157BEGIN { AnyEvent::common_sense }
1125 1158
1126use Carp (); 1159use Carp ();
1127 1160
1128our $VERSION = '5.21'; 1161our $VERSION = '5.251';
1129our $MODEL; 1162our $MODEL;
1130 1163
1131our $AUTOLOAD; 1164our $AUTOLOAD;
1132our @ISA; 1165our @ISA;
1133 1166
1134our @REGISTRY; 1167our @REGISTRY;
1135 1168
1136our $VERBOSE; 1169our $VERBOSE;
1137 1170
1138BEGIN { 1171BEGIN {
1139 eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }"; 1172 require "AnyEvent/constants.pl";
1173
1140 eval "sub TAINT(){ " . (${^TAINT}*1) . " }"; 1174 eval "sub TAINT (){" . (${^TAINT} *1) . "}";
1141 1175
1142 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV} 1176 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
1143 if ${^TAINT}; 1177 if ${^TAINT};
1144 1178
1145 $VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1; 1179 $VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1;
… …
1206sub AnyEvent::Util::postdetect::DESTROY { 1240sub AnyEvent::Util::postdetect::DESTROY {
1207 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1241 @post_detect = grep $_ != ${$_[0]}, @post_detect;
1208} 1242}
1209 1243
1210sub detect() { 1244sub detect() {
1245 # free some memory
1246 *detect = sub () { $MODEL };
1247
1248 local $!; # for good measure
1249 local $SIG{__DIE__};
1250
1251 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) {
1252 my $model = "AnyEvent::Impl::$1";
1253 if (eval "require $model") {
1254 $MODEL = $model;
1255 warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2;
1256 } else {
1257 warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE;
1258 }
1259 }
1260
1261 # check for already loaded models
1211 unless ($MODEL) { 1262 unless ($MODEL) {
1212 local $SIG{__DIE__}; 1263 for (@REGISTRY, @models) {
1213 1264 my ($package, $model) = @$_;
1214 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) { 1265 if (${"$package\::VERSION"} > 0) {
1215 my $model = "AnyEvent::Impl::$1";
1216 if (eval "require $model") { 1266 if (eval "require $model") {
1217 $MODEL = $model; 1267 $MODEL = $model;
1218 warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2; 1268 warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2;
1219 } else { 1269 last;
1220 warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE; 1270 }
1221 } 1271 }
1222 } 1272 }
1223 1273
1224 # check for already loaded models
1225 unless ($MODEL) { 1274 unless ($MODEL) {
1275 # try to autoload a model
1226 for (@REGISTRY, @models) { 1276 for (@REGISTRY, @models) {
1227 my ($package, $model) = @$_; 1277 my ($package, $model, $autoload) = @$_;
1278 if (
1279 $autoload
1280 and eval "require $package"
1228 if (${"$package\::VERSION"} > 0) { 1281 and ${"$package\::VERSION"} > 0
1229 if (eval "require $model") { 1282 and eval "require $model"
1283 ) {
1230 $MODEL = $model; 1284 $MODEL = $model;
1231 warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2; 1285 warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1232 last; 1286 last;
1233 }
1234 } 1287 }
1235 } 1288 }
1236 1289
1237 unless ($MODEL) {
1238 # try to autoload a model
1239 for (@REGISTRY, @models) {
1240 my ($package, $model, $autoload) = @$_;
1241 if (
1242 $autoload
1243 and eval "require $package"
1244 and ${"$package\::VERSION"} > 0
1245 and eval "require $model"
1246 ) {
1247 $MODEL = $model;
1248 warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1249 last;
1250 }
1251 }
1252
1253 $MODEL 1290 $MODEL
1254 or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n"; 1291 or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";
1255 }
1256 } 1292 }
1257
1258 push @{"$MODEL\::ISA"}, "AnyEvent::Base";
1259
1260 unshift @ISA, $MODEL;
1261
1262 require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
1263
1264 (shift @post_detect)->() while @post_detect;
1265 } 1293 }
1294
1295 @models = (); # free probe data
1296
1297 push @{"$MODEL\::ISA"}, "AnyEvent::Base";
1298 unshift @ISA, $MODEL;
1299
1300 require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
1301
1302 (shift @post_detect)->() while @post_detect;
1266 1303
1267 $MODEL 1304 $MODEL
1268} 1305}
1269 1306
1270sub AUTOLOAD { 1307sub AUTOLOAD {
1271 (my $func = $AUTOLOAD) =~ s/.*://; 1308 (my $func = $AUTOLOAD) =~ s/.*://;
1272 1309
1273 $method{$func} 1310 $method{$func}
1274 or Carp::croak "$func: not a valid method for AnyEvent objects"; 1311 or Carp::croak "$func: not a valid AnyEvent class method";
1275 1312
1276 detect unless $MODEL; 1313 detect;
1277 1314
1278 my $class = shift; 1315 my $class = shift;
1279 $class->$func (@_); 1316 $class->$func (@_);
1280} 1317}
1281 1318
… …
1349package AnyEvent::Base; 1386package AnyEvent::Base;
1350 1387
1351# default implementations for many methods 1388# default implementations for many methods
1352 1389
1353sub _time() { 1390sub _time() {
1391 eval q{ # poor man's autoloading
1354 # probe for availability of Time::HiRes 1392 # probe for availability of Time::HiRes
1355 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") { 1393 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1356 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8; 1394 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;
1357 *_time = \&Time::HiRes::time; 1395 *_time = \&Time::HiRes::time;
1358 # if (eval "use POSIX (); (POSIX::times())... 1396 # if (eval "use POSIX (); (POSIX::times())...
1359 } else { 1397 } else {
1360 warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE; 1398 warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;
1361 *_time = sub { time }; # epic fail 1399 *_time = sub (){ time }; # epic fail
1400 }
1362 } 1401 };
1402 die if $@;
1363 1403
1364 &_time 1404 &_time
1365} 1405}
1366 1406
1367sub time { _time } 1407sub time { _time }
… …
1388 1428
1389our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO); 1429our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
1390our (%SIG_ASY, %SIG_ASY_W); 1430our (%SIG_ASY, %SIG_ASY_W);
1391our ($SIG_COUNT, $SIG_TW); 1431our ($SIG_COUNT, $SIG_TW);
1392 1432
1393sub _signal_exec {
1394 $HAVE_ASYNC_INTERRUPT
1395 ? $SIGPIPE_R->drain
1396 : sysread $SIGPIPE_R, (my $dummy), 9;
1397
1398 while (%SIG_EV) {
1399 for (keys %SIG_EV) {
1400 delete $SIG_EV{$_};
1401 $_->() for values %{ $SIG_CB{$_} || {} };
1402 }
1403 }
1404}
1405
1406# install a dummy wakeup watcher to reduce signal catching latency 1433# install a dummy wakeup watcher to reduce signal catching latency
1434# used by Impls
1407sub _sig_add() { 1435sub _sig_add() {
1408 unless ($SIG_COUNT++) { 1436 unless ($SIG_COUNT++) {
1409 # try to align timer on a full-second boundary, if possible 1437 # try to align timer on a full-second boundary, if possible
1410 my $NOW = AE::now; 1438 my $NOW = AE::now;
1411 1439
… …
1463 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec; 1491 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1464 1492
1465 } else { 1493 } else {
1466 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8; 1494 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
1467 1495
1468 require Fcntl;
1469
1470 if (AnyEvent::WIN32) { 1496 if (AnyEvent::WIN32) {
1471 require AnyEvent::Util; 1497 require AnyEvent::Util;
1472 1498
1473 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe (); 1499 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1474 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R; 1500 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R;
1475 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case 1501 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case
1476 } else { 1502 } else {
1477 pipe $SIGPIPE_R, $SIGPIPE_W; 1503 pipe $SIGPIPE_R, $SIGPIPE_W;
1478 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R; 1504 fcntl $SIGPIPE_R, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_R;
1479 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case 1505 fcntl $SIGPIPE_W, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_W; # just in case
1480 1506
1481 # not strictly required, as $^F is normally 2, but let's make sure... 1507 # not strictly required, as $^F is normally 2, but let's make sure...
1482 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC; 1508 fcntl $SIGPIPE_R, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1483 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC; 1509 fcntl $SIGPIPE_W, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1484 } 1510 }
1485 1511
1486 $SIGPIPE_R 1512 $SIGPIPE_R
1487 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n"; 1513 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1488 1514
… …
1542 # print weird messages, or just unconditionally exit 1568 # print weird messages, or just unconditionally exit
1543 # instead of getting the default action. 1569 # instead of getting the default action.
1544 undef $SIG{$signal} 1570 undef $SIG{$signal}
1545 unless keys %{ $SIG_CB{$signal} }; 1571 unless keys %{ $SIG_CB{$signal} };
1546 }; 1572 };
1573
1574 *_signal_exec = sub {
1575 $HAVE_ASYNC_INTERRUPT
1576 ? $SIGPIPE_R->drain
1577 : sysread $SIGPIPE_R, (my $dummy), 9;
1578
1579 while (%SIG_EV) {
1580 for (keys %SIG_EV) {
1581 delete $SIG_EV{$_};
1582 $_->() for values %{ $SIG_CB{$_} || {} };
1583 }
1584 }
1585 };
1547 }; 1586 };
1548 die if $@; 1587 die if $@;
1588
1549 &signal 1589 &signal
1550} 1590}
1551 1591
1552# default implementation for ->child 1592# default implementation for ->child
1553 1593
1554our %PID_CB; 1594our %PID_CB;
1555our $CHLD_W; 1595our $CHLD_W;
1556our $CHLD_DELAY_W; 1596our $CHLD_DELAY_W;
1557our $WNOHANG; 1597our $WNOHANG;
1558 1598
1599# used by many Impl's
1559sub _emit_childstatus($$) { 1600sub _emit_childstatus($$) {
1560 my (undef, $rpid, $rstatus) = @_; 1601 my (undef, $rpid, $rstatus) = @_;
1561 1602
1562 $_->($rpid, $rstatus) 1603 $_->($rpid, $rstatus)
1563 for values %{ $PID_CB{$rpid} || {} }, 1604 for values %{ $PID_CB{$rpid} || {} },
1564 values %{ $PID_CB{0} || {} }; 1605 values %{ $PID_CB{0} || {} };
1565} 1606}
1566 1607
1567sub _sigchld {
1568 my $pid;
1569
1570 AnyEvent->_emit_childstatus ($pid, $?)
1571 while ($pid = waitpid -1, $WNOHANG) > 0;
1572}
1573
1574sub child { 1608sub child {
1609 eval q{ # poor man's autoloading {}
1610 *_sigchld = sub {
1611 my $pid;
1612
1613 AnyEvent->_emit_childstatus ($pid, $?)
1614 while ($pid = waitpid -1, $WNOHANG) > 0;
1615 };
1616
1617 *child = sub {
1575 my (undef, %arg) = @_; 1618 my (undef, %arg) = @_;
1576 1619
1577 defined (my $pid = $arg{pid} + 0) 1620 defined (my $pid = $arg{pid} + 0)
1578 or Carp::croak "required option 'pid' is missing"; 1621 or Carp::croak "required option 'pid' is missing";
1579 1622
1580 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1623 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1581 1624
1582 # WNOHANG is almost cetrainly 1 everywhere 1625 # WNOHANG is almost cetrainly 1 everywhere
1583 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/ 1626 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/
1584 ? 1 1627 ? 1
1585 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1628 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1586 1629
1587 unless ($CHLD_W) { 1630 unless ($CHLD_W) {
1588 $CHLD_W = AE::signal CHLD => \&_sigchld; 1631 $CHLD_W = AE::signal CHLD => \&_sigchld;
1589 # child could be a zombie already, so make at least one round 1632 # child could be a zombie already, so make at least one round
1590 &_sigchld; 1633 &_sigchld;
1591 } 1634 }
1592 1635
1593 bless [$pid, $arg{cb}], "AnyEvent::Base::child" 1636 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1594} 1637 };
1595 1638
1596sub AnyEvent::Base::child::DESTROY { 1639 *AnyEvent::Base::child::DESTROY = sub {
1597 my ($pid, $cb) = @{$_[0]}; 1640 my ($pid, $cb) = @{$_[0]};
1598 1641
1599 delete $PID_CB{$pid}{$cb}; 1642 delete $PID_CB{$pid}{$cb};
1600 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} }; 1643 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1601 1644
1602 undef $CHLD_W unless keys %PID_CB; 1645 undef $CHLD_W unless keys %PID_CB;
1646 };
1647 };
1648 die if $@;
1649
1650 &child
1603} 1651}
1604 1652
1605# idle emulation is done by simply using a timer, regardless 1653# idle emulation is done by simply using a timer, regardless
1606# of whether the process is idle or not, and not letting 1654# of whether the process is idle or not, and not letting
1607# the callback use more than 50% of the time. 1655# the callback use more than 50% of the time.
1608sub idle { 1656sub idle {
1657 eval q{ # poor man's autoloading {}
1658 *idle = sub {
1609 my (undef, %arg) = @_; 1659 my (undef, %arg) = @_;
1610 1660
1611 my ($cb, $w, $rcb) = $arg{cb}; 1661 my ($cb, $w, $rcb) = $arg{cb};
1612 1662
1613 $rcb = sub { 1663 $rcb = sub {
1614 if ($cb) { 1664 if ($cb) {
1615 $w = _time; 1665 $w = _time;
1616 &$cb; 1666 &$cb;
1617 $w = _time - $w; 1667 $w = _time - $w;
1618 1668
1619 # never use more then 50% of the time for the idle watcher, 1669 # never use more then 50% of the time for the idle watcher,
1620 # within some limits 1670 # within some limits
1621 $w = 0.0001 if $w < 0.0001; 1671 $w = 0.0001 if $w < 0.0001;
1622 $w = 5 if $w > 5; 1672 $w = 5 if $w > 5;
1623 1673
1624 $w = AE::timer $w, 0, $rcb; 1674 $w = AE::timer $w, 0, $rcb;
1625 } else { 1675 } else {
1626 # clean up... 1676 # clean up...
1627 undef $w; 1677 undef $w;
1628 undef $rcb; 1678 undef $rcb;
1679 }
1680 };
1681
1682 $w = AE::timer 0.05, 0, $rcb;
1683
1684 bless \\$cb, "AnyEvent::Base::idle"
1629 } 1685 };
1686
1687 *AnyEvent::Base::idle::DESTROY = sub {
1688 undef $${$_[0]};
1689 };
1630 }; 1690 };
1691 die if $@;
1631 1692
1632 $w = AE::timer 0.05, 0, $rcb; 1693 &idle
1633
1634 bless \\$cb, "AnyEvent::Base::idle"
1635}
1636
1637sub AnyEvent::Base::idle::DESTROY {
1638 undef $${$_[0]};
1639} 1694}
1640 1695
1641package AnyEvent::CondVar; 1696package AnyEvent::CondVar;
1642 1697
1643our @ISA = AnyEvent::CondVar::Base::; 1698our @ISA = AnyEvent::CondVar::Base::;
… …
2431it's built-in modules) are required to use it. 2486it's built-in modules) are required to use it.
2432 2487
2433That does not mean that AnyEvent won't take advantage of some additional 2488That does not mean that AnyEvent won't take advantage of some additional
2434modules if they are installed. 2489modules if they are installed.
2435 2490
2436This section epxlains which additional modules will be used, and how they 2491This section explains which additional modules will be used, and how they
2437affect AnyEvent's operetion. 2492affect AnyEvent's operation.
2438 2493
2439=over 4 2494=over 4
2440 2495
2441=item L<Async::Interrupt> 2496=item L<Async::Interrupt>
2442 2497
… …
2447catch the signals) with some delay (default is 10 seconds, look for 2502catch the signals) with some delay (default is 10 seconds, look for
2448C<$AnyEvent::MAX_SIGNAL_LATENCY>). 2503C<$AnyEvent::MAX_SIGNAL_LATENCY>).
2449 2504
2450If this module is available, then it will be used to implement signal 2505If this module is available, then it will be used to implement signal
2451catching, which means that signals will not be delayed, and the event loop 2506catching, which means that signals will not be delayed, and the event loop
2452will not be interrupted regularly, which is more efficient (And good for 2507will not be interrupted regularly, which is more efficient (and good for
2453battery life on laptops). 2508battery life on laptops).
2454 2509
2455This affects not just the pure-perl event loop, but also other event loops 2510This affects not just the pure-perl event loop, but also other event loops
2456that have no signal handling on their own (e.g. Glib, Tk, Qt). 2511that have no signal handling on their own (e.g. Glib, Tk, Qt).
2457 2512
… …
2469automatic timer adjustments even when no monotonic clock is available, 2524automatic timer adjustments even when no monotonic clock is available,
2470can take avdantage of advanced kernel interfaces such as C<epoll> and 2525can take avdantage of advanced kernel interfaces such as C<epoll> and
2471C<kqueue>, and is the fastest backend I<by far>. You can even embed 2526C<kqueue>, and is the fastest backend I<by far>. You can even embed
2472L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>). 2527L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>).
2473 2528
2529If you only use backends that rely on another event loop (e.g. C<Tk>),
2530then this module will do nothing for you.
2531
2474=item L<Guard> 2532=item L<Guard>
2475 2533
2476The guard module, when used, will be used to implement 2534The guard module, when used, will be used to implement
2477C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a 2535C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a
2478lot less memory), but otherwise doesn't affect guard operation much. It is 2536lot less memory), but otherwise doesn't affect guard operation much. It is
2479purely used for performance. 2537purely used for performance.
2480 2538
2481=item L<JSON> and L<JSON::XS> 2539=item L<JSON> and L<JSON::XS>
2482 2540
2483One of these modules is required when you want to read or write JSON data 2541One of these modules is required when you want to read or write JSON data
2484via L<AnyEvent::Handle>. It is also written in pure-perl, but can take 2542via L<AnyEvent::Handle>. L<JSON> is also written in pure-perl, but can take
2485advantage of the ultra-high-speed L<JSON::XS> module when it is installed. 2543advantage of the ultra-high-speed L<JSON::XS> module when it is installed.
2486
2487In fact, L<AnyEvent::Handle> will use L<JSON::XS> by default if it is
2488installed.
2489 2544
2490=item L<Net::SSLeay> 2545=item L<Net::SSLeay>
2491 2546
2492Implementing TLS/SSL in Perl is certainly interesting, but not very 2547Implementing TLS/SSL in Perl is certainly interesting, but not very
2493worthwhile: If this module is installed, then L<AnyEvent::Handle> (with 2548worthwhile: If this module is installed, then L<AnyEvent::Handle> (with
… …
2504 2559
2505 2560
2506=head1 FORK 2561=head1 FORK
2507 2562
2508Most event libraries are not fork-safe. The ones who are usually are 2563Most event libraries are not fork-safe. The ones who are usually are
2509because they rely on inefficient but fork-safe C<select> or C<poll> 2564because they rely on inefficient but fork-safe C<select> or C<poll> calls
2510calls. Only L<EV> is fully fork-aware. 2565- higher performance APIs such as BSD's kqueue or the dreaded Linux epoll
2566are usually badly thought-out hacks that are incompatible with fork in
2567one way or another. Only L<EV> is fully fork-aware and ensures that you
2568continue event-processing in both parent and child (or both, if you know
2569what you are doing).
2570
2571This means that, in general, you cannot fork and do event processing in
2572the child if the event library was initialised before the fork (which
2573usually happens when the first AnyEvent watcher is created, or the library
2574is loaded).
2511 2575
2512If you have to fork, you must either do so I<before> creating your first 2576If you have to fork, you must either do so I<before> creating your first
2513watcher OR you must not use AnyEvent at all in the child OR you must do 2577watcher OR you must not use AnyEvent at all in the child OR you must do
2514something completely out of the scope of AnyEvent. 2578something completely out of the scope of AnyEvent.
2579
2580The problem of doing event processing in the parent I<and> the child
2581is much more complicated: even for backends that I<are> fork-aware or
2582fork-safe, their behaviour is not usually what you want: fork clones all
2583watchers, that means all timers, I/O watchers etc. are active in both
2584parent and child, which is almost never what you want. USing C<exec>
2585to start worker children from some kind of manage rprocess is usually
2586preferred, because it is much easier and cleaner, at the expense of having
2587to have another binary.
2515 2588
2516 2589
2517=head1 SECURITY CONSIDERATIONS 2590=head1 SECURITY CONSIDERATIONS
2518 2591
2519AnyEvent can be forced to load any event model via 2592AnyEvent can be forced to load any event model via

Diff Legend

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