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.386 by root, Mon Sep 26 11:32:19 2011 UTC vs.
Revision 1.408 by root, Thu Dec 6 12:04:23 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
… …
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
… …
1225 1227
1226package AnyEvent; 1228package AnyEvent;
1227 1229
1228# basically a tuned-down version of common::sense 1230# basically a tuned-down version of common::sense
1229sub common_sense { 1231sub common_sense {
1230 # from common:.sense 3.4 1232 # from common:.sense 3.5
1233 local $^W;
1231 ${^WARNING_BITS} ^= ${^WARNING_BITS} ^ "\x3c\x3f\x33\x00\x0f\xf0\x0f\xc0\xf0\xfc\x33\x00"; 1234 ${^WARNING_BITS} ^= ${^WARNING_BITS} ^ "\x3c\x3f\x33\x00\x0f\xf0\x0f\xc0\xf0\xfc\x33\x00";
1232 # use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl) 1235 # use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1233 $^H |= 0x00000600; 1236 $^H |= 0x00000600;
1234} 1237}
1235 1238
1236BEGIN { AnyEvent::common_sense } 1239BEGIN { AnyEvent::common_sense }
1237 1240
1238use Carp (); 1241use Carp ();
1239 1242
1240our $VERSION = '6.02'; 1243our $VERSION = '7.04';
1241our $MODEL; 1244our $MODEL;
1242our @ISA; 1245our @ISA;
1243our @REGISTRY; 1246our @REGISTRY;
1244our $VERBOSE; 1247our $VERBOSE;
1245our $MAX_SIGNAL_LATENCY = 10;
1246our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred 1248our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred
1249our $MAX_SIGNAL_LATENCY = $ENV{PERL_ANYEVENT_MAX_SIGNAL_LATENCY} || 10; # executes after the BEGIN block below (tainting!)
1247 1250
1248BEGIN { 1251BEGIN {
1249 require "AnyEvent/constants.pl"; 1252 require "AnyEvent/constants.pl";
1250 1253
1251 eval "sub TAINT (){" . (${^TAINT}*1) . "}"; 1254 eval "sub TAINT (){" . (${^TAINT}*1) . "}";
… …
1304} 1307}
1305 1308
1306sub log($$;@) { 1309sub log($$;@) {
1307 # only load the big bloated module when we actually are about to log something 1310 # only load the big bloated module when we actually are about to log something
1308 if ($_[0] <= ($VERBOSE || 1)) { # also catches non-numeric levels(!) and fatal 1311 if ($_[0] <= ($VERBOSE || 1)) { # also catches non-numeric levels(!) and fatal
1312 local ($!, $@);
1309 require AnyEvent::Log; # among other things, sets $VERBOSE to 9 1313 require AnyEvent::Log; # among other things, sets $VERBOSE to 9
1310 # AnyEvent::Log overwrites this function 1314 # AnyEvent::Log overwrites this function
1311 goto &log; 1315 goto &log;
1312 } 1316 }
1313 1317
1314 0 # not logged 1318 0 # not logged
1315} 1319}
1316 1320
1317sub logger($;$) { 1321sub _logger($;$) {
1318 package AnyEvent::Log;
1319
1320 my ($level, $renabled) = @_; 1322 my ($level, $renabled) = @_;
1321 1323
1322 $$renabled = $level <= $VERBOSE; 1324 $$renabled = $level <= $VERBOSE;
1323 1325
1324 my $pkg = (caller)[0];
1325
1326 my $logger = [$pkg, $level, $renabled]; 1326 my $logger = [(caller)[0], $level, $renabled];
1327 1327
1328 our %LOGGER;
1329 $LOGGER{$logger+0} = $logger; 1328 $AnyEvent::Log::LOGGER{$logger+0} = $logger;
1330 1329
1330# return unless defined wantarray;
1331#
1331 require AnyEvent::Util; 1332# require AnyEvent::Util;
1332 my $guard = AnyEvent::Util::guard (sub { 1333# my $guard = AnyEvent::Util::guard (sub {
1333 # "clean up" 1334# # "clean up"
1334 delete $LOGGER{$logger+0}; 1335# delete $LOGGER{$logger+0};
1335 }); 1336# });
1336 1337#
1337 sub { 1338# sub {
1338 return 0 unless $$renabled; 1339# return 0 unless $$renabled;
1339 1340#
1340 $guard if 0; # keep guard alive, but don't cause runtime overhead 1341# $guard if 0; # keep guard alive, but don't cause runtime overhead
1341 require AnyEvent::Log unless $AnyEvent::Log::VERSION; 1342# require AnyEvent::Log unless $AnyEvent::Log::VERSION;
1342 package AnyEvent::Log; 1343# package AnyEvent::Log;
1343 _log ($logger->[0], $level, @_) # logger->[0] has been converted at load time 1344# _log ($logger->[0], $level, @_) # logger->[0] has been converted at load time
1344 } 1345# }
1345} 1346}
1346 1347
1347if (length $ENV{PERL_ANYEVENT_LOG}) { 1348if (length $ENV{PERL_ANYEVENT_LOG}) {
1348 require AnyEvent::Log; # AnyEvent::Log does the thing for us 1349 require AnyEvent::Log; # AnyEvent::Log does the thing for us
1349} 1350}
… …
1399 1400
1400 # IO::Async::Loop::AnyEvent is extremely evil, refuse to work with it 1401 # IO::Async::Loop::AnyEvent is extremely evil, refuse to work with it
1401 # the author knows about the problems and what it does to AnyEvent as a whole 1402 # the author knows about the problems and what it does to AnyEvent as a whole
1402 # (and the ability of others to use AnyEvent), but simply wants to abuse AnyEvent 1403 # (and the ability of others to use AnyEvent), but simply wants to abuse AnyEvent
1403 # anyway. 1404 # anyway.
1404 AnyEvent::log fatal => "AnyEvent: IO::Async::Loop::AnyEvent detected - this module is broken by design,\n" 1405 AnyEvent::log fatal => "IO::Async::Loop::AnyEvent detected - that module is broken by\n"
1405 . "abuses internals and breaks AnyEvent, will not continue." 1406 . "design, abuses internals and breaks AnyEvent - will not continue."
1406 if exists $INC{"IO/Async/Loop/AnyEvent.pm"}; 1407 if exists $INC{"IO/Async/Loop/AnyEvent.pm"};
1407 1408
1408 local $!; # for good measure 1409 local $!; # for good measure
1409 local $SIG{__DIE__}; # we use eval 1410 local $SIG{__DIE__}; # we use eval
1410 1411
… …
1420 1421
1421 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z0-9:]+)$/) { 1422 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z0-9:]+)$/) {
1422 my $model = $1; 1423 my $model = $1;
1423 $model = "AnyEvent::Impl::$model" unless $model =~ s/::$//; 1424 $model = "AnyEvent::Impl::$model" unless $model =~ s/::$//;
1424 if (eval "require $model") { 1425 if (eval "require $model") {
1425 AnyEvent::log 7 => "loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it."; 1426 AnyEvent::log 7 => "Loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.";
1426 $MODEL = $model; 1427 $MODEL = $model;
1427 } else { 1428 } else {
1428 AnyEvent::log 4 => "unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@"; 1429 AnyEvent::log 4 => "Unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@";
1429 } 1430 }
1430 } 1431 }
1431 1432
1432 # check for already loaded models 1433 # check for already loaded models
1433 unless ($MODEL) { 1434 unless ($MODEL) {
1434 for (@REGISTRY, @models) { 1435 for (@REGISTRY, @models) {
1435 my ($package, $model) = @$_; 1436 my ($package, $model) = @$_;
1436 if (${"$package\::VERSION"} > 0) { 1437 if (${"$package\::VERSION"} > 0) {
1437 if (eval "require $model") { 1438 if (eval "require $model") {
1438 AnyEvent::log 7 => "autodetected model '$model', using it."; 1439 AnyEvent::log 7 => "Autodetected model '$model', using it.";
1439 $MODEL = $model; 1440 $MODEL = $model;
1440 last; 1441 last;
1442 } else {
1443 AnyEvent::log 8 => "Detected event loop $package, but cannot load '$model', skipping: $@";
1441 } 1444 }
1442 } 1445 }
1443 } 1446 }
1444 1447
1445 unless ($MODEL) { 1448 unless ($MODEL) {
… …
1449 if ( 1452 if (
1450 eval "require $package" 1453 eval "require $package"
1451 and ${"$package\::VERSION"} > 0 1454 and ${"$package\::VERSION"} > 0
1452 and eval "require $model" 1455 and eval "require $model"
1453 ) { 1456 ) {
1454 AnyEvent::log 7 => "autoloaded model '$model', using it."; 1457 AnyEvent::log 7 => "Autoloaded model '$model', using it.";
1455 $MODEL = $model; 1458 $MODEL = $model;
1456 last; 1459 last;
1457 } 1460 }
1458 } 1461 }
1459 1462
1460 $MODEL 1463 $MODEL
1461 or AnyEvent::log fatal => "AnyEvent: backend autodetection failed - did you properly install AnyEvent?"; 1464 or AnyEvent::log fatal => "Backend autodetection failed - did you properly install AnyEvent?";
1462 } 1465 }
1463 } 1466 }
1464 1467
1465 # free memory only needed for probing 1468 # free memory only needed for probing
1466 undef @models; 1469 undef @models;
… …
1613 # probe for availability of Time::HiRes 1616 # probe for availability of Time::HiRes
1614 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") { 1617 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1615 *time = sub { Time::HiRes::time () }; 1618 *time = sub { Time::HiRes::time () };
1616 *AE::time = \& Time::HiRes::time ; 1619 *AE::time = \& Time::HiRes::time ;
1617 *now = \&time; 1620 *now = \&time;
1618 AnyEvent::log 8 => "AnyEvent: using Time::HiRes for sub-second timing accuracy."; 1621 AnyEvent::log 8 => "using Time::HiRes for sub-second timing accuracy.";
1619 # if (eval "use POSIX (); (POSIX::times())... 1622 # if (eval "use POSIX (); (POSIX::times())...
1620 } else { 1623 } else {
1621 *time = sub { CORE::time }; 1624 *time = sub { CORE::time };
1622 *AE::time = sub (){ CORE::time }; 1625 *AE::time = sub (){ CORE::time };
1623 *now = \&time; 1626 *now = \&time;
1624 AnyEvent::log 3 => "using built-in time(), WARNING, no sub-second resolution!"; 1627 AnyEvent::log 3 => "Using built-in time(), no sub-second resolution!";
1625 } 1628 }
1626 }; 1629 };
1627 die if $@; 1630 die if $@;
1628 1631
1629 &time 1632 &time
… …
1723 1726
1724sub signal { 1727sub signal {
1725 eval q{ # poor man's autoloading {} 1728 eval q{ # poor man's autoloading {}
1726 # probe for availability of Async::Interrupt 1729 # probe for availability of Async::Interrupt
1727 if (_have_async_interrupt) { 1730 if (_have_async_interrupt) {
1728 AnyEvent::log 8 => "using Async::Interrupt for race-free signal handling."; 1731 AnyEvent::log 8 => "Using Async::Interrupt for race-free signal handling.";
1729 1732
1730 $SIGPIPE_R = new Async::Interrupt::EventPipe; 1733 $SIGPIPE_R = new Async::Interrupt::EventPipe;
1731 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec; 1734 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1732 1735
1733 } else { 1736 } else {
1734 AnyEvent::log 8 => "using emulated perl signal handling with latency timer."; 1737 AnyEvent::log 8 => "Using emulated perl signal handling with latency timer.";
1735 1738
1736 if (AnyEvent::WIN32) { 1739 if (AnyEvent::WIN32) {
1737 require AnyEvent::Util; 1740 require AnyEvent::Util;
1738 1741
1739 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe (); 1742 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
… …
2075 2078
2076=over 4 2079=over 4
2077 2080
2078=item C<PERL_ANYEVENT_VERBOSE> 2081=item C<PERL_ANYEVENT_VERBOSE>
2079 2082
2080By default, AnyEvent will only log messages with loglevel C<3> 2083By default, AnyEvent will log messages with loglevel C<4> (C<error>) or
2081(C<critical>) or higher (see L<AnyEvent::Log>). You can set this 2084higher (see L<AnyEvent::Log>). You can set this environment variable to a
2082environment variable to a numerical loglevel to make AnyEvent more (or 2085numerical loglevel to make AnyEvent more (or less) talkative.
2083less) talkative.
2084 2086
2085If you want to do more than just set the global logging level 2087If you want to do more than just set the global logging level
2086you should have a look at C<PERL_ANYEVENT_LOG>, which allows much more 2088you should have a look at C<PERL_ANYEVENT_LOG>, which allows much more
2087complex specifications. 2089complex specifications.
2088 2090
2089When set to C<0> (C<off>), then no messages whatsoever will be logged with 2091When set to C<0> (C<off>), then no messages whatsoever will be logged with
2090the default logging settings. 2092everything else at defaults.
2091 2093
2092When set to C<5> or higher (C<warn>), causes AnyEvent to warn about 2094When set to C<5> or higher (C<warn>), AnyEvent warns about unexpected
2093unexpected conditions, such as not being able to load the event model 2095conditions, such as not being able to load the event model specified by
2094specified by C<PERL_ANYEVENT_MODEL>, or a guard callback throwing an 2096C<PERL_ANYEVENT_MODEL>, or a guard callback throwing an exception - this
2095exception - this is the minimum recommended level. 2097is the minimum recommended level for use during development.
2096 2098
2097When set to C<7> or higher (info), cause AnyEvent to report which event model it 2099When set to C<7> or higher (info), AnyEvent reports which event model it
2098chooses. 2100chooses.
2099 2101
2100When set to C<8> or higher (debug), then AnyEvent will report extra information on 2102When set to C<8> or higher (debug), then AnyEvent will report extra
2101which optional modules it loads and how it implements certain features. 2103information on which optional modules it loads and how it implements
2104certain features.
2102 2105
2103=item C<PERL_ANYEVENT_LOG> 2106=item C<PERL_ANYEVENT_LOG>
2104 2107
2105Accepts rather complex logging specifications. For example, you could log 2108Accepts rather complex logging specifications. For example, you could log
2106all C<debug> messages of some module to stderr, warnings and above to 2109all C<debug> messages of some module to stderr, warnings and above to
… …
2113This variable is evaluated when AnyEvent (or L<AnyEvent::Log>) is loaded, 2116This variable is evaluated when AnyEvent (or L<AnyEvent::Log>) is loaded,
2114so will take effect even before AnyEvent has initialised itself. 2117so will take effect even before AnyEvent has initialised itself.
2115 2118
2116Note that specifying this environment variable causes the L<AnyEvent::Log> 2119Note that specifying this environment variable causes the L<AnyEvent::Log>
2117module to be loaded, while C<PERL_ANYEVENT_VERBOSE> does not, so only 2120module to be loaded, while C<PERL_ANYEVENT_VERBOSE> does not, so only
2118using the latter saves a few hundred kB of memory until the first message 2121using the latter saves a few hundred kB of memory unless a module
2119is being logged. 2122explicitly needs the extra features of AnyEvent::Log.
2120 2123
2121=item C<PERL_ANYEVENT_STRICT> 2124=item C<PERL_ANYEVENT_STRICT>
2122 2125
2123AnyEvent does not do much argument checking by default, as thorough 2126AnyEvent does not do much argument checking by default, as thorough
2124argument checking is very costly. Setting this variable to a true value 2127argument checking is very costly. Setting this variable to a true value
… …
2179For example, to force the pure perl model (L<AnyEvent::Loop::Perl>) you 2182For example, to force the pure perl model (L<AnyEvent::Loop::Perl>) you
2180could start your program like this: 2183could start your program like this:
2181 2184
2182 PERL_ANYEVENT_MODEL=Perl perl ... 2185 PERL_ANYEVENT_MODEL=Perl perl ...
2183 2186
2187=item C<PERL_ANYEVENT_IO_MODEL>
2188
2189The current file I/O model - see L<AnyEvent::IO> for more info.
2190
2191At the moment, only C<Perl> (small, pure-perl, synchronous) and
2192C<IOAIO> (truly asynchronous) are supported. The default is C<IOAIO> if
2193L<AnyEvent::AIO> can be loaded, otherwise it is C<Perl>.
2194
2184=item C<PERL_ANYEVENT_PROTOCOLS> 2195=item C<PERL_ANYEVENT_PROTOCOLS>
2185 2196
2186Used by both L<AnyEvent::DNS> and L<AnyEvent::Socket> to determine preferences 2197Used by both L<AnyEvent::DNS> and L<AnyEvent::Socket> to determine preferences
2187for IPv4 or IPv6. The default is unspecified (and might change, or be the result 2198for IPv4 or IPv6. The default is unspecified (and might change, or be the result
2188of auto probing). 2199of auto probing).
… …
2226=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS> 2237=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS>
2227 2238
2228The default value for the C<max_outstanding> parameter for the default DNS 2239The default value for the C<max_outstanding> parameter for the default DNS
2229resolver - this is the maximum number of parallel DNS requests that are 2240resolver - this is the maximum number of parallel DNS requests that are
2230sent to the DNS server. 2241sent to the DNS server.
2242
2243=item C<PERL_ANYEVENT_MAX_SIGNAL_LATENCY>
2244
2245Perl has inherently racy signal handling (you can basically choose between
2246losing signals and memory corruption) - pure perl event loops (including
2247C<AnyEvent::Loop>, when C<Async::Interrupt> isn't available) therefore
2248have to poll regularly to avoid losing signals.
2249
2250Some event loops are racy, but don't poll regularly, and some event loops
2251are written in C but are still racy. For those event loops, AnyEvent
2252installs a timer that regularly wakes up the event loop.
2253
2254By default, the interval for this timer is C<10> seconds, but you can
2255override this delay with this environment variable (or by setting
2256the C<$AnyEvent::MAX_SIGNAL_LATENCY> variable before creating signal
2257watchers).
2258
2259Lower values increase CPU (and energy) usage, higher values can introduce
2260long delays when reaping children or waiting for signals.
2261
2262The L<AnyEvent::Async> module, if available, will be used to avoid this
2263polling (with most event loops).
2231 2264
2232=item C<PERL_ANYEVENT_RESOLV_CONF> 2265=item C<PERL_ANYEVENT_RESOLV_CONF>
2233 2266
2234The absolute path to a F<resolv.conf>-style file to use instead of 2267The absolute path to a F<resolv.conf>-style file to use instead of
2235F</etc/resolv.conf> (or the OS-specific configuration) in the default 2268F</etc/resolv.conf> (or the OS-specific configuration) in the default
… …
2984L<AnyEvent::Impl::FLTK>. 3017L<AnyEvent::Impl::FLTK>.
2985 3018
2986Non-blocking handles, pipes, stream sockets, TCP clients and 3019Non-blocking handles, pipes, stream sockets, TCP clients and
2987servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>. 3020servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.
2988 3021
3022Asynchronous File I/O: L<AnyEvent::IO>.
3023
2989Asynchronous DNS: L<AnyEvent::DNS>. 3024Asynchronous DNS: L<AnyEvent::DNS>.
2990 3025
2991Thread support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>. 3026Thread support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>.
2992 3027
2993Nontrivial usage examples: L<AnyEvent::GPSD>, L<AnyEvent::IRC>, 3028Nontrivial usage examples: L<AnyEvent::GPSD>, L<AnyEvent::IRC>,
… …
2995 3030
2996 3031
2997=head1 AUTHOR 3032=head1 AUTHOR
2998 3033
2999 Marc Lehmann <schmorp@schmorp.de> 3034 Marc Lehmann <schmorp@schmorp.de>
3000 http://home.schmorp.de/ 3035 http://anyevent.schmorp.de
3001 3036
3002=cut 3037=cut
3003 3038
30041 30391
3005 3040

Diff Legend

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