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

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.295 by root, Wed Oct 28 02:42:06 2009 UTC vs.
Revision 1.317 by root, Wed Mar 24 21:22:57 2010 UTC

…		…
363	might affect timers and time-outs.	363	might affect timers and time-outs.
364		364
365	When this is the case, you can call this method, which will update the	365	When this is the case, you can call this method, which will update the
366	event loop's idea of "current time".	366	event loop's idea of "current time".
367		367
		368	A typical example would be a script in a web server (e.g. C<mod_perl>) -
		369	when mod_perl executes the script, then the event loop will have the wrong
		370	idea about the "current time" (being potentially far in the past, when the
		371	script ran the last time). In that case you should arrange a call to C<<
		372	AnyEvent->now_update >> each time the web server process wakes up again
		373	(e.g. at the start of your script, or in a handler).
		374
368	Note that updating the time I<might> cause some events to be handled.	375	Note that updating the time I<might> cause some events to be handled.
369		376
370	=back	377	=back
371		378
372	=head2 SIGNAL WATCHERS	379	=head2 SIGNAL WATCHERS
…		…
395	correctly.	402	correctly.
396		403
397	Example: exit on SIGINT	404	Example: exit on SIGINT
398		405
399	my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });	406	my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
		407
		408	=head3 Restart Behaviour
		409
		410	While restart behaviour is up to the event loop implementation, most will
		411	not restart syscalls (that includes L<Async::Interrupt> and AnyEvent's
		412	pure perl implementation).
		413
		414	=head3 Safe/Unsafe Signals
		415
		416	Perl signals can be either "safe" (synchronous to opcode handling) or
		417	"unsafe" (asynchronous) - the former might get delayed indefinitely, the
		418	latter might corrupt your memory.
		419
		420	AnyEvent signal handlers are, in addition, synchronous to the event loop,
		421	i.e. they will not interrupt your running perl program but will only be
		422	called as part of the normal event handling (just like timer, I/O etc.
		423	callbacks, too).
400		424
401	=head3 Signal Races, Delays and Workarounds	425	=head3 Signal Races, Delays and Workarounds
402		426
403	Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching	427	Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching
404	callbacks to signals in a generic way, which is a pity, as you cannot	428	callbacks to signals in a generic way, which is a pity, as you cannot
…		…
479		503
480	=head2 IDLE WATCHERS	504	=head2 IDLE WATCHERS
481		505
482	$w = AnyEvent->idle (cb => <callback>);	506	$w = AnyEvent->idle (cb => <callback>);
483		507
484	Sometimes there is a need to do something, but it is not so important	508	Repeatedly invoke the callback after the process becomes idle, until
485	to do it instantly, but only when there is nothing better to do. This	509	either the watcher is destroyed or new events have been detected.
486	"nothing better to do" is usually defined to be "no other events need
487	attention by the event loop".
488		510
489	Idle watchers ideally get invoked when the event loop has nothing	511	Idle watchers are useful when there is a need to do something, but it
490	better to do, just before it would block the process to wait for new	512	is not so important (or wise) to do it instantly. The callback will be
491	events. Instead of blocking, the idle watcher is invoked.	513	invoked only when there is "nothing better to do", which is usually
		514	defined as "all outstanding events have been handled and no new events
		515	have been detected". That means that idle watchers ideally get invoked
		516	when the event loop has just polled for new events but none have been
		517	detected. Instead of blocking to wait for more events, the idle watchers
		518	will be invoked.
492		519
493	Most event loops unfortunately do not really support idle watchers (only	520	Unfortunately, most event loops do not really support idle watchers (only
494	EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent	521	EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
495	will simply call the callback "from time to time".	522	will simply call the callback "from time to time".
496		523
497	Example: read lines from STDIN, but only process them when the	524	Example: read lines from STDIN, but only process them when the
498	program is otherwise idle:	525	program is otherwise idle:
…		…
942	You should check C<$AnyEvent::MODEL> before adding to this array, though:	969	You should check C<$AnyEvent::MODEL> before adding to this array, though:
943	if it is defined then the event loop has already been detected, and the	970	if it is defined then the event loop has already been detected, and the
944	array will be ignored.	971	array will be ignored.
945		972
946	Best use C<AnyEvent::post_detect { BLOCK }> when your application allows	973	Best use C<AnyEvent::post_detect { BLOCK }> when your application allows
947	it,as it takes care of these details.	974	it, as it takes care of these details.
948		975
949	This variable is mainly useful for modules that can do something useful	976	This variable is mainly useful for modules that can do something useful
950	when AnyEvent is used and thus want to know when it is initialised, but do	977	when AnyEvent is used and thus want to know when it is initialised, but do
951	not need to even load it by default. This array provides the means to hook	978	not need to even load it by default. This array provides the means to hook
952	into AnyEvent passively, without loading it.	979	into AnyEvent passively, without loading it.
		980
		981	Example: To load Coro::AnyEvent whenever Coro and AnyEvent are used
		982	together, you could put this into Coro (this is the actual code used by
		983	Coro to accomplish this):
		984
		985	if (defined $AnyEvent::MODEL) {
		986	# AnyEvent already initialised, so load Coro::AnyEvent
		987	require Coro::AnyEvent;
		988	} else {
		989	# AnyEvent not yet initialised, so make sure to load Coro::AnyEvent
		990	# as soon as it is
		991	push @AnyEvent::post_detect, sub { require Coro::AnyEvent };
		992	}
953		993
954	=back	994	=back
955		995
956	=head1 WHAT TO DO IN A MODULE	996	=head1 WHAT TO DO IN A MODULE
957		997
…		…
1107	package AnyEvent;	1147	package AnyEvent;
1108		1148
1109	# basically a tuned-down version of common::sense	1149	# basically a tuned-down version of common::sense
1110	sub common_sense {	1150	sub common_sense {
1111	# from common:.sense 1.0	1151	# from common:.sense 1.0
1112	${^WARNING_BITS} = "\xfc\x3f\xf3\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x03";	1152	${^WARNING_BITS} = "\xfc\x3f\x33\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x00";
1113	# use strict vars subs	1153	# use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1114	$^H \|= 0x00000600;	1154	$^H \|= 0x00000600;
1115	}	1155	}
1116		1156
1117	BEGIN { AnyEvent::common_sense }	1157	BEGIN { AnyEvent::common_sense }
1118		1158
1119	use Carp ();	1159	use Carp ();
1120		1160
1121	our $VERSION = '5.202';	1161	our $VERSION = '5.251';
1122	our $MODEL;	1162	our $MODEL;
1123		1163
1124	our $AUTOLOAD;	1164	our $AUTOLOAD;
1125	our @ISA;	1165	our @ISA;
1126		1166
1127	our @REGISTRY;	1167	our @REGISTRY;
1128		1168
1129	our $WIN32;
1130
1131	our $VERBOSE;	1169	our $VERBOSE;
1132		1170
1133	BEGIN {	1171	BEGIN {
1134	eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }";	1172	require "AnyEvent/constants.pl";
		1173
1135	eval "sub TAINT(){ " . (${^TAINT}*1) . " }";	1174	eval "sub TAINT (){" . (${^TAINT}*1) . "}";
1136		1175
1137	delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}	1176	delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
1138	if ${^TAINT};	1177	if ${^TAINT};
1139		1178
1140	$VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1;	1179	$VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1;
…		…
1183	our @post_detect;	1222	our @post_detect;
1184		1223
1185	sub post_detect(&) {	1224	sub post_detect(&) {
1186	my ($cb) = @_;	1225	my ($cb) = @_;
1187		1226
1188	if ($MODEL) {
1189	$cb->();
1190
1191	undef
1192	} else {
1193	push @post_detect, $cb;	1227	push @post_detect, $cb;
1194		1228
1195	defined wantarray	1229	defined wantarray
1196	? bless \$cb, "AnyEvent::Util::postdetect"	1230	? bless \$cb, "AnyEvent::Util::postdetect"
1197	: ()	1231	: ()
1198	}
1199	}	1232	}
1200		1233
1201	sub AnyEvent::Util::postdetect::DESTROY {	1234	sub AnyEvent::Util::postdetect::DESTROY {
1202	@post_detect = grep $_ != ${$_[0]}, @post_detect;	1235	@post_detect = grep $_ != ${$_[0]}, @post_detect;
1203	}	1236	}
1204		1237
1205	sub detect() {	1238	sub detect() {
		1239	# free some memory
		1240	*detect = sub () { $MODEL };
		1241
		1242	local $!; # for good measure
		1243	local $SIG{__DIE__};
		1244
		1245	if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) {
		1246	my $model = "AnyEvent::Impl::$1";
		1247	if (eval "require $model") {
		1248	$MODEL = $model;
		1249	warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2;
		1250	} else {
		1251	warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE;
		1252	}
		1253	}
		1254
		1255	# check for already loaded models
1206	unless ($MODEL) {	1256	unless ($MODEL) {
1207	local $SIG{__DIE__};	1257	for (@REGISTRY, @models) {
1208		1258	my ($package, $model) = @$_;
1209	if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) {	1259	if (${"$package\::VERSION"} > 0) {
1210	my $model = "AnyEvent::Impl::$1";
1211	if (eval "require $model") {	1260	if (eval "require $model") {
1212	$MODEL = $model;	1261	$MODEL = $model;
1213	warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2;	1262	warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2;
1214	} else {	1263	last;
1215	warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE;	1264	}
1216	}	1265	}
1217	}	1266	}
1218		1267
1219	# check for already loaded models
1220	unless ($MODEL) {	1268	unless ($MODEL) {
		1269	# try to autoload a model
1221	for (@REGISTRY, @models) {	1270	for (@REGISTRY, @models) {
1222	my ($package, $model) = @$_;	1271	my ($package, $model, $autoload) = @$_;
		1272	if (
		1273	$autoload
		1274	and eval "require $package"
1223	if (${"$package\::VERSION"} > 0) {	1275	and ${"$package\::VERSION"} > 0
1224	if (eval "require $model") {	1276	and eval "require $model"
		1277	) {
1225	$MODEL = $model;	1278	$MODEL = $model;
1226	warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2;	1279	warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1227	last;	1280	last;
1228	}
1229	}	1281	}
1230	}	1282	}
1231		1283
1232	unless ($MODEL) {
1233	# try to autoload a model
1234	for (@REGISTRY, @models) {
1235	my ($package, $model, $autoload) = @$_;
1236	if (
1237	$autoload
1238	and eval "require $package"
1239	and ${"$package\::VERSION"} > 0
1240	and eval "require $model"
1241	) {
1242	$MODEL = $model;
1243	warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1244	last;
1245	}
1246	}
1247
1248	$MODEL	1284	$MODEL
1249	or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";	1285	or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";
1250	}
1251	}	1286	}
1252
1253	push @{"$MODEL\::ISA"}, "AnyEvent::Base";
1254
1255	unshift @ISA, $MODEL;
1256
1257	require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
1258
1259	(shift @post_detect)->() while @post_detect;
1260	}	1287	}
		1288
		1289	@models = (); # free probe data
		1290
		1291	push @{"$MODEL\::ISA"}, "AnyEvent::Base";
		1292	unshift @ISA, $MODEL;
		1293
		1294	# now nuke some methods that are overriden by the backend.
		1295	# SUPER is not allowed.
		1296	for (qw(time signal child idle)) {
		1297	undef &{"AnyEvent::Base::$_"}
		1298	if defined &{"$MODEL\::$_"};
		1299	}
		1300
		1301	require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
		1302
		1303	(shift @post_detect)->() while @post_detect;
		1304
		1305	*post_detect = sub(&) {
		1306	shift->();
		1307
		1308	undef
		1309	};
1261		1310
1262	$MODEL	1311	$MODEL
1263	}	1312	}
1264		1313
1265	sub AUTOLOAD {	1314	sub AUTOLOAD {
1266	(my $func = $AUTOLOAD) =~ s/.*://;	1315	(my $func = $AUTOLOAD) =~ s/.*://;
1267		1316
1268	$method{$func}	1317	$method{$func}
1269	or Carp::croak "$func: not a valid method for AnyEvent objects";	1318	or Carp::croak "$func: not a valid AnyEvent class method";
1270		1319
1271	detect unless $MODEL;	1320	detect;
1272		1321
1273	my $class = shift;	1322	my $class = shift;
1274	$class->$func (@_);	1323	$class->$func (@_);
1275	}	1324	}
1276		1325
…		…
1343		1392
1344	package AnyEvent::Base;	1393	package AnyEvent::Base;
1345		1394
1346	# default implementations for many methods	1395	# default implementations for many methods
1347		1396
1348	sub _time() {	1397	sub time {
		1398	eval q{ # poor man's autoloading {}
1349	# probe for availability of Time::HiRes	1399	# probe for availability of Time::HiRes
1350	if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {	1400	if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1351	warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;	1401	warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;
1352	*_time = \&Time::HiRes::time;	1402	*AE::time = \&Time::HiRes::time;
1353	# if (eval "use POSIX (); (POSIX::times())...	1403	# if (eval "use POSIX (); (POSIX::times())...
1354	} else {	1404	} else {
1355	warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;	1405	warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;
1356	*_time = sub { time }; # epic fail	1406	*AE::time = sub (){ time }; # epic fail
		1407	}
		1408
		1409	*time = sub { AE::time }; # different prototypes
1357	}	1410	};
		1411	die if $@;
1358		1412
1359	&_time	1413	&time
1360	}	1414	}
1361		1415
1362	sub time { _time }	1416	*now = \&time;
1363	sub now { _time }	1417
1364	sub now_update { }	1418	sub now_update { }
1365		1419
1366	# default implementation for ->condvar	1420	# default implementation for ->condvar
1367		1421
1368	sub condvar {	1422	sub condvar {
		1423	eval q{ # poor man's autoloading {}
		1424	*condvar = sub {
1369	bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"	1425	bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
		1426	};
		1427
		1428	*AE::cv = sub (;&) {
		1429	bless { @_ ? (_ae_cb => shift) : () }, "AnyEvent::CondVar"
		1430	};
		1431	};
		1432	die if $@;
		1433
		1434	&condvar
1370	}	1435	}
1371		1436
1372	# default implementation for ->signal	1437	# default implementation for ->signal
1373		1438
1374	our $HAVE_ASYNC_INTERRUPT;	1439	our $HAVE_ASYNC_INTERRUPT;
…		…
1383		1448
1384	our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);	1449	our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
1385	our (%SIG_ASY, %SIG_ASY_W);	1450	our (%SIG_ASY, %SIG_ASY_W);
1386	our ($SIG_COUNT, $SIG_TW);	1451	our ($SIG_COUNT, $SIG_TW);
1387		1452
1388	sub _signal_exec {
1389	$HAVE_ASYNC_INTERRUPT
1390	? $SIGPIPE_R->drain
1391	: sysread $SIGPIPE_R, (my $dummy), 9;
1392
1393	while (%SIG_EV) {
1394	for (keys %SIG_EV) {
1395	delete $SIG_EV{$_};
1396	$_->() for values %{ $SIG_CB{$_} \|\| {} };
1397	}
1398	}
1399	}
1400
1401	# install a dummy wakeup watcher to reduce signal catching latency	1453	# install a dummy wakeup watcher to reduce signal catching latency
		1454	# used by Impls
1402	sub _sig_add() {	1455	sub _sig_add() {
1403	unless ($SIG_COUNT++) {	1456	unless ($SIG_COUNT++) {
1404	# try to align timer on a full-second boundary, if possible	1457	# try to align timer on a full-second boundary, if possible
1405	my $NOW = AE::now;	1458	my $NOW = AE::now;
1406		1459
…		…
1416	undef $SIG_TW	1469	undef $SIG_TW
1417	unless --$SIG_COUNT;	1470	unless --$SIG_COUNT;
1418	}	1471	}
1419		1472
1420	our $_sig_name_init; $_sig_name_init = sub {	1473	our $_sig_name_init; $_sig_name_init = sub {
1421	eval q{ # poor man's autoloading	1474	eval q{ # poor man's autoloading {}
1422	undef $_sig_name_init;	1475	undef $_sig_name_init;
1423		1476
1424	if (_have_async_interrupt) {	1477	if (_have_async_interrupt) {
1425	*sig2num = \&Async::Interrupt::sig2num;	1478	*sig2num = \&Async::Interrupt::sig2num;
1426	*sig2name = \&Async::Interrupt::sig2name;	1479	*sig2name = \&Async::Interrupt::sig2name;
…		…
1458	$SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;	1511	$SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1459		1512
1460	} else {	1513	} else {
1461	warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;	1514	warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
1462		1515
1463	require Fcntl;
1464
1465	if (AnyEvent::WIN32) {	1516	if (AnyEvent::WIN32) {
1466	require AnyEvent::Util;	1517	require AnyEvent::Util;
1467		1518
1468	($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();	1519	($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1469	AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R;	1520	AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R;
1470	AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case	1521	AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case
1471	} else {	1522	} else {
1472	pipe $SIGPIPE_R, $SIGPIPE_W;	1523	pipe $SIGPIPE_R, $SIGPIPE_W;
1473	fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;	1524	fcntl $SIGPIPE_R, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_R;
1474	fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case	1525	fcntl $SIGPIPE_W, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_W; # just in case
1475		1526
1476	# not strictly required, as $^F is normally 2, but let's make sure...	1527	# not strictly required, as $^F is normally 2, but let's make sure...
1477	fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;	1528	fcntl $SIGPIPE_R, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1478	fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;	1529	fcntl $SIGPIPE_W, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1479	}	1530	}
1480		1531
1481	$SIGPIPE_R	1532	$SIGPIPE_R
1482	or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";	1533	or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1483		1534
1484	$SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec;	1535	$SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec;
1485	}	1536	}
1486		1537
1487	*signal = sub {	1538	*signal = $HAVE_ASYNC_INTERRUPT
		1539	? sub {
1488	my (undef, %arg) = @_;	1540	my (undef, %arg) = @_;
1489		1541
1490	my $signal = uc $arg{signal}
1491	or Carp::croak "required option 'signal' is missing";
1492
1493	if ($HAVE_ASYNC_INTERRUPT) {
1494	# async::interrupt	1542	# async::interrupt
1495
1496	$signal = sig2num $signal;	1543	my $signal = sig2num $arg{signal};
1497	$SIG_CB{$signal}{$arg{cb}} = $arg{cb};	1544	$SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1498		1545
1499	$SIG_ASY{$signal} \|\|= new Async::Interrupt	1546	$SIG_ASY{$signal} \|\|= new Async::Interrupt
1500	cb => sub { undef $SIG_EV{$signal} },	1547	cb => sub { undef $SIG_EV{$signal} },
1501	signal => $signal,	1548	signal => $signal,
1502	pipe => [$SIGPIPE_R->filenos],	1549	pipe => [$SIGPIPE_R->filenos],
1503	pipe_autodrain => 0,	1550	pipe_autodrain => 0,
1504	;	1551	;
1505		1552
1506	} else {	1553	bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
		1554	}
		1555	: sub {
		1556	my (undef, %arg) = @_;
		1557
1507	# pure perl	1558	# pure perl
1508
1509	# AE::Util has been loaded in signal
1510	$signal = sig2name $signal;	1559	my $signal = sig2name $arg{signal};
1511	$SIG_CB{$signal}{$arg{cb}} = $arg{cb};	1560	$SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1512		1561
1513	$SIG{$signal} \|\|= sub {	1562	$SIG{$signal} \|\|= sub {
1514	local $!;	1563	local $!;
1515	syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;	1564	syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1516	undef $SIG_EV{$signal};	1565	undef $SIG_EV{$signal};
1517	};	1566	};
1518		1567
1519	# can't do signal processing without introducing races in pure perl,	1568	# can't do signal processing without introducing races in pure perl,
1520	# so limit the signal latency.	1569	# so limit the signal latency.
1521	_sig_add;	1570	_sig_add;
1522	}
1523		1571
1524	bless [$signal, $arg{cb}], "AnyEvent::Base::signal"	1572	bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
		1573	}
1525	};	1574	;
1526		1575
1527	*AnyEvent::Base::signal::DESTROY = sub {	1576	*AnyEvent::Base::signal::DESTROY = sub {
1528	my ($signal, $cb) = @{$_[0]};	1577	my ($signal, $cb) = @{$_[0]};
1529		1578
1530	_sig_del;	1579	_sig_del;
…		…
1537	# print weird messages, or just unconditionally exit	1586	# print weird messages, or just unconditionally exit
1538	# instead of getting the default action.	1587	# instead of getting the default action.
1539	undef $SIG{$signal}	1588	undef $SIG{$signal}
1540	unless keys %{ $SIG_CB{$signal} };	1589	unless keys %{ $SIG_CB{$signal} };
1541	};	1590	};
		1591
		1592	*_signal_exec = sub {
		1593	$HAVE_ASYNC_INTERRUPT
		1594	? $SIGPIPE_R->drain
		1595	: sysread $SIGPIPE_R, (my $dummy), 9;
		1596
		1597	while (%SIG_EV) {
		1598	for (keys %SIG_EV) {
		1599	delete $SIG_EV{$_};
		1600	$_->() for values %{ $SIG_CB{$_} \|\| {} };
		1601	}
		1602	}
		1603	};
1542	};	1604	};
1543	die if $@;	1605	die if $@;
		1606
1544	&signal	1607	&signal
1545	}	1608	}
1546		1609
1547	# default implementation for ->child	1610	# default implementation for ->child
1548		1611
1549	our %PID_CB;	1612	our %PID_CB;
1550	our $CHLD_W;	1613	our $CHLD_W;
1551	our $CHLD_DELAY_W;	1614	our $CHLD_DELAY_W;
1552	our $WNOHANG;	1615	our $WNOHANG;
1553		1616
		1617	# used by many Impl's
1554	sub _emit_childstatus($$) {	1618	sub _emit_childstatus($$) {
1555	my (undef, $rpid, $rstatus) = @_;	1619	my (undef, $rpid, $rstatus) = @_;
1556		1620
1557	$_->($rpid, $rstatus)	1621	$_->($rpid, $rstatus)
1558	for values %{ $PID_CB{$rpid} \|\| {} },	1622	for values %{ $PID_CB{$rpid} \|\| {} },
1559	values %{ $PID_CB{0} \|\| {} };	1623	values %{ $PID_CB{0} \|\| {} };
1560	}	1624	}
1561		1625
1562	sub _sigchld {
1563	my $pid;
1564
1565	AnyEvent->_emit_childstatus ($pid, $?)
1566	while ($pid = waitpid -1, $WNOHANG) > 0;
1567	}
1568
1569	sub child {	1626	sub child {
		1627	eval q{ # poor man's autoloading {}
		1628	*_sigchld = sub {
		1629	my $pid;
		1630
		1631	AnyEvent->_emit_childstatus ($pid, $?)
		1632	while ($pid = waitpid -1, $WNOHANG) > 0;
		1633	};
		1634
		1635	*child = sub {
1570	my (undef, %arg) = @_;	1636	my (undef, %arg) = @_;
1571		1637
1572	defined (my $pid = $arg{pid} + 0)	1638	defined (my $pid = $arg{pid} + 0)
1573	or Carp::croak "required option 'pid' is missing";	1639	or Carp::croak "required option 'pid' is missing";
1574		1640
1575	$PID_CB{$pid}{$arg{cb}} = $arg{cb};	1641	$PID_CB{$pid}{$arg{cb}} = $arg{cb};
1576		1642
1577	# WNOHANG is almost cetrainly 1 everywhere	1643	# WNOHANG is almost cetrainly 1 everywhere
1578	$WNOHANG \|\|= $^O =~ /^(?:openbsd\|netbsd\|linux\|freebsd\|cygwin\|MSWin32)$/	1644	$WNOHANG \|\|= $^O =~ /^(?:openbsd\|netbsd\|linux\|freebsd\|cygwin\|MSWin32)$/
1579	? 1	1645	? 1
1580	: eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } \|\| 1;	1646	: eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } \|\| 1;
1581		1647
1582	unless ($CHLD_W) {	1648	unless ($CHLD_W) {
1583	$CHLD_W = AE::signal CHLD => \&_sigchld;	1649	$CHLD_W = AE::signal CHLD => \&_sigchld;
1584	# child could be a zombie already, so make at least one round	1650	# child could be a zombie already, so make at least one round
1585	&_sigchld;	1651	&_sigchld;
1586	}	1652	}
1587		1653
1588	bless [$pid, $arg{cb}], "AnyEvent::Base::child"	1654	bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1589	}	1655	};
1590		1656
1591	sub AnyEvent::Base::child::DESTROY {	1657	*AnyEvent::Base::child::DESTROY = sub {
1592	my ($pid, $cb) = @{$_[0]};	1658	my ($pid, $cb) = @{$_[0]};
1593		1659
1594	delete $PID_CB{$pid}{$cb};	1660	delete $PID_CB{$pid}{$cb};
1595	delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };	1661	delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1596		1662
1597	undef $CHLD_W unless keys %PID_CB;	1663	undef $CHLD_W unless keys %PID_CB;
		1664	};
		1665	};
		1666	die if $@;
		1667
		1668	&child
1598	}	1669	}
1599		1670
1600	# idle emulation is done by simply using a timer, regardless	1671	# idle emulation is done by simply using a timer, regardless
1601	# of whether the process is idle or not, and not letting	1672	# of whether the process is idle or not, and not letting
1602	# the callback use more than 50% of the time.	1673	# the callback use more than 50% of the time.
1603	sub idle {	1674	sub idle {
		1675	eval q{ # poor man's autoloading {}
		1676	*idle = sub {
1604	my (undef, %arg) = @_;	1677	my (undef, %arg) = @_;
1605		1678
1606	my ($cb, $w, $rcb) = $arg{cb};	1679	my ($cb, $w, $rcb) = $arg{cb};
1607		1680
1608	$rcb = sub {	1681	$rcb = sub {
1609	if ($cb) {	1682	if ($cb) {
1610	$w = _time;	1683	$w = _time;
1611	&$cb;	1684	&$cb;
1612	$w = _time - $w;	1685	$w = _time - $w;
1613		1686
1614	# never use more then 50% of the time for the idle watcher,	1687	# never use more then 50% of the time for the idle watcher,
1615	# within some limits	1688	# within some limits
1616	$w = 0.0001 if $w < 0.0001;	1689	$w = 0.0001 if $w < 0.0001;
1617	$w = 5 if $w > 5;	1690	$w = 5 if $w > 5;
1618		1691
1619	$w = AE::timer $w, 0, $rcb;	1692	$w = AE::timer $w, 0, $rcb;
1620	} else {	1693	} else {
1621	# clean up...	1694	# clean up...
1622	undef $w;	1695	undef $w;
1623	undef $rcb;	1696	undef $rcb;
		1697	}
		1698	};
		1699
		1700	$w = AE::timer 0.05, 0, $rcb;
		1701
		1702	bless \\$cb, "AnyEvent::Base::idle"
1624	}	1703	};
		1704
		1705	*AnyEvent::Base::idle::DESTROY = sub {
		1706	undef $${$_[0]};
		1707	};
1625	};	1708	};
		1709	die if $@;
1626		1710
1627	$w = AE::timer 0.05, 0, $rcb;	1711	&idle
1628
1629	bless \\$cb, "AnyEvent::Base::idle"
1630	}
1631
1632	sub AnyEvent::Base::idle::DESTROY {
1633	undef $${$_[0]};
1634	}	1712	}
1635		1713
1636	package AnyEvent::CondVar;	1714	package AnyEvent::CondVar;
1637		1715
1638	our @ISA = AnyEvent::CondVar::Base::;	1716	our @ISA = AnyEvent::CondVar::Base::;
…		…
2426	it's built-in modules) are required to use it.	2504	it's built-in modules) are required to use it.
2427		2505
2428	That does not mean that AnyEvent won't take advantage of some additional	2506	That does not mean that AnyEvent won't take advantage of some additional
2429	modules if they are installed.	2507	modules if they are installed.
2430		2508
2431	This section epxlains which additional modules will be used, and how they	2509	This section explains which additional modules will be used, and how they
2432	affect AnyEvent's operetion.	2510	affect AnyEvent's operation.
2433		2511
2434	=over 4	2512	=over 4
2435		2513
2436	=item L<Async::Interrupt>	2514	=item L<Async::Interrupt>
2437		2515
…		…
2442	catch the signals) with some delay (default is 10 seconds, look for	2520	catch the signals) with some delay (default is 10 seconds, look for
2443	C<$AnyEvent::MAX_SIGNAL_LATENCY>).	2521	C<$AnyEvent::MAX_SIGNAL_LATENCY>).
2444		2522
2445	If this module is available, then it will be used to implement signal	2523	If this module is available, then it will be used to implement signal
2446	catching, which means that signals will not be delayed, and the event loop	2524	catching, which means that signals will not be delayed, and the event loop
2447	will not be interrupted regularly, which is more efficient (And good for	2525	will not be interrupted regularly, which is more efficient (and good for
2448	battery life on laptops).	2526	battery life on laptops).
2449		2527
2450	This affects not just the pure-perl event loop, but also other event loops	2528	This affects not just the pure-perl event loop, but also other event loops
2451	that have no signal handling on their own (e.g. Glib, Tk, Qt).	2529	that have no signal handling on their own (e.g. Glib, Tk, Qt).
2452		2530
…		…
2464	automatic timer adjustments even when no monotonic clock is available,	2542	automatic timer adjustments even when no monotonic clock is available,
2465	can take avdantage of advanced kernel interfaces such as C<epoll> and	2543	can take avdantage of advanced kernel interfaces such as C<epoll> and
2466	C<kqueue>, and is the fastest backend I<by far>. You can even embed	2544	C<kqueue>, and is the fastest backend I<by far>. You can even embed
2467	L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>).	2545	L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>).
2468		2546
		2547	If you only use backends that rely on another event loop (e.g. C<Tk>),
		2548	then this module will do nothing for you.
		2549
2469	=item L<Guard>	2550	=item L<Guard>
2470		2551
2471	The guard module, when used, will be used to implement	2552	The guard module, when used, will be used to implement
2472	C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a	2553	C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a
2473	lot less memory), but otherwise doesn't affect guard operation much. It is	2554	lot less memory), but otherwise doesn't affect guard operation much. It is
2474	purely used for performance.	2555	purely used for performance.
2475		2556
2476	=item L<JSON> and L<JSON::XS>	2557	=item L<JSON> and L<JSON::XS>
2477		2558
2478	One of these modules is required when you want to read or write JSON data	2559	One of these modules is required when you want to read or write JSON data
2479	via L<AnyEvent::Handle>. It is also written in pure-perl, but can take	2560	via L<AnyEvent::Handle>. L<JSON> is also written in pure-perl, but can take
2480	advantage of the ultra-high-speed L<JSON::XS> module when it is installed.	2561	advantage of the ultra-high-speed L<JSON::XS> module when it is installed.
2481
2482	In fact, L<AnyEvent::Handle> will use L<JSON::XS> by default if it is
2483	installed.
2484		2562
2485	=item L<Net::SSLeay>	2563	=item L<Net::SSLeay>
2486		2564
2487	Implementing TLS/SSL in Perl is certainly interesting, but not very	2565	Implementing TLS/SSL in Perl is certainly interesting, but not very
2488	worthwhile: If this module is installed, then L<AnyEvent::Handle> (with	2566	worthwhile: If this module is installed, then L<AnyEvent::Handle> (with
…		…
2499		2577
2500		2578
2501	=head1 FORK	2579	=head1 FORK
2502		2580
2503	Most event libraries are not fork-safe. The ones who are usually are	2581	Most event libraries are not fork-safe. The ones who are usually are
2504	because they rely on inefficient but fork-safe C<select> or C<poll>	2582	because they rely on inefficient but fork-safe C<select> or C<poll> calls
2505	calls. Only L<EV> is fully fork-aware.	2583	- higher performance APIs such as BSD's kqueue or the dreaded Linux epoll
		2584	are usually badly thought-out hacks that are incompatible with fork in
		2585	one way or another. Only L<EV> is fully fork-aware and ensures that you
		2586	continue event-processing in both parent and child (or both, if you know
		2587	what you are doing).
		2588
		2589	This means that, in general, you cannot fork and do event processing in
		2590	the child if the event library was initialised before the fork (which
		2591	usually happens when the first AnyEvent watcher is created, or the library
		2592	is loaded).
2506		2593
2507	If you have to fork, you must either do so I<before> creating your first	2594	If you have to fork, you must either do so I<before> creating your first
2508	watcher OR you must not use AnyEvent at all in the child OR you must do	2595	watcher OR you must not use AnyEvent at all in the child OR you must do
2509	something completely out of the scope of AnyEvent.	2596	something completely out of the scope of AnyEvent.
		2597
		2598	The problem of doing event processing in the parent I<and> the child
		2599	is much more complicated: even for backends that I<are> fork-aware or
		2600	fork-safe, their behaviour is not usually what you want: fork clones all
		2601	watchers, that means all timers, I/O watchers etc. are active in both
		2602	parent and child, which is almost never what you want. USing C<exec>
		2603	to start worker children from some kind of manage rprocess is usually
		2604	preferred, because it is much easier and cleaner, at the expense of having
		2605	to have another binary.
2510		2606
2511		2607
2512	=head1 SECURITY CONSIDERATIONS	2608	=head1 SECURITY CONSIDERATIONS
2513		2609
2514	AnyEvent can be forced to load any event model via	2610	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.295 by root, Wed Oct 28 02:42:06 2009 UTC vs. Revision 1.317 by root, Wed Mar 24 21:22:57 2010 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.295 by root, Wed Oct 28 02:42:06 2009 UTC vs.
Revision 1.317 by root, Wed Mar 24 21:22:57 2010 UTC