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.303 by root, Sat Dec 5 02:52:03 2009 UTC vs.
Revision 1.320 by root, Mon Apr 12 02:50:31 2010 UTC

… …
7 7
8=head1 SYNOPSIS 8=head1 SYNOPSIS
9 9
10 use AnyEvent; 10 use AnyEvent;
11 11
12 # if you prefer function calls, look at the L<AE> manpage for
13 # an alternative API.
14
12 # file descriptor readable 15 # file handle or descriptor readable
13 my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... }); 16 my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... });
14 17
15 # one-shot or repeating timers 18 # one-shot or repeating timers
16 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... }); 19 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... });
17 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ... 20 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ...
… …
503 506
504=head2 IDLE WATCHERS 507=head2 IDLE WATCHERS
505 508
506 $w = AnyEvent->idle (cb => <callback>); 509 $w = AnyEvent->idle (cb => <callback>);
507 510
508Sometimes there is a need to do something, but it is not so important 511Repeatedly invoke the callback after the process becomes idle, until
509to do it instantly, but only when there is nothing better to do. This 512either 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 513
513Idle watchers ideally get invoked when the event loop has nothing 514Idle 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 515is not so important (or wise) to do it instantly. The callback will be
515events. Instead of blocking, the idle watcher is invoked. 516invoked only when there is "nothing better to do", which is usually
517defined as "all outstanding events have been handled and no new events
518have been detected". That means that idle watchers ideally get invoked
519when the event loop has just polled for new events but none have been
520detected. Instead of blocking to wait for more events, the idle watchers
521will be invoked.
516 522
517Most event loops unfortunately do not really support idle watchers (only 523Unfortunately, most event loops do not really support idle watchers (only
518EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent 524EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
519will simply call the callback "from time to time". 525will simply call the callback "from time to time".
520 526
521Example: read lines from STDIN, but only process them when the 527Example: read lines from STDIN, but only process them when the
522program is otherwise idle: 528program is otherwise idle:
… …
603eventually calls C<< -> send >>, and the "consumer side", which waits 609eventually calls C<< -> send >>, and the "consumer side", which waits
604for the send to occur. 610for the send to occur.
605 611
606Example: wait for a timer. 612Example: wait for a timer.
607 613
608 # wait till the result is ready 614 # condition: "wait till the timer is fired"
609 my $result_ready = AnyEvent->condvar; 615 my $timer_fired = AnyEvent->condvar;
610 616
611 # do something such as adding a timer 617 # create the timer - we could wait for, say
612 # or socket watcher the calls $result_ready->send 618 # a handle becomign ready, or even an
613 # when the "result" is ready. 619 # AnyEvent::HTTP request to finish, but
614 # in this case, we simply use a timer: 620 # in this case, we simply use a timer:
615 my $w = AnyEvent->timer ( 621 my $w = AnyEvent->timer (
616 after => 1, 622 after => 1,
617 cb => sub { $result_ready->send }, 623 cb => sub { $timer_fired->send },
618 ); 624 );
619 625
620 # this "blocks" (while handling events) till the callback 626 # this "blocks" (while handling events) till the callback
621 # calls ->send 627 # calls ->send
622 $result_ready->recv; 628 $timer_fired->recv;
623 629
624Example: wait for a timer, but take advantage of the fact that condition 630Example: wait for a timer, but take advantage of the fact that condition
625variables are also callable directly. 631variables are also callable directly.
626 632
627 my $done = AnyEvent->condvar; 633 my $done = AnyEvent->condvar;
… …
966You should check C<$AnyEvent::MODEL> before adding to this array, though: 972You 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 973if it is defined then the event loop has already been detected, and the
968array will be ignored. 974array will be ignored.
969 975
970Best use C<AnyEvent::post_detect { BLOCK }> when your application allows 976Best use C<AnyEvent::post_detect { BLOCK }> when your application allows
971it,as it takes care of these details. 977it, as it takes care of these details.
972 978
973This variable is mainly useful for modules that can do something useful 979This 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 980when 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 981not need to even load it by default. This array provides the means to hook
976into AnyEvent passively, without loading it. 982into AnyEvent passively, without loading it.
983
984Example: To load Coro::AnyEvent whenever Coro and AnyEvent are used
985together, you could put this into Coro (this is the actual code used by
986Coro to accomplish this):
987
988 if (defined $AnyEvent::MODEL) {
989 # AnyEvent already initialised, so load Coro::AnyEvent
990 require Coro::AnyEvent;
991 } else {
992 # AnyEvent not yet initialised, so make sure to load Coro::AnyEvent
993 # as soon as it is
994 push @AnyEvent::post_detect, sub { require Coro::AnyEvent };
995 }
977 996
978=back 997=back
979 998
980=head1 WHAT TO DO IN A MODULE 999=head1 WHAT TO DO IN A MODULE
981 1000
… …
1131package AnyEvent; 1150package AnyEvent;
1132 1151
1133# basically a tuned-down version of common::sense 1152# basically a tuned-down version of common::sense
1134sub common_sense { 1153sub common_sense {
1135 # from common:.sense 1.0 1154 # from common:.sense 1.0
1136 ${^WARNING_BITS} = "\xfc\x3f\x33\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x03"; 1155 ${^WARNING_BITS} = "\xfc\x3f\x33\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x00";
1137 # use strict vars subs 1156 # use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1138 $^H |= 0x00000600; 1157 $^H |= 0x00000600;
1139} 1158}
1140 1159
1141BEGIN { AnyEvent::common_sense } 1160BEGIN { AnyEvent::common_sense }
1142 1161
1143use Carp (); 1162use Carp ();
1144 1163
1145our $VERSION = '5.22'; 1164our $VERSION = '5.26';
1146our $MODEL; 1165our $MODEL;
1147 1166
1148our $AUTOLOAD; 1167our $AUTOLOAD;
1149our @ISA; 1168our @ISA;
1150 1169
1151our @REGISTRY; 1170our @REGISTRY;
1152 1171
1153our $VERBOSE; 1172our $VERBOSE;
1154 1173
1155BEGIN { 1174BEGIN {
1156 eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }"; 1175 require "AnyEvent/constants.pl";
1176
1157 eval "sub TAINT(){ " . (${^TAINT}*1) . " }"; 1177 eval "sub TAINT (){" . (${^TAINT}*1) . "}";
1158 1178
1159 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV} 1179 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
1160 if ${^TAINT}; 1180 if ${^TAINT};
1161 1181
1162 $VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1; 1182 $VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1;
… …
1205our @post_detect; 1225our @post_detect;
1206 1226
1207sub post_detect(&) { 1227sub post_detect(&) {
1208 my ($cb) = @_; 1228 my ($cb) = @_;
1209 1229
1210 if ($MODEL) {
1211 $cb->();
1212
1213 undef
1214 } else {
1215 push @post_detect, $cb; 1230 push @post_detect, $cb;
1216 1231
1217 defined wantarray 1232 defined wantarray
1218 ? bless \$cb, "AnyEvent::Util::postdetect" 1233 ? bless \$cb, "AnyEvent::Util::postdetect"
1219 : () 1234 : ()
1220 }
1221} 1235}
1222 1236
1223sub AnyEvent::Util::postdetect::DESTROY { 1237sub AnyEvent::Util::postdetect::DESTROY {
1224 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1238 @post_detect = grep $_ != ${$_[0]}, @post_detect;
1225} 1239}
1226 1240
1227sub detect() { 1241sub detect() {
1242 # free some memory
1243 *detect = sub () { $MODEL };
1244
1245 local $!; # for good measure
1246 local $SIG{__DIE__};
1247
1248 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) {
1249 my $model = "AnyEvent::Impl::$1";
1250 if (eval "require $model") {
1251 $MODEL = $model;
1252 warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2;
1253 } else {
1254 warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE;
1255 }
1256 }
1257
1258 # check for already loaded models
1228 unless ($MODEL) { 1259 unless ($MODEL) {
1229 local $SIG{__DIE__}; 1260 for (@REGISTRY, @models) {
1230 1261 my ($package, $model) = @$_;
1231 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) { 1262 if (${"$package\::VERSION"} > 0) {
1232 my $model = "AnyEvent::Impl::$1";
1233 if (eval "require $model") { 1263 if (eval "require $model") {
1234 $MODEL = $model; 1264 $MODEL = $model;
1235 warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2; 1265 warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2;
1236 } else { 1266 last;
1237 warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE; 1267 }
1238 } 1268 }
1239 } 1269 }
1240 1270
1241 # check for already loaded models
1242 unless ($MODEL) { 1271 unless ($MODEL) {
1272 # try to autoload a model
1243 for (@REGISTRY, @models) { 1273 for (@REGISTRY, @models) {
1244 my ($package, $model) = @$_; 1274 my ($package, $model, $autoload) = @$_;
1275 if (
1276 $autoload
1277 and eval "require $package"
1245 if (${"$package\::VERSION"} > 0) { 1278 and ${"$package\::VERSION"} > 0
1246 if (eval "require $model") { 1279 and eval "require $model"
1280 ) {
1247 $MODEL = $model; 1281 $MODEL = $model;
1248 warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2; 1282 warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1249 last; 1283 last;
1250 }
1251 } 1284 }
1252 } 1285 }
1253 1286
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 1287 $MODEL
1271 or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n"; 1288 or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";
1272 }
1273 } 1289 }
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 } 1290 }
1291
1292 @models = (); # free probe data
1293
1294 push @{"$MODEL\::ISA"}, "AnyEvent::Base";
1295 unshift @ISA, $MODEL;
1296
1297 # now nuke some methods that are overriden by the backend.
1298 # SUPER is not allowed.
1299 for (qw(time signal child idle)) {
1300 undef &{"AnyEvent::Base::$_"}
1301 if defined &{"$MODEL\::$_"};
1302 }
1303
1304 require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
1305
1306 (shift @post_detect)->() while @post_detect;
1307
1308 *post_detect = sub(&) {
1309 shift->();
1310
1311 undef
1312 };
1283 1313
1284 $MODEL 1314 $MODEL
1285} 1315}
1286 1316
1287sub AUTOLOAD { 1317sub AUTOLOAD {
1288 (my $func = $AUTOLOAD) =~ s/.*://; 1318 (my $func = $AUTOLOAD) =~ s/.*://;
1289 1319
1290 $method{$func} 1320 $method{$func}
1291 or Carp::croak "$func: not a valid method for AnyEvent objects"; 1321 or Carp::croak "$func: not a valid AnyEvent class method";
1292 1322
1293 detect unless $MODEL; 1323 detect;
1294 1324
1295 my $class = shift; 1325 my $class = shift;
1296 $class->$func (@_); 1326 $class->$func (@_);
1297} 1327}
1298 1328
… …
1315 1345
1316=head1 SIMPLIFIED AE API 1346=head1 SIMPLIFIED AE API
1317 1347
1318Starting with version 5.0, AnyEvent officially supports a second, much 1348Starting with version 5.0, AnyEvent officially supports a second, much
1319simpler, API that is designed to reduce the calling, typing and memory 1349simpler, API that is designed to reduce the calling, typing and memory
1320overhead. 1350overhead by using function call syntax and a fixed number of parameters.
1321 1351
1322See the L<AE> manpage for details. 1352See the L<AE> manpage for details.
1323 1353
1324=cut 1354=cut
1325 1355
1326package AE; 1356package AE;
1327 1357
1328our $VERSION = $AnyEvent::VERSION; 1358our $VERSION = $AnyEvent::VERSION;
1359
1360# fall back to the main API by default - backends and AnyEvent::Base
1361# implementations can overwrite these.
1329 1362
1330sub io($$$) { 1363sub io($$$) {
1331 AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2]) 1364 AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2])
1332} 1365}
1333 1366
… …
1365 1398
1366package AnyEvent::Base; 1399package AnyEvent::Base;
1367 1400
1368# default implementations for many methods 1401# default implementations for many methods
1369 1402
1370sub _time() { 1403sub time {
1404 eval q{ # poor man's autoloading {}
1371 # probe for availability of Time::HiRes 1405 # probe for availability of Time::HiRes
1372 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") { 1406 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1373 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8; 1407 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;
1374 *_time = \&Time::HiRes::time; 1408 *AE::time = \&Time::HiRes::time;
1375 # if (eval "use POSIX (); (POSIX::times())... 1409 # if (eval "use POSIX (); (POSIX::times())...
1376 } else { 1410 } else {
1377 warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE; 1411 warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;
1378 *_time = sub { time }; # epic fail 1412 *AE::time = sub (){ time }; # epic fail
1413 }
1414
1415 *time = sub { AE::time }; # different prototypes
1379 } 1416 };
1417 die if $@;
1380 1418
1381 &_time 1419 &time
1382} 1420}
1383 1421
1384sub time { _time } 1422*now = \&time;
1385sub now { _time } 1423
1386sub now_update { } 1424sub now_update { }
1387 1425
1388# default implementation for ->condvar 1426# default implementation for ->condvar
1389 1427
1390sub condvar { 1428sub condvar {
1429 eval q{ # poor man's autoloading {}
1430 *condvar = sub {
1391 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar" 1431 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
1432 };
1433
1434 *AE::cv = sub (;&) {
1435 bless { @_ ? (_ae_cb => shift) : () }, "AnyEvent::CondVar"
1436 };
1437 };
1438 die if $@;
1439
1440 &condvar
1392} 1441}
1393 1442
1394# default implementation for ->signal 1443# default implementation for ->signal
1395 1444
1396our $HAVE_ASYNC_INTERRUPT; 1445our $HAVE_ASYNC_INTERRUPT;
… …
1405 1454
1406our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO); 1455our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
1407our (%SIG_ASY, %SIG_ASY_W); 1456our (%SIG_ASY, %SIG_ASY_W);
1408our ($SIG_COUNT, $SIG_TW); 1457our ($SIG_COUNT, $SIG_TW);
1409 1458
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 1459# install a dummy wakeup watcher to reduce signal catching latency
1460# used by Impls
1424sub _sig_add() { 1461sub _sig_add() {
1425 unless ($SIG_COUNT++) { 1462 unless ($SIG_COUNT++) {
1426 # try to align timer on a full-second boundary, if possible 1463 # try to align timer on a full-second boundary, if possible
1427 my $NOW = AE::now; 1464 my $NOW = AE::now;
1428 1465
… …
1438 undef $SIG_TW 1475 undef $SIG_TW
1439 unless --$SIG_COUNT; 1476 unless --$SIG_COUNT;
1440} 1477}
1441 1478
1442our $_sig_name_init; $_sig_name_init = sub { 1479our $_sig_name_init; $_sig_name_init = sub {
1443 eval q{ # poor man's autoloading 1480 eval q{ # poor man's autoloading {}
1444 undef $_sig_name_init; 1481 undef $_sig_name_init;
1445 1482
1446 if (_have_async_interrupt) { 1483 if (_have_async_interrupt) {
1447 *sig2num = \&Async::Interrupt::sig2num; 1484 *sig2num = \&Async::Interrupt::sig2num;
1448 *sig2name = \&Async::Interrupt::sig2name; 1485 *sig2name = \&Async::Interrupt::sig2name;
… …
1480 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec; 1517 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1481 1518
1482 } else { 1519 } else {
1483 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8; 1520 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
1484 1521
1485 require Fcntl;
1486
1487 if (AnyEvent::WIN32) { 1522 if (AnyEvent::WIN32) {
1488 require AnyEvent::Util; 1523 require AnyEvent::Util;
1489 1524
1490 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe (); 1525 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1491 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R; 1526 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R;
1492 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case 1527 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case
1493 } else { 1528 } else {
1494 pipe $SIGPIPE_R, $SIGPIPE_W; 1529 pipe $SIGPIPE_R, $SIGPIPE_W;
1495 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R; 1530 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 1531 fcntl $SIGPIPE_W, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_W; # just in case
1497 1532
1498 # not strictly required, as $^F is normally 2, but let's make sure... 1533 # not strictly required, as $^F is normally 2, but let's make sure...
1499 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC; 1534 fcntl $SIGPIPE_R, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1500 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC; 1535 fcntl $SIGPIPE_W, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1501 } 1536 }
1502 1537
1503 $SIGPIPE_R 1538 $SIGPIPE_R
1504 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n"; 1539 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1505 1540
1506 $SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec; 1541 $SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec;
1507 } 1542 }
1508 1543
1509 *signal = sub { 1544 *signal = $HAVE_ASYNC_INTERRUPT
1545 ? sub {
1510 my (undef, %arg) = @_; 1546 my (undef, %arg) = @_;
1511 1547
1512 my $signal = uc $arg{signal}
1513 or Carp::croak "required option 'signal' is missing";
1514
1515 if ($HAVE_ASYNC_INTERRUPT) {
1516 # async::interrupt 1548 # async::interrupt
1517
1518 $signal = sig2num $signal; 1549 my $signal = sig2num $arg{signal};
1519 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1550 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1520 1551
1521 $SIG_ASY{$signal} ||= new Async::Interrupt 1552 $SIG_ASY{$signal} ||= new Async::Interrupt
1522 cb => sub { undef $SIG_EV{$signal} }, 1553 cb => sub { undef $SIG_EV{$signal} },
1523 signal => $signal, 1554 signal => $signal,
1524 pipe => [$SIGPIPE_R->filenos], 1555 pipe => [$SIGPIPE_R->filenos],
1525 pipe_autodrain => 0, 1556 pipe_autodrain => 0,
1526 ; 1557 ;
1527 1558
1528 } else { 1559 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1560 }
1561 : sub {
1562 my (undef, %arg) = @_;
1563
1529 # pure perl 1564 # pure perl
1530
1531 # AE::Util has been loaded in signal
1532 $signal = sig2name $signal; 1565 my $signal = sig2name $arg{signal};
1533 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1566 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1534 1567
1535 $SIG{$signal} ||= sub { 1568 $SIG{$signal} ||= sub {
1536 local $!; 1569 local $!;
1537 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1570 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1538 undef $SIG_EV{$signal}; 1571 undef $SIG_EV{$signal};
1539 }; 1572 };
1540 1573
1541 # can't do signal processing without introducing races in pure perl, 1574 # can't do signal processing without introducing races in pure perl,
1542 # so limit the signal latency. 1575 # so limit the signal latency.
1543 _sig_add; 1576 _sig_add;
1544 }
1545 1577
1546 bless [$signal, $arg{cb}], "AnyEvent::Base::signal" 1578 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1579 }
1547 }; 1580 ;
1548 1581
1549 *AnyEvent::Base::signal::DESTROY = sub { 1582 *AnyEvent::Base::signal::DESTROY = sub {
1550 my ($signal, $cb) = @{$_[0]}; 1583 my ($signal, $cb) = @{$_[0]};
1551 1584
1552 _sig_del; 1585 _sig_del;
… …
1559 # print weird messages, or just unconditionally exit 1592 # print weird messages, or just unconditionally exit
1560 # instead of getting the default action. 1593 # instead of getting the default action.
1561 undef $SIG{$signal} 1594 undef $SIG{$signal}
1562 unless keys %{ $SIG_CB{$signal} }; 1595 unless keys %{ $SIG_CB{$signal} };
1563 }; 1596 };
1597
1598 *_signal_exec = sub {
1599 $HAVE_ASYNC_INTERRUPT
1600 ? $SIGPIPE_R->drain
1601 : sysread $SIGPIPE_R, (my $dummy), 9;
1602
1603 while (%SIG_EV) {
1604 for (keys %SIG_EV) {
1605 delete $SIG_EV{$_};
1606 $_->() for values %{ $SIG_CB{$_} || {} };
1607 }
1608 }
1609 };
1564 }; 1610 };
1565 die if $@; 1611 die if $@;
1612
1566 &signal 1613 &signal
1567} 1614}
1568 1615
1569# default implementation for ->child 1616# default implementation for ->child
1570 1617
1571our %PID_CB; 1618our %PID_CB;
1572our $CHLD_W; 1619our $CHLD_W;
1573our $CHLD_DELAY_W; 1620our $CHLD_DELAY_W;
1574our $WNOHANG; 1621our $WNOHANG;
1575 1622
1623# used by many Impl's
1576sub _emit_childstatus($$) { 1624sub _emit_childstatus($$) {
1577 my (undef, $rpid, $rstatus) = @_; 1625 my (undef, $rpid, $rstatus) = @_;
1578 1626
1579 $_->($rpid, $rstatus) 1627 $_->($rpid, $rstatus)
1580 for values %{ $PID_CB{$rpid} || {} }, 1628 for values %{ $PID_CB{$rpid} || {} },
1581 values %{ $PID_CB{0} || {} }; 1629 values %{ $PID_CB{0} || {} };
1582} 1630}
1583 1631
1584sub _sigchld {
1585 my $pid;
1586
1587 AnyEvent->_emit_childstatus ($pid, $?)
1588 while ($pid = waitpid -1, $WNOHANG) > 0;
1589}
1590
1591sub child { 1632sub child {
1633 eval q{ # poor man's autoloading {}
1634 *_sigchld = sub {
1635 my $pid;
1636
1637 AnyEvent->_emit_childstatus ($pid, $?)
1638 while ($pid = waitpid -1, $WNOHANG) > 0;
1639 };
1640
1641 *child = sub {
1592 my (undef, %arg) = @_; 1642 my (undef, %arg) = @_;
1593 1643
1594 defined (my $pid = $arg{pid} + 0) 1644 defined (my $pid = $arg{pid} + 0)
1595 or Carp::croak "required option 'pid' is missing"; 1645 or Carp::croak "required option 'pid' is missing";
1596 1646
1597 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1647 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1598 1648
1599 # WNOHANG is almost cetrainly 1 everywhere 1649 # WNOHANG is almost cetrainly 1 everywhere
1600 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/ 1650 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/
1601 ? 1 1651 ? 1
1602 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1652 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1603 1653
1604 unless ($CHLD_W) { 1654 unless ($CHLD_W) {
1605 $CHLD_W = AE::signal CHLD => \&_sigchld; 1655 $CHLD_W = AE::signal CHLD => \&_sigchld;
1606 # child could be a zombie already, so make at least one round 1656 # child could be a zombie already, so make at least one round
1607 &_sigchld; 1657 &_sigchld;
1608 } 1658 }
1609 1659
1610 bless [$pid, $arg{cb}], "AnyEvent::Base::child" 1660 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1611} 1661 };
1612 1662
1613sub AnyEvent::Base::child::DESTROY { 1663 *AnyEvent::Base::child::DESTROY = sub {
1614 my ($pid, $cb) = @{$_[0]}; 1664 my ($pid, $cb) = @{$_[0]};
1615 1665
1616 delete $PID_CB{$pid}{$cb}; 1666 delete $PID_CB{$pid}{$cb};
1617 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} }; 1667 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1618 1668
1619 undef $CHLD_W unless keys %PID_CB; 1669 undef $CHLD_W unless keys %PID_CB;
1670 };
1671 };
1672 die if $@;
1673
1674 &child
1620} 1675}
1621 1676
1622# idle emulation is done by simply using a timer, regardless 1677# idle emulation is done by simply using a timer, regardless
1623# of whether the process is idle or not, and not letting 1678# of whether the process is idle or not, and not letting
1624# the callback use more than 50% of the time. 1679# the callback use more than 50% of the time.
1625sub idle { 1680sub idle {
1681 eval q{ # poor man's autoloading {}
1682 *idle = sub {
1626 my (undef, %arg) = @_; 1683 my (undef, %arg) = @_;
1627 1684
1628 my ($cb, $w, $rcb) = $arg{cb}; 1685 my ($cb, $w, $rcb) = $arg{cb};
1629 1686
1630 $rcb = sub { 1687 $rcb = sub {
1631 if ($cb) { 1688 if ($cb) {
1632 $w = _time; 1689 $w = _time;
1633 &$cb; 1690 &$cb;
1634 $w = _time - $w; 1691 $w = _time - $w;
1635 1692
1636 # never use more then 50% of the time for the idle watcher, 1693 # never use more then 50% of the time for the idle watcher,
1637 # within some limits 1694 # within some limits
1638 $w = 0.0001 if $w < 0.0001; 1695 $w = 0.0001 if $w < 0.0001;
1639 $w = 5 if $w > 5; 1696 $w = 5 if $w > 5;
1640 1697
1641 $w = AE::timer $w, 0, $rcb; 1698 $w = AE::timer $w, 0, $rcb;
1642 } else { 1699 } else {
1643 # clean up... 1700 # clean up...
1644 undef $w; 1701 undef $w;
1645 undef $rcb; 1702 undef $rcb;
1703 }
1704 };
1705
1706 $w = AE::timer 0.05, 0, $rcb;
1707
1708 bless \\$cb, "AnyEvent::Base::idle"
1646 } 1709 };
1710
1711 *AnyEvent::Base::idle::DESTROY = sub {
1712 undef $${$_[0]};
1713 };
1647 }; 1714 };
1715 die if $@;
1648 1716
1649 $w = AE::timer 0.05, 0, $rcb; 1717 &idle
1650
1651 bless \\$cb, "AnyEvent::Base::idle"
1652}
1653
1654sub AnyEvent::Base::idle::DESTROY {
1655 undef $${$_[0]};
1656} 1718}
1657 1719
1658package AnyEvent::CondVar; 1720package AnyEvent::CondVar;
1659 1721
1660our @ISA = AnyEvent::CondVar::Base::; 1722our @ISA = AnyEvent::CondVar::Base::;
… …
2019 2081
2020The actual code goes further and collects all errors (C<die>s, exceptions) 2082The actual code goes further and collects all errors (C<die>s, exceptions)
2021that occurred during request processing. The C<result> method detects 2083that occurred during request processing. The C<result> method detects
2022whether an exception as thrown (it is stored inside the $txn object) 2084whether an exception as thrown (it is stored inside the $txn object)
2023and just throws the exception, which means connection errors and other 2085and just throws the exception, which means connection errors and other
2024problems get reported tot he code that tries to use the result, not in a 2086problems get reported to the code that tries to use the result, not in a
2025random callback. 2087random callback.
2026 2088
2027All of this enables the following usage styles: 2089All of this enables the following usage styles:
2028 2090
20291. Blocking: 20911. Blocking:
… …
2486automatic timer adjustments even when no monotonic clock is available, 2548automatic timer adjustments even when no monotonic clock is available,
2487can take avdantage of advanced kernel interfaces such as C<epoll> and 2549can 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 2550C<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>). 2551L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>).
2490 2552
2553If you only use backends that rely on another event loop (e.g. C<Tk>),
2554then this module will do nothing for you.
2555
2491=item L<Guard> 2556=item L<Guard>
2492 2557
2493The guard module, when used, will be used to implement 2558The guard module, when used, will be used to implement
2494C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a 2559C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a
2495lot less memory), but otherwise doesn't affect guard operation much. It is 2560lot less memory), but otherwise doesn't affect guard operation much. It is
2496purely used for performance. 2561purely used for performance.
2497 2562
2498=item L<JSON> and L<JSON::XS> 2563=item L<JSON> and L<JSON::XS>
2499 2564
2500One of these modules is required when you want to read or write JSON data 2565One 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 2566via 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. 2567advantage 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 2568
2507=item L<Net::SSLeay> 2569=item L<Net::SSLeay>
2508 2570
2509Implementing TLS/SSL in Perl is certainly interesting, but not very 2571Implementing TLS/SSL in Perl is certainly interesting, but not very
2510worthwhile: If this module is installed, then L<AnyEvent::Handle> (with 2572worthwhile: If this module is installed, then L<AnyEvent::Handle> (with
… …
2521 2583
2522 2584
2523=head1 FORK 2585=head1 FORK
2524 2586
2525Most event libraries are not fork-safe. The ones who are usually are 2587Most 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> 2588because they rely on inefficient but fork-safe C<select> or C<poll> calls
2527calls. Only L<EV> is fully fork-aware. 2589- higher performance APIs such as BSD's kqueue or the dreaded Linux epoll
2590are usually badly thought-out hacks that are incompatible with fork in
2591one way or another. Only L<EV> is fully fork-aware and ensures that you
2592continue event-processing in both parent and child (or both, if you know
2593what you are doing).
2528 2594
2529This means that, in general, you cannot fork and do event processing 2595This 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 2596the child if the event library was initialised before the fork (which
2531initialises the event library). 2597usually happens when the first AnyEvent watcher is created, or the library
2598is loaded).
2532 2599
2533If you have to fork, you must either do so I<before> creating your first 2600If 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 2601watcher OR you must not use AnyEvent at all in the child OR you must do
2535something completely out of the scope of AnyEvent. 2602something completely out of the scope of AnyEvent.
2536 2603
2537The problem of doing event processing in the parent I<and> the child 2604The 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 2605is 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 2606fork-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 2607watchers, that means all timers, I/O watchers etc. are active in both
2541parent and child, which is almost never what you want. 2608parent and child, which is almost never what you want. USing C<exec>
2609to start worker children from some kind of manage rprocess is usually
2610preferred, because it is much easier and cleaner, at the expense of having
2611to have another binary.
2542 2612
2543 2613
2544=head1 SECURITY CONSIDERATIONS 2614=head1 SECURITY CONSIDERATIONS
2545 2615
2546AnyEvent can be forced to load any event model via 2616AnyEvent can be forced to load any event model via

Diff Legend

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