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.206 by root, Mon Apr 20 14:34:18 2009 UTC vs.
Revision 1.213 by root, Sat Jun 20 07:14:35 2009 UTC

1=head1 NAME 1=head1 NAME
2 2
3AnyEvent - provide framework for multiple event loops 3AnyEvent - provide framework for multiple event loops
4 4
5EV, Event, Glib, Tk, Perl, Event::Lib, Qt, POE - various supported event loops 5EV, Event, Glib, Tk, Perl, Event::Lib, Qt and POE are various supported
6event loops.
6 7
7=head1 SYNOPSIS 8=head1 SYNOPSIS
8 9
9 use AnyEvent; 10 use AnyEvent;
10 11
12 # file descriptor readable
11 my $w = AnyEvent->io (fh => $fh, poll => "r|w", cb => sub { ... }); 13 my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... });
12 14
15 # one-shot or repeating timers
13 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... }); 16 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... });
14 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ... 17 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ...
15 18
16 print AnyEvent->now; # prints current event loop time 19 print AnyEvent->now; # prints current event loop time
17 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time. 20 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time.
18 21
22 # POSIX signal
19 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... }); 23 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... });
20 24
25 # child process exit
21 my $w = AnyEvent->child (pid => $pid, cb => sub { 26 my $w = AnyEvent->child (pid => $pid, cb => sub {
22 my ($pid, $status) = @_; 27 my ($pid, $status) = @_;
23 ... 28 ...
24 }); 29 });
30
31 # called when event loop idle (if applicable)
32 my $w = AnyEvent->idle (cb => sub { ... });
25 33
26 my $w = AnyEvent->condvar; # stores whether a condition was flagged 34 my $w = AnyEvent->condvar; # stores whether a condition was flagged
27 $w->send; # wake up current and all future recv's 35 $w->send; # wake up current and all future recv's
28 $w->recv; # enters "main loop" till $condvar gets ->send 36 $w->recv; # enters "main loop" till $condvar gets ->send
29 # use a condvar in callback mode: 37 # use a condvar in callback mode:
… …
410 ); 418 );
411 419
412 # do something else, then wait for process exit 420 # do something else, then wait for process exit
413 $done->recv; 421 $done->recv;
414 422
423=head2 IDLE WATCHERS
424
425Sometimes there is a need to do something, but it is not so important
426to do it instantly, but only when there is nothing better to do. This
427"nothing better to do" is usually defined to be "no other events need
428attention by the event loop".
429
430Idle watchers ideally get invoked when the event loop has nothing
431better to do, just before it would block the process to wait for new
432events. Instead of blocking, the idle watcher is invoked.
433
434Most event loops unfortunately do not really support idle watchers (only
435EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
436will simply call the callback "from time to time".
437
438Example: read lines from STDIN, but only process them when the
439program is otherwise idle:
440
441 my @lines; # read data
442 my $idle_w;
443 my $io_w = AnyEvent->io (fh => \*STDIN, poll => 'r', cb => sub {
444 push @lines, scalar <STDIN>;
445
446 # start an idle watcher, if not already done
447 $idle_w ||= AnyEvent->idle (cb => sub {
448 # handle only one line, when there are lines left
449 if (my $line = shift @lines) {
450 print "handled when idle: $line";
451 } else {
452 # otherwise disable the idle watcher again
453 undef $idle_w;
454 }
455 });
456 });
457
415=head2 CONDITION VARIABLES 458=head2 CONDITION VARIABLES
416 459
417If you are familiar with some event loops you will know that all of them 460If you are familiar with some event loops you will know that all of them
418require you to run some blocking "loop", "run" or similar function that 461require you to run some blocking "loop", "run" or similar function that
419will actively watch for new events and call your callbacks. 462will actively watch for new events and call your callbacks.
… …
888no warnings; 931no warnings;
889use strict qw(vars subs); 932use strict qw(vars subs);
890 933
891use Carp; 934use Carp;
892 935
893our $VERSION = 4.352; 936our $VERSION = 4.411;
894our $MODEL; 937our $MODEL;
895 938
896our $AUTOLOAD; 939our $AUTOLOAD;
897our @ISA; 940our @ISA;
898 941
… …
931 [Wx:: => AnyEvent::Impl::POE::], 974 [Wx:: => AnyEvent::Impl::POE::],
932 [Prima:: => AnyEvent::Impl::POE::], 975 [Prima:: => AnyEvent::Impl::POE::],
933); 976);
934 977
935our %method = map +($_ => 1), 978our %method = map +($_ => 1),
936 qw(io timer time now now_update signal child condvar one_event DESTROY); 979 qw(io timer time now now_update signal child idle condvar one_event DESTROY);
937 980
938our @post_detect; 981our @post_detect;
939 982
940sub post_detect(&) { 983sub post_detect(&) {
941 my ($cb) = @_; 984 my ($cb) = @_;
… …
946 1 989 1
947 } else { 990 } else {
948 push @post_detect, $cb; 991 push @post_detect, $cb;
949 992
950 defined wantarray 993 defined wantarray
951 ? bless \$cb, "AnyEvent::Util::PostDetect" 994 ? bless \$cb, "AnyEvent::Util::postdetect"
952 : () 995 : ()
953 } 996 }
954} 997}
955 998
956sub AnyEvent::Util::PostDetect::DESTROY { 999sub AnyEvent::Util::postdetect::DESTROY {
957 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1000 @post_detect = grep $_ != ${$_[0]}, @post_detect;
958} 1001}
959 1002
960sub detect() { 1003sub detect() {
961 unless ($MODEL) { 1004 unless ($MODEL) {
… …
1050package AnyEvent::Base; 1093package AnyEvent::Base;
1051 1094
1052# default implementations for many methods 1095# default implementations for many methods
1053 1096
1054BEGIN { 1097BEGIN {
1055 if (eval "use Time::HiRes (); time (); 1") { 1098 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1056 *_time = \&Time::HiRes::time; 1099 *_time = \&Time::HiRes::time;
1057 # if (eval "use POSIX (); (POSIX::times())... 1100 # if (eval "use POSIX (); (POSIX::times())...
1058 } else { 1101 } else {
1059 *_time = sub { time }; # epic fail 1102 *_time = sub { time }; # epic fail
1060 } 1103 }
… …
1065sub now_update { } 1108sub now_update { }
1066 1109
1067# default implementation for ->condvar 1110# default implementation for ->condvar
1068 1111
1069sub condvar { 1112sub condvar {
1070 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, AnyEvent::CondVar:: 1113 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
1071} 1114}
1072 1115
1073# default implementation for ->signal 1116# default implementation for ->signal
1074 1117
1075our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO); 1118our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
… …
1099 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case 1142 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case
1100 } else { 1143 } else {
1101 pipe $SIGPIPE_R, $SIGPIPE_W; 1144 pipe $SIGPIPE_R, $SIGPIPE_W;
1102 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R; 1145 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;
1103 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case 1146 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case
1147
1148 # not strictly required, as $^F is normally 2, but let's make sure...
1149 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1150 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1104 } 1151 }
1105 1152
1106 $SIGPIPE_R 1153 $SIGPIPE_R
1107 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n"; 1154 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1108
1109 # not strictly required, as $^F is normally 2, but let's make sure...
1110 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1111 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1112 1155
1113 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec); 1156 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec);
1114 } 1157 }
1115 1158
1116 my $signal = uc $arg{signal} 1159 my $signal = uc $arg{signal}
… …
1121 local $!; 1164 local $!;
1122 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1165 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1123 undef $SIG_EV{$signal}; 1166 undef $SIG_EV{$signal};
1124 }; 1167 };
1125 1168
1126 bless [$signal, $arg{cb}], "AnyEvent::Base::Signal" 1169 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1127} 1170}
1128 1171
1129sub AnyEvent::Base::Signal::DESTROY { 1172sub AnyEvent::Base::signal::DESTROY {
1130 my ($signal, $cb) = @{$_[0]}; 1173 my ($signal, $cb) = @{$_[0]};
1131 1174
1132 delete $SIG_CB{$signal}{$cb}; 1175 delete $SIG_CB{$signal}{$cb};
1133 1176
1177 # delete doesn't work with older perls - they then
1178 # print weird messages, or just unconditionally exit
1179 # instead of getting the default action.
1134 delete $SIG{$signal} unless keys %{ $SIG_CB{$signal} }; 1180 undef $SIG{$signal} unless keys %{ $SIG_CB{$signal} };
1135} 1181}
1136 1182
1137# default implementation for ->child 1183# default implementation for ->child
1138 1184
1139our %PID_CB; 1185our %PID_CB;
1140our $CHLD_W; 1186our $CHLD_W;
1141our $CHLD_DELAY_W; 1187our $CHLD_DELAY_W;
1142our $PID_IDLE;
1143our $WNOHANG; 1188our $WNOHANG;
1144 1189
1145sub _child_wait { 1190sub _sigchld {
1146 while (0 < (my $pid = waitpid -1, $WNOHANG)) { 1191 while (0 < (my $pid = waitpid -1, $WNOHANG)) {
1147 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }), 1192 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }),
1148 (values %{ $PID_CB{0} || {} }); 1193 (values %{ $PID_CB{0} || {} });
1149 } 1194 }
1150
1151 undef $PID_IDLE;
1152}
1153
1154sub _sigchld {
1155 # make sure we deliver these changes "synchronous" with the event loop.
1156 $CHLD_DELAY_W ||= AnyEvent->timer (after => 0, cb => sub {
1157 undef $CHLD_DELAY_W;
1158 &_child_wait;
1159 });
1160} 1195}
1161 1196
1162sub child { 1197sub child {
1163 my (undef, %arg) = @_; 1198 my (undef, %arg) = @_;
1164 1199
1165 defined (my $pid = $arg{pid} + 0) 1200 defined (my $pid = $arg{pid} + 0)
1166 or Carp::croak "required option 'pid' is missing"; 1201 or Carp::croak "required option 'pid' is missing";
1167 1202
1168 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1203 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1169 1204
1170 unless ($WNOHANG) {
1171 $WNOHANG = eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1205 $WNOHANG ||= eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1172 }
1173 1206
1174 unless ($CHLD_W) { 1207 unless ($CHLD_W) {
1175 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld); 1208 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld);
1176 # child could be a zombie already, so make at least one round 1209 # child could be a zombie already, so make at least one round
1177 &_sigchld; 1210 &_sigchld;
1178 } 1211 }
1179 1212
1180 bless [$pid, $arg{cb}], "AnyEvent::Base::Child" 1213 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1181} 1214}
1182 1215
1183sub AnyEvent::Base::Child::DESTROY { 1216sub AnyEvent::Base::child::DESTROY {
1184 my ($pid, $cb) = @{$_[0]}; 1217 my ($pid, $cb) = @{$_[0]};
1185 1218
1186 delete $PID_CB{$pid}{$cb}; 1219 delete $PID_CB{$pid}{$cb};
1187 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} }; 1220 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1188 1221
1189 undef $CHLD_W unless keys %PID_CB; 1222 undef $CHLD_W unless keys %PID_CB;
1223}
1224
1225# idle emulation is done by simply using a timer, regardless
1226# of whether the process is idle or not, and not letting
1227# the callback use more than 50% of the time.
1228sub idle {
1229 my (undef, %arg) = @_;
1230
1231 my ($cb, $w, $rcb) = $arg{cb};
1232
1233 $rcb = sub {
1234 if ($cb) {
1235 $w = _time;
1236 &$cb;
1237 $w = _time - $w;
1238
1239 # never use more then 50% of the time for the idle watcher,
1240 # within some limits
1241 $w = 0.0001 if $w < 0.0001;
1242 $w = 5 if $w > 5;
1243
1244 $w = AnyEvent->timer (after => $w, cb => $rcb);
1245 } else {
1246 # clean up...
1247 undef $w;
1248 undef $rcb;
1249 }
1250 };
1251
1252 $w = AnyEvent->timer (after => 0.05, cb => $rcb);
1253
1254 bless \\$cb, "AnyEvent::Base::idle"
1255}
1256
1257sub AnyEvent::Base::idle::DESTROY {
1258 undef $${$_[0]};
1190} 1259}
1191 1260
1192package AnyEvent::CondVar; 1261package AnyEvent::CondVar;
1193 1262
1194our @ISA = AnyEvent::CondVar::Base::; 1263our @ISA = AnyEvent::CondVar::Base::;
… …
1884 use AnyEvent; 1953 use AnyEvent;
1885 1954
1886Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can 1955Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can
1887be used to probe what backend is used and gain other information (which is 1956be used to probe what backend is used and gain other information (which is
1888probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and 1957probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and
1889$ENV{PERL_ANYEGENT_STRICT}. 1958$ENV{PERL_ANYEVENT_STRICT}.
1890 1959
1891 1960
1892=head1 BUGS 1961=head1 BUGS
1893 1962
1894Perl 5.8 has numerous memleaks that sometimes hit this module and are hard 1963Perl 5.8 has numerous memleaks that sometimes hit this module and are hard

Diff Legend

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