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.361 by root, Sun Aug 14 01:38:14 2011 UTC vs.
Revision 1.410 by root, Fri Mar 1 06:03:21 2013 UTC

1=head1 NAME 1=head1 NAME
2 2
3AnyEvent - the DBI of event loop programming 3AnyEvent - the DBI of event loop programming
4 4
5EV, Event, Glib, Tk, Perl, Event::Lib, Irssi, rxvt-unicode, IO::Async, Qt 5EV, Event, Glib, Tk, Perl, Event::Lib, Irssi, rxvt-unicode, IO::Async, Qt,
6and POE are various supported event loops/environments. 6FLTK and 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
… …
415not restart syscalls (that includes L<Async::Interrupt> and AnyEvent's 415not restart syscalls (that includes L<Async::Interrupt> and AnyEvent's
416pure perl implementation). 416pure perl implementation).
417 417
418=head3 Safe/Unsafe Signals 418=head3 Safe/Unsafe Signals
419 419
420Perl signals can be either "safe" (synchronous to opcode handling) or 420Perl signals can be either "safe" (synchronous to opcode handling)
421"unsafe" (asynchronous) - the former might get delayed indefinitely, the 421or "unsafe" (asynchronous) - the former might delay signal delivery
422latter might corrupt your memory. 422indefinitely, the latter might corrupt your memory.
423 423
424AnyEvent signal handlers are, in addition, synchronous to the event loop, 424AnyEvent signal handlers are, in addition, synchronous to the event loop,
425i.e. they will not interrupt your running perl program but will only be 425i.e. they will not interrupt your running perl program but will only be
426called as part of the normal event handling (just like timer, I/O etc. 426called as part of the normal event handling (just like timer, I/O etc.
427callbacks, too). 427callbacks, too).
428 428
429=head3 Signal Races, Delays and Workarounds 429=head3 Signal Races, Delays and Workarounds
430 430
431Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching 431Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support
432callbacks to signals in a generic way, which is a pity, as you cannot 432attaching callbacks to signals in a generic way, which is a pity,
433do race-free signal handling in perl, requiring C libraries for 433as you cannot do race-free signal handling in perl, requiring
434this. AnyEvent will try to do its best, which means in some cases, 434C libraries for this. AnyEvent will try to do its best, which
435signals will be delayed. The maximum time a signal might be delayed is 435means in some cases, signals will be delayed. The maximum time
436specified in C<$AnyEvent::MAX_SIGNAL_LATENCY> (default: 10 seconds). This 436a signal might be delayed is 10 seconds by default, but can
437variable can be changed only before the first signal watcher is created, 437be overriden via C<$ENV{PERL_ANYEVENT_MAX_SIGNAL_LATENCY}> or
438and should be left alone otherwise. This variable determines how often 438C<$AnyEvent::MAX_SIGNAL_LATENCY> - see the L<ENVIRONMENT VARIABLES>
439AnyEvent polls for signals (in case a wake-up was missed). Higher values 439section for details.
440will cause fewer spurious wake-ups, which is better for power and CPU
441saving.
442 440
443All these problems can be avoided by installing the optional 441All these problems can be avoided by installing the optional
444L<Async::Interrupt> module, which works with most event loops. It will not 442L<Async::Interrupt> module, which works with most event loops. It will not
445work with inherently broken event loops such as L<Event> or L<Event::Lib> 443work with inherently broken event loops such as L<Event> or L<Event::Lib>
446(and not with L<POE> currently, as POE does its own workaround with 444(and not with L<POE> currently). For those, you just have to suffer the
447one-second latency). For those, you just have to suffer the delays. 445delays.
448 446
449=head2 CHILD PROCESS WATCHERS 447=head2 CHILD PROCESS WATCHERS
450 448
451 $w = AnyEvent->child (pid => <process id>, cb => <callback>); 449 $w = AnyEvent->child (pid => <process id>, cb => <callback>);
452 450
… …
765 }; 763 };
766 } 764 }
767 765
768 $cv->end; 766 $cv->end;
769 767
768 ...
769
770 my $results = $cv->recv;
771
770This code fragment supposedly pings a number of hosts and calls 772This code fragment supposedly pings a number of hosts and calls
771C<send> after results for all then have have been gathered - in any 773C<send> after results for all then have have been gathered - in any
772order. To achieve this, the code issues a call to C<begin> when it starts 774order. To achieve this, the code issues a call to C<begin> when it starts
773each ping request and calls C<end> when it has received some result for 775each ping request and calls C<end> when it has received some result for
774it. Since C<begin> and C<end> only maintain a counter, the order in which 776it. Since C<begin> and C<end> only maintain a counter, the order in which
… …
809 811
810In list context, all parameters passed to C<send> will be returned, 812In list context, all parameters passed to C<send> will be returned,
811in scalar context only the first one will be returned. 813in scalar context only the first one will be returned.
812 814
813Note that doing a blocking wait in a callback is not supported by any 815Note that doing a blocking wait in a callback is not supported by any
814event loop, that is, recursive invocation of a blocking C<< ->recv 816event loop, that is, recursive invocation of a blocking C<< ->recv >> is
815>> is not allowed, and the C<recv> call will C<croak> if such a 817not allowed and the C<recv> call will C<croak> if such a condition is
816condition is detected. This condition can be slightly loosened by using 818detected. This requirement can be dropped by relying on L<Coro::AnyEvent>
817L<Coro::AnyEvent>, which allows you to do a blocking C<< ->recv >> from 819, which allows you to do a blocking C<< ->recv >> from any thread
818any thread that doesn't run the event loop itself. 820that doesn't run the event loop itself. L<Coro::AnyEvent> is loaded
821automatically when L<Coro> is used with L<AnyEvent>, so code does not need
822to do anything special to take advantage of that: any code that would
823normally block your program because it calls C<recv>, be executed in an
824C<async> thread instead without blocking other threads.
819 825
820Not all event models support a blocking wait - some die in that case 826Not all event models support a blocking wait - some die in that case
821(programs might want to do that to stay interactive), so I<if you are 827(programs might want to do that to stay interactive), so I<if you are
822using this from a module, never require a blocking wait>. Instead, let the 828using this from a module, never require a blocking wait>. Instead, let the
823caller decide whether the call will block or not (for example, by coupling 829caller decide whether the call will block or not (for example, by coupling
… …
878 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse. 884 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
879 AnyEvent::Impl::POE based on POE, very slow, some limitations. 885 AnyEvent::Impl::POE based on POE, very slow, some limitations.
880 AnyEvent::Impl::Irssi used when running within irssi. 886 AnyEvent::Impl::Irssi used when running within irssi.
881 AnyEvent::Impl::IOAsync based on IO::Async. 887 AnyEvent::Impl::IOAsync based on IO::Async.
882 AnyEvent::Impl::Cocoa based on Cocoa::EventLoop. 888 AnyEvent::Impl::Cocoa based on Cocoa::EventLoop.
883 AnyEvent::Impl::FLTK2 based on FLTK (fltk 2 binding). 889 AnyEvent::Impl::FLTK based on FLTK (fltk 2 binding).
884 890
885=item Backends with special needs. 891=item Backends with special needs.
886 892
887Qt requires the Qt::Application to be instantiated first, but will 893Qt requires the Qt::Application to be instantiated first, but will
888otherwise be picked up automatically. As long as the main program 894otherwise be picked up automatically. As long as the main program
… …
1049It should use C<postpone>: 1055It should use C<postpone>:
1050 1056
1051 AnyEvent::postpone { $cb->(undef) }, return # signal error to callback, later 1057 AnyEvent::postpone { $cb->(undef) }, return # signal error to callback, later
1052 if $some_error_condition; 1058 if $some_error_condition;
1053 1059
1060=item AnyEvent::log $level, $msg[, @args]
1061
1062Log the given C<$msg> at the given C<$level>.
1063
1064If L<AnyEvent::Log> is not loaded then this function makes a simple test
1065to see whether the message will be logged. If the test succeeds it will
1066load AnyEvent::Log and call C<AnyEvent::Log::log> - consequently, look at
1067the L<AnyEvent::Log> documentation for details.
1068
1069If the test fails it will simply return. Right now this happens when a
1070numerical loglevel is used and it is larger than the level specified via
1071C<$ENV{PERL_ANYEVENT_VERBOSE}>.
1072
1073If you want to sprinkle loads of logging calls around your code, consider
1074creating a logger callback with the C<AnyEvent::Log::logger> function,
1075which can reduce typing, codesize and can reduce the logging overhead
1076enourmously.
1077
1054=back 1078=back
1055 1079
1056=head1 WHAT TO DO IN A MODULE 1080=head1 WHAT TO DO IN A MODULE
1057 1081
1058As a module author, you should C<use AnyEvent> and call AnyEvent methods 1082As a module author, you should C<use AnyEvent> and call AnyEvent methods
… …
1114 1138
1115 1139
1116=head1 OTHER MODULES 1140=head1 OTHER MODULES
1117 1141
1118The following is a non-exhaustive list of additional modules that use 1142The following is a non-exhaustive list of additional modules that use
1119AnyEvent as a client and can therefore be mixed easily with other AnyEvent 1143AnyEvent as a client and can therefore be mixed easily with other
1120modules and other event loops in the same program. Some of the modules 1144AnyEvent modules and other event loops in the same program. Some of the
1121come as part of AnyEvent, the others are available via CPAN. 1145modules come as part of AnyEvent, the others are available via CPAN (see
1146L<http://search.cpan.org/search?m=module&q=anyevent%3A%3A*> for
1147a longer non-exhaustive list), and the list is heavily biased towards
1148modules of the AnyEvent author himself :)
1122 1149
1123=over 4 1150=over 4
1124 1151
1125=item L<AnyEvent::Util> 1152=item L<AnyEvent::Util>
1126 1153
… …
1146=item L<AnyEvent::HTTP>, L<AnyEvent::IRC>, L<AnyEvent::XMPP>, L<AnyEvent::GPSD>, L<AnyEvent::IGS>, L<AnyEvent::FCP> 1173=item L<AnyEvent::HTTP>, L<AnyEvent::IRC>, L<AnyEvent::XMPP>, L<AnyEvent::GPSD>, L<AnyEvent::IGS>, L<AnyEvent::FCP>
1147 1174
1148Implement event-based interfaces to the protocols of the same name (for 1175Implement event-based interfaces to the protocols of the same name (for
1149the curious, IGS is the International Go Server and FCP is the Freenet 1176the curious, IGS is the International Go Server and FCP is the Freenet
1150Client Protocol). 1177Client Protocol).
1151
1152=item L<AnyEvent::Handle::UDP>
1153
1154Here be danger!
1155
1156As Pauli would put it, "Not only is it not right, it's not even wrong!" -
1157there are so many things wrong with AnyEvent::Handle::UDP, most notably
1158its use of a stream-based API with a protocol that isn't streamable, that
1159the only way to improve it is to delete it.
1160
1161It features data corruption (but typically only under load) and general
1162confusion. On top, the author is not only clueless about UDP but also
1163fact-resistant - some gems of his understanding: "connect doesn't work
1164with UDP", "UDP packets are not IP packets", "UDP only has datagrams, not
1165packets", "I don't need to implement proper error checking as UDP doesn't
1166support error checking" and so on - he doesn't even understand what's
1167wrong with his module when it is explained to him.
1168
1169=item L<AnyEvent::DBI>
1170
1171Executes L<DBI> requests asynchronously in a proxy process for you,
1172notifying you in an event-based way when the operation is finished.
1173 1178
1174=item L<AnyEvent::AIO> 1179=item L<AnyEvent::AIO>
1175 1180
1176Truly asynchronous (as opposed to non-blocking) I/O, should be in the 1181Truly asynchronous (as opposed to non-blocking) I/O, should be in the
1177toolbox of every event programmer. AnyEvent::AIO transparently fuses 1182toolbox of every event programmer. AnyEvent::AIO transparently fuses
1178L<IO::AIO> and AnyEvent together, giving AnyEvent access to event-based 1183L<IO::AIO> and AnyEvent together, giving AnyEvent access to event-based
1179file I/O, and much more. 1184file I/O, and much more.
1180 1185
1186=item L<AnyEvent::Filesys::Notify>
1187
1188AnyEvent is good for non-blocking stuff, but it can't detect file or
1189path changes (e.g. "watch this directory for new files", "watch this
1190file for changes"). The L<AnyEvent::Filesys::Notify> module promises to
1191do just that in a portbale fashion, supporting inotify on GNU/Linux and
1192some weird, without doubt broken, stuff on OS X to monitor files. It can
1193fall back to blocking scans at regular intervals transparently on other
1194platforms, so it's about as portable as it gets.
1195
1196(I haven't used it myself, but I haven't heard anybody complaining about
1197it yet).
1198
1199=item L<AnyEvent::DBI>
1200
1201Executes L<DBI> requests asynchronously in a proxy process for you,
1202notifying you in an event-based way when the operation is finished.
1203
1181=item L<AnyEvent::HTTPD> 1204=item L<AnyEvent::HTTPD>
1182 1205
1183A simple embedded webserver. 1206A simple embedded webserver.
1184 1207
1185=item L<AnyEvent::FastPing> 1208=item L<AnyEvent::FastPing>
1186 1209
1187The fastest ping in the west. 1210The fastest ping in the west.
1188 1211
1189=item L<Coro> 1212=item L<Coro>
1190 1213
1191Has special support for AnyEvent via L<Coro::AnyEvent>. 1214Has special support for AnyEvent via L<Coro::AnyEvent>, which allows you
1215to simply invert the flow control - don't call us, we will call you:
1216
1217 async {
1218 Coro::AnyEvent::sleep 5; # creates a 5s timer and waits for it
1219 print "5 seconds later!\n";
1220
1221 Coro::AnyEvent::readable *STDIN; # uses an I/O watcher
1222 my $line = <STDIN>; # works for ttys
1223
1224 AnyEvent::HTTP::http_get "url", Coro::rouse_cb;
1225 my ($body, $hdr) = Coro::rouse_wait;
1226 };
1192 1227
1193=back 1228=back
1194 1229
1195=cut 1230=cut
1196 1231
1197package AnyEvent; 1232package AnyEvent;
1198 1233
1199# basically a tuned-down version of common::sense 1234# basically a tuned-down version of common::sense
1200sub common_sense { 1235sub common_sense {
1201 # from common:.sense 3.4 1236 # from common:.sense 3.5
1237 local $^W;
1202 ${^WARNING_BITS} ^= ${^WARNING_BITS} ^ "\x3c\x3f\x33\x00\x0f\xf0\x0f\xc0\xf0\xfc\x33\x00"; 1238 ${^WARNING_BITS} ^= ${^WARNING_BITS} ^ "\x3c\x3f\x33\x00\x0f\xf0\x0f\xc0\xf0\xfc\x33\x00";
1203 # use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl) 1239 # use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1204 $^H |= 0x00000600; 1240 $^H |= 0x00000600;
1205} 1241}
1206 1242
1207BEGIN { AnyEvent::common_sense } 1243BEGIN { AnyEvent::common_sense }
1208 1244
1209use Carp (); 1245use Carp ();
1210 1246
1211our $VERSION = '6.01'; 1247our $VERSION = '7.04';
1212our $MODEL; 1248our $MODEL;
1213
1214our @ISA; 1249our @ISA;
1215
1216our @REGISTRY; 1250our @REGISTRY;
1217
1218our $VERBOSE; 1251our $VERBOSE;
1252our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred
1253our $MAX_SIGNAL_LATENCY = $ENV{PERL_ANYEVENT_MAX_SIGNAL_LATENCY} || 10; # executes after the BEGIN block below (tainting!)
1219 1254
1220BEGIN { 1255BEGIN {
1221 require "AnyEvent/constants.pl"; 1256 require "AnyEvent/constants.pl";
1222 1257
1223 eval "sub TAINT (){" . (${^TAINT}*1) . "}"; 1258 eval "sub TAINT (){" . (${^TAINT}*1) . "}";
1224 1259
1225 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV} 1260 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
1226 if ${^TAINT}; 1261 if ${^TAINT};
1227 1262
1228 $VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1; 1263 $ENV{"PERL_ANYEVENT_$_"} = $ENV{"AE_$_"}
1264 for grep s/^AE_// && !exists $ENV{"PERL_ANYEVENT_$_"}, keys %ENV;
1229 1265
1230} 1266 @ENV{grep /^PERL_ANYEVENT_/, keys %ENV} = ()
1267 if ${^TAINT};
1231 1268
1232our $MAX_SIGNAL_LATENCY = 10; 1269 # $ENV{PERL_ANYEVENT_xxx} now valid
1233 1270
1234our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred 1271 $VERBOSE = length $ENV{PERL_ANYEVENT_VERBOSE} ? $ENV{PERL_ANYEVENT_VERBOSE}*1 : 4;
1235 1272
1236{
1237 my $idx; 1273 my $idx;
1238 $PROTOCOL{$_} = ++$idx 1274 $PROTOCOL{$_} = ++$idx
1239 for reverse split /\s*,\s*/, 1275 for reverse split /\s*,\s*/,
1240 $ENV{PERL_ANYEVENT_PROTOCOLS} || "ipv4,ipv6"; 1276 $ENV{PERL_ANYEVENT_PROTOCOLS} || "ipv4,ipv6";
1241} 1277}
… …
1272 $POSTPONE_W ||= AE::timer (0, 0, \&_postpone_exec); 1308 $POSTPONE_W ||= AE::timer (0, 0, \&_postpone_exec);
1273 1309
1274 () 1310 ()
1275} 1311}
1276 1312
1313sub log($$;@) {
1314 # only load the big bloated module when we actually are about to log something
1315 if ($_[0] <= ($VERBOSE || 1)) { # also catches non-numeric levels(!) and fatal
1316 local ($!, $@);
1317 require AnyEvent::Log; # among other things, sets $VERBOSE to 9
1318 # AnyEvent::Log overwrites this function
1319 goto &log;
1320 }
1321
1322 0 # not logged
1323}
1324
1325sub _logger($;$) {
1326 my ($level, $renabled) = @_;
1327
1328 $$renabled = $level <= $VERBOSE;
1329
1330 my $logger = [(caller)[0], $level, $renabled];
1331
1332 $AnyEvent::Log::LOGGER{$logger+0} = $logger;
1333
1334# return unless defined wantarray;
1335#
1336# require AnyEvent::Util;
1337# my $guard = AnyEvent::Util::guard (sub {
1338# # "clean up"
1339# delete $LOGGER{$logger+0};
1340# });
1341#
1342# sub {
1343# return 0 unless $$renabled;
1344#
1345# $guard if 0; # keep guard alive, but don't cause runtime overhead
1346# require AnyEvent::Log unless $AnyEvent::Log::VERSION;
1347# package AnyEvent::Log;
1348# _log ($logger->[0], $level, @_) # logger->[0] has been converted at load time
1349# }
1350}
1351
1352if (length $ENV{PERL_ANYEVENT_LOG}) {
1353 require AnyEvent::Log; # AnyEvent::Log does the thing for us
1354}
1355
1277our @models = ( 1356our @models = (
1278 [EV:: => AnyEvent::Impl::EV:: , 1], 1357 [EV:: => AnyEvent::Impl::EV::],
1279 [AnyEvent::Loop:: => AnyEvent::Impl::Perl:: , 1], 1358 [AnyEvent::Loop:: => AnyEvent::Impl::Perl::],
1280 # everything below here will not (normally) be autoprobed 1359 # everything below here will not (normally) be autoprobed
1281 # as the pure perl backend should work everywhere 1360 # as the pure perl backend should work everywhere
1282 # and is usually faster 1361 # and is usually faster
1362 [Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package, so msut be near the top
1283 [Event:: => AnyEvent::Impl::Event::, 1], 1363 [Event:: => AnyEvent::Impl::Event::], # slow, stable
1284 [Glib:: => AnyEvent::Impl::Glib:: , 1], # becomes extremely slow with many watchers 1364 [Glib:: => AnyEvent::Impl::Glib::], # becomes extremely slow with many watchers
1365 # everything below here should not be autoloaded
1285 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy 1366 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy
1286 [Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package
1287 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles 1367 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles
1288 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program 1368 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program
1289 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza 1369 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza
1290 [Wx:: => AnyEvent::Impl::POE::], 1370 [Wx:: => AnyEvent::Impl::POE::],
1291 [Prima:: => AnyEvent::Impl::POE::], 1371 [Prima:: => AnyEvent::Impl::POE::],
1292 [IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # a bitch to autodetect 1372 [IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # a bitch to autodetect
1293 [Cocoa::EventLoop:: => AnyEvent::Impl::Cocoa::], 1373 [Cocoa::EventLoop:: => AnyEvent::Impl::Cocoa::],
1294 [FLTK:: => AnyEvent::Impl::FLTK2::], 1374 [FLTK:: => AnyEvent::Impl::FLTK::],
1295); 1375);
1296 1376
1297our @isa_hook; 1377our @isa_hook;
1298 1378
1299sub _isa_set { 1379sub _isa_set {
1300 my @pkg = ("AnyEvent", (grep defined, map $_->[0], @isa_hook), $MODEL); 1380 my @pkg = ("AnyEvent", (map $_->[0], grep defined, @isa_hook), $MODEL);
1301 1381
1302 @{"$pkg[$_-1]::ISA"} = $pkg[$_] 1382 @{"$pkg[$_-1]::ISA"} = $pkg[$_]
1303 for 1 .. $#pkg; 1383 for 1 .. $#pkg;
1304 1384
1305 grep $_->[1], @isa_hook 1385 grep $_ && $_->[1], @isa_hook
1306 and AE::_reset (); 1386 and AE::_reset ();
1307} 1387}
1308 1388
1309# used for hooking AnyEvent::Strict and AnyEvent::Debug::Wrap into the class hierarchy 1389# used for hooking AnyEvent::Strict and AnyEvent::Debug::Wrap into the class hierarchy
1310sub _isa_hook($$;$) { 1390sub _isa_hook($$;$) {
1311 my ($i, $pkg, $reset_ae) = @_; 1391 my ($i, $pkg, $reset_ae) = @_;
1312 1392
1313 $isa_hook[$i] = [$pkg, $reset_ae]; 1393 $isa_hook[$i] = $pkg ? [$pkg, $reset_ae] : undef;
1314 1394
1315 _isa_set; 1395 _isa_set;
1316} 1396}
1317 1397
1318# all autoloaded methods reserve the complete glob, not just the method slot. 1398# all autoloaded methods reserve the complete glob, not just the method slot.
1319# due to bugs in perls method cache implementation. 1399# due to bugs in perls method cache implementation.
1320our @methods = qw(io timer time now now_update signal child idle condvar); 1400our @methods = qw(io timer time now now_update signal child idle condvar);
1321 1401
1322sub detect() { 1402sub detect() {
1403 return $MODEL if $MODEL; # some programs keep references to detect
1404
1405 # IO::Async::Loop::AnyEvent is extremely evil, refuse to work with it
1406 # the author knows about the problems and what it does to AnyEvent as a whole
1407 # (and the ability of others to use AnyEvent), but simply wants to abuse AnyEvent
1408 # anyway.
1409 AnyEvent::log fatal => "IO::Async::Loop::AnyEvent detected - that module is broken by\n"
1410 . "design, abuses internals and breaks AnyEvent - will not continue."
1411 if exists $INC{"IO/Async/Loop/AnyEvent.pm"};
1412
1323 local $!; # for good measure 1413 local $!; # for good measure
1324 local $SIG{__DIE__}; # we use eval 1414 local $SIG{__DIE__}; # we use eval
1325 1415
1326 # free some memory 1416 # free some memory
1327 *detect = sub () { $MODEL }; 1417 *detect = sub () { $MODEL };
… …
1335 1425
1336 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z0-9:]+)$/) { 1426 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z0-9:]+)$/) {
1337 my $model = $1; 1427 my $model = $1;
1338 $model = "AnyEvent::Impl::$model" unless $model =~ s/::$//; 1428 $model = "AnyEvent::Impl::$model" unless $model =~ s/::$//;
1339 if (eval "require $model") { 1429 if (eval "require $model") {
1430 AnyEvent::log 7 => "Loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.";
1340 $MODEL = $model; 1431 $MODEL = $model;
1341 warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2;
1342 } else { 1432 } else {
1343 warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE; 1433 AnyEvent::log 4 => "Unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@";
1344 } 1434 }
1345 } 1435 }
1346 1436
1347 # check for already loaded models 1437 # check for already loaded models
1348 unless ($MODEL) { 1438 unless ($MODEL) {
1349 for (@REGISTRY, @models) { 1439 for (@REGISTRY, @models) {
1350 my ($package, $model) = @$_; 1440 my ($package, $model) = @$_;
1351 if (${"$package\::VERSION"} > 0) { 1441 if (${"$package\::VERSION"} > 0) {
1352 if (eval "require $model") { 1442 if (eval "require $model") {
1443 AnyEvent::log 7 => "Autodetected model '$model', using it.";
1353 $MODEL = $model; 1444 $MODEL = $model;
1354 warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2; 1445 last;
1446 } else {
1447 AnyEvent::log 8 => "Detected event loop $package, but cannot load '$model', skipping: $@";
1448 }
1449 }
1450 }
1451
1452 unless ($MODEL) {
1453 # try to autoload a model
1454 for (@REGISTRY, @models) {
1455 my ($package, $model) = @$_;
1456 if (
1457 eval "require $package"
1458 and ${"$package\::VERSION"} > 0
1459 and eval "require $model"
1460 ) {
1461 AnyEvent::log 7 => "Autoloaded model '$model', using it.";
1462 $MODEL = $model;
1355 last; 1463 last;
1356 } 1464 }
1357 } 1465 }
1358 }
1359
1360 unless ($MODEL) {
1361 # try to autoload a model
1362 for (@REGISTRY, @models) {
1363 my ($package, $model, $autoload) = @$_;
1364 if (
1365 $autoload
1366 and eval "require $package"
1367 and ${"$package\::VERSION"} > 0
1368 and eval "require $model"
1369 ) {
1370 $MODEL = $model;
1371 warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1372 last;
1373 }
1374 }
1375 1466
1376 $MODEL 1467 $MODEL
1377 or die "AnyEvent: backend autodetection failed - did you properly install AnyEvent?\n"; 1468 or AnyEvent::log fatal => "Backend autodetection failed - did you properly install AnyEvent?";
1378 } 1469 }
1379 } 1470 }
1380 1471
1381 # free memory only needed for probing 1472 # free memory only needed for probing
1382 undef @models; 1473 undef @models;
… …
1391 if defined &{"$MODEL\::$_"}; 1482 if defined &{"$MODEL\::$_"};
1392 } 1483 }
1393 1484
1394 _isa_set; 1485 _isa_set;
1395 1486
1487 # we're officially open!
1488
1396 if ($ENV{PERL_ANYEVENT_STRICT}) { 1489 if ($ENV{PERL_ANYEVENT_STRICT}) {
1397 require AnyEvent::Strict; 1490 require AnyEvent::Strict;
1398 } 1491 }
1399 1492
1400 if ($ENV{PERL_ANYEVENT_DEBUG_WRAP}) { 1493 if ($ENV{PERL_ANYEVENT_DEBUG_WRAP}) {
1401 require AnyEvent::Debug; 1494 require AnyEvent::Debug;
1402 AnyEvent::Debug::wrap ($ENV{PERL_ANYEVENT_DEBUG_WRAP}); 1495 AnyEvent::Debug::wrap ($ENV{PERL_ANYEVENT_DEBUG_WRAP});
1403 } 1496 }
1404 1497
1405 if (exists $ENV{PERL_ANYEVENT_DEBUG_SHELL}) { 1498 if (length $ENV{PERL_ANYEVENT_DEBUG_SHELL}) {
1406 require AnyEvent::Socket; 1499 require AnyEvent::Socket;
1407 require AnyEvent::Debug; 1500 require AnyEvent::Debug;
1408 1501
1409 my $shell = $ENV{PERL_ANYEVENT_DEBUG_SHELL}; 1502 my $shell = $ENV{PERL_ANYEVENT_DEBUG_SHELL};
1410 $shell =~ s/\$\$/$$/g; 1503 $shell =~ s/\$\$/$$/g;
1411 1504
1412 my ($host, $service) = AnyEvent::Socket::parse_hostport ($shell); 1505 my ($host, $service) = AnyEvent::Socket::parse_hostport ($shell);
1413 $AnyEvent::Debug::SHELL = AnyEvent::Debug::shell ($host, $service); 1506 $AnyEvent::Debug::SHELL = AnyEvent::Debug::shell ($host, $service);
1414 } 1507 }
1508
1509 # now the anyevent environment is set up as the user told us to, so
1510 # call the actual user code - post detects
1415 1511
1416 (shift @post_detect)->() while @post_detect; 1512 (shift @post_detect)->() while @post_detect;
1417 undef @post_detect; 1513 undef @post_detect;
1418 1514
1419 *post_detect = sub(&) { 1515 *post_detect = sub(&) {
… …
1506 sub time() { 1602 sub time() {
1507 AnyEvent->time 1603 AnyEvent->time
1508 } 1604 }
1509 1605
1510 *postpone = \&AnyEvent::postpone; 1606 *postpone = \&AnyEvent::postpone;
1607 *log = \&AnyEvent::log;
1511 }; 1608 };
1512 die if $@; 1609 die if $@;
1513} 1610}
1514 1611
1515BEGIN { _reset } 1612BEGIN { _reset }
… …
1520 1617
1521sub time { 1618sub time {
1522 eval q{ # poor man's autoloading {} 1619 eval q{ # poor man's autoloading {}
1523 # probe for availability of Time::HiRes 1620 # probe for availability of Time::HiRes
1524 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") { 1621 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1525 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;
1526 *time = sub { Time::HiRes::time () }; 1622 *time = sub { Time::HiRes::time () };
1527 *AE::time = \& Time::HiRes::time ; 1623 *AE::time = \& Time::HiRes::time ;
1624 *now = \&time;
1625 AnyEvent::log 8 => "using Time::HiRes for sub-second timing accuracy.";
1528 # if (eval "use POSIX (); (POSIX::times())... 1626 # if (eval "use POSIX (); (POSIX::times())...
1529 } else { 1627 } else {
1530 warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;
1531 *time = sub { CORE::time }; 1628 *time = sub { CORE::time };
1532 *AE::time = sub (){ CORE::time }; 1629 *AE::time = sub (){ CORE::time };
1630 *now = \&time;
1631 AnyEvent::log 3 => "Using built-in time(), no sub-second resolution!";
1533 } 1632 }
1534
1535 *now = \&time;
1536 }; 1633 };
1537 die if $@; 1634 die if $@;
1538 1635
1539 &time 1636 &time
1540} 1637}
… …
1633 1730
1634sub signal { 1731sub signal {
1635 eval q{ # poor man's autoloading {} 1732 eval q{ # poor man's autoloading {}
1636 # probe for availability of Async::Interrupt 1733 # probe for availability of Async::Interrupt
1637 if (_have_async_interrupt) { 1734 if (_have_async_interrupt) {
1638 warn "AnyEvent: using Async::Interrupt for race-free signal handling.\n" if $VERBOSE >= 8; 1735 AnyEvent::log 8 => "Using Async::Interrupt for race-free signal handling.";
1639 1736
1640 $SIGPIPE_R = new Async::Interrupt::EventPipe; 1737 $SIGPIPE_R = new Async::Interrupt::EventPipe;
1641 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec; 1738 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1642 1739
1643 } else { 1740 } else {
1644 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8; 1741 AnyEvent::log 8 => "Using emulated perl signal handling with latency timer.";
1645 1742
1646 if (AnyEvent::WIN32) { 1743 if (AnyEvent::WIN32) {
1647 require AnyEvent::Util; 1744 require AnyEvent::Util;
1648 1745
1649 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe (); 1746 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
… …
1943$Event/EV::DIED->() >>, L<Glib> uses C<< install_exception_handler >> and 2040$Event/EV::DIED->() >>, L<Glib> uses C<< install_exception_handler >> and
1944so on. 2041so on.
1945 2042
1946=head1 ENVIRONMENT VARIABLES 2043=head1 ENVIRONMENT VARIABLES
1947 2044
1948The following environment variables are used by this module or its 2045AnyEvent supports a number of environment variables that tune the
1949submodules. 2046runtime behaviour. They are usually evaluated when AnyEvent is
2047loaded, initialised, or a submodule that uses them is loaded. Many of
2048them also cause AnyEvent to load additional modules - for example,
2049C<PERL_ANYEVENT_DEBUG_WRAP> causes the L<AnyEvent::Debug> module to be
2050loaded.
1950 2051
1951Note that AnyEvent will remove I<all> environment variables starting with 2052All the environment variables documented here start with
1952C<PERL_ANYEVENT_> from C<%ENV> when it is loaded while taint mode is 2053C<PERL_ANYEVENT_>, which is what AnyEvent considers its own
1953enabled. 2054namespace. Other modules are encouraged (but by no means required) to use
2055C<PERL_ANYEVENT_SUBMODULE> if they have registered the AnyEvent::Submodule
2056namespace on CPAN, for any submodule. For example, L<AnyEvent::HTTP> could
2057be expected to use C<PERL_ANYEVENT_HTTP_PROXY> (it should not access env
2058variables starting with C<AE_>, see below).
2059
2060All variables can also be set via the C<AE_> prefix, that is, instead
2061of setting C<PERL_ANYEVENT_VERBOSE> you can also set C<AE_VERBOSE>. In
2062case there is a clash btween anyevent and another program that uses
2063C<AE_something> you can set the corresponding C<PERL_ANYEVENT_something>
2064variable to the empty string, as those variables take precedence.
2065
2066When AnyEvent is first loaded, it copies all C<AE_xxx> env variables
2067to their C<PERL_ANYEVENT_xxx> counterpart unless that variable already
2068exists. If taint mode is on, then AnyEvent will remove I<all> environment
2069variables starting with C<PERL_ANYEVENT_> from C<%ENV> (or replace them
2070with C<undef> or the empty string, if the corresaponding C<AE_> variable
2071is set).
2072
2073The exact algorithm is currently:
2074
2075 1. if taint mode enabled, delete all PERL_ANYEVENT_xyz variables from %ENV
2076 2. copy over AE_xyz to PERL_ANYEVENT_xyz unless the latter alraedy exists
2077 3. if taint mode enabled, set all PERL_ANYEVENT_xyz variables to undef.
2078
2079This ensures that child processes will not see the C<AE_> variables.
2080
2081The following environment variables are currently known to AnyEvent:
1954 2082
1955=over 4 2083=over 4
1956 2084
1957=item C<PERL_ANYEVENT_VERBOSE> 2085=item C<PERL_ANYEVENT_VERBOSE>
1958 2086
1959By default, AnyEvent will be completely silent except in fatal 2087By default, AnyEvent will log messages with loglevel C<4> (C<error>) or
1960conditions. You can set this environment variable to make AnyEvent more 2088higher (see L<AnyEvent::Log>). You can set this environment variable to a
1961talkative. 2089numerical loglevel to make AnyEvent more (or less) talkative.
1962 2090
2091If you want to do more than just set the global logging level
2092you should have a look at C<PERL_ANYEVENT_LOG>, which allows much more
2093complex specifications.
2094
2095When set to C<0> (C<off>), then no messages whatsoever will be logged with
2096everything else at defaults.
2097
1963When set to C<1> or higher, causes AnyEvent to warn about unexpected 2098When set to C<5> or higher (C<warn>), AnyEvent warns about unexpected
1964conditions, such as not being able to load the event model specified by 2099conditions, such as not being able to load the event model specified by
1965C<PERL_ANYEVENT_MODEL>. 2100C<PERL_ANYEVENT_MODEL>, or a guard callback throwing an exception - this
2101is the minimum recommended level for use during development.
1966 2102
1967When set to C<2> or higher, cause AnyEvent to report to STDERR which event 2103When set to C<7> or higher (info), AnyEvent reports which event model it
1968model it chooses. 2104chooses.
1969 2105
1970When set to C<8> or higher, then AnyEvent will report extra information on 2106When set to C<8> or higher (debug), then AnyEvent will report extra
1971which optional modules it loads and how it implements certain features. 2107information on which optional modules it loads and how it implements
2108certain features.
2109
2110=item C<PERL_ANYEVENT_LOG>
2111
2112Accepts rather complex logging specifications. For example, you could log
2113all C<debug> messages of some module to stderr, warnings and above to
2114stderr, and errors and above to syslog, with:
2115
2116 PERL_ANYEVENT_LOG=Some::Module=debug,+log:filter=warn,+%syslog:%syslog=error,syslog
2117
2118For the rather extensive details, see L<AnyEvent::Log>.
2119
2120This variable is evaluated when AnyEvent (or L<AnyEvent::Log>) is loaded,
2121so will take effect even before AnyEvent has initialised itself.
2122
2123Note that specifying this environment variable causes the L<AnyEvent::Log>
2124module to be loaded, while C<PERL_ANYEVENT_VERBOSE> does not, so only
2125using the latter saves a few hundred kB of memory unless a module
2126explicitly needs the extra features of AnyEvent::Log.
1972 2127
1973=item C<PERL_ANYEVENT_STRICT> 2128=item C<PERL_ANYEVENT_STRICT>
1974 2129
1975AnyEvent does not do much argument checking by default, as thorough 2130AnyEvent does not do much argument checking by default, as thorough
1976argument checking is very costly. Setting this variable to a true value 2131argument checking is very costly. Setting this variable to a true value
… …
1985C<PERL_ANYEVENT_STRICT=1> in your environment while developing programs 2140C<PERL_ANYEVENT_STRICT=1> in your environment while developing programs
1986can be very useful, however. 2141can be very useful, however.
1987 2142
1988=item C<PERL_ANYEVENT_DEBUG_SHELL> 2143=item C<PERL_ANYEVENT_DEBUG_SHELL>
1989 2144
1990If this env variable is set, then its contents will be interpreted by 2145If this env variable is nonempty, then its contents will be interpreted by
1991C<AnyEvent::Socket::parse_hostport> (after replacing every occurance of 2146C<AnyEvent::Socket::parse_hostport> and C<AnyEvent::Debug::shell> (after
1992C<$$> by the process pid) and an C<AnyEvent::Debug::shell> is bound on 2147replacing every occurance of C<$$> by the process pid). The shell object
1993that port. The shell object is saved in C<$AnyEvent::Debug::SHELL>. 2148is saved in C<$AnyEvent::Debug::SHELL>.
1994 2149
1995This takes place when the first watcher is created. 2150This happens when the first watcher is created.
1996 2151
1997For example, to bind a debug shell on a unix domain socket in 2152For example, to bind a debug shell on a unix domain socket in
1998F<< /tmp/debug<pid>.sock >>, you could use this: 2153F<< /tmp/debug<pid>.sock >>, you could use this:
1999 2154
2000 PERL_ANYEVENT_DEBUG_SHELL=unix/:/tmp/debug\$\$.sock perlprog 2155 PERL_ANYEVENT_DEBUG_SHELL=/tmp/debug\$\$.sock perlprog
2156 # connect with e.g.: socat readline /tmp/debug123.sock
2001 2157
2158Or to bind to tcp port 4545 on localhost:
2159
2160 PERL_ANYEVENT_DEBUG_SHELL=127.0.0.1:4545 perlprog
2161 # connect with e.g.: telnet localhost 4545
2162
2002Note that creating sockets in F</tmp> is very unsafe on multiuser 2163Note that creating sockets in F</tmp> or on localhost is very unsafe on
2003systems. 2164multiuser systems.
2004 2165
2005=item C<PERL_ANYEVENT_DEBUG_WRAP> 2166=item C<PERL_ANYEVENT_DEBUG_WRAP>
2006 2167
2007Can be set to C<0>, C<1> or C<2> and enables wrapping of all watchers for 2168Can be set to C<0>, C<1> or C<2> and enables wrapping of all watchers for
2008debugging purposes. See C<AnyEvent::Debug::wrap> for details. 2169debugging purposes. See C<AnyEvent::Debug::wrap> for details.
… …
2025For example, to force the pure perl model (L<AnyEvent::Loop::Perl>) you 2186For example, to force the pure perl model (L<AnyEvent::Loop::Perl>) you
2026could start your program like this: 2187could start your program like this:
2027 2188
2028 PERL_ANYEVENT_MODEL=Perl perl ... 2189 PERL_ANYEVENT_MODEL=Perl perl ...
2029 2190
2191=item C<PERL_ANYEVENT_IO_MODEL>
2192
2193The current file I/O model - see L<AnyEvent::IO> for more info.
2194
2195At the moment, only C<Perl> (small, pure-perl, synchronous) and
2196C<IOAIO> (truly asynchronous) are supported. The default is C<IOAIO> if
2197L<AnyEvent::AIO> can be loaded, otherwise it is C<Perl>.
2198
2030=item C<PERL_ANYEVENT_PROTOCOLS> 2199=item C<PERL_ANYEVENT_PROTOCOLS>
2031 2200
2032Used by both L<AnyEvent::DNS> and L<AnyEvent::Socket> to determine preferences 2201Used by both L<AnyEvent::DNS> and L<AnyEvent::Socket> to determine preferences
2033for IPv4 or IPv6. The default is unspecified (and might change, or be the result 2202for IPv4 or IPv6. The default is unspecified (and might change, or be the result
2034of auto probing). 2203of auto probing).
… …
2046but support both and try to use both. C<PERL_ANYEVENT_PROTOCOLS=ipv4> 2215but support both and try to use both. C<PERL_ANYEVENT_PROTOCOLS=ipv4>
2047- only support IPv4, never try to resolve or contact IPv6 2216- only support IPv4, never try to resolve or contact IPv6
2048addresses. C<PERL_ANYEVENT_PROTOCOLS=ipv6,ipv4> support either IPv4 or 2217addresses. C<PERL_ANYEVENT_PROTOCOLS=ipv6,ipv4> support either IPv4 or
2049IPv6, but prefer IPv6 over IPv4. 2218IPv6, but prefer IPv6 over IPv4.
2050 2219
2220=item C<PERL_ANYEVENT_HOSTS>
2221
2222This variable, if specified, overrides the F</etc/hosts> file used by
2223L<AnyEvent::Socket>C<::resolve_sockaddr>, i.e. hosts aliases will be read
2224from that file instead.
2225
2051=item C<PERL_ANYEVENT_EDNS0> 2226=item C<PERL_ANYEVENT_EDNS0>
2052 2227
2053Used by L<AnyEvent::DNS> to decide whether to use the EDNS0 extension 2228Used by L<AnyEvent::DNS> to decide whether to use the EDNS0 extension for
2054for DNS. This extension is generally useful to reduce DNS traffic, but 2229DNS. This extension is generally useful to reduce DNS traffic, especially
2055some (broken) firewalls drop such DNS packets, which is why it is off by 2230when DNSSEC is involved, but some (broken) firewalls drop such DNS
2056default. 2231packets, which is why it is off by default.
2057 2232
2058Setting this variable to C<1> will cause L<AnyEvent::DNS> to announce 2233Setting this variable to C<1> will cause L<AnyEvent::DNS> to announce
2059EDNS0 in its DNS requests. 2234EDNS0 in its DNS requests.
2060 2235
2061=item C<PERL_ANYEVENT_MAX_FORKS> 2236=item C<PERL_ANYEVENT_MAX_FORKS>
… …
2067 2242
2068The default value for the C<max_outstanding> parameter for the default DNS 2243The default value for the C<max_outstanding> parameter for the default DNS
2069resolver - this is the maximum number of parallel DNS requests that are 2244resolver - this is the maximum number of parallel DNS requests that are
2070sent to the DNS server. 2245sent to the DNS server.
2071 2246
2247=item C<PERL_ANYEVENT_MAX_SIGNAL_LATENCY>
2248
2249Perl has inherently racy signal handling (you can basically choose between
2250losing signals and memory corruption) - pure perl event loops (including
2251C<AnyEvent::Loop>, when C<Async::Interrupt> isn't available) therefore
2252have to poll regularly to avoid losing signals.
2253
2254Some event loops are racy, but don't poll regularly, and some event loops
2255are written in C but are still racy. For those event loops, AnyEvent
2256installs a timer that regularly wakes up the event loop.
2257
2258By default, the interval for this timer is C<10> seconds, but you can
2259override this delay with this environment variable (or by setting
2260the C<$AnyEvent::MAX_SIGNAL_LATENCY> variable before creating signal
2261watchers).
2262
2263Lower values increase CPU (and energy) usage, higher values can introduce
2264long delays when reaping children or waiting for signals.
2265
2266The L<AnyEvent::Async> module, if available, will be used to avoid this
2267polling (with most event loops).
2268
2072=item C<PERL_ANYEVENT_RESOLV_CONF> 2269=item C<PERL_ANYEVENT_RESOLV_CONF>
2073 2270
2074The file to use instead of F</etc/resolv.conf> (or OS-specific 2271The absolute path to a F<resolv.conf>-style file to use instead of
2075configuration) in the default resolver. When set to the empty string, no 2272F</etc/resolv.conf> (or the OS-specific configuration) in the default
2076default config will be used. 2273resolver, or the empty string to select the default configuration.
2077 2274
2078=item C<PERL_ANYEVENT_CA_FILE>, C<PERL_ANYEVENT_CA_PATH>. 2275=item C<PERL_ANYEVENT_CA_FILE>, C<PERL_ANYEVENT_CA_PATH>.
2079 2276
2080When neither C<ca_file> nor C<ca_path> was specified during 2277When neither C<ca_file> nor C<ca_path> was specified during
2081L<AnyEvent::TLS> context creation, and either of these environment 2278L<AnyEvent::TLS> context creation, and either of these environment
2082variables exist, they will be used to specify CA certificate locations 2279variables are nonempty, they will be used to specify CA certificate
2083instead of a system-dependent default. 2280locations instead of a system-dependent default.
2084 2281
2085=item C<PERL_ANYEVENT_AVOID_GUARD> and C<PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT> 2282=item C<PERL_ANYEVENT_AVOID_GUARD> and C<PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT>
2086 2283
2087When these are set to C<1>, then the respective modules are not 2284When these are set to C<1>, then the respective modules are not
2088loaded. Mostly good for testing AnyEvent itself. 2285loaded. Mostly good for testing AnyEvent itself.
… …
2420(even when used without AnyEvent), but most event loops have acceptable 2617(even when used without AnyEvent), but most event loops have acceptable
2421performance with or without AnyEvent. 2618performance with or without AnyEvent.
2422 2619
2423=item * The overhead AnyEvent adds is usually much smaller than the overhead of 2620=item * The overhead AnyEvent adds is usually much smaller than the overhead of
2424the actual event loop, only with extremely fast event loops such as EV 2621the actual event loop, only with extremely fast event loops such as EV
2425adds AnyEvent significant overhead. 2622does AnyEvent add significant overhead.
2426 2623
2427=item * You should avoid POE like the plague if you want performance or 2624=item * You should avoid POE like the plague if you want performance or
2428reasonable memory usage. 2625reasonable memory usage.
2429 2626
2430=back 2627=back
… …
2732This module is part of perl since release 5.008. It will be used when the 2929This module is part of perl since release 5.008. It will be used when the
2733chosen event library does not come with a timing source of its own. The 2930chosen event library does not come with a timing source of its own. The
2734pure-perl event loop (L<AnyEvent::Loop>) will additionally load it to 2931pure-perl event loop (L<AnyEvent::Loop>) will additionally load it to
2735try to use a monotonic clock for timing stability. 2932try to use a monotonic clock for timing stability.
2736 2933
2934=item L<AnyEvent::AIO> (and L<IO::AIO>)
2935
2936The default implementation of L<AnyEvent::IO> is to do I/O synchronously,
2937stopping programs while they access the disk, which is fine for a lot of
2938programs.
2939
2940Installing AnyEvent::AIO (and its IO::AIO dependency) makes it switch to
2941a true asynchronous implementation, so event processing can continue even
2942while waiting for disk I/O.
2943
2737=back 2944=back
2738 2945
2739 2946
2740=head1 FORK 2947=head1 FORK
2741 2948
… …
2805 3012
2806Tutorial/Introduction: L<AnyEvent::Intro>. 3013Tutorial/Introduction: L<AnyEvent::Intro>.
2807 3014
2808FAQ: L<AnyEvent::FAQ>. 3015FAQ: L<AnyEvent::FAQ>.
2809 3016
2810Utility functions: L<AnyEvent::Util>. 3017Utility functions: L<AnyEvent::Util> (misc. grab-bag), L<AnyEvent::Log>
3018(simply logging).
2811 3019
3020Development/Debugging: L<AnyEvent::Strict> (stricter checking),
3021L<AnyEvent::Debug> (interactive shell, watcher tracing).
3022
2812Event modules: L<AnyEvent::Loop>, L<EV>, L<EV::Glib>, L<Glib::EV>, 3023Supported event modules: L<AnyEvent::Loop>, L<EV>, L<EV::Glib>,
2813L<Event>, L<Glib::Event>, L<Glib>, L<Tk>, L<Event::Lib>, L<Qt>, L<POE>. 3024L<Glib::EV>, L<Event>, L<Glib::Event>, L<Glib>, L<Tk>, L<Event::Lib>,
3025L<Qt>, L<POE>, L<FLTK>.
2814 3026
2815Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>, 3027Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>,
2816L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>, 3028L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>,
2817L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>, 3029L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>,
2818L<AnyEvent::Impl::POE>, L<AnyEvent::Impl::IOAsync>, L<Anyevent::Impl::Irssi>. 3030L<AnyEvent::Impl::POE>, L<AnyEvent::Impl::IOAsync>, L<Anyevent::Impl::Irssi>,
3031L<AnyEvent::Impl::FLTK>.
2819 3032
2820Non-blocking file handles, sockets, TCP clients and 3033Non-blocking handles, pipes, stream sockets, TCP clients and
2821servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>. 3034servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.
3035
3036Asynchronous File I/O: L<AnyEvent::IO>.
2822 3037
2823Asynchronous DNS: L<AnyEvent::DNS>. 3038Asynchronous DNS: L<AnyEvent::DNS>.
2824 3039
2825Thread support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>. 3040Thread support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>.
2826 3041
… …
2829 3044
2830 3045
2831=head1 AUTHOR 3046=head1 AUTHOR
2832 3047
2833 Marc Lehmann <schmorp@schmorp.de> 3048 Marc Lehmann <schmorp@schmorp.de>
2834 http://home.schmorp.de/ 3049 http://anyevent.schmorp.de
2835 3050
2836=cut 3051=cut
2837 3052
28381 30531
2839 3054

Diff Legend

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