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.302 by root, Fri Dec 4 16:31:57 2009 UTC vs.
Revision 1.317 by root, Wed Mar 24 21:22:57 2010 UTC

… …
503 503
504=head2 IDLE WATCHERS 504=head2 IDLE WATCHERS
505 505
506 $w = AnyEvent->idle (cb => <callback>); 506 $w = AnyEvent->idle (cb => <callback>);
507 507
508Sometimes there is a need to do something, but it is not so important 508Repeatedly invoke the callback after the process becomes idle, until
509to do it instantly, but only when there is nothing better to do. This 509either the watcher is destroyed or new events have been detected.
510"nothing better to do" is usually defined to be "no other events need
511attention by the event loop".
512 510
513Idle watchers ideally get invoked when the event loop has nothing 511Idle watchers are useful when there is a need to do something, but it
514better 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
515events. 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.
516 519
517Most event loops unfortunately do not really support idle watchers (only 520Unfortunately, most event loops do not really support idle watchers (only
518EV, 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
519will simply call the callback "from time to time". 522will simply call the callback "from time to time".
520 523
521Example: read lines from STDIN, but only process them when the 524Example: read lines from STDIN, but only process them when the
522program is otherwise idle: 525program is otherwise idle:
… …
966You should check C<$AnyEvent::MODEL> before adding to this array, though: 969You should check C<$AnyEvent::MODEL> before adding to this array, though:
967if 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
968array will be ignored. 971array will be ignored.
969 972
970Best use C<AnyEvent::post_detect { BLOCK }> when your application allows 973Best use C<AnyEvent::post_detect { BLOCK }> when your application allows
971it,as it takes care of these details. 974it, as it takes care of these details.
972 975
973This variable is mainly useful for modules that can do something useful 976This variable is mainly useful for modules that can do something useful
974when 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
975not 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
976into 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 }
977 993
978=back 994=back
979 995
980=head1 WHAT TO DO IN A MODULE 996=head1 WHAT TO DO IN A MODULE
981 997
… …
1131package AnyEvent; 1147package AnyEvent;
1132 1148
1133# basically a tuned-down version of common::sense 1149# basically a tuned-down version of common::sense
1134sub common_sense { 1150sub common_sense {
1135 # from common:.sense 1.0 1151 # from common:.sense 1.0
1136 ${^WARNING_BITS} = "\xfc\x3f\x33\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x03"; 1152 ${^WARNING_BITS} = "\xfc\x3f\x33\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x00";
1137 # use strict vars subs 1153 # use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1138 $^H |= 0x00000600; 1154 $^H |= 0x00000600;
1139} 1155}
1140 1156
1141BEGIN { AnyEvent::common_sense } 1157BEGIN { AnyEvent::common_sense }
1142 1158
1143use Carp (); 1159use Carp ();
1144 1160
1145our $VERSION = '5.21'; 1161our $VERSION = '5.251';
1146our $MODEL; 1162our $MODEL;
1147 1163
1148our $AUTOLOAD; 1164our $AUTOLOAD;
1149our @ISA; 1165our @ISA;
1150 1166
1151our @REGISTRY; 1167our @REGISTRY;
1152 1168
1153our $VERBOSE; 1169our $VERBOSE;
1154 1170
1155BEGIN { 1171BEGIN {
1156 eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }"; 1172 require "AnyEvent/constants.pl";
1173
1157 eval "sub TAINT(){ " . (${^TAINT}*1) . " }"; 1174 eval "sub TAINT (){" . (${^TAINT}*1) . "}";
1158 1175
1159 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV} 1176 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
1160 if ${^TAINT}; 1177 if ${^TAINT};
1161 1178
1162 $VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1; 1179 $VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1;
… …
1205our @post_detect; 1222our @post_detect;
1206 1223
1207sub post_detect(&) { 1224sub post_detect(&) {
1208 my ($cb) = @_; 1225 my ($cb) = @_;
1209 1226
1210 if ($MODEL) {
1211 $cb->();
1212
1213 undef
1214 } else {
1215 push @post_detect, $cb; 1227 push @post_detect, $cb;
1216 1228
1217 defined wantarray 1229 defined wantarray
1218 ? bless \$cb, "AnyEvent::Util::postdetect" 1230 ? bless \$cb, "AnyEvent::Util::postdetect"
1219 : () 1231 : ()
1220 }
1221} 1232}
1222 1233
1223sub AnyEvent::Util::postdetect::DESTROY { 1234sub AnyEvent::Util::postdetect::DESTROY {
1224 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1235 @post_detect = grep $_ != ${$_[0]}, @post_detect;
1225} 1236}
1226 1237
1227sub detect() { 1238sub detect() {
1239 # free some memory
1240 *detect = sub () { $MODEL };
1241
1242 local $!; # for good measure
1243 local $SIG{__DIE__};
1244
1245 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) {
1246 my $model = "AnyEvent::Impl::$1";
1247 if (eval "require $model") {
1248 $MODEL = $model;
1249 warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2;
1250 } else {
1251 warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE;
1252 }
1253 }
1254
1255 # check for already loaded models
1228 unless ($MODEL) { 1256 unless ($MODEL) {
1229 local $SIG{__DIE__}; 1257 for (@REGISTRY, @models) {
1230 1258 my ($package, $model) = @$_;
1231 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) { 1259 if (${"$package\::VERSION"} > 0) {
1232 my $model = "AnyEvent::Impl::$1";
1233 if (eval "require $model") { 1260 if (eval "require $model") {
1234 $MODEL = $model; 1261 $MODEL = $model;
1235 warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2; 1262 warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2;
1236 } else { 1263 last;
1237 warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE; 1264 }
1238 } 1265 }
1239 } 1266 }
1240 1267
1241 # check for already loaded models
1242 unless ($MODEL) { 1268 unless ($MODEL) {
1269 # try to autoload a model
1243 for (@REGISTRY, @models) { 1270 for (@REGISTRY, @models) {
1244 my ($package, $model) = @$_; 1271 my ($package, $model, $autoload) = @$_;
1272 if (
1273 $autoload
1274 and eval "require $package"
1245 if (${"$package\::VERSION"} > 0) { 1275 and ${"$package\::VERSION"} > 0
1246 if (eval "require $model") { 1276 and eval "require $model"
1277 ) {
1247 $MODEL = $model; 1278 $MODEL = $model;
1248 warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2; 1279 warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1249 last; 1280 last;
1250 }
1251 } 1281 }
1252 } 1282 }
1253 1283
1254 unless ($MODEL) {
1255 # try to autoload a model
1256 for (@REGISTRY, @models) {
1257 my ($package, $model, $autoload) = @$_;
1258 if (
1259 $autoload
1260 and eval "require $package"
1261 and ${"$package\::VERSION"} > 0
1262 and eval "require $model"
1263 ) {
1264 $MODEL = $model;
1265 warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1266 last;
1267 }
1268 }
1269
1270 $MODEL 1284 $MODEL
1271 or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n"; 1285 or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";
1272 }
1273 } 1286 }
1274
1275 push @{"$MODEL\::ISA"}, "AnyEvent::Base";
1276
1277 unshift @ISA, $MODEL;
1278
1279 require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
1280
1281 (shift @post_detect)->() while @post_detect;
1282 } 1287 }
1288
1289 @models = (); # free probe data
1290
1291 push @{"$MODEL\::ISA"}, "AnyEvent::Base";
1292 unshift @ISA, $MODEL;
1293
1294 # now nuke some methods that are overriden by the backend.
1295 # SUPER is not allowed.
1296 for (qw(time signal child idle)) {
1297 undef &{"AnyEvent::Base::$_"}
1298 if defined &{"$MODEL\::$_"};
1299 }
1300
1301 require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
1302
1303 (shift @post_detect)->() while @post_detect;
1304
1305 *post_detect = sub(&) {
1306 shift->();
1307
1308 undef
1309 };
1283 1310
1284 $MODEL 1311 $MODEL
1285} 1312}
1286 1313
1287sub AUTOLOAD { 1314sub AUTOLOAD {
1288 (my $func = $AUTOLOAD) =~ s/.*://; 1315 (my $func = $AUTOLOAD) =~ s/.*://;
1289 1316
1290 $method{$func} 1317 $method{$func}
1291 or Carp::croak "$func: not a valid method for AnyEvent objects"; 1318 or Carp::croak "$func: not a valid AnyEvent class method";
1292 1319
1293 detect unless $MODEL; 1320 detect;
1294 1321
1295 my $class = shift; 1322 my $class = shift;
1296 $class->$func (@_); 1323 $class->$func (@_);
1297} 1324}
1298 1325
… …
1365 1392
1366package AnyEvent::Base; 1393package AnyEvent::Base;
1367 1394
1368# default implementations for many methods 1395# default implementations for many methods
1369 1396
1370sub _time() { 1397sub time {
1398 eval q{ # poor man's autoloading {}
1371 # probe for availability of Time::HiRes 1399 # probe for availability of Time::HiRes
1372 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") { 1400 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1373 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8; 1401 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;
1374 *_time = \&Time::HiRes::time; 1402 *AE::time = \&Time::HiRes::time;
1375 # if (eval "use POSIX (); (POSIX::times())... 1403 # if (eval "use POSIX (); (POSIX::times())...
1376 } else { 1404 } else {
1377 warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE; 1405 warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;
1378 *_time = sub { time }; # epic fail 1406 *AE::time = sub (){ time }; # epic fail
1407 }
1408
1409 *time = sub { AE::time }; # different prototypes
1379 } 1410 };
1411 die if $@;
1380 1412
1381 &_time 1413 &time
1382} 1414}
1383 1415
1384sub time { _time } 1416*now = \&time;
1385sub now { _time } 1417
1386sub now_update { } 1418sub now_update { }
1387 1419
1388# default implementation for ->condvar 1420# default implementation for ->condvar
1389 1421
1390sub condvar { 1422sub condvar {
1423 eval q{ # poor man's autoloading {}
1424 *condvar = sub {
1391 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar" 1425 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
1426 };
1427
1428 *AE::cv = sub (;&) {
1429 bless { @_ ? (_ae_cb => shift) : () }, "AnyEvent::CondVar"
1430 };
1431 };
1432 die if $@;
1433
1434 &condvar
1392} 1435}
1393 1436
1394# default implementation for ->signal 1437# default implementation for ->signal
1395 1438
1396our $HAVE_ASYNC_INTERRUPT; 1439our $HAVE_ASYNC_INTERRUPT;
… …
1405 1448
1406our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO); 1449our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
1407our (%SIG_ASY, %SIG_ASY_W); 1450our (%SIG_ASY, %SIG_ASY_W);
1408our ($SIG_COUNT, $SIG_TW); 1451our ($SIG_COUNT, $SIG_TW);
1409 1452
1410sub _signal_exec {
1411 $HAVE_ASYNC_INTERRUPT
1412 ? $SIGPIPE_R->drain
1413 : sysread $SIGPIPE_R, (my $dummy), 9;
1414
1415 while (%SIG_EV) {
1416 for (keys %SIG_EV) {
1417 delete $SIG_EV{$_};
1418 $_->() for values %{ $SIG_CB{$_} || {} };
1419 }
1420 }
1421}
1422
1423# install a dummy wakeup watcher to reduce signal catching latency 1453# install a dummy wakeup watcher to reduce signal catching latency
1454# used by Impls
1424sub _sig_add() { 1455sub _sig_add() {
1425 unless ($SIG_COUNT++) { 1456 unless ($SIG_COUNT++) {
1426 # try to align timer on a full-second boundary, if possible 1457 # try to align timer on a full-second boundary, if possible
1427 my $NOW = AE::now; 1458 my $NOW = AE::now;
1428 1459
… …
1438 undef $SIG_TW 1469 undef $SIG_TW
1439 unless --$SIG_COUNT; 1470 unless --$SIG_COUNT;
1440} 1471}
1441 1472
1442our $_sig_name_init; $_sig_name_init = sub { 1473our $_sig_name_init; $_sig_name_init = sub {
1443 eval q{ # poor man's autoloading 1474 eval q{ # poor man's autoloading {}
1444 undef $_sig_name_init; 1475 undef $_sig_name_init;
1445 1476
1446 if (_have_async_interrupt) { 1477 if (_have_async_interrupt) {
1447 *sig2num = \&Async::Interrupt::sig2num; 1478 *sig2num = \&Async::Interrupt::sig2num;
1448 *sig2name = \&Async::Interrupt::sig2name; 1479 *sig2name = \&Async::Interrupt::sig2name;
… …
1480 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec; 1511 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1481 1512
1482 } else { 1513 } else {
1483 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8; 1514 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
1484 1515
1485 require Fcntl;
1486
1487 if (AnyEvent::WIN32) { 1516 if (AnyEvent::WIN32) {
1488 require AnyEvent::Util; 1517 require AnyEvent::Util;
1489 1518
1490 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe (); 1519 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1491 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R; 1520 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R;
1492 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case 1521 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case
1493 } else { 1522 } else {
1494 pipe $SIGPIPE_R, $SIGPIPE_W; 1523 pipe $SIGPIPE_R, $SIGPIPE_W;
1495 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R; 1524 fcntl $SIGPIPE_R, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_R;
1496 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case 1525 fcntl $SIGPIPE_W, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_W; # just in case
1497 1526
1498 # not strictly required, as $^F is normally 2, but let's make sure... 1527 # not strictly required, as $^F is normally 2, but let's make sure...
1499 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC; 1528 fcntl $SIGPIPE_R, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1500 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC; 1529 fcntl $SIGPIPE_W, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1501 } 1530 }
1502 1531
1503 $SIGPIPE_R 1532 $SIGPIPE_R
1504 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n"; 1533 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1505 1534
1506 $SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec; 1535 $SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec;
1507 } 1536 }
1508 1537
1509 *signal = sub { 1538 *signal = $HAVE_ASYNC_INTERRUPT
1539 ? sub {
1510 my (undef, %arg) = @_; 1540 my (undef, %arg) = @_;
1511 1541
1512 my $signal = uc $arg{signal}
1513 or Carp::croak "required option 'signal' is missing";
1514
1515 if ($HAVE_ASYNC_INTERRUPT) {
1516 # async::interrupt 1542 # async::interrupt
1517
1518 $signal = sig2num $signal; 1543 my $signal = sig2num $arg{signal};
1519 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1544 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1520 1545
1521 $SIG_ASY{$signal} ||= new Async::Interrupt 1546 $SIG_ASY{$signal} ||= new Async::Interrupt
1522 cb => sub { undef $SIG_EV{$signal} }, 1547 cb => sub { undef $SIG_EV{$signal} },
1523 signal => $signal, 1548 signal => $signal,
1524 pipe => [$SIGPIPE_R->filenos], 1549 pipe => [$SIGPIPE_R->filenos],
1525 pipe_autodrain => 0, 1550 pipe_autodrain => 0,
1526 ; 1551 ;
1527 1552
1528 } else { 1553 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1554 }
1555 : sub {
1556 my (undef, %arg) = @_;
1557
1529 # pure perl 1558 # pure perl
1530
1531 # AE::Util has been loaded in signal
1532 $signal = sig2name $signal; 1559 my $signal = sig2name $arg{signal};
1533 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1560 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1534 1561
1535 $SIG{$signal} ||= sub { 1562 $SIG{$signal} ||= sub {
1536 local $!; 1563 local $!;
1537 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1564 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1538 undef $SIG_EV{$signal}; 1565 undef $SIG_EV{$signal};
1539 }; 1566 };
1540 1567
1541 # can't do signal processing without introducing races in pure perl, 1568 # can't do signal processing without introducing races in pure perl,
1542 # so limit the signal latency. 1569 # so limit the signal latency.
1543 _sig_add; 1570 _sig_add;
1544 }
1545 1571
1546 bless [$signal, $arg{cb}], "AnyEvent::Base::signal" 1572 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1573 }
1547 }; 1574 ;
1548 1575
1549 *AnyEvent::Base::signal::DESTROY = sub { 1576 *AnyEvent::Base::signal::DESTROY = sub {
1550 my ($signal, $cb) = @{$_[0]}; 1577 my ($signal, $cb) = @{$_[0]};
1551 1578
1552 _sig_del; 1579 _sig_del;
… …
1559 # print weird messages, or just unconditionally exit 1586 # print weird messages, or just unconditionally exit
1560 # instead of getting the default action. 1587 # instead of getting the default action.
1561 undef $SIG{$signal} 1588 undef $SIG{$signal}
1562 unless keys %{ $SIG_CB{$signal} }; 1589 unless keys %{ $SIG_CB{$signal} };
1563 }; 1590 };
1591
1592 *_signal_exec = sub {
1593 $HAVE_ASYNC_INTERRUPT
1594 ? $SIGPIPE_R->drain
1595 : sysread $SIGPIPE_R, (my $dummy), 9;
1596
1597 while (%SIG_EV) {
1598 for (keys %SIG_EV) {
1599 delete $SIG_EV{$_};
1600 $_->() for values %{ $SIG_CB{$_} || {} };
1601 }
1602 }
1603 };
1564 }; 1604 };
1565 die if $@; 1605 die if $@;
1606
1566 &signal 1607 &signal
1567} 1608}
1568 1609
1569# default implementation for ->child 1610# default implementation for ->child
1570 1611
1571our %PID_CB; 1612our %PID_CB;
1572our $CHLD_W; 1613our $CHLD_W;
1573our $CHLD_DELAY_W; 1614our $CHLD_DELAY_W;
1574our $WNOHANG; 1615our $WNOHANG;
1575 1616
1617# used by many Impl's
1576sub _emit_childstatus($$) { 1618sub _emit_childstatus($$) {
1577 my (undef, $rpid, $rstatus) = @_; 1619 my (undef, $rpid, $rstatus) = @_;
1578 1620
1579 $_->($rpid, $rstatus) 1621 $_->($rpid, $rstatus)
1580 for values %{ $PID_CB{$rpid} || {} }, 1622 for values %{ $PID_CB{$rpid} || {} },
1581 values %{ $PID_CB{0} || {} }; 1623 values %{ $PID_CB{0} || {} };
1582} 1624}
1583 1625
1584sub _sigchld {
1585 my $pid;
1586
1587 AnyEvent->_emit_childstatus ($pid, $?)
1588 while ($pid = waitpid -1, $WNOHANG) > 0;
1589}
1590
1591sub child { 1626sub child {
1627 eval q{ # poor man's autoloading {}
1628 *_sigchld = sub {
1629 my $pid;
1630
1631 AnyEvent->_emit_childstatus ($pid, $?)
1632 while ($pid = waitpid -1, $WNOHANG) > 0;
1633 };
1634
1635 *child = sub {
1592 my (undef, %arg) = @_; 1636 my (undef, %arg) = @_;
1593 1637
1594 defined (my $pid = $arg{pid} + 0) 1638 defined (my $pid = $arg{pid} + 0)
1595 or Carp::croak "required option 'pid' is missing"; 1639 or Carp::croak "required option 'pid' is missing";
1596 1640
1597 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1641 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1598 1642
1599 # WNOHANG is almost cetrainly 1 everywhere 1643 # WNOHANG is almost cetrainly 1 everywhere
1600 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/ 1644 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/
1601 ? 1 1645 ? 1
1602 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1646 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1603 1647
1604 unless ($CHLD_W) { 1648 unless ($CHLD_W) {
1605 $CHLD_W = AE::signal CHLD => \&_sigchld; 1649 $CHLD_W = AE::signal CHLD => \&_sigchld;
1606 # child could be a zombie already, so make at least one round 1650 # child could be a zombie already, so make at least one round
1607 &_sigchld; 1651 &_sigchld;
1608 } 1652 }
1609 1653
1610 bless [$pid, $arg{cb}], "AnyEvent::Base::child" 1654 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1611} 1655 };
1612 1656
1613sub AnyEvent::Base::child::DESTROY { 1657 *AnyEvent::Base::child::DESTROY = sub {
1614 my ($pid, $cb) = @{$_[0]}; 1658 my ($pid, $cb) = @{$_[0]};
1615 1659
1616 delete $PID_CB{$pid}{$cb}; 1660 delete $PID_CB{$pid}{$cb};
1617 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} }; 1661 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1618 1662
1619 undef $CHLD_W unless keys %PID_CB; 1663 undef $CHLD_W unless keys %PID_CB;
1664 };
1665 };
1666 die if $@;
1667
1668 &child
1620} 1669}
1621 1670
1622# idle emulation is done by simply using a timer, regardless 1671# idle emulation is done by simply using a timer, regardless
1623# of whether the process is idle or not, and not letting 1672# of whether the process is idle or not, and not letting
1624# the callback use more than 50% of the time. 1673# the callback use more than 50% of the time.
1625sub idle { 1674sub idle {
1675 eval q{ # poor man's autoloading {}
1676 *idle = sub {
1626 my (undef, %arg) = @_; 1677 my (undef, %arg) = @_;
1627 1678
1628 my ($cb, $w, $rcb) = $arg{cb}; 1679 my ($cb, $w, $rcb) = $arg{cb};
1629 1680
1630 $rcb = sub { 1681 $rcb = sub {
1631 if ($cb) { 1682 if ($cb) {
1632 $w = _time; 1683 $w = _time;
1633 &$cb; 1684 &$cb;
1634 $w = _time - $w; 1685 $w = _time - $w;
1635 1686
1636 # never use more then 50% of the time for the idle watcher, 1687 # never use more then 50% of the time for the idle watcher,
1637 # within some limits 1688 # within some limits
1638 $w = 0.0001 if $w < 0.0001; 1689 $w = 0.0001 if $w < 0.0001;
1639 $w = 5 if $w > 5; 1690 $w = 5 if $w > 5;
1640 1691
1641 $w = AE::timer $w, 0, $rcb; 1692 $w = AE::timer $w, 0, $rcb;
1642 } else { 1693 } else {
1643 # clean up... 1694 # clean up...
1644 undef $w; 1695 undef $w;
1645 undef $rcb; 1696 undef $rcb;
1697 }
1698 };
1699
1700 $w = AE::timer 0.05, 0, $rcb;
1701
1702 bless \\$cb, "AnyEvent::Base::idle"
1646 } 1703 };
1704
1705 *AnyEvent::Base::idle::DESTROY = sub {
1706 undef $${$_[0]};
1707 };
1647 }; 1708 };
1709 die if $@;
1648 1710
1649 $w = AE::timer 0.05, 0, $rcb; 1711 &idle
1650
1651 bless \\$cb, "AnyEvent::Base::idle"
1652}
1653
1654sub AnyEvent::Base::idle::DESTROY {
1655 undef $${$_[0]};
1656} 1712}
1657 1713
1658package AnyEvent::CondVar; 1714package AnyEvent::CondVar;
1659 1715
1660our @ISA = AnyEvent::CondVar::Base::; 1716our @ISA = AnyEvent::CondVar::Base::;
… …
2486automatic timer adjustments even when no monotonic clock is available, 2542automatic timer adjustments even when no monotonic clock is available,
2487can take avdantage of advanced kernel interfaces such as C<epoll> and 2543can take avdantage of advanced kernel interfaces such as C<epoll> and
2488C<kqueue>, and is the fastest backend I<by far>. You can even embed 2544C<kqueue>, and is the fastest backend I<by far>. You can even embed
2489L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>). 2545L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>).
2490 2546
2547If you only use backends that rely on another event loop (e.g. C<Tk>),
2548then this module will do nothing for you.
2549
2491=item L<Guard> 2550=item L<Guard>
2492 2551
2493The guard module, when used, will be used to implement 2552The guard module, when used, will be used to implement
2494C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a 2553C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a
2495lot less memory), but otherwise doesn't affect guard operation much. It is 2554lot less memory), but otherwise doesn't affect guard operation much. It is
2496purely used for performance. 2555purely used for performance.
2497 2556
2498=item L<JSON> and L<JSON::XS> 2557=item L<JSON> and L<JSON::XS>
2499 2558
2500One of these modules is required when you want to read or write JSON data 2559One of these modules is required when you want to read or write JSON data
2501via L<AnyEvent::Handle>. It is also written in pure-perl, but can take 2560via L<AnyEvent::Handle>. L<JSON> is also written in pure-perl, but can take
2502advantage of the ultra-high-speed L<JSON::XS> module when it is installed. 2561advantage of the ultra-high-speed L<JSON::XS> module when it is installed.
2503
2504In fact, L<AnyEvent::Handle> will use L<JSON::XS> by default if it is
2505installed.
2506 2562
2507=item L<Net::SSLeay> 2563=item L<Net::SSLeay>
2508 2564
2509Implementing TLS/SSL in Perl is certainly interesting, but not very 2565Implementing TLS/SSL in Perl is certainly interesting, but not very
2510worthwhile: If this module is installed, then L<AnyEvent::Handle> (with 2566worthwhile: If this module is installed, then L<AnyEvent::Handle> (with
… …
2521 2577
2522 2578
2523=head1 FORK 2579=head1 FORK
2524 2580
2525Most event libraries are not fork-safe. The ones who are usually are 2581Most event libraries are not fork-safe. The ones who are usually are
2526because they rely on inefficient but fork-safe C<select> or C<poll> 2582because they rely on inefficient but fork-safe C<select> or C<poll> calls
2527calls. Only L<EV> is fully fork-aware. 2583- higher performance APIs such as BSD's kqueue or the dreaded Linux epoll
2584are usually badly thought-out hacks that are incompatible with fork in
2585one way or another. Only L<EV> is fully fork-aware and ensures that you
2586continue event-processing in both parent and child (or both, if you know
2587what you are doing).
2528 2588
2529This means that, in general, you cannot fork and do event processing 2589This means that, in general, you cannot fork and do event processing in
2530in the child if a watcher was created before the fork (which in turn 2590the child if the event library was initialised before the fork (which
2531initialises the event library). 2591usually happens when the first AnyEvent watcher is created, or the library
2592is loaded).
2532 2593
2533If you have to fork, you must either do so I<before> creating your first 2594If you have to fork, you must either do so I<before> creating your first
2534watcher OR you must not use AnyEvent at all in the child OR you must do 2595watcher OR you must not use AnyEvent at all in the child OR you must do
2535something completely out of the scope of AnyEvent. 2596something completely out of the scope of AnyEvent.
2536 2597
2537The problem of doing event processing in the parent I<and> the child 2598The problem of doing event processing in the parent I<and> the child
2538is much more complicated: even for backends that I<are> fork-aware or 2599is much more complicated: even for backends that I<are> fork-aware or
2539fork-safe, their behaviour is not usually what you want: fork clones all 2600fork-safe, their behaviour is not usually what you want: fork clones all
2540watchers, that means all timers, I/O watchers etc. are active in both 2601watchers, that means all timers, I/O watchers etc. are active in both
2541parent and child, which is almost never what you want. 2602parent and child, which is almost never what you want. USing C<exec>
2603to start worker children from some kind of manage rprocess is usually
2604preferred, because it is much easier and cleaner, at the expense of having
2605to have another binary.
2542 2606
2543 2607
2544=head1 SECURITY CONSIDERATIONS 2608=head1 SECURITY CONSIDERATIONS
2545 2609
2546AnyEvent can be forced to load any event model via 2610AnyEvent can be forced to load any event model via

Diff Legend

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