[ViewVC] Diff of: cvs/AnyEvent/lib/AnyEvent.pm

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.304 by root, Fri Dec 11 18:09:24 2009 UTC vs.
Revision 1.323 by root, Thu May 20 21:22:20 2010 UTC

…		…
7		7
8	=head1 SYNOPSIS	8	=head1 SYNOPSIS
9		9
10	use AnyEvent;	10	use AnyEvent;
11		11
		12	# if you prefer function calls, look at the AE manpage for
		13	# an alternative API.
		14
12	# file descriptor readable	15	# file handle or descriptor readable
13	my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... });	16	my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... });
14		17
15	# one-shot or repeating timers	18	# one-shot or repeating timers
16	my $w = AnyEvent->timer (after => $seconds, cb => sub { ... });	19	my $w = AnyEvent->timer (after => $seconds, cb => sub { ... });
17	my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ...	20	my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ...
…		…
503		506
504	=head2 IDLE WATCHERS	507	=head2 IDLE WATCHERS
505		508
506	$w = AnyEvent->idle (cb => <callback>);	509	$w = AnyEvent->idle (cb => <callback>);
507		510
508	Sometimes there is a need to do something, but it is not so important	511	Repeatedly invoke the callback after the process becomes idle, until
509	to do it instantly, but only when there is nothing better to do. This	512	either the watcher is destroyed or new events have been detected.
510	"nothing better to do" is usually defined to be "no other events need
511	attention by the event loop".
512		513
513	Idle watchers ideally get invoked when the event loop has nothing	514	Idle watchers are useful when there is a need to do something, but it
514	better to do, just before it would block the process to wait for new	515	is not so important (or wise) to do it instantly. The callback will be
515	events. Instead of blocking, the idle watcher is invoked.	516	invoked only when there is "nothing better to do", which is usually
		517	defined as "all outstanding events have been handled and no new events
		518	have been detected". That means that idle watchers ideally get invoked
		519	when the event loop has just polled for new events but none have been
		520	detected. Instead of blocking to wait for more events, the idle watchers
		521	will be invoked.
516		522
517	Most event loops unfortunately do not really support idle watchers (only	523	Unfortunately, most event loops do not really support idle watchers (only
518	EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent	524	EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
519	will simply call the callback "from time to time".	525	will simply call the callback "from time to time".
520		526
521	Example: read lines from STDIN, but only process them when the	527	Example: read lines from STDIN, but only process them when the
522	program is otherwise idle:	528	program is otherwise idle:
…		…
603	eventually calls C<< -> send >>, and the "consumer side", which waits	609	eventually calls C<< -> send >>, and the "consumer side", which waits
604	for the send to occur.	610	for the send to occur.
605		611
606	Example: wait for a timer.	612	Example: wait for a timer.
607		613
608	# wait till the result is ready	614	# condition: "wait till the timer is fired"
609	my $result_ready = AnyEvent->condvar;	615	my $timer_fired = AnyEvent->condvar;
610		616
611	# do something such as adding a timer	617	# create the timer - we could wait for, say
612	# or socket watcher the calls $result_ready->send	618	# a handle becomign ready, or even an
613	# when the "result" is ready.	619	# AnyEvent::HTTP request to finish, but
614	# in this case, we simply use a timer:	620	# in this case, we simply use a timer:
615	my $w = AnyEvent->timer (	621	my $w = AnyEvent->timer (
616	after => 1,	622	after => 1,
617	cb => sub { $result_ready->send },	623	cb => sub { $timer_fired->send },
618	);	624	);
619		625
620	# this "blocks" (while handling events) till the callback	626	# this "blocks" (while handling events) till the callback
621	# calls ->send	627	# calls ->send
622	$result_ready->recv;	628	$timer_fired->recv;
623		629
624	Example: wait for a timer, but take advantage of the fact that condition	630	Example: wait for a timer, but take advantage of the fact that condition
625	variables are also callable directly.	631	variables are also callable directly.
626		632
627	my $done = AnyEvent->condvar;	633	my $done = AnyEvent->condvar;
…		…
1076		1082
1077	=item L<AnyEvent::DNS>	1083	=item L<AnyEvent::DNS>
1078		1084
1079	Provides rich asynchronous DNS resolver capabilities.	1085	Provides rich asynchronous DNS resolver capabilities.
1080		1086
		1087	=item L<AnyEvent::HTTP>, L<AnyEvent::IRC>, L<AnyEvent::XMPP>, L<AnyEvent::GPSD>, L<AnyEvent::IGS>, L<AnyEvent::FCP>
		1088
		1089	Implement event-based interfaces to the protocols of the same name (for
		1090	the curious, IGS is the International Go Server and FCP is the Freenet
		1091	Client Protocol).
		1092
		1093	=item L<AnyEvent::Handle::UDP>
		1094
		1095	Here be danger!
		1096
		1097	As Pauli would put it, "Not only is it not right, it's not even wrong!" -
		1098	there are so many things wrong with AnyEvent::Handle::UDP, most notably
		1099	it's use of a stream-based API with a protocol that isn't streamable, that
		1100	the only way to improve it is to delete it.
		1101
		1102	It features data corruption (but typically only under load) and general
		1103	confusion. On top, the author is not only clueless about UDP but also
		1104	fact-resistant - some gems of his understanding: "connect doesn't work
		1105	with UDP", "UDP packets are not IP packets", "UDP only has datagrams, not
		1106	packets", "I don't need to implement proper error checking as UDP doesn't
		1107	support error checking" and so on - he doesn't even understand what's
		1108	wrong with his module when it is explained to him.
		1109
1081	=item L<AnyEvent::HTTP>	1110	=item L<AnyEvent::DBI>
1082		1111
1083	A simple-to-use HTTP library that is capable of making a lot of concurrent	1112	Executes L<DBI> requests asynchronously in a proxy process for you,
1084	HTTP requests.	1113	notifying you in an event-bnased way when the operation is finished.
		1114
		1115	=item L<AnyEvent::AIO>
		1116
		1117	Truly asynchronous (as opposed to non-blocking) I/O, should be in the
		1118	toolbox of every event programmer. AnyEvent::AIO transparently fuses
		1119	L<IO::AIO> and AnyEvent together, giving AnyEvent access to event-based
		1120	file I/O, and much more.
1085		1121
1086	=item L<AnyEvent::HTTPD>	1122	=item L<AnyEvent::HTTPD>
1087		1123
1088	Provides a simple web application server framework.	1124	A simple embedded webserver.
1089		1125
1090	=item L<AnyEvent::FastPing>	1126	=item L<AnyEvent::FastPing>
1091		1127
1092	The fastest ping in the west.	1128	The fastest ping in the west.
1093
1094	=item L<AnyEvent::DBI>
1095
1096	Executes L<DBI> requests asynchronously in a proxy process.
1097
1098	=item L<AnyEvent::AIO>
1099
1100	Truly asynchronous I/O, should be in the toolbox of every event
1101	programmer. AnyEvent::AIO transparently fuses L<IO::AIO> and AnyEvent
1102	together.
1103
1104	=item L<AnyEvent::BDB>
1105
1106	Truly asynchronous Berkeley DB access. AnyEvent::BDB transparently fuses
1107	L<BDB> and AnyEvent together.
1108
1109	=item L<AnyEvent::GPSD>
1110
1111	A non-blocking interface to gpsd, a daemon delivering GPS information.
1112
1113	=item L<AnyEvent::IRC>
1114
1115	AnyEvent based IRC client module family (replacing the older Net::IRC3).
1116
1117	=item L<AnyEvent::XMPP>
1118
1119	AnyEvent based XMPP (Jabber protocol) module family (replacing the older
1120	Net::XMPP2>.
1121
1122	=item L<AnyEvent::IGS>
1123
1124	A non-blocking interface to the Internet Go Server protocol (used by
1125	L<App::IGS>).
1126
1127	=item L<Net::FCP>
1128
1129	AnyEvent-based implementation of the Freenet Client Protocol, birthplace
1130	of AnyEvent.
1131
1132	=item L<Event::ExecFlow>
1133
1134	High level API for event-based execution flow control.
1135		1129
1136	=item L<Coro>	1130	=item L<Coro>
1137		1131
1138	Has special support for AnyEvent via L<Coro::AnyEvent>.	1132	Has special support for AnyEvent via L<Coro::AnyEvent>.
1139		1133
…		…
1144	package AnyEvent;	1138	package AnyEvent;
1145		1139
1146	# basically a tuned-down version of common::sense	1140	# basically a tuned-down version of common::sense
1147	sub common_sense {	1141	sub common_sense {
1148	# from common:.sense 1.0	1142	# from common:.sense 1.0
1149	${^WARNING_BITS} = "\xfc\x3f\x33\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x03";	1143	${^WARNING_BITS} = "\xfc\x3f\x33\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x00";
1150	# use strict vars subs	1144	# use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1151	$^H \|= 0x00000600;	1145	$^H \|= 0x00000600;
1152	}	1146	}
1153		1147
1154	BEGIN { AnyEvent::common_sense }	1148	BEGIN { AnyEvent::common_sense }
1155		1149
1156	use Carp ();	1150	use Carp ();
1157		1151
1158	our $VERSION = '5.22';	1152	our $VERSION = '5.261';
1159	our $MODEL;	1153	our $MODEL;
1160		1154
1161	our $AUTOLOAD;	1155	our $AUTOLOAD;
1162	our @ISA;	1156	our @ISA;
1163		1157
1164	our @REGISTRY;	1158	our @REGISTRY;
1165		1159
1166	our $VERBOSE;	1160	our $VERBOSE;
1167		1161
1168	BEGIN {	1162	BEGIN {
1169	eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }";	1163	require "AnyEvent/constants.pl";
		1164
1170	eval "sub TAINT(){ " . (${^TAINT}*1) . " }";	1165	eval "sub TAINT (){" . (${^TAINT}*1) . "}";
1171		1166
1172	delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}	1167	delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
1173	if ${^TAINT};	1168	if ${^TAINT};
1174		1169
1175	$VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1;	1170	$VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1;
…		…
1218	our @post_detect;	1213	our @post_detect;
1219		1214
1220	sub post_detect(&) {	1215	sub post_detect(&) {
1221	my ($cb) = @_;	1216	my ($cb) = @_;
1222		1217
1223	if ($MODEL) {
1224	$cb->();
1225
1226	undef
1227	} else {
1228	push @post_detect, $cb;	1218	push @post_detect, $cb;
1229		1219
1230	defined wantarray	1220	defined wantarray
1231	? bless \$cb, "AnyEvent::Util::postdetect"	1221	? bless \$cb, "AnyEvent::Util::postdetect"
1232	: ()	1222	: ()
1233	}
1234	}	1223	}
1235		1224
1236	sub AnyEvent::Util::postdetect::DESTROY {	1225	sub AnyEvent::Util::postdetect::DESTROY {
1237	@post_detect = grep $_ != ${$_[0]}, @post_detect;	1226	@post_detect = grep $_ != ${$_[0]}, @post_detect;
1238	}	1227	}
1239		1228
1240	sub detect() {	1229	sub detect() {
		1230	# free some memory
		1231	*detect = sub () { $MODEL };
		1232
		1233	local $!; # for good measure
		1234	local $SIG{__DIE__};
		1235
		1236	if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) {
		1237	my $model = "AnyEvent::Impl::$1";
		1238	if (eval "require $model") {
		1239	$MODEL = $model;
		1240	warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2;
		1241	} else {
		1242	warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE;
		1243	}
		1244	}
		1245
		1246	# check for already loaded models
1241	unless ($MODEL) {	1247	unless ($MODEL) {
1242	local $SIG{__DIE__};	1248	for (@REGISTRY, @models) {
1243		1249	my ($package, $model) = @$_;
1244	if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) {	1250	if (${"$package\::VERSION"} > 0) {
1245	my $model = "AnyEvent::Impl::$1";
1246	if (eval "require $model") {	1251	if (eval "require $model") {
1247	$MODEL = $model;	1252	$MODEL = $model;
1248	warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2;	1253	warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2;
1249	} else {	1254	last;
1250	warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE;	1255	}
1251	}	1256	}
1252	}	1257	}
1253		1258
1254	# check for already loaded models
1255	unless ($MODEL) {	1259	unless ($MODEL) {
		1260	# try to autoload a model
1256	for (@REGISTRY, @models) {	1261	for (@REGISTRY, @models) {
1257	my ($package, $model) = @$_;	1262	my ($package, $model, $autoload) = @$_;
		1263	if (
		1264	$autoload
		1265	and eval "require $package"
1258	if (${"$package\::VERSION"} > 0) {	1266	and ${"$package\::VERSION"} > 0
1259	if (eval "require $model") {	1267	and eval "require $model"
		1268	) {
1260	$MODEL = $model;	1269	$MODEL = $model;
1261	warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2;	1270	warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1262	last;	1271	last;
1263	}
1264	}	1272	}
1265	}	1273	}
1266		1274
1267	unless ($MODEL) {
1268	# try to autoload a model
1269	for (@REGISTRY, @models) {
1270	my ($package, $model, $autoload) = @$_;
1271	if (
1272	$autoload
1273	and eval "require $package"
1274	and ${"$package\::VERSION"} > 0
1275	and eval "require $model"
1276	) {
1277	$MODEL = $model;
1278	warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1279	last;
1280	}
1281	}
1282
1283	$MODEL	1275	$MODEL
1284	or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";	1276	or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";
1285	}
1286	}	1277	}
1287
1288	push @{"$MODEL\::ISA"}, "AnyEvent::Base";
1289
1290	unshift @ISA, $MODEL;
1291
1292	require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
1293
1294	(shift @post_detect)->() while @post_detect;
1295	}	1278	}
		1279
		1280	@models = (); # free probe data
		1281
		1282	push @{"$MODEL\::ISA"}, "AnyEvent::Base";
		1283	unshift @ISA, $MODEL;
		1284
		1285	# now nuke some methods that are overriden by the backend.
		1286	# SUPER is not allowed.
		1287	for (qw(time signal child idle)) {
		1288	undef &{"AnyEvent::Base::$_"}
		1289	if defined &{"$MODEL\::$_"};
		1290	}
		1291
		1292	require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
		1293
		1294	(shift @post_detect)->() while @post_detect;
		1295
		1296	*post_detect = sub(&) {
		1297	shift->();
		1298
		1299	undef
		1300	};
1296		1301
1297	$MODEL	1302	$MODEL
1298	}	1303	}
1299		1304
1300	sub AUTOLOAD {	1305	sub AUTOLOAD {
1301	(my $func = $AUTOLOAD) =~ s/.*://;	1306	(my $func = $AUTOLOAD) =~ s/.*://;
1302		1307
1303	$method{$func}	1308	$method{$func}
1304	or Carp::croak "$func: not a valid method for AnyEvent objects";	1309	or Carp::croak "$func: not a valid AnyEvent class method";
1305		1310
1306	detect unless $MODEL;	1311	detect;
1307		1312
1308	my $class = shift;	1313	my $class = shift;
1309	$class->$func (@_);	1314	$class->$func (@_);
1310	}	1315	}
1311		1316
…		…
1328		1333
1329	=head1 SIMPLIFIED AE API	1334	=head1 SIMPLIFIED AE API
1330		1335
1331	Starting with version 5.0, AnyEvent officially supports a second, much	1336	Starting with version 5.0, AnyEvent officially supports a second, much
1332	simpler, API that is designed to reduce the calling, typing and memory	1337	simpler, API that is designed to reduce the calling, typing and memory
1333	overhead.	1338	overhead by using function call syntax and a fixed number of parameters.
1334		1339
1335	See the L<AE> manpage for details.	1340	See the L<AE> manpage for details.
1336		1341
1337	=cut	1342	=cut
1338		1343
1339	package AE;	1344	package AE;
1340		1345
1341	our $VERSION = $AnyEvent::VERSION;	1346	our $VERSION = $AnyEvent::VERSION;
		1347
		1348	# fall back to the main API by default - backends and AnyEvent::Base
		1349	# implementations can overwrite these.
1342		1350
1343	sub io($$$) {	1351	sub io($$$) {
1344	AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2])	1352	AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2])
1345	}	1353	}
1346		1354
…		…
1378		1386
1379	package AnyEvent::Base;	1387	package AnyEvent::Base;
1380		1388
1381	# default implementations for many methods	1389	# default implementations for many methods
1382		1390
1383	sub _time() {	1391	sub time {
		1392	eval q{ # poor man's autoloading {}
1384	# probe for availability of Time::HiRes	1393	# probe for availability of Time::HiRes
1385	if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {	1394	if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1386	warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;	1395	warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;
1387	*_time = \&Time::HiRes::time;	1396	*AE::time = \&Time::HiRes::time;
1388	# if (eval "use POSIX (); (POSIX::times())...	1397	# if (eval "use POSIX (); (POSIX::times())...
1389	} else {	1398	} else {
1390	warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;	1399	warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;
1391	*_time = sub { time }; # epic fail	1400	*AE::time = sub (){ time }; # epic fail
		1401	}
		1402
		1403	*time = sub { AE::time }; # different prototypes
1392	}	1404	};
		1405	die if $@;
1393		1406
1394	&_time	1407	&time
1395	}	1408	}
1396		1409
1397	sub time { _time }	1410	*now = \&time;
1398	sub now { _time }	1411
1399	sub now_update { }	1412	sub now_update { }
1400		1413
1401	# default implementation for ->condvar	1414	# default implementation for ->condvar
1402		1415
1403	sub condvar {	1416	sub condvar {
		1417	eval q{ # poor man's autoloading {}
		1418	*condvar = sub {
1404	bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"	1419	bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
		1420	};
		1421
		1422	*AE::cv = sub (;&) {
		1423	bless { @_ ? (_ae_cb => shift) : () }, "AnyEvent::CondVar"
		1424	};
		1425	};
		1426	die if $@;
		1427
		1428	&condvar
1405	}	1429	}
1406		1430
1407	# default implementation for ->signal	1431	# default implementation for ->signal
1408		1432
1409	our $HAVE_ASYNC_INTERRUPT;	1433	our $HAVE_ASYNC_INTERRUPT;
…		…
1418		1442
1419	our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);	1443	our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
1420	our (%SIG_ASY, %SIG_ASY_W);	1444	our (%SIG_ASY, %SIG_ASY_W);
1421	our ($SIG_COUNT, $SIG_TW);	1445	our ($SIG_COUNT, $SIG_TW);
1422		1446
1423	sub _signal_exec {
1424	$HAVE_ASYNC_INTERRUPT
1425	? $SIGPIPE_R->drain
1426	: sysread $SIGPIPE_R, (my $dummy), 9;
1427
1428	while (%SIG_EV) {
1429	for (keys %SIG_EV) {
1430	delete $SIG_EV{$_};
1431	$_->() for values %{ $SIG_CB{$_} \|\| {} };
1432	}
1433	}
1434	}
1435
1436	# install a dummy wakeup watcher to reduce signal catching latency	1447	# install a dummy wakeup watcher to reduce signal catching latency
		1448	# used by Impls
1437	sub _sig_add() {	1449	sub _sig_add() {
1438	unless ($SIG_COUNT++) {	1450	unless ($SIG_COUNT++) {
1439	# try to align timer on a full-second boundary, if possible	1451	# try to align timer on a full-second boundary, if possible
1440	my $NOW = AE::now;	1452	my $NOW = AE::now;
1441		1453
…		…
1451	undef $SIG_TW	1463	undef $SIG_TW
1452	unless --$SIG_COUNT;	1464	unless --$SIG_COUNT;
1453	}	1465	}
1454		1466
1455	our $_sig_name_init; $_sig_name_init = sub {	1467	our $_sig_name_init; $_sig_name_init = sub {
1456	eval q{ # poor man's autoloading	1468	eval q{ # poor man's autoloading {}
1457	undef $_sig_name_init;	1469	undef $_sig_name_init;
1458		1470
1459	if (_have_async_interrupt) {	1471	if (_have_async_interrupt) {
1460	*sig2num = \&Async::Interrupt::sig2num;	1472	*sig2num = \&Async::Interrupt::sig2num;
1461	*sig2name = \&Async::Interrupt::sig2name;	1473	*sig2name = \&Async::Interrupt::sig2name;
…		…
1493	$SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;	1505	$SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1494		1506
1495	} else {	1507	} else {
1496	warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;	1508	warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
1497		1509
1498	require Fcntl;
1499
1500	if (AnyEvent::WIN32) {	1510	if (AnyEvent::WIN32) {
1501	require AnyEvent::Util;	1511	require AnyEvent::Util;
1502		1512
1503	($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();	1513	($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1504	AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R;	1514	AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R;
1505	AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case	1515	AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case
1506	} else {	1516	} else {
1507	pipe $SIGPIPE_R, $SIGPIPE_W;	1517	pipe $SIGPIPE_R, $SIGPIPE_W;
1508	fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;	1518	fcntl $SIGPIPE_R, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_R;
1509	fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case	1519	fcntl $SIGPIPE_W, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_W; # just in case
1510		1520
1511	# not strictly required, as $^F is normally 2, but let's make sure...	1521	# not strictly required, as $^F is normally 2, but let's make sure...
1512	fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;	1522	fcntl $SIGPIPE_R, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1513	fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;	1523	fcntl $SIGPIPE_W, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1514	}	1524	}
1515		1525
1516	$SIGPIPE_R	1526	$SIGPIPE_R
1517	or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";	1527	or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1518		1528
1519	$SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec;	1529	$SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec;
1520	}	1530	}
1521		1531
1522	*signal = sub {	1532	*signal = $HAVE_ASYNC_INTERRUPT
		1533	? sub {
1523	my (undef, %arg) = @_;	1534	my (undef, %arg) = @_;
1524		1535
1525	my $signal = uc $arg{signal}
1526	or Carp::croak "required option 'signal' is missing";
1527
1528	if ($HAVE_ASYNC_INTERRUPT) {
1529	# async::interrupt	1536	# async::interrupt
1530
1531	$signal = sig2num $signal;	1537	my $signal = sig2num $arg{signal};
1532	$SIG_CB{$signal}{$arg{cb}} = $arg{cb};	1538	$SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1533		1539
1534	$SIG_ASY{$signal} \|\|= new Async::Interrupt	1540	$SIG_ASY{$signal} \|\|= new Async::Interrupt
1535	cb => sub { undef $SIG_EV{$signal} },	1541	cb => sub { undef $SIG_EV{$signal} },
1536	signal => $signal,	1542	signal => $signal,
1537	pipe => [$SIGPIPE_R->filenos],	1543	pipe => [$SIGPIPE_R->filenos],
1538	pipe_autodrain => 0,	1544	pipe_autodrain => 0,
1539	;	1545	;
1540		1546
1541	} else {	1547	bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
		1548	}
		1549	: sub {
		1550	my (undef, %arg) = @_;
		1551
1542	# pure perl	1552	# pure perl
1543
1544	# AE::Util has been loaded in signal
1545	$signal = sig2name $signal;	1553	my $signal = sig2name $arg{signal};
1546	$SIG_CB{$signal}{$arg{cb}} = $arg{cb};	1554	$SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1547		1555
1548	$SIG{$signal} \|\|= sub {	1556	$SIG{$signal} \|\|= sub {
1549	local $!;	1557	local $!;
1550	syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;	1558	syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1551	undef $SIG_EV{$signal};	1559	undef $SIG_EV{$signal};
1552	};	1560	};
1553		1561
1554	# can't do signal processing without introducing races in pure perl,	1562	# can't do signal processing without introducing races in pure perl,
1555	# so limit the signal latency.	1563	# so limit the signal latency.
1556	_sig_add;	1564	_sig_add;
1557	}
1558		1565
1559	bless [$signal, $arg{cb}], "AnyEvent::Base::signal"	1566	bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
		1567	}
1560	};	1568	;
1561		1569
1562	*AnyEvent::Base::signal::DESTROY = sub {	1570	*AnyEvent::Base::signal::DESTROY = sub {
1563	my ($signal, $cb) = @{$_[0]};	1571	my ($signal, $cb) = @{$_[0]};
1564		1572
1565	_sig_del;	1573	_sig_del;
…		…
1572	# print weird messages, or just unconditionally exit	1580	# print weird messages, or just unconditionally exit
1573	# instead of getting the default action.	1581	# instead of getting the default action.
1574	undef $SIG{$signal}	1582	undef $SIG{$signal}
1575	unless keys %{ $SIG_CB{$signal} };	1583	unless keys %{ $SIG_CB{$signal} };
1576	};	1584	};
		1585
		1586	*_signal_exec = sub {
		1587	$HAVE_ASYNC_INTERRUPT
		1588	? $SIGPIPE_R->drain
		1589	: sysread $SIGPIPE_R, (my $dummy), 9;
		1590
		1591	while (%SIG_EV) {
		1592	for (keys %SIG_EV) {
		1593	delete $SIG_EV{$_};
		1594	$_->() for values %{ $SIG_CB{$_} \|\| {} };
		1595	}
		1596	}
		1597	};
1577	};	1598	};
1578	die if $@;	1599	die if $@;
		1600
1579	&signal	1601	&signal
1580	}	1602	}
1581		1603
1582	# default implementation for ->child	1604	# default implementation for ->child
1583		1605
1584	our %PID_CB;	1606	our %PID_CB;
1585	our $CHLD_W;	1607	our $CHLD_W;
1586	our $CHLD_DELAY_W;	1608	our $CHLD_DELAY_W;
1587	our $WNOHANG;	1609	our $WNOHANG;
1588		1610
		1611	# used by many Impl's
1589	sub _emit_childstatus($$) {	1612	sub _emit_childstatus($$) {
1590	my (undef, $rpid, $rstatus) = @_;	1613	my (undef, $rpid, $rstatus) = @_;
1591		1614
1592	$_->($rpid, $rstatus)	1615	$_->($rpid, $rstatus)
1593	for values %{ $PID_CB{$rpid} \|\| {} },	1616	for values %{ $PID_CB{$rpid} \|\| {} },
1594	values %{ $PID_CB{0} \|\| {} };	1617	values %{ $PID_CB{0} \|\| {} };
1595	}	1618	}
1596		1619
1597	sub _sigchld {
1598	my $pid;
1599
1600	AnyEvent->_emit_childstatus ($pid, $?)
1601	while ($pid = waitpid -1, $WNOHANG) > 0;
1602	}
1603
1604	sub child {	1620	sub child {
		1621	eval q{ # poor man's autoloading {}
		1622	*_sigchld = sub {
		1623	my $pid;
		1624
		1625	AnyEvent->_emit_childstatus ($pid, $?)
		1626	while ($pid = waitpid -1, $WNOHANG) > 0;
		1627	};
		1628
		1629	*child = sub {
1605	my (undef, %arg) = @_;	1630	my (undef, %arg) = @_;
1606		1631
1607	defined (my $pid = $arg{pid} + 0)	1632	defined (my $pid = $arg{pid} + 0)
1608	or Carp::croak "required option 'pid' is missing";	1633	or Carp::croak "required option 'pid' is missing";
1609		1634
1610	$PID_CB{$pid}{$arg{cb}} = $arg{cb};	1635	$PID_CB{$pid}{$arg{cb}} = $arg{cb};
1611		1636
1612	# WNOHANG is almost cetrainly 1 everywhere	1637	# WNOHANG is almost cetrainly 1 everywhere
1613	$WNOHANG \|\|= $^O =~ /^(?:openbsd\|netbsd\|linux\|freebsd\|cygwin\|MSWin32)$/	1638	$WNOHANG \|\|= $^O =~ /^(?:openbsd\|netbsd\|linux\|freebsd\|cygwin\|MSWin32)$/
1614	? 1	1639	? 1
1615	: eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } \|\| 1;	1640	: eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } \|\| 1;
1616		1641
1617	unless ($CHLD_W) {	1642	unless ($CHLD_W) {
1618	$CHLD_W = AE::signal CHLD => \&_sigchld;	1643	$CHLD_W = AE::signal CHLD => \&_sigchld;
1619	# child could be a zombie already, so make at least one round	1644	# child could be a zombie already, so make at least one round
1620	&_sigchld;	1645	&_sigchld;
1621	}	1646	}
1622		1647
1623	bless [$pid, $arg{cb}], "AnyEvent::Base::child"	1648	bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1624	}	1649	};
1625		1650
1626	sub AnyEvent::Base::child::DESTROY {	1651	*AnyEvent::Base::child::DESTROY = sub {
1627	my ($pid, $cb) = @{$_[0]};	1652	my ($pid, $cb) = @{$_[0]};
1628		1653
1629	delete $PID_CB{$pid}{$cb};	1654	delete $PID_CB{$pid}{$cb};
1630	delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };	1655	delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1631		1656
1632	undef $CHLD_W unless keys %PID_CB;	1657	undef $CHLD_W unless keys %PID_CB;
		1658	};
		1659	};
		1660	die if $@;
		1661
		1662	&child
1633	}	1663	}
1634		1664
1635	# idle emulation is done by simply using a timer, regardless	1665	# idle emulation is done by simply using a timer, regardless
1636	# of whether the process is idle or not, and not letting	1666	# of whether the process is idle or not, and not letting
1637	# the callback use more than 50% of the time.	1667	# the callback use more than 50% of the time.
1638	sub idle {	1668	sub idle {
		1669	eval q{ # poor man's autoloading {}
		1670	*idle = sub {
1639	my (undef, %arg) = @_;	1671	my (undef, %arg) = @_;
1640		1672
1641	my ($cb, $w, $rcb) = $arg{cb};	1673	my ($cb, $w, $rcb) = $arg{cb};
1642		1674
1643	$rcb = sub {	1675	$rcb = sub {
1644	if ($cb) {	1676	if ($cb) {
1645	$w = _time;	1677	$w = _time;
1646	&$cb;	1678	&$cb;
1647	$w = _time - $w;	1679	$w = _time - $w;
1648		1680
1649	# never use more then 50% of the time for the idle watcher,	1681	# never use more then 50% of the time for the idle watcher,
1650	# within some limits	1682	# within some limits
1651	$w = 0.0001 if $w < 0.0001;	1683	$w = 0.0001 if $w < 0.0001;
1652	$w = 5 if $w > 5;	1684	$w = 5 if $w > 5;
1653		1685
1654	$w = AE::timer $w, 0, $rcb;	1686	$w = AE::timer $w, 0, $rcb;
1655	} else {	1687	} else {
1656	# clean up...	1688	# clean up...
1657	undef $w;	1689	undef $w;
1658	undef $rcb;	1690	undef $rcb;
		1691	}
		1692	};
		1693
		1694	$w = AE::timer 0.05, 0, $rcb;
		1695
		1696	bless \\$cb, "AnyEvent::Base::idle"
1659	}	1697	};
		1698
		1699	*AnyEvent::Base::idle::DESTROY = sub {
		1700	undef $${$_[0]};
		1701	};
1660	};	1702	};
		1703	die if $@;
1661		1704
1662	$w = AE::timer 0.05, 0, $rcb;	1705	&idle
1663
1664	bless \\$cb, "AnyEvent::Base::idle"
1665	}
1666
1667	sub AnyEvent::Base::idle::DESTROY {
1668	undef $${$_[0]};
1669	}	1706	}
1670		1707
1671	package AnyEvent::CondVar;	1708	package AnyEvent::CondVar;
1672		1709
1673	our @ISA = AnyEvent::CondVar::Base::;	1710	our @ISA = AnyEvent::CondVar::Base::;
…		…
2032		2069
2033	The actual code goes further and collects all errors (C<die>s, exceptions)	2070	The actual code goes further and collects all errors (C<die>s, exceptions)
2034	that occurred during request processing. The C<result> method detects	2071	that occurred during request processing. The C<result> method detects
2035	whether an exception as thrown (it is stored inside the $txn object)	2072	whether an exception as thrown (it is stored inside the $txn object)
2036	and just throws the exception, which means connection errors and other	2073	and just throws the exception, which means connection errors and other
2037	problems get reported tot he code that tries to use the result, not in a	2074	problems get reported to the code that tries to use the result, not in a
2038	random callback.	2075	random callback.
2039		2076
2040	All of this enables the following usage styles:	2077	All of this enables the following usage styles:
2041		2078
2042	1. Blocking:	2079	1. Blocking:
…		…
2499	automatic timer adjustments even when no monotonic clock is available,	2536	automatic timer adjustments even when no monotonic clock is available,
2500	can take avdantage of advanced kernel interfaces such as C<epoll> and	2537	can take avdantage of advanced kernel interfaces such as C<epoll> and
2501	C<kqueue>, and is the fastest backend I<by far>. You can even embed	2538	C<kqueue>, and is the fastest backend I<by far>. You can even embed
2502	L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>).	2539	L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>).
2503		2540
		2541	If you only use backends that rely on another event loop (e.g. C<Tk>),
		2542	then this module will do nothing for you.
		2543
2504	=item L<Guard>	2544	=item L<Guard>
2505		2545
2506	The guard module, when used, will be used to implement	2546	The guard module, when used, will be used to implement
2507	C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a	2547	C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a
2508	lot less memory), but otherwise doesn't affect guard operation much. It is	2548	lot less memory), but otherwise doesn't affect guard operation much. It is
2509	purely used for performance.	2549	purely used for performance.
2510		2550
2511	=item L<JSON> and L<JSON::XS>	2551	=item L<JSON> and L<JSON::XS>
2512		2552
2513	One of these modules is required when you want to read or write JSON data	2553	One of these modules is required when you want to read or write JSON data
2514	via L<AnyEvent::Handle>. It is also written in pure-perl, but can take	2554	via L<AnyEvent::Handle>. L<JSON> is also written in pure-perl, but can take
2515	advantage of the ultra-high-speed L<JSON::XS> module when it is installed.	2555	advantage of the ultra-high-speed L<JSON::XS> module when it is installed.
2516
2517	In fact, L<AnyEvent::Handle> will use L<JSON::XS> by default if it is
2518	installed.
2519		2556
2520	=item L<Net::SSLeay>	2557	=item L<Net::SSLeay>
2521		2558
2522	Implementing TLS/SSL in Perl is certainly interesting, but not very	2559	Implementing TLS/SSL in Perl is certainly interesting, but not very
2523	worthwhile: If this module is installed, then L<AnyEvent::Handle> (with	2560	worthwhile: If this module is installed, then L<AnyEvent::Handle> (with
…		…
2534		2571
2535		2572
2536	=head1 FORK	2573	=head1 FORK
2537		2574
2538	Most event libraries are not fork-safe. The ones who are usually are	2575	Most event libraries are not fork-safe. The ones who are usually are
2539	because they rely on inefficient but fork-safe C<select> or C<poll>	2576	because they rely on inefficient but fork-safe C<select> or C<poll> calls
2540	calls. Only L<EV> is fully fork-aware.	2577	- higher performance APIs such as BSD's kqueue or the dreaded Linux epoll
		2578	are usually badly thought-out hacks that are incompatible with fork in
		2579	one way or another. Only L<EV> is fully fork-aware and ensures that you
		2580	continue event-processing in both parent and child (or both, if you know
		2581	what you are doing).
2541		2582
2542	This means that, in general, you cannot fork and do event processing	2583	This means that, in general, you cannot fork and do event processing in
2543	in the child if a watcher was created before the fork (which in turn	2584	the child if the event library was initialised before the fork (which
2544	initialises the event library).	2585	usually happens when the first AnyEvent watcher is created, or the library
		2586	is loaded).
2545		2587
2546	If you have to fork, you must either do so I<before> creating your first	2588	If you have to fork, you must either do so I<before> creating your first
2547	watcher OR you must not use AnyEvent at all in the child OR you must do	2589	watcher OR you must not use AnyEvent at all in the child OR you must do
2548	something completely out of the scope of AnyEvent.	2590	something completely out of the scope of AnyEvent.
2549		2591
2550	The problem of doing event processing in the parent I<and> the child	2592	The problem of doing event processing in the parent I<and> the child
2551	is much more complicated: even for backends that I<are> fork-aware or	2593	is much more complicated: even for backends that I<are> fork-aware or
2552	fork-safe, their behaviour is not usually what you want: fork clones all	2594	fork-safe, their behaviour is not usually what you want: fork clones all
2553	watchers, that means all timers, I/O watchers etc. are active in both	2595	watchers, that means all timers, I/O watchers etc. are active in both
2554	parent and child, which is almost never what you want.	2596	parent and child, which is almost never what you want. USing C<exec>
		2597	to start worker children from some kind of manage rprocess is usually
		2598	preferred, because it is much easier and cleaner, at the expense of having
		2599	to have another binary.
2555		2600
2556		2601
2557	=head1 SECURITY CONSIDERATIONS	2602	=head1 SECURITY CONSIDERATIONS
2558		2603
2559	AnyEvent can be forced to load any event model via	2604	AnyEvent can be forced to load any event model via

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent.pm (file contents): Revision 1.304 by root, Fri Dec 11 18:09:24 2009 UTC vs. Revision 1.323 by root, Thu May 20 21:22:20 2010 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.304 by root, Fri Dec 11 18:09:24 2009 UTC vs.
Revision 1.323 by root, Thu May 20 21:22:20 2010 UTC