[ViewVC] Diff of: cvs/EV/EV.pm

Comparing EV/EV.pm (file contents):
Revision 1.7 by root, Sat Oct 27 14:54:20 2007 UTC vs.
Revision 1.28 by root, Sun Nov 4 16:52:52 2007 UTC

1	=head1 NAME	1	=head1 NAME
2		2
3	EV - perl interface to libevent, monkey.org/~provos/libevent/	3	EV - perl interface to libev, a high performance full-featured event loop
4		4
5	=head1 SYNOPSIS	5	=head1 SYNOPSIS
6		6
7	use EV;	7	use EV;
8		8
9	# TIMER	9	# TIMERS
10		10
11	my $w = EV::timer 2, 0, sub {	11	my $w = EV::timer 2, 0, sub {
12	warn "is called after 2s";	12	warn "is called after 2s";
13	};	13	};
14		14
15	my $w = EV::timer 2, 1, sub {	15	my $w = EV::timer 2, 1, sub {
16	warn "is called roughly every 2s (repeat = 1)";	16	warn "is called roughly every 2s (repeat = 1)";
17	};	17	};
18		18
19	undef $w; # destroy event watcher again	19	undef $w; # destroy event watcher again
20		20
21	# IO
22
23	my $w = EV::timer_abs 0, 60, sub {	21	my $w = EV::periodic 0, 60, sub {
24	warn "is called every minute, on the minute, exactly";	22	warn "is called every minute, on the minute, exactly";
25	};	23	};
26		24
		25	# IO
		26
27	my $w = EV::io \*STDIN, EV::READ \| EV::PERSIST, sub {	27	my $w = EV::io *STDIN, EV::READ, sub {
28	my ($w, $events) = @_; # all callbacks get the watcher object and event mask	28	my ($w, $revents) = @_; # all callbacks get the watcher object and event mask
29	if ($events & EV::TIMEOUT) {
30	warn "nothign received on stdin for 10 seconds, retrying";
31	} else {
32	warn "stdin is readable, you entered: ", <STDIN>;	29	warn "stdin is readable, you entered: ", <STDIN>;
33	}
34	};	30	};
35	$w->timeout (10);	31
		32	# SIGNALS
		33
		34	my $w = EV::signal 'QUIT', sub {
		35	warn "sigquit received\n";
		36	};
		37
		38	my $w = EV::signal 3, sub {
		39	warn "sigquit received (this is GNU/Linux, right?)\n";
		40	};
36		41
		42	# CHILD/PID STATUS CHANGES
		43
		44	my $w = EV::child 666, sub {
		45	my ($w, $revents) = @_;
		46	# my $pid = $w->rpid;
		47	my $status = $w->rstatus;
		48	};
		49
37	# MAINLOOP	50	# MAINLOOP
38	EV::dispatch; # loop as long as watchers are active	51	EV::loop; # loop until EV::loop_done is called
39	EV::loop; # the same thing	52	EV::loop EV::LOOP_ONESHOT; # block until at least one event could be handled
40	EV::loop EV::LOOP_ONCE;	53	EV::loop EV::LOOP_NONBLOCK; # try to handle same events, but do not block
41	EV::loop EV::LOOP_ONSHOT;
42		54
43	=head1 DESCRIPTION	55	=head1 DESCRIPTION
44		56
45	This module provides an interface to libevent	57	This module provides an interface to libev
46	(L<http://monkey.org/~provos/libevent/>). You probably should acquaint	58	(L<http://software.schmorp.de/pkg/libev.html>).
47	yourself with its documentation and source code to be able to use this
48	module fully.
49
50	Please note thta this module disables the libevent EPOLL method by
51	default, see BUGS, below, if you need to enable it.
52		59
53	=cut	60	=cut
54		61
55	package EV;	62	package EV;
56		63
57	use strict;	64	use strict;
58		65
59	BEGIN {	66	BEGIN {
60	our $VERSION = '0.01';	67	our $VERSION = '0.5';
61	use XSLoader;	68	use XSLoader;
62	XSLoader::load "EV", $VERSION;	69	XSLoader::load "EV", $VERSION;
63	}	70	}
64		71
65	=head1 FUNCTIONAL INTERFACE	72	@EV::Io::ISA =
		73	@EV::Timer::ISA =
		74	@EV::Periodic::ISA =
		75	@EV::Signal::ISA =
		76	@EV::Idle::ISA =
		77	@EV::Prepare::ISA =
		78	@EV::Check::ISA =
		79	@EV::Child::ISA = "EV::Watcher";
		80
		81	=head1 BASIC INTERFACE
66		82
67	=over 4	83	=over 4
68		84
69	=item $EV::NPRI	85	=item $EV::DIED
70		86
71	How many priority levels are available.	87	Must contain a reference to a function that is called when a callback
		88	throws an exception (with $@ containing thr error). The default prints an
		89	informative message and continues.
		90
		91	If this callback throws an exception it will be silently ignored.
		92
		93	=item $time = EV::time
		94
		95	Returns the current time in (fractional) seconds since the epoch.
72		96
73	=item $time = EV::now	97	=item $time = EV::now
74		98
75	Returns the time in (fractional) seconds since the epoch.	99	Returns the time the last event loop iteration has been started. This
		100	is the time that (relative) timers are based on, and refering to it is
		101	usually faster then calling EV::time.
76		102
77	=item $version = EV::version
78
79	=item $method = EV::method	103	=item $method = EV::ev_method
80		104
81	Return version string and event polling method used.	105	Returns an integer describing the backend used by libev (EV::METHOD_SELECT
		106	or EV::METHOD_EPOLL).
82		107
83	=item EV::loop $flags # EV::LOOP_ONCE, EV::LOOP_ONESHOT	108	=item EV::loop [$flags]
84		109
85	=item EV::loopexit $after	110	Begin checking for events and calling callbacks. It returns when a
		111	callback calls EV::loop_done.
86		112
87	Exit any active loop or dispatch after C<$after> seconds or immediately if	113	The $flags argument can be one of the following:
88	C<$after> is missing or zero.
89		114
90	=item EV::dispatch	115	0 as above
		116	EV::LOOP_ONESHOT block at most once (wait, but do not loop)
		117	EV::LOOP_NONBLOCK do not block at all (fetch/handle events but do not wait)
91		118
92	Same as C<EV::loop 0>.	119	=item EV::loop_done [$how]
93		120
94	=item EV::event $callback	121	When called with no arguments or an argument of 1, makes the innermost
		122	call to EV::loop return.
95		123
96	Creates a new event watcher waiting for nothing, calling the given callback.	124	When called with an agrument of 2, all calls to EV::loop will return as
		125	fast as possible.
97		126
		127	=back
		128
		129	=head2 WATCHER
		130
		131	A watcher is an object that gets created to record your interest in some
		132	event. For instance, if you want to wait for STDIN to become readable, you
		133	would create an EV::io watcher for that:
		134
		135	my $watcher = EV::io *STDIN, EV::READ, sub {
		136	my ($watcher, $revents) = @_;
		137	warn "yeah, STDIN should not be readable without blocking!\n"
		138	};
		139
		140	All watchers can be active (waiting for events) or inactive (paused). Only
		141	active watchers will have their callbacks invoked. All callbacks will be
		142	called with at least two arguments: the watcher and a bitmask of received
		143	events.
		144
		145	Each watcher type has its associated bit in revents, so you can use the
		146	same callback for multiple watchers. The event mask is named after the
		147	type, i..e. EV::child sets EV::CHILD, EV::prepare sets EV::PREPARE,
		148	EV::periodic sets EV::PERIODIC and so on, with the exception of IO events
		149	(which can set both EV::READ and EV::WRITE bits), and EV::timer (which
		150	uses EV::TIMEOUT).
		151
		152	In the rare case where one wants to create a watcher but not start it at
		153	the same time, each constructor has a variant with a trailing C<_ns> in
		154	its name, e.g. EV::io has a non-starting variant EV::io_ns and so on.
		155
		156	Please note that a watcher will automatically be stopped when the watcher
		157	object is destroyed, so you I<need> to keep the watcher objects returned by
		158	the constructors.
		159
		160	Also, all methods changing some aspect of a watcher (->set, ->priority,
		161	->fh and so on) automatically stop and start it again if it is active,
		162	which means pending events get lost.
		163
		164	=head2 WATCHER TYPES
		165
		166	Now lets move to the existing watcher types and asociated methods.
		167
		168	The following methods are available for all watchers. Then followes a
		169	description of each watcher constructor (EV::io, EV::timer, EV::periodic,
		170	EV::signal, EV::child, EV::idle, EV::prepare and EV::check), followed by
		171	any type-specific methods (if any).
		172
		173	=over 4
		174
		175	=item $w->start
		176
		177	Starts a watcher if it isn't active already. Does nothing to an already
		178	active watcher. By default, all watchers start out in the active state
		179	(see the description of the C<_ns> variants if you need stopped watchers).
		180
		181	=item $w->stop
		182
		183	Stop a watcher if it is active. Also clear any pending events (events that
		184	have been received but that didn't yet result in a callback invocation),
		185	regardless of wether the watcher was active or not.
		186
		187	=item $bool = $w->is_active
		188
		189	Returns true if the watcher is active, false otherwise.
		190
		191	=item $current_cb = $w->cb
		192
		193	=item $old_cb = $w->cb ($new_cb)
		194
		195	Queries the callback on the watcher and optionally changes it. You can do
		196	this at any time without the watcher restarting.
		197
		198	=item $current_priority = $w->priority
		199
		200	=item $old_priority = $w->priority ($new_priority)
		201
		202	Queries the priority on the watcher and optionally changes it. Pending
		203	watchers with higher priority will be invoked first. The valid range of
		204	priorities lies between EV::MAXPRI (default 2) and EV::MINPRI (default
		205	-2). If the priority is outside this range it will automatically be
		206	normalised to the nearest valid priority.
		207
		208	The default priority of any newly-created weatcher is 0.
		209
		210	=item $w->trigger ($revents)
		211
		212	Call the callback now with the given event mask.
		213
		214
98	=item my $w = EV::io $fileno_or_fh, $eventmask, $callback	215	=item $w = EV::io $fileno_or_fh, $eventmask, $callback
99		216
100	=item my $w = EV::io_ns $fileno_or_fh, $eventmask, $callback	217	=item $w = EV::io_ns $fileno_or_fh, $eventmask, $callback
101		218
102	As long as the returned watcher object is alive, call the C<$callback>	219	As long as the returned watcher object is alive, call the C<$callback>
103	when the events specified in C<$eventmask> happen. Initially, the timeout	220	when the events specified in C<$eventmask>.
104	is disabled.
105		221
106	Youc an additionall set a timeout to occur on the watcher, but note that
107	this timeout will not be reset when you get an I/O event in the EV::PERSIST
108	case, and reaching a timeout will always stop the watcher even in the
109	EV::PERSIST case.
110
111	If you want a timeout to occur only after a specific time of inactivity, set
112	a repeating timeout and do NOT use EV::PERSIST.
113
114	Eventmask can be one or more of these constants ORed together:	222	The $eventmask can be one or more of these constants ORed together:
115		223
116	EV::READ wait until read() wouldn't block anymore	224	EV::READ wait until read() wouldn't block anymore
117	EV::WRITE wait until write() wouldn't block anymore	225	EV::WRITE wait until write() wouldn't block anymore
118	EV::PERSIST stay active after a (non-timeout) event occured
119		226
120	The C<io_ns> variant doesn't add/start the newly created watcher.	227	The C<io_ns> variant doesn't start (activate) the newly created watcher.
121		228
		229	=item $w->set ($fileno_or_fh, $eventmask)
		230
		231	Reconfigures the watcher, see the constructor above for details. Can be
		232	called at any time.
		233
		234	=item $current_fh = $w->fh
		235
		236	=item $old_fh = $w->fh ($new_fh)
		237
		238	Returns the previously set filehandle and optionally set a new one.
		239
		240	=item $current_eventmask = $w->events
		241
		242	=item $old_eventmask = $w->events ($new_eventmask)
		243
		244	Returns the previously set event mask and optionally set a new one.
		245
		246
122	=item my $w = EV::timer $after, $repeat, $callback	247	=item $w = EV::timer $after, $repeat, $callback
123		248
124	=item my $w = EV::timer_ns $after, $repeat, $callback	249	=item $w = EV::timer_ns $after, $repeat, $callback
125		250
126	Calls the callback after C<$after> seconds. If C<$repeat> is true, the	251	Calls the callback after C<$after> seconds. If C<$repeat> is non-zero,
127	timer will be restarted after the callback returns. This means that the	252	the timer will be restarted (with the $repeat value as $after) after the
128	callback would be called roughly every C<$after> seconds, prolonged by the	253	callback returns.
129	time the callback takes.
130		254
		255	This means that the callback would be called roughly after C<$after>
		256	seconds, and then every C<$repeat> seconds. "Roughly" because the time of
		257	callback processing is not taken into account, so the timer will slowly
		258	drift. If that isn't acceptable, look at EV::periodic.
		259
		260	The timer is based on a monotonic clock, that is if somebody is sitting
		261	in front of the machine while the timer is running and changes the system
		262	clock, the timer will nevertheless run (roughly) the same time.
		263
131	The C<timer_ns> variant doesn't add/start the newly created watcher.	264	The C<timer_ns> variant doesn't start (activate) the newly created watcher.
132		265
		266	=item $w->set ($after, $repeat)
		267
		268	Reconfigures the watcher, see the constructor above for details. Can be at
		269	any time.
		270
		271	=item $w->again
		272
		273	Similar to the C<start> method, but has special semantics for repeating timers:
		274
		275	If the timer is active and repeating, reset the timeout to occur
		276	C<$repeat> seconds after now.
		277
		278	If the timer is active and non-repeating, it will be stopped.
		279
		280	If the timer is in active and repeating, start it.
		281
		282	Otherwise do nothing.
		283
		284	This behaviour is useful when you have a timeout for some IO
		285	operation. You create a timer object with the same value for C<$after> and
		286	C<$repeat>, and then, in the read/write watcher, run the C<again> method
		287	on the timeout.
		288
		289
		290	=item $w = EV::periodic $at, $interval, $callback
		291
133	=item my $w = EV::timer_abs $at, $interval, $callback	292	=item $w = EV::periodic_ns $at, $interval, $callback
134
135	=item my $w = EV::timer_abs_ns $at, $interval, $callback
136		293
137	Similar to EV::timer, but the time is given as an absolute point in time	294	Similar to EV::timer, but the time is given as an absolute point in time
138	(C<$at>), plus an optional C<$interval>.	295	(C<$at>), plus an optional C<$interval>.
139		296
140	If the C<$interval> is zero, then the callback will be called at the time	297	If the C<$interval> is zero, then the callback will be called at the time
141	C<$at> if that is in the future, or as soon as possible if its in the	298	C<$at> if that is in the future, or as soon as possible if it is in the
142	past. It will not automatically repeat.	299	past. It will not automatically repeat.
143		300
144	If the C<$interval> is nonzero, then the watcher will always be scheduled	301	If the C<$interval> is nonzero, then the watcher will always be scheduled
145	to time out at the next C<$at + integer * $interval> time.	302	to time out at the next C<$at + N * $interval> time.
146		303
147	This can be used to schedule a callback to run at very regular intervals,	304	This can be used to schedule a callback to run at very regular intervals,
148	as long as the processing time is less then the interval (otherwise	305	as long as the processing time is less then the interval (otherwise
149	obviously events will be skipped).	306	obviously events will be skipped).
150		307
151	Another way to think about it (for the mathematically inclined) is that	308	Another way to think about it (for the mathematically inclined) is that
152	C<timer_abs> will try to tun the callback at the next possible time where	309	EV::periodic will try to run the callback at the next possible time where
153	C<$time = $at (mod $interval)>, regardless of any time jumps.	310	C<$time = $at (mod $interval)>, regardless of any time jumps.
154		311
		312	This periodic timer is based on "wallclock time", that is, if the clock
		313	changes (C<ntp>, C<date -s> etc.), then the timer will nevertheless run at
		314	the specified time. This means it will never drift (it might jitter, but
		315	it will not drift).
		316
155	The C<timer_abs_ns> variant doesn't add/start the newly created watcher.	317	The C<periodic_ns> variant doesn't start (activate) the newly created watcher.
156		318
		319	=item $w->set ($at, $interval)
		320
		321	Reconfigures the watcher, see the constructor above for details. Can be at
		322	any time.
		323
		324
157	=item my $w = EV::signal $signum, $callback	325	=item $w = EV::signal $signal, $callback
158		326
159	=item my $w = EV::signal_ns $signum, $callback	327	=item $w = EV::signal_ns $signal, $callback
160		328
161	Call the callback when signal $signum is received.	329	Call the callback when $signal is received (the signal can be specified
		330	by number or by name, just as with kill or %SIG).
162		331
		332	EV will grab the signal for the process (the kernel only allows one
		333	component to receive a signal at a time) when you start a signal watcher,
		334	and removes it again when you stop it. Perl does the same when you
		335	add/remove callbacks to %SIG, so watch out.
		336
		337	You can have as many signal watchers per signal as you want.
		338
163	The C<signal_ns> variant doesn't add/start the newly created watcher.	339	The C<signal_ns> variant doesn't start (activate) the newly created watcher.
		340
		341	=item $w->set ($signal)
		342
		343	Reconfigures the watcher, see the constructor above for details. Can be at
		344	any time.
		345
		346	=item $current_signum = $w->signal
		347
		348	=item $old_signum = $w->signal ($new_signal)
		349
		350	Returns the previously set signal (always as a number not name) and
		351	optionally set a new one.
		352
		353
		354	=item $w = EV::child $pid, $callback
		355
		356	=item $w = EV::child_ns $pid, $callback
		357
		358	Call the callback when a status change for pid C<$pid> (or any pid
		359	if C<$pid> is 0) has been received. More precisely: when the process
		360	receives a SIGCHLD, EV will fetch the outstanding exit/wait status for all
		361	changed/zombie children and call the callback.
		362
		363	You can access both status and pid by using the C<rstatus> and C<rpid>
		364	methods on the watcher object.
		365
		366	You can have as many pid watchers per pid as you want.
		367
		368	The C<child_ns> variant doesn't start (activate) the newly created watcher.
		369
		370	=item $w->set ($pid)
		371
		372	Reconfigures the watcher, see the constructor above for details. Can be at
		373	any time.
		374
		375	=item $current_pid = $w->pid
		376
		377	=item $old_pid = $w->pid ($new_pid)
		378
		379	Returns the previously set process id and optionally set a new one.
		380
		381	=item $exit_status = $w->rstatus
		382
		383	Return the exit/wait status (as returned by waitpid, see the waitpid entry
		384	in perlfunc).
		385
		386	=item $pid = $w->rpid
		387
		388	Return the pid of the awaited child (useful when you have installed a
		389	watcher for all pids).
		390
		391
		392	=item $w = EV::idle $callback
		393
		394	=item $w = EV::idle_ns $callback
		395
		396	Call the callback when there are no pending io, timer/periodic, signal or
		397	child events, i.e. when the process is idle.
		398
		399	The process will not block as long as any idle watchers are active, and
		400	they will be called repeatedly until stopped.
		401
		402	The C<idle_ns> variant doesn't start (activate) the newly created watcher.
		403
		404
		405	=item $w = EV::prepare $callback
		406
		407	=item $w = EV::prepare_ns $callback
		408
		409	Call the callback just before the process would block. You can still
		410	create/modify any watchers at this point.
		411
		412	See the EV::check watcher, below, for explanations and an example.
		413
		414	The C<prepare_ns> variant doesn't start (activate) the newly created watcher.
		415
		416
		417	=item $w = EV::check $callback
		418
		419	=item $w = EV::check_ns $callback
		420
		421	Call the callback just after the process wakes up again (after it has
		422	gathered events), but before any other callbacks have been invoked.
		423
		424	This is used to integrate other event-based software into the EV
		425	mainloop: You register a prepare callback and in there, you create io and
		426	timer watchers as required by the other software. Here is a real-world
		427	example of integrating Net::SNMP (with some details left out):
		428
		429	our @snmp_watcher;
		430
		431	our $snmp_prepare = EV::prepare sub {
		432	# do nothing unless active
		433	$dispatcher->{_event_queue_h}
		434	or return;
		435
		436	# make the dispatcher handle any outstanding stuff
		437
		438	# create an IO watcher for each and every socket
		439	@snmp_watcher = (
		440	(map { EV::io $_, EV::READ, sub { } }
		441	keys %{ $dispatcher->{_descriptors} }),
		442	);
		443
		444	# if there are any timeouts, also create a timer
		445	push @snmp_watcher, EV::timer $event->[Net::SNMP::Dispatcher::_TIME] - EV::now, 0, sub { }
		446	if $event->[Net::SNMP::Dispatcher::_ACTIVE];
		447	};
		448
		449	The callbacks are irrelevant, the only purpose of those watchers is
		450	to wake up the process as soon as one of those events occurs (socket
		451	readable, or timer timed out). The corresponding EV::check watcher will then
		452	clean up:
		453
		454	our $snmp_check = EV::check sub {
		455	# destroy all watchers
		456	@snmp_watcher = ();
		457
		458	# make the dispatcher handle any new stuff
		459	};
		460
		461	The callbacks of the created watchers will not be called as the watchers
		462	are destroyed before this cna happen (remember EV::check gets called
		463	first).
		464
		465	The C<check_ns> variant doesn't start (activate) the newly created watcher.
164		466
165	=back	467	=back
166		468
167	=head1 THE EV::Event CLASS	469	=head1 THREADS
168		470
169	All EV functions creating an event watcher (designated by C<my $w =>	471	Threads are not supported by this in any way. Perl pseudo-threads is evil
170	above) support the following methods on the returned watcher object:	472	stuff and must die.
171
172	=over 4
173
174	=item $w->add ($timeout)
175
176	Stops and (re-)starts the event watcher, setting the optional timeout to
177	the given value, or clearing the timeout if none is given.
178
179	=item $w->start
180
181	Stops and (re-)starts the event watcher without touching the timeout.
182
183	=item $w->del
184
185	=item $w->stop
186
187	Stop the event watcher if it was started.
188
189	=item $current_callback = $w->cb
190
191	=item $old_callback = $w->cb ($new_callback)
192
193	Return the previously set callback and optionally set a new one.
194
195	=item $current_fh = $w->fh
196
197	=item $old_fh = $w->fh ($new_fh)
198
199	Returns the previously set filehandle and optionally set a new one.
200
201	=item $current_eventmask = $w->events
202
203	=item $old_eventmask = $w->events ($new_eventmask)
204
205	Returns the previously set event mask and optionally set a new one.
206
207	=item $w->timeout ($after, $repeat)
208
209	Resets the timeout (see C<EV::timer> for details).
210
211	=item $w->timeout_abs ($at, $interval)
212
213	Resets the timeout (see C<EV::timer_abs> for details).
214
215	=item $w->priority_set ($priority)
216
217	Set the priority of the watcher to C<$priority> (0 <= $priority < $EV::NPRI).
218
219	=back
220
221	=head1 BUGS
222
223	Lots. Libevent itself isn't well tested and rather buggy, and this module
224	is quite new at the moment.
225
226	Please note that the epoll method is not, in general, reliable in programs
227	that use fork (even if no libveent calls are being made in the forked
228	process). If your program behaves erratically, try setting the environment
229	variable C<EVENT_NOEPOLL> first when running the program.
230
231	In general, if you fork, then you can only use the EV module in one of the
232	children.
233		473
234	=cut	474	=cut
235		475
236	our $NPRI = 4;	476	our $DIED = sub {
237	our $BASE = init;	477	warn "EV: error in callback (ignoring): $@";
238	priority_init $NPRI;	478	};
		479
		480	default_loop
		481	or die 'EV: cannot initialise libev backend. bad $ENV{LIBEV_METHODS}?';
239		482
240	push @AnyEvent::REGISTRY, [EV => "EV::AnyEvent"];	483	push @AnyEvent::REGISTRY, [EV => "EV::AnyEvent"];
241		484
242	1;	485	1;
243		486
244	=head1 SEE ALSO	487	=head1 SEE ALSO
245		488
246	L<EV::DNS>, L<event(3)>, L<event.h>, L<evdns.h>.
247	L<EV::AnyEvent>.	489	L<EV::DNS>, L<EV::AnyEvent>.
248		490
249	=head1 AUTHOR	491	=head1 AUTHOR
250		492
251	Marc Lehmann <schmorp@schmorp.de>	493	Marc Lehmann <schmorp@schmorp.de>
252	http://home.schmorp.de/	494	http://home.schmorp.de/

Diff Legend

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

Comparing EV/EV.pm (file contents): Revision 1.7 by root, Sat Oct 27 14:54:20 2007 UTC vs. Revision 1.28 by root, Sun Nov 4 16:52:52 2007 UTC

Diff Legend

Comparing EV/EV.pm (file contents):
Revision 1.7 by root, Sat Oct 27 14:54:20 2007 UTC vs.
Revision 1.28 by root, Sun Nov 4 16:52:52 2007 UTC