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.376 by root, Thu Aug 25 06:34:11 2011 UTC vs.
Revision 1.398 by root, Tue Mar 27 16:21:11 2012 UTC

… …
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
… …
878 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse. 876 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
879 AnyEvent::Impl::POE based on POE, very slow, some limitations. 877 AnyEvent::Impl::POE based on POE, very slow, some limitations.
880 AnyEvent::Impl::Irssi used when running within irssi. 878 AnyEvent::Impl::Irssi used when running within irssi.
881 AnyEvent::Impl::IOAsync based on IO::Async. 879 AnyEvent::Impl::IOAsync based on IO::Async.
882 AnyEvent::Impl::Cocoa based on Cocoa::EventLoop. 880 AnyEvent::Impl::Cocoa based on Cocoa::EventLoop.
883 AnyEvent::Impl::FLTK2 based on FLTK (fltk 2 binding). 881 AnyEvent::Impl::FLTK based on FLTK (fltk 2 binding).
884 882
885=item Backends with special needs. 883=item Backends with special needs.
886 884
887Qt requires the Qt::Application to be instantiated first, but will 885Qt requires the Qt::Application to be instantiated first, but will
888otherwise be picked up automatically. As long as the main program 886otherwise be picked up automatically. As long as the main program
… …
1058If L<AnyEvent::Log> is not loaded then this function makes a simple test 1056If L<AnyEvent::Log> is not loaded then this function makes a simple test
1059to see whether the message will be logged. If the test succeeds it will 1057to see whether the message will be logged. If the test succeeds it will
1060load AnyEvent::Log and call C<AnyEvent::Log::log> - consequently, look at 1058load AnyEvent::Log and call C<AnyEvent::Log::log> - consequently, look at
1061the L<AnyEvent::Log> documentation for details. 1059the L<AnyEvent::Log> documentation for details.
1062 1060
1063If the test fails it will simply return. 1061If the test fails it will simply return. Right now this happens when a
1062numerical loglevel is used and it is larger than the level specified via
1063C<$ENV{PERL_ANYEVENT_VERBOSE}>.
1064 1064
1065If you want to sprinkle loads of logging calls around your code, consider 1065If you want to sprinkle loads of logging calls around your code, consider
1066creating a logger callback with the C<AnyEvent::Log::logger> function, 1066creating a logger callback with the C<AnyEvent::Log::logger> function,
1067which can reduce typing, codesize and can reduce the logging overhead 1067which can reduce typing, codesize and can reduce the logging overhead
1068enourmously. 1068enourmously.
… …
1166 1166
1167Implement event-based interfaces to the protocols of the same name (for 1167Implement event-based interfaces to the protocols of the same name (for
1168the curious, IGS is the International Go Server and FCP is the Freenet 1168the curious, IGS is the International Go Server and FCP is the Freenet
1169Client Protocol). 1169Client Protocol).
1170 1170
1171=item L<AnyEvent::Handle::UDP>
1172
1173Here be danger!
1174
1175As Pauli would put it, "Not only is it not right, it's not even wrong!" -
1176there are so many things wrong with AnyEvent::Handle::UDP, most notably
1177its use of a stream-based API with a protocol that isn't streamable, that
1178the only way to improve it is to delete it.
1179
1180It features data corruption (but typically only under load) and general
1181confusion. On top, the author is not only clueless about UDP but also
1182fact-resistant - some gems of his understanding: "connect doesn't work
1183with UDP", "UDP packets are not IP packets", "UDP only has datagrams, not
1184packets", "I don't need to implement proper error checking as UDP doesn't
1185support error checking" and so on - he doesn't even understand what's
1186wrong with his module when it is explained to him.
1187
1188=item L<AnyEvent::DBI>
1189
1190Executes L<DBI> requests asynchronously in a proxy process for you,
1191notifying you in an event-based way when the operation is finished.
1192
1193=item L<AnyEvent::AIO> 1171=item L<AnyEvent::AIO>
1194 1172
1195Truly asynchronous (as opposed to non-blocking) I/O, should be in the 1173Truly asynchronous (as opposed to non-blocking) I/O, should be in the
1196toolbox of every event programmer. AnyEvent::AIO transparently fuses 1174toolbox of every event programmer. AnyEvent::AIO transparently fuses
1197L<IO::AIO> and AnyEvent together, giving AnyEvent access to event-based 1175L<IO::AIO> and AnyEvent together, giving AnyEvent access to event-based
1198file I/O, and much more. 1176file I/O, and much more.
1199 1177
1178=item L<AnyEvent::Filesys::Notify>
1179
1180AnyEvent is good for non-blocking stuff, but it can't detect file or
1181path changes (e.g. "watch this directory for new files", "watch this
1182file for changes"). The L<AnyEvent::Filesys::Notify> module promises to
1183do just that in a portbale fashion, supporting inotify on GNU/Linux and
1184some weird, without doubt broken, stuff on OS X to monitor files. It can
1185fall back to blocking scans at regular intervals transparently on other
1186platforms, so it's about as portable as it gets.
1187
1188(I haven't used it myself, but I haven't heard anybody complaining about
1189it yet).
1190
1191=item L<AnyEvent::DBI>
1192
1193Executes L<DBI> requests asynchronously in a proxy process for you,
1194notifying you in an event-based way when the operation is finished.
1195
1200=item L<AnyEvent::HTTPD> 1196=item L<AnyEvent::HTTPD>
1201 1197
1202A simple embedded webserver. 1198A simple embedded webserver.
1203 1199
1204=item L<AnyEvent::FastPing> 1200=item L<AnyEvent::FastPing>
1205 1201
1206The fastest ping in the west. 1202The fastest ping in the west.
1207 1203
1208=item L<Coro> 1204=item L<Coro>
1209 1205
1210Has special support for AnyEvent via L<Coro::AnyEvent>. 1206Has special support for AnyEvent via L<Coro::AnyEvent>, which allows you
1207to simply invert the flow control - don't call us, we will call you:
1208
1209 async {
1210 Coro::AnyEvent::sleep 5; # creates a 5s timer and waits for it
1211 print "5 seconds later!\n";
1212
1213 Coro::AnyEvent::readable *STDIN; # uses an I/O watcher
1214 my $line = <STDIN>; # works for ttys
1215
1216 AnyEvent::HTTP::http_get "url", Coro::rouse_cb;
1217 my ($body, $hdr) = Coro::rouse_wait;
1218 };
1211 1219
1212=back 1220=back
1213 1221
1214=cut 1222=cut
1215 1223
1216package AnyEvent; 1224package AnyEvent;
1217 1225
1218# basically a tuned-down version of common::sense 1226# basically a tuned-down version of common::sense
1219sub common_sense { 1227sub common_sense {
1220 # from common:.sense 3.4 1228 # from common:.sense 3.5
1229 local $^W;
1221 ${^WARNING_BITS} ^= ${^WARNING_BITS} ^ "\x3c\x3f\x33\x00\x0f\xf0\x0f\xc0\xf0\xfc\x33\x00"; 1230 ${^WARNING_BITS} ^= ${^WARNING_BITS} ^ "\x3c\x3f\x33\x00\x0f\xf0\x0f\xc0\xf0\xfc\x33\x00";
1222 # use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl) 1231 # use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1223 $^H |= 0x00000600; 1232 $^H |= 0x00000600;
1224} 1233}
1225 1234
1226BEGIN { AnyEvent::common_sense } 1235BEGIN { AnyEvent::common_sense }
1227 1236
1228use Carp (); 1237use Carp ();
1229 1238
1230our $VERSION = '6.01'; 1239our $VERSION = '6.14';
1231our $MODEL; 1240our $MODEL;
1232
1233our @ISA; 1241our @ISA;
1234
1235our @REGISTRY; 1242our @REGISTRY;
1236
1237our $VERBOSE; 1243our $VERBOSE;
1244our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred
1245our $MAX_SIGNAL_LATENCY = $ENV{PERL_ANYEVENT_MAX_SIGNAL_LATENCY} || 10; # executes after the BEGIN block below (tainting!)
1238 1246
1239BEGIN { 1247BEGIN {
1240 require "AnyEvent/constants.pl"; 1248 require "AnyEvent/constants.pl";
1241 1249
1242 eval "sub TAINT (){" . (${^TAINT}*1) . "}"; 1250 eval "sub TAINT (){" . (${^TAINT}*1) . "}";
… …
1248 for grep s/^AE_// && !exists $ENV{"PERL_ANYEVENT_$_"}, keys %ENV; 1256 for grep s/^AE_// && !exists $ENV{"PERL_ANYEVENT_$_"}, keys %ENV;
1249 1257
1250 @ENV{grep /^PERL_ANYEVENT_/, keys %ENV} = () 1258 @ENV{grep /^PERL_ANYEVENT_/, keys %ENV} = ()
1251 if ${^TAINT}; 1259 if ${^TAINT};
1252 1260
1253 $VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1; 1261 # $ENV{PERL_ANYEVENT_xxx} now valid
1254}
1255 1262
1256our $MAX_SIGNAL_LATENCY = 10; 1263 $VERBOSE = length $ENV{PERL_ANYEVENT_VERBOSE} ? $ENV{PERL_ANYEVENT_VERBOSE}*1 : 4;
1257 1264
1258our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred
1259
1260{
1261 my $idx; 1265 my $idx;
1262 $PROTOCOL{$_} = ++$idx 1266 $PROTOCOL{$_} = ++$idx
1263 for reverse split /\s*,\s*/, 1267 for reverse split /\s*,\s*/,
1264 $ENV{PERL_ANYEVENT_PROTOCOLS} || "ipv4,ipv6"; 1268 $ENV{PERL_ANYEVENT_PROTOCOLS} || "ipv4,ipv6";
1265} 1269}
… …
1298 () 1302 ()
1299} 1303}
1300 1304
1301sub log($$;@) { 1305sub log($$;@) {
1302 # only load the big bloated module when we actually are about to log something 1306 # only load the big bloated module when we actually are about to log something
1303 if ($_[0] <= $VERBOSE) { # also catches non-numeric levels(!) 1307 if ($_[0] <= ($VERBOSE || 1)) { # also catches non-numeric levels(!) and fatal
1304 require AnyEvent::Log; 1308 local ($!, $@);
1309 require AnyEvent::Log; # among other things, sets $VERBOSE to 9
1305 # AnyEvent::Log overwrites this function 1310 # AnyEvent::Log overwrites this function
1306 goto &log; 1311 goto &log;
1307 } 1312 }
1308 1313
1309 0 # not logged 1314 0 # not logged
1310} 1315}
1311 1316
1317sub _logger($;$) {
1318 my ($level, $renabled) = @_;
1319
1320 $$renabled = $level <= $VERBOSE;
1321
1322 my $logger = [(caller)[0], $level, $renabled];
1323
1324 $AnyEvent::Log::LOGGER{$logger+0} = $logger;
1325
1326# return unless defined wantarray;
1327#
1328# require AnyEvent::Util;
1329# my $guard = AnyEvent::Util::guard (sub {
1330# # "clean up"
1331# delete $LOGGER{$logger+0};
1332# });
1333#
1334# sub {
1335# return 0 unless $$renabled;
1336#
1337# $guard if 0; # keep guard alive, but don't cause runtime overhead
1338# require AnyEvent::Log unless $AnyEvent::Log::VERSION;
1339# package AnyEvent::Log;
1340# _log ($logger->[0], $level, @_) # logger->[0] has been converted at load time
1341# }
1342}
1343
1312if (length $ENV{PERL_ANYEVENT_LOG}) { 1344if (length $ENV{PERL_ANYEVENT_LOG}) {
1313 require AnyEvent::Log; # AnyEvent::Log does the thing for us 1345 require AnyEvent::Log; # AnyEvent::Log does the thing for us
1314} 1346}
1315 1347
1316our @models = ( 1348our @models = (
1317 [EV:: => AnyEvent::Impl::EV:: , 1], 1349 [EV:: => AnyEvent::Impl::EV::],
1318 [AnyEvent::Loop:: => AnyEvent::Impl::Perl:: , 1], 1350 [AnyEvent::Loop:: => AnyEvent::Impl::Perl::],
1319 # everything below here will not (normally) be autoprobed 1351 # everything below here will not (normally) be autoprobed
1320 # as the pure perl backend should work everywhere 1352 # as the pure perl backend should work everywhere
1321 # and is usually faster 1353 # and is usually faster
1354 [Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package, so msut be near the top
1322 [Event:: => AnyEvent::Impl::Event::, 1], 1355 [Event:: => AnyEvent::Impl::Event::], # slow, stable
1323 [Glib:: => AnyEvent::Impl::Glib:: , 1], # becomes extremely slow with many watchers 1356 [Glib:: => AnyEvent::Impl::Glib::], # becomes extremely slow with many watchers
1357 # everything below here should not be autoloaded
1324 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy 1358 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy
1325 [Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package
1326 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles 1359 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles
1327 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program 1360 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program
1328 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza 1361 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza
1329 [Wx:: => AnyEvent::Impl::POE::], 1362 [Wx:: => AnyEvent::Impl::POE::],
1330 [Prima:: => AnyEvent::Impl::POE::], 1363 [Prima:: => AnyEvent::Impl::POE::],
1331 [IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # a bitch to autodetect 1364 [IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # a bitch to autodetect
1332 [Cocoa::EventLoop:: => AnyEvent::Impl::Cocoa::], 1365 [Cocoa::EventLoop:: => AnyEvent::Impl::Cocoa::],
1333 [FLTK:: => AnyEvent::Impl::FLTK2::], 1366 [FLTK:: => AnyEvent::Impl::FLTK::],
1334); 1367);
1335 1368
1336our @isa_hook; 1369our @isa_hook;
1337 1370
1338sub _isa_set { 1371sub _isa_set {
… …
1358# due to bugs in perls method cache implementation. 1391# due to bugs in perls method cache implementation.
1359our @methods = qw(io timer time now now_update signal child idle condvar); 1392our @methods = qw(io timer time now now_update signal child idle condvar);
1360 1393
1361sub detect() { 1394sub detect() {
1362 return $MODEL if $MODEL; # some programs keep references to detect 1395 return $MODEL if $MODEL; # some programs keep references to detect
1396
1397 # IO::Async::Loop::AnyEvent is extremely evil, refuse to work with it
1398 # the author knows about the problems and what it does to AnyEvent as a whole
1399 # (and the ability of others to use AnyEvent), but simply wants to abuse AnyEvent
1400 # anyway.
1401 AnyEvent::log fatal => "AnyEvent: IO::Async::Loop::AnyEvent detected - that module is broken by\n"
1402 . "design, abuses internals and breaks AnyEvent - will not continue."
1403 if exists $INC{"IO/Async/Loop/AnyEvent.pm"};
1363 1404
1364 local $!; # for good measure 1405 local $!; # for good measure
1365 local $SIG{__DIE__}; # we use eval 1406 local $SIG{__DIE__}; # we use eval
1366 1407
1367 # free some memory 1408 # free some memory
… …
1379 $model = "AnyEvent::Impl::$model" unless $model =~ s/::$//; 1420 $model = "AnyEvent::Impl::$model" unless $model =~ s/::$//;
1380 if (eval "require $model") { 1421 if (eval "require $model") {
1381 AnyEvent::log 7 => "loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it."; 1422 AnyEvent::log 7 => "loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.";
1382 $MODEL = $model; 1423 $MODEL = $model;
1383 } else { 1424 } else {
1384 AnyEvent::log 5 => "unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@"; 1425 AnyEvent::log 4 => "unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@";
1385 } 1426 }
1386 } 1427 }
1387 1428
1388 # check for already loaded models 1429 # check for already loaded models
1389 unless ($MODEL) { 1430 unless ($MODEL) {
… …
1392 if (${"$package\::VERSION"} > 0) { 1433 if (${"$package\::VERSION"} > 0) {
1393 if (eval "require $model") { 1434 if (eval "require $model") {
1394 AnyEvent::log 7 => "autodetected model '$model', using it."; 1435 AnyEvent::log 7 => "autodetected model '$model', using it.";
1395 $MODEL = $model; 1436 $MODEL = $model;
1396 last; 1437 last;
1438 } else {
1439 AnyEvent::log 8 => "detected event loop $package, but cannot load '$model', skipping: $@";
1397 } 1440 }
1398 } 1441 }
1399 } 1442 }
1400 1443
1401 unless ($MODEL) { 1444 unless ($MODEL) {
1402 # try to autoload a model 1445 # try to autoload a model
1403 for (@REGISTRY, @models) { 1446 for (@REGISTRY, @models) {
1404 my ($package, $model, $autoload) = @$_; 1447 my ($package, $model) = @$_;
1405 if ( 1448 if (
1406 $autoload
1407 and eval "require $package" 1449 eval "require $package"
1408 and ${"$package\::VERSION"} > 0 1450 and ${"$package\::VERSION"} > 0
1409 and eval "require $model" 1451 and eval "require $model"
1410 ) { 1452 ) {
1411 AnyEvent::log 7 => "autoloaded model '$model', using it."; 1453 AnyEvent::log 7 => "autoloaded model '$model', using it.";
1412 $MODEL = $model; 1454 $MODEL = $model;
1413 last; 1455 last;
1414 } 1456 }
1415 } 1457 }
1416 1458
1417 $MODEL 1459 $MODEL
1418 or die "AnyEvent: backend autodetection failed - did you properly install AnyEvent?"; 1460 or AnyEvent::log fatal => "AnyEvent: backend autodetection failed - did you properly install AnyEvent?";
1419 } 1461 }
1420 } 1462 }
1421 1463
1422 # free memory only needed for probing 1464 # free memory only needed for probing
1423 undef @models; 1465 undef @models;
… …
2032 2074
2033=over 4 2075=over 4
2034 2076
2035=item C<PERL_ANYEVENT_VERBOSE> 2077=item C<PERL_ANYEVENT_VERBOSE>
2036 2078
2037By default, AnyEvent will be completely silent except in fatal 2079By default, AnyEvent will log messages with loglevel C<4> (C<error>) or
2038conditions. You can set this environment variable to make AnyEvent more 2080higher (see L<AnyEvent::Log>). You can set this environment variable to a
2081numerical loglevel to make AnyEvent more (or less) talkative.
2082
2039talkative. If you want to do more than just set the global logging level 2083If you want to do more than just set the global logging level
2040you should have a look at C<PERL_ANYEVENT_LOG>, which allows much more 2084you should have a look at C<PERL_ANYEVENT_LOG>, which allows much more
2041complex specifications. 2085complex specifications.
2042 2086
2087When set to C<0> (C<off>), then no messages whatsoever will be logged with
2088everything else at defaults.
2089
2043When set to C<5> or higher (warn), causes AnyEvent to warn about unexpected 2090When set to C<5> or higher (C<warn>), AnyEvent warns about unexpected
2044conditions, such as not being able to load the event model specified by 2091conditions, such as not being able to load the event model specified by
2045C<PERL_ANYEVENT_MODEL>, or a guard callback throwing an exception - this 2092C<PERL_ANYEVENT_MODEL>, or a guard callback throwing an exception - this
2046is the minimum recommended level. 2093is the minimum recommended level for use during development.
2047 2094
2048When set to C<7> or higher (info), cause AnyEvent to report which event model it 2095When set to C<7> or higher (info), AnyEvent reports which event model it
2049chooses. 2096chooses.
2050 2097
2051When set to C<8> or higher (debug), then AnyEvent will report extra information on 2098When set to C<8> or higher (debug), then AnyEvent will report extra
2052which optional modules it loads and how it implements certain features. 2099information on which optional modules it loads and how it implements
2100certain features.
2053 2101
2054=item C<PERL_ANYEVENT_LOG> 2102=item C<PERL_ANYEVENT_LOG>
2055 2103
2056Accepts rather complex logging specifications. For example, you could log 2104Accepts rather complex logging specifications. For example, you could log
2057all C<debug> messages of some module to stderr, warnings and above to 2105all C<debug> messages of some module to stderr, warnings and above to
… …
2064This variable is evaluated when AnyEvent (or L<AnyEvent::Log>) is loaded, 2112This variable is evaluated when AnyEvent (or L<AnyEvent::Log>) is loaded,
2065so will take effect even before AnyEvent has initialised itself. 2113so will take effect even before AnyEvent has initialised itself.
2066 2114
2067Note that specifying this environment variable causes the L<AnyEvent::Log> 2115Note that specifying this environment variable causes the L<AnyEvent::Log>
2068module to be loaded, while C<PERL_ANYEVENT_VERBOSE> does not, so only 2116module to be loaded, while C<PERL_ANYEVENT_VERBOSE> does not, so only
2069using the latter saves a few hundred kB of memory until the first message 2117using the latter saves a few hundred kB of memory unless a module
2070is being logged. 2118explicitly needs the extra features of AnyEvent::Log.
2071 2119
2072=item C<PERL_ANYEVENT_STRICT> 2120=item C<PERL_ANYEVENT_STRICT>
2073 2121
2074AnyEvent does not do much argument checking by default, as thorough 2122AnyEvent does not do much argument checking by default, as thorough
2075argument checking is very costly. Setting this variable to a true value 2123argument checking is very costly. Setting this variable to a true value
… …
2084C<PERL_ANYEVENT_STRICT=1> in your environment while developing programs 2132C<PERL_ANYEVENT_STRICT=1> in your environment while developing programs
2085can be very useful, however. 2133can be very useful, however.
2086 2134
2087=item C<PERL_ANYEVENT_DEBUG_SHELL> 2135=item C<PERL_ANYEVENT_DEBUG_SHELL>
2088 2136
2089If this env variable is set, then its contents will be interpreted by 2137If this env variable is nonempty, then its contents will be interpreted by
2090C<AnyEvent::Socket::parse_hostport> (after replacing every occurance of 2138C<AnyEvent::Socket::parse_hostport> and C<AnyEvent::Debug::shell> (after
2091C<$$> by the process pid) and an C<AnyEvent::Debug::shell> is bound on 2139replacing every occurance of C<$$> by the process pid). The shell object
2092that port. The shell object is saved in C<$AnyEvent::Debug::SHELL>. 2140is saved in C<$AnyEvent::Debug::SHELL>.
2093 2141
2094This happens when the first watcher is created. 2142This happens when the first watcher is created.
2095 2143
2096For example, to bind a debug shell on a unix domain socket in 2144For example, to bind a debug shell on a unix domain socket in
2097F<< /tmp/debug<pid>.sock >>, you could use this: 2145F<< /tmp/debug<pid>.sock >>, you could use this:
2098 2146
2099 PERL_ANYEVENT_DEBUG_SHELL=/tmp/debug\$\$.sock perlprog 2147 PERL_ANYEVENT_DEBUG_SHELL=/tmp/debug\$\$.sock perlprog
2148 # connect with e.g.: socat readline /tmp/debug123.sock
2100 2149
2150Or to bind to tcp port 4545 on localhost:
2151
2152 PERL_ANYEVENT_DEBUG_SHELL=127.0.0.1:4545 perlprog
2153 # connect with e.g.: telnet localhost 4545
2154
2101Note that creating sockets in F</tmp> is very unsafe on multiuser 2155Note that creating sockets in F</tmp> or on localhost is very unsafe on
2102systems. 2156multiuser systems.
2103 2157
2104=item C<PERL_ANYEVENT_DEBUG_WRAP> 2158=item C<PERL_ANYEVENT_DEBUG_WRAP>
2105 2159
2106Can be set to C<0>, C<1> or C<2> and enables wrapping of all watchers for 2160Can be set to C<0>, C<1> or C<2> and enables wrapping of all watchers for
2107debugging purposes. See C<AnyEvent::Debug::wrap> for details. 2161debugging purposes. See C<AnyEvent::Debug::wrap> for details.
… …
2171=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS> 2225=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS>
2172 2226
2173The default value for the C<max_outstanding> parameter for the default DNS 2227The default value for the C<max_outstanding> parameter for the default DNS
2174resolver - this is the maximum number of parallel DNS requests that are 2228resolver - this is the maximum number of parallel DNS requests that are
2175sent to the DNS server. 2229sent to the DNS server.
2230
2231=item C<PERL_ANYEVENT_MAX_SIGNAL_LATENCY>
2232
2233Perl has inherently racy signal handling (you can basically choose between
2234losing signals and memory corruption) - pure perl event loops (including
2235C<AnyEvent::Loop>, when C<Async::Interrupt> isn't available) therefore
2236have to poll regularly to avoid losing signals.
2237
2238Some event loops are racy, but don't poll regularly, and some event loops
2239are written in C but are still racy. For those event loops, AnyEvent
2240installs a timer that regularly wakes up the event loop.
2241
2242By default, the interval for this timer is C<10> seconds, but you can
2243override this delay with this environment variable (or by setting
2244the C<$AnyEvent::MAX_SIGNAL_LATENCY> variable before creating signal
2245watchers).
2246
2247Lower values increase CPU (and energy) usage, higher values can introduce
2248long delays when reaping children or waiting for signals.
2249
2250The L<AnyEvent::Async> module, if available, will be used to avoid this
2251polling (with most event loops).
2176 2252
2177=item C<PERL_ANYEVENT_RESOLV_CONF> 2253=item C<PERL_ANYEVENT_RESOLV_CONF>
2178 2254
2179The absolute path to a F<resolv.conf>-style file to use instead of 2255The absolute path to a F<resolv.conf>-style file to use instead of
2180F</etc/resolv.conf> (or the OS-specific configuration) in the default 2256F</etc/resolv.conf> (or the OS-specific configuration) in the default

Diff Legend

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