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

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.9 by root, Sun Jan 8 04:48:52 2006 UTC vs.
Revision 1.33 by root, Fri Nov 9 19:34:32 2007 UTC

…		…
1	=head1 NAME	1	=head1 NAME
2		2
3	AnyEvent - provide framework for multiple event loops	3	AnyEvent - provide framework for multiple event loops
4		4
5	Event, Coro, Glib, Tk - various supported event loops	5	Event, Coro, Glib, Tk, Perl - various supported event loops
6		6
7	=head1 SYNOPSIS	7	=head1 SYNOPSIS
8		8
9	use AnyEvent;	9	use AnyEvent;
10		10
11	my $w = AnyEvent->io (fh => ..., poll => "[rw]+", cb => sub {	11	my $w = AnyEvent->io (fh => $fh, poll => "r\|w", cb => sub {
12	my ($poll_got) = @_;
13	...	12	...
14	});	13	});
15
16	* only one io watcher per $fh and $poll type is allowed (i.e. on a socket
17	you can have one r + one w or one rw watcher, not any more (limitation by
18	Tk).
19
20	* the C<$poll_got> passed to the handler needs to be checked by looking
21	for single characters (e.g. with a regex), as it can contain more event
22	types than were requested (e.g. a 'w' watcher might generate 'rw' events,
23	limitation by Glib).
24
25	* AnyEvent will keep filehandles alive, so as long as the watcher exists,
26	the filehandle exists.
27		14
28	my $w = AnyEvent->timer (after => $seconds, cb => sub {	15	my $w = AnyEvent->timer (after => $seconds, cb => sub {
29	...	16	...
30	});	17	});
31		18
32	* io and time watchers get canceled whenever $w is destroyed, so keep a copy	19	my $w = AnyEvent->condvar; # stores wether a condition was flagged
33
34	* timers can only be used once and must be recreated for repeated
35	operation (limitation by Glib and Tk).
36
37	my $w = AnyEvent->condvar; # kind of main loop replacement
38	$w->wait; # enters main loop till $condvar gets ->broadcast	20	$w->wait; # enters "main loop" till $condvar gets ->broadcast
39	$w->broadcast; # wake up current and all future wait's	21	$w->broadcast; # wake up current and all future wait's
40		22
41	* condvars are used to give blocking behaviour when neccessary. Create
42	a condvar for any "request" or "event" your module might create, C<<
43	->broadcast >> it when the event happens and provide a function that calls
44	C<< ->wait >> for it. See the examples below.
45
46	=head1 DESCRIPTION	23	=head1 DESCRIPTION
47		24
48	L<AnyEvent> provides an identical interface to multiple event loops. This	25	L<AnyEvent> provides an identical interface to multiple event loops. This
49	allows module authors to utilizy an event loop without forcing module	26	allows module authors to utilise an event loop without forcing module
50	users to use the same event loop (as only a single event loop can coexist	27	users to use the same event loop (as only a single event loop can coexist
51	peacefully at any one time).	28	peacefully at any one time).
52		29
53	The interface itself is vaguely similar but not identical to the Event	30	The interface itself is vaguely similar but not identical to the Event
54	module.	31	module.
56	On the first call of any method, the module tries to detect the currently	33	On the first call of any method, the module tries to detect the currently
57	loaded event loop by probing wether any of the following modules is	34	loaded event loop by probing wether any of the following modules is
58	loaded: L<Coro::Event>, L<Event>, L<Glib>, L<Tk>. The first one found is	35	loaded: L<Coro::Event>, L<Event>, L<Glib>, L<Tk>. The first one found is
59	used. If none is found, the module tries to load these modules in the	36	used. If none is found, the module tries to load these modules in the
60	order given. The first one that could be successfully loaded will be	37	order given. The first one that could be successfully loaded will be
61	used. If still none could be found, it will issue an error.	38	used. If still none could be found, AnyEvent will fall back to a pure-perl
		39	event loop, which is also not very efficient.
		40
		41	Because AnyEvent first checks for modules that are already loaded, loading
		42	an Event model explicitly before first using AnyEvent will likely make
		43	that model the default. For example:
		44
		45	use Tk;
		46	use AnyEvent;
		47
		48	# .. AnyEvent will likely default to Tk
		49
		50	The pure-perl implementation of AnyEvent is called
		51	C<AnyEvent::Impl::Perl>. Like other event modules you can load it
		52	explicitly.
		53
		54	=head1 WATCHERS
		55
		56	AnyEvent has the central concept of a I<watcher>, which is an object that
		57	stores relevant data for each kind of event you are waiting for, such as
		58	the callback to call, the filehandle to watch, etc.
		59
		60	These watchers are normal Perl objects with normal Perl lifetime. After
		61	creating a watcher it will immediately "watch" for events and invoke
		62	the callback. To disable the watcher you have to destroy it (e.g. by
		63	setting the variable that stores it to C<undef> or otherwise deleting all
		64	references to it).
		65
		66	All watchers are created by calling a method on the C<AnyEvent> class.
		67
		68	=head2 IO WATCHERS
		69
		70	You can create I/O watcher by calling the C<< AnyEvent->io >> method with
		71	the following mandatory arguments:
		72
		73	C<fh> the Perl I<filehandle> (not filedescriptor) to watch for
		74	events. C<poll> must be a string that is either C<r> or C<w>, that creates
		75	a watcher waiting for "r"eadable or "w"ritable events. C<cb> teh callback
		76	to invoke everytime the filehandle becomes ready.
		77
		78	Only one io watcher per C<fh> and C<poll> combination is allowed (i.e. on
		79	a socket you can have one r + one w, not any more (limitation comes from
		80	Tk - if you are sure you are not using Tk this limitation is gone).
		81
		82	Filehandles will be kept alive, so as long as the watcher exists, the
		83	filehandle exists, too.
		84
		85	Example:
		86
		87	# wait for readability of STDIN, then read a line and disable the watcher
		88	my $w; $w = AnyEvent->io (fh => \*STDIN, poll => 'r', cb => sub {
		89	chomp (my $input = <STDIN>);
		90	warn "read: $input\n";
		91	undef $w;
		92	});
		93
		94	=head2 TIME WATCHERS
		95
		96	You can create a time watcher by calling the C<< AnyEvent->timer >>
		97	method with the following mandatory arguments:
		98
		99	C<after> after how many seconds (fractions are supported) should the timer
		100	activate. C<cb> the callback to invoke.
		101
		102	The timer callback will be invoked at most once: if you want a repeating
		103	timer you have to create a new watcher (this is a limitation by both Tk
		104	and Glib).
		105
		106	Example:
		107
		108	# fire an event after 7.7 seconds
		109	my $w = AnyEvent->timer (after => 7.7, cb => sub {
		110	warn "timeout\n";
		111	});
		112
		113	# to cancel the timer:
		114	undef $w
		115
		116	=head2 CONDITION WATCHERS
		117
		118	Condition watchers can be created by calling the C<< AnyEvent->condvar >>
		119	method without any arguments.
		120
		121	A condition watcher watches for a condition - precisely that the C<<
		122	->broadcast >> method has been called.
		123
		124	The watcher has only two methods:
62		125
63	=over 4	126	=over 4
64		127
		128	=item $cv->wait
		129
		130	Wait (blocking if necessary) until the C<< ->broadcast >> method has been
		131	called on c<$cv>, while servicing other watchers normally.
		132
		133	Not all event models support a blocking wait - some die in that case, so
		134	if you are using this from a module, never require a blocking wait, but
		135	let the caller decide wether the call will block or not (for example,
		136	by coupling condition variables with some kind of request results and
		137	supporting callbacks so the caller knows that getting the result will not
		138	block, while still suppporting blockign waits if the caller so desires).
		139
		140	You can only wait once on a condition - additional calls will return
		141	immediately.
		142
		143	=item $cv->broadcast
		144
		145	Flag the condition as ready - a running C<< ->wait >> and all further
		146	calls to C<wait> will return after this method has been called. If nobody
		147	is waiting the broadcast will be remembered..
		148
		149	Example:
		150
		151	# wait till the result is ready
		152	my $result_ready = AnyEvent->condvar;
		153
		154	# do something such as adding a timer
		155	# or socket watcher the calls $result_ready->broadcast
		156	# when the "result" is ready.
		157
		158	$result_ready->wait;
		159
		160	=back
		161
		162	=head2 SIGNAL WATCHERS
		163
		164	You can listen for signals using a signal watcher, C<signal> is the signal
		165	I<name> without any C<SIG> prefix. Multiple signals events can be clumped
		166	together into one callback invocation, and callback invocation might or
		167	might not be asynchronous.
		168
		169	These watchers might use C<%SIG>, so programs overwriting those signals
		170	directly will likely not work correctly.
		171
		172	Example: exit on SIGINT
		173
		174	my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
		175
		176	=head2 CHILD PROCESS WATCHERS
		177
		178	You can also listen for the status of a child process specified by the
		179	C<pid> argument (or any child if the pid argument is 0). The watcher will
		180	trigger as often as status change for the child are received. This works
		181	by installing a signal handler for C<SIGCHLD>. The callback will be called with
		182	the pid and exit status (as returned by waitpid).
		183
		184	Example: wait for pid 1333
		185
		186	my $w = AnyEvent->child (pid => 1333, cb => sub { warn "exit status $?" });
		187
		188	=head1 GLOBALS
		189
		190	=over 4
		191
		192	=item $AnyEvent::MODEL
		193
		194	Contains C<undef> until the first watcher is being created. Then it
		195	contains the event model that is being used, which is the name of the
		196	Perl class implementing the model. This class is usually one of the
		197	C<AnyEvent::Impl:xxx> modules, but can be any other class in the case
		198	AnyEvent has been extended at runtime (e.g. in I<rxvt-unicode>).
		199
		200	The known classes so far are:
		201
		202	AnyEvent::Impl::CoroEV based on Coro::EV, best choice.
		203	AnyEvent::Impl::EV based on EV (an interface to libev, also best choice).
		204	AnyEvent::Impl::Coro based on Coro::Event, second best choice.
		205	AnyEvent::Impl::Event based on Event, also second best choice :)
		206	AnyEvent::Impl::Glib based on Glib, second-best choice.
		207	AnyEvent::Impl::Tk based on Tk, very bad choice.
		208	AnyEvent::Impl::Perl pure-perl implementation, inefficient.
		209
		210	=item AnyEvent::detect
		211
		212	Returns C<$AnyEvent::MODEL>, forcing autodetection of the event model if
		213	necessary. You should only call this function right before you would have
		214	created an AnyEvent watcher anyway, that is, very late at runtime.
		215
		216	=back
		217
		218	=head1 WHAT TO DO IN A MODULE
		219
		220	As a module author, you should "use AnyEvent" and call AnyEvent methods
		221	freely, but you should not load a specific event module or rely on it.
		222
		223	Be careful when you create watchers in the module body - Anyevent will
		224	decide which event module to use as soon as the first method is called, so
		225	by calling AnyEvent in your module body you force the user of your module
		226	to load the event module first.
		227
		228	=head1 WHAT TO DO IN THE MAIN PROGRAM
		229
		230	There will always be a single main program - the only place that should
		231	dictate which event model to use.
		232
		233	If it doesn't care, it can just "use AnyEvent" and use it itself, or not
		234	do anything special and let AnyEvent decide which implementation to chose.
		235
		236	If the main program relies on a specific event model (for example, in Gtk2
		237	programs you have to rely on either Glib or Glib::Event), you should load
		238	it before loading AnyEvent or any module that uses it, generally, as early
		239	as possible. The reason is that modules might create watchers when they
		240	are loaded, and AnyEvent will decide on the event model to use as soon as
		241	it creates watchers, and it might chose the wrong one unless you load the
		242	correct one yourself.
		243
		244	You can chose to use a rather inefficient pure-perl implementation by
		245	loading the C<AnyEvent::Impl::Perl> module, but letting AnyEvent chose is
		246	generally better.
		247
65	=cut	248	=cut
66		249
67	package AnyEvent;	250	package AnyEvent;
68		251
69	no warnings;	252	no warnings;
70	use strict 'vars';	253	use strict;
		254
71	use Carp;	255	use Carp;
72		256
73	our $VERSION = '1.01';	257	our $VERSION = '2.55';
74	our $MODEL;	258	our $MODEL;
75		259
76	our $AUTOLOAD;	260	our $AUTOLOAD;
77	our @ISA;	261	our @ISA;
78		262
79	our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1;	263	our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1;
80		264
81	our @REGISTRY;	265	our @REGISTRY;
82		266
83	my @models = (	267	my @models = (
		268	[Coro::EV:: => AnyEvent::Impl::CoroEV::],
		269	[EV:: => AnyEvent::Impl::EV::],
84	[Coro::Event:: => AnyEvent::Impl::Coro::],	270	[Coro::Event:: => AnyEvent::Impl::Coro::],
85	[Event:: => AnyEvent::Impl::Event::],	271	[Event:: => AnyEvent::Impl::Event::],
86	[Glib:: => AnyEvent::Impl::Glib::],	272	[Glib:: => AnyEvent::Impl::Glib::],
87	[Tk:: => AnyEvent::Impl::Tk::],	273	[Tk:: => AnyEvent::Impl::Tk::],
		274	[AnyEvent::Impl::Perl:: => AnyEvent::Impl::Perl::],
88	);	275	);
89		276
90	our %method = map +($_ => 1), qw(io timer condvar broadcast wait cancel DESTROY);	277	our %method = map +($_ => 1), qw(io timer condvar broadcast wait signal one_event DESTROY);
91		278
92	sub AUTOLOAD {	279	sub detect() {
93	$AUTOLOAD =~ s/.*://;
94
95	$method{$AUTOLOAD}
96	or croak "$AUTOLOAD: not a valid method for AnyEvent objects";
97
98	unless ($MODEL) {	280	unless ($MODEL) {
		281	no strict 'refs';
		282
99	# check for already loaded models	283	# check for already loaded models
100	for (@REGISTRY, @models) {	284	for (@REGISTRY, @models) {
101	my ($package, $model) = @$_;	285	my ($package, $model) = @$_;
102	if (${"$package\::VERSION"} > 0) {	286	if (${"$package\::VERSION"} > 0) {
103	if (eval "require $model") {	287	if (eval "require $model") {
…		…
111	unless ($MODEL) {	295	unless ($MODEL) {
112	# try to load a model	296	# try to load a model
113		297
114	for (@REGISTRY, @models) {	298	for (@REGISTRY, @models) {
115	my ($package, $model) = @$_;	299	my ($package, $model) = @$_;
		300	if (eval "require $package"
		301	and ${"$package\::VERSION"} > 0
116	if (eval "require $model") {	302	and eval "require $model") {
117	$MODEL = $model;	303	$MODEL = $model;
118	warn "AnyEvent: autoprobed and loaded model '$model', using it.\n" if $verbose > 1;	304	warn "AnyEvent: autoprobed and loaded model '$model', using it.\n" if $verbose > 1;
119	last;	305	last;
120	}	306	}
121	}	307	}
122		308
123	$MODEL	309	$MODEL
124	or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: Coro, Event, Glib or Tk.";	310	or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: Event (or Coro+Event), Glib or Tk.";
125	}	311	}
		312
		313	unshift @ISA, $MODEL;
		314	push @{"$MODEL\::ISA"}, "AnyEvent::Base";
126	}	315	}
127		316
128	@ISA = $MODEL;	317	$MODEL
		318	}
		319
		320	sub AUTOLOAD {
		321	(my $func = $AUTOLOAD) =~ s/.*://;
		322
		323	$method{$func}
		324	or croak "$func: not a valid method for AnyEvent objects";
		325
		326	detect unless $MODEL;
129		327
130	my $class = shift;	328	my $class = shift;
131	$class->$AUTOLOAD (@_);	329	$class->$func (@_);
132	}	330	}
133		331
134	=back	332	package AnyEvent::Base;
		333
		334	# default implementation for ->condvar, ->wait, ->broadcast
		335
		336	sub condvar {
		337	bless \my $flag, "AnyEvent::Base::CondVar"
		338	}
		339
		340	sub AnyEvent::Base::CondVar::broadcast {
		341	${$_[0]}++;
		342	}
		343
		344	sub AnyEvent::Base::CondVar::wait {
		345	AnyEvent->one_event while !${$_[0]};
		346	}
		347
		348	# default implementation for ->signal
		349
		350	our %SIG_CB;
		351
		352	sub signal {
		353	my (undef, %arg) = @_;
		354
		355	my $signal = uc $arg{signal}
		356	or Carp::croak "required option 'signal' is missing";
		357
		358	$SIG_CB{$signal}{$arg{cb}} = $arg{cb};
		359	$SIG{$signal} \|\|= sub {
		360	$_->() for values %{ $SIG_CB{$signal} \|\| {} };
		361	};
		362
		363	bless [$signal, $arg{cb}], "AnyEvent::Base::Signal"
		364	}
		365
		366	sub AnyEvent::Base::Signal::DESTROY {
		367	my ($signal, $cb) = @{$_[0]};
		368
		369	delete $SIG_CB{$signal}{$cb};
		370
		371	$SIG{$signal} = 'DEFAULT' unless keys %{ $SIG_CB{$signal} };
		372	}
		373
		374	# default implementation for ->child
		375
		376	our %PID_CB;
		377	our $CHLD_W;
		378	our $PID_IDLE;
		379	our $WNOHANG;
		380
		381	sub _child_wait {
		382	while (0 <= (my $pid = waitpid -1, $WNOHANG)) {
		383	$_->($pid, $?) for (values %{ $PID_CB{$pid} \|\| {} }),
		384	(values %{ $PID_CB{0} \|\| {} });
		385	}
		386
		387	undef $PID_IDLE;
		388	}
		389
		390	sub child {
		391	my (undef, %arg) = @_;
		392
		393	defined (my $pid = $arg{pid} + 0)
		394	or Carp::croak "required option 'pid' is missing";
		395
		396	$PID_CB{$pid}{$arg{cb}} = $arg{cb};
		397
		398	unless ($WNOHANG) {
		399	$WNOHANG = eval { require POSIX; &POSIX::WNOHANG } \|\| 1;
		400	}
		401
		402	unless ($CHLD_W) {
		403	$CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_child_wait);
		404	# child could be a zombie already
		405	$PID_IDLE \|\|= AnyEvent->timer (after => 0, cb => \&_child_wait);
		406	}
		407
		408	bless [$pid, $arg{cb}], "AnyEvent::Base::Child"
		409	}
		410
		411	sub AnyEvent::Base::Child::DESTROY {
		412	my ($pid, $cb) = @{$_[0]};
		413
		414	delete $PID_CB{$pid}{$cb};
		415	delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
		416
		417	undef $CHLD_W unless keys %PID_CB;
		418	}
135		419
136	=head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE	420	=head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE
137		421
138	If you need to support another event library which isn't directly	422	If you need to support another event library which isn't directly
139	supported by AnyEvent, you can supply your own interface to it by	423	supported by AnyEvent, you can supply your own interface to it by
140	pushing, before the first watch gets created, the package name of	424	pushing, before the first watcher gets created, the package name of
141	the event module and the package name of the interface to use onto	425	the event module and the package name of the interface to use onto
142	C<@AnyEvent::REGISTRY>. You can do that before and even without loading	426	C<@AnyEvent::REGISTRY>. You can do that before and even without loading
143	AnyEvent.	427	AnyEvent.
144		428
145	Example:	429	Example:
146		430
147	push @AnyEvent::REGISTRY, [urxvt => urxvt::anyevent::];	431	push @AnyEvent::REGISTRY, [urxvt => urxvt::anyevent::];
148		432
149	This tells AnyEvent to (literally) use the C<urxvt::anyevent::> module	433	This tells AnyEvent to (literally) use the C<urxvt::anyevent::>
150	when it finds the C<urxvt> module is loaded. When AnyEvent is loaded and	434	package/class when it finds the C<urxvt> package/module is loaded. When
151	requested to find a suitable event model, it will first check for the	435	AnyEvent is loaded and asked to find a suitable event model, it will
152	urxvt module.	436	first check for the presence of urxvt.
153		437
		438	The class should provide implementations for all watcher types (see
		439	L<AnyEvent::Impl::Event> (source code), L<AnyEvent::Impl::Glib>
		440	(Source code) and so on for actual examples, use C<perldoc -m
		441	AnyEvent::Impl::Glib> to see the sources).
		442
154	The above isn't fictitious, the I<rxvt-unicode> (a.k.a. urxvt) uses	443	The above isn't fictitious, the I<rxvt-unicode> (a.k.a. urxvt)
155	the above line exactly. An interface isn't included in AnyEvent	444	uses the above line as-is. An interface isn't included in AnyEvent
156	because it doesn't make sense outside the embedded interpreter inside	445	because it doesn't make sense outside the embedded interpreter inside
157	I<rxvt-unicode>, and it is updated and maintained as part of the	446	I<rxvt-unicode>, and it is updated and maintained as part of the
158	I<rxvt-unicode> distribution.	447	I<rxvt-unicode> distribution.
		448
		449	I<rxvt-unicode> also cheats a bit by not providing blocking access to
		450	condition variables: code blocking while waiting for a condition will
		451	C<die>. This still works with most modules/usages, and blocking calls must
		452	not be in an interactive application, so it makes sense.
159		453
160	=head1 ENVIRONMENT VARIABLES	454	=head1 ENVIRONMENT VARIABLES
161		455
162	The following environment variables are used by this module:	456	The following environment variables are used by this module:
163		457

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent.pm (file contents): Revision 1.9 by root, Sun Jan 8 04:48:52 2006 UTC vs. Revision 1.33 by root, Fri Nov 9 19:34:32 2007 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.9 by root, Sun Jan 8 04:48:52 2006 UTC vs.
Revision 1.33 by root, Fri Nov 9 19:34:32 2007 UTC