[ViewVC] Diff of: cvs/AnyEvent-MP/MP.pm

Comparing AnyEvent-MP/MP.pm (file contents):
Revision 1.32 by root, Wed Aug 5 19:58:46 2009 UTC vs.
Revision 1.37 by root, Fri Aug 7 16:47:23 2009 UTC

…		…
22	snd $port2, ping => $port1;	22	snd $port2, ping => $port1;
23		23
24	# more, smarter, matches (_any_ is exported by this module)	24	# more, smarter, matches (_any_ is exported by this module)
25	rcv $port, [child_died => $pid] => sub { ...	25	rcv $port, [child_died => $pid] => sub { ...
26	rcv $port, [_any_, _any_, 3] => sub { .. $_[2] is 3	26	rcv $port, [_any_, _any_, 3] => sub { .. $_[2] is 3
		27
		28	# monitoring
		29	mon $port, $cb->(@msg) # callback is invoked on death
		30	mon $port, $otherport # kill otherport on abnormal death
		31	mon $port, $otherport, @msg # send message on death
27		32
28	=head1 DESCRIPTION	33	=head1 DESCRIPTION
29		34
30	This module (-family) implements a simple message passing framework.	35	This module (-family) implements a simple message passing framework.
31		36
…		…
123	The C<NODE> function returns, and the C<$NODE> variable contains	128	The C<NODE> function returns, and the C<$NODE> variable contains
124	the noderef of the local node. The value is initialised by a call	129	the noderef of the local node. The value is initialised by a call
125	to C<become_public> or C<become_slave>, after which all local port	130	to C<become_public> or C<become_slave>, after which all local port
126	identifiers become invalid.	131	identifiers become invalid.
127		132
128	=item $noderef = node_of $portid	133	=item $noderef = node_of $port
129		134
130	Extracts and returns the noderef from a portid or a noderef.	135	Extracts and returns the noderef from a portid or a noderef.
		136
		137	=item initialise_node $noderef, $seednode, $seednode...
		138
		139	=item initialise_node "slave/", $master, $master...
		140
		141	Before a node can talk to other nodes on the network it has to initialise
		142	itself - the minimum a node needs to know is it's own name, and optionally
		143	it should know the noderefs of some other nodes in the network.
		144
		145	This function initialises a node - it must be called exactly once (or
		146	never) before calling other AnyEvent::MP functions.
		147
		148	All arguments are noderefs, which can be either resolved or unresolved.
		149
		150	There are two types of networked nodes, public nodes and slave nodes:
		151
		152	=over 4
		153
		154	=item public nodes
		155
		156	For public nodes, C<$noderef> must either be a (possibly unresolved)
		157	noderef, in which case it will be resolved, or C<undef> (or missing), in
		158	which case the noderef will be guessed.
		159
		160	Afterwards, the node will bind itself on all endpoints and try to connect
		161	to all additional C<$seednodes> that are specified. Seednodes are optional
		162	and can be used to quickly bootstrap the node into an existing network.
		163
		164	=item slave nodes
		165
		166	When the C<$noderef> is the special string C<slave/>, then the node will
		167	become a slave node. Slave nodes cannot be contacted from outside and will
		168	route most of their traffic to the master node that they attach to.
		169
		170	At least one additional noderef is required: The node will try to connect
		171	to all of them and will become a slave attached to the first node it can
		172	successfully connect to.
		173
		174	=back
		175
		176	This function will block until all nodes have been resolved and, for slave
		177	nodes, until it has successfully established a connection to a master
		178	server.
		179
		180	Example: become a public node listening on the default node.
		181
		182	initialise_node;
		183
		184	Example: become a public node, and try to contact some well-known master
		185	servers to become part of the network.
		186
		187	initialise_node undef, "master1", "master2";
		188
		189	Example: become a public node listening on port C<4041>.
		190
		191	initialise_node 4041;
		192
		193	Example: become a public node, only visible on localhost port 4044.
		194
		195	initialise_node "locahost:4044";
		196
		197	Example: become a slave node to any of the specified master servers.
		198
		199	initialise_node "slave/", "master1", "192.168.13.17", "mp.example.net";
131		200
132	=item $cv = resolve_node $noderef	201	=item $cv = resolve_node $noderef
133		202
134	Takes an unresolved node reference that may contain hostnames and	203	Takes an unresolved node reference that may contain hostnames and
135	abbreviated IDs, resolves all of them and returns a resolved node	204	abbreviated IDs, resolves all of them and returns a resolved node
…		…
167		236
168	Due to some quirks in how perl exports variables, it is impossible to	237	Due to some quirks in how perl exports variables, it is impossible to
169	just export C<$SELF>, all the symbols called C<SELF> are exported by this	238	just export C<$SELF>, all the symbols called C<SELF> are exported by this
170	module, but only C<$SELF> is currently used.	239	module, but only C<$SELF> is currently used.
171		240
172	=item snd $portid, type => @data	241	=item snd $port, type => @data
173		242
174	=item snd $portid, @msg	243	=item snd $port, @msg
175		244
176	Send the given message to the given port ID, which can identify either	245	Send the given message to the given port ID, which can identify either
177	a local or a remote port, and can be either a string or soemthignt hat	246	a local or a remote port, and can be either a string or soemthignt hat
178	stringifies a sa port ID (such as a port object :).	247	stringifies a sa port ID (such as a port object :).
179		248
…		…
195		264
196	Create a new local port object that can be used either as a pattern	265	Create a new local port object that can be used either as a pattern
197	matching port ("full port") or a single-callback port ("miniport"),	266	matching port ("full port") or a single-callback port ("miniport"),
198	depending on how C<rcv> callbacks are bound to the object.	267	depending on how C<rcv> callbacks are bound to the object.
199		268
200	=item $portid = port { my @msg = @_; $finished }	269	=item $port = port { my @msg = @_; $finished }
201		270
202	Creates a "mini port", that is, a very lightweight port without any	271	Creates a "miniport", that is, a very lightweight port without any pattern
203	pattern matching behind it, and returns its ID.	272	matching behind it, and returns its ID. Semantically the same as creating
		273	a port and calling C<rcv $port, $callback> on it.
204		274
205	The block will be called for every message received on the port. When the	275	The block will be called for every message received on the port. When the
206	callback returns a true value its job is considered "done" and the port	276	callback returns a true value its job is considered "done" and the port
207	will be destroyed. Otherwise it will stay alive.	277	will be destroyed. Otherwise it will stay alive.
208		278
…		…
215	snd $otherport, reply => $port;	285	snd $otherport, reply => $port;
216	};	286	};
217		287
218	=cut	288	=cut
219		289
		290	sub rcv($@);
		291
220	sub port(;&) {	292	sub port(;&) {
221	my $id = "$UNIQ." . $ID++;	293	my $id = "$UNIQ." . $ID++;
222	my $port = "$NODE#$id";	294	my $port = "$NODE#$id";
223		295
224	if (@_) {	296	if (@_) {
		297	rcv $port, shift;
		298	} else {
		299	$PORT{$id} = sub { }; # nop
		300	}
		301
		302	$port
		303	}
		304
		305	=item reg $port, $name
		306
		307	=item reg $name
		308
		309	Registers the given port (or C<$SELF><<< if missing) under the name
		310	C<$name>. If the name already exists it is replaced.
		311
		312	A port can only be registered under one well known name.
		313
		314	A port automatically becomes unregistered when it is killed.
		315
		316	=cut
		317
		318	sub reg(@) {
		319	my $port = @_ > 1 ? shift : $SELF \|\| Carp::croak 'reg: called with one argument only, but $SELF not set,';
		320
		321	$REG{$_[0]} = $port;
		322	}
		323
		324	=item rcv $port, $callback->(@msg)
		325
		326	Replaces the callback on the specified miniport (after converting it to
		327	one if required).
		328
		329	=item rcv $port, tagstring => $callback->(@msg), ...
		330
		331	=item rcv $port, $smartmatch => $callback->(@msg), ...
		332
		333	=item rcv $port, [$smartmatch...] => $callback->(@msg), ...
		334
		335	Register callbacks to be called on matching messages on the given full
		336	port (after converting it to one if required) and return the port.
		337
		338	The callback has to return a true value when its work is done, after
		339	which is will be removed, or a false value in which case it will stay
		340	registered.
		341
		342	The global C<$SELF> (exported by this module) contains C<$port> while
		343	executing the callback.
		344
		345	Runtime errors wdurign callback execution will result in the port being
		346	C<kil>ed.
		347
		348	If the match is an array reference, then it will be matched against the
		349	first elements of the message, otherwise only the first element is being
		350	matched.
		351
		352	Any element in the match that is specified as C<_any_> (a function
		353	exported by this module) matches any single element of the message.
		354
		355	While not required, it is highly recommended that the first matching
		356	element is a string identifying the message. The one-string-only match is
		357	also the most efficient match (by far).
		358
		359	Example: create a port and bind receivers on it in one go.
		360
		361	my $port = rcv port,
		362	msg1 => sub { ...; 0 },
		363	msg2 => sub { ...; 0 },
		364	;
		365
		366	Example: create a port, bind receivers and send it in a message elsewhere
		367	in one go:
		368
		369	snd $otherport, reply =>
		370	rcv port,
		371	msg1 => sub { ...; 0 },
		372	...
		373	;
		374
		375	=cut
		376
		377	sub rcv($@) {
		378	my $port = shift;
		379	my ($noderef, $portid) = split /#/, $port, 2;
		380
		381	($NODE{$noderef} \|\| add_node $noderef) == $NODE{""}
		382	or Carp::croak "$port: rcv can only be called on local ports, caught";
		383
		384	if (@_ == 1) {
225	my $cb = shift;	385	my $cb = shift;
		386	delete $PORT_DATA{$portid};
226	$PORT{$id} = sub {	387	$PORT{$portid} = sub {
227	local $SELF = $port;	388	local $SELF = $port;
228	eval {	389	eval {
229	&$cb	390	&$cb
230	and kil $id;	391	and kil $port;
231	};	392	};
232	_self_die if $@;	393	_self_die if $@;
233	};	394	};
234	} else {	395	} else {
		396	my $self = $PORT_DATA{$portid} \|\|= do {
235	my $self = bless {	397	my $self = bless {
236	id => "$NODE#$id",	398	id => $port,
237	}, "AnyEvent::MP::Port";	399	}, "AnyEvent::MP::Port";
238		400
239	$PORT_DATA{$id} = $self;
240	$PORT{$id} = sub {	401	$PORT{$portid} = sub {
241	local $SELF = $port;	402	local $SELF = $port;
242		403
243	eval {	404	eval {
244	for (@{ $self->{rc0}{$_[0]} }) {	405	for (@{ $self->{rc0}{$_[0]} }) {
245	$_ && &{$_->[0]}	406	$_ && &{$_->[0]}
246	&& undef $_;	407	&& undef $_;
247	}	408	}
248		409
249	for (@{ $self->{rcv}{$_[0]} }) {	410	for (@{ $self->{rcv}{$_[0]} }) {
250	$_ && [@_[1 .. @{$_->[1]}]] ~~ $_->[1]	411	$_ && [@_[1 .. @{$_->[1]}]] ~~ $_->[1]
251	&& &{$_->[0]}	412	&& &{$_->[0]}
252	&& undef $_;	413	&& undef $_;
253	}	414	}
254		415
255	for (@{ $self->{any} }) {	416	for (@{ $self->{any} }) {
256	$_ && [@_[0 .. $#{$_->[1]}]] ~~ $_->[1]	417	$_ && [@_[0 .. $#{$_->[1]}]] ~~ $_->[1]
257	&& &{$_->[0]}	418	&& &{$_->[0]}
258	&& undef $_;	419	&& undef $_;
		420	}
259	}	421	};
		422	_self_die if $@;
260	};	423	};
261	_self_die if $@;	424
		425	$self
262	};	426	};
263	}
264		427
265	$port
266	}
267
268	=item reg $portid, $name
269
270	Registers the given port under the name C<$name>. If the name already
271	exists it is replaced.
272
273	A port can only be registered under one well known name.
274
275	A port automatically becomes unregistered when it is killed.
276
277	=cut
278
279	sub reg(@) {
280	my ($portid, $name) = @_;
281
282	$REG{$name} = $portid;
283	}
284
285	=item rcv $portid, $callback->(@msg)
286
287	Replaces the callback on the specified miniport (or newly created port
288	object, see C<port>). Full ports are configured with the following calls:
289
290	=item rcv $portid, tagstring => $callback->(@msg), ...
291
292	=item rcv $portid, $smartmatch => $callback->(@msg), ...
293
294	=item rcv $portid, [$smartmatch...] => $callback->(@msg), ...
295
296	Register callbacks to be called on matching messages on the given full
297	port (or newly created port).
298
299	The callback has to return a true value when its work is done, after
300	which is will be removed, or a false value in which case it will stay
301	registered.
302
303	The global C<$SELF> (exported by this module) contains C<$portid> while
304	executing the callback.
305
306	Runtime errors wdurign callback execution will result in the port being
307	C<kil>ed.
308
309	If the match is an array reference, then it will be matched against the
310	first elements of the message, otherwise only the first element is being
311	matched.
312
313	Any element in the match that is specified as C<_any_> (a function
314	exported by this module) matches any single element of the message.
315
316	While not required, it is highly recommended that the first matching
317	element is a string identifying the message. The one-string-only match is
318	also the most efficient match (by far).
319
320	=cut
321
322	sub rcv($@) {
323	my $portid = shift;
324	my ($noderef, $port) = split /#/, $port, 2;
325
326	($NODE{$noderef} \|\| add_node $noderef) == $NODE{""}
327	or Carp::croak "$noderef#$port: rcv can only be called on local ports, caught";
328
329	my $self = $PORT_DATA{$port}
330	or Carp::croak "$noderef#$port: rcv can only be called on message matching ports, caught";
331
332	"AnyEvent::MP::Port" eq ref $self	428	"AnyEvent::MP::Port" eq ref $self
333	or Carp::croak "$noderef#$port: rcv can only be called on message matching ports, caught";	429	or Carp::croak "$port: rcv can only be called on message matching ports, caught";
334		430
335	while (@_) {	431	while (@_) {
336	my ($match, $cb) = splice @_, 0, 2;	432	my ($match, $cb) = splice @_, 0, 2;
337		433
338	if (!ref $match) {	434	if (!ref $match) {
339	push @{ $self->{rc0}{$match} }, [$cb];	435	push @{ $self->{rc0}{$match} }, [$cb];
340	} elsif (("ARRAY" eq ref $match && !ref $match->[0])) {	436	} elsif (("ARRAY" eq ref $match && !ref $match->[0])) {
341	my ($type, @match) = @$match;	437	my ($type, @match) = @$match;
342	@match	438	@match
343	? push @{ $self->{rcv}{$match->[0]} }, [$cb, \@match]	439	? push @{ $self->{rcv}{$match->[0]} }, [$cb, \@match]
344	: push @{ $self->{rc0}{$match->[0]} }, [$cb];	440	: push @{ $self->{rc0}{$match->[0]} }, [$cb];
345	} else {	441	} else {
346	push @{ $self->{any} }, [$cb, $match];	442	push @{ $self->{any} }, [$cb, $match];
		443	}
347	}	444	}
348	}	445	}
349		446
350	$portid	447	$port
351	}	448	}
352		449
353	=item $closure = psub { BLOCK }	450	=item $closure = psub { BLOCK }
354		451
355	Remembers C<$SELF> and creates a closure out of the BLOCK. When the	452	Remembers C<$SELF> and creates a closure out of the BLOCK. When the
…		…
386	$res	483	$res
387	}	484	}
388	}	485	}
389	}	486	}
390		487
391	=item $guard = mon $portid, $cb->(@reason)	488	=item $guard = mon $port, $cb->(@reason)
392		489
393	=item $guard = mon $portid, $otherport	490	=item $guard = mon $port, $rcvport
394		491
		492	=item $guard = mon $port
		493
395	=item $guard = mon $portid, $otherport, @msg	494	=item $guard = mon $port, $rcvport, @msg
396		495
397	Monitor the given port and do something when the port is killed.	496	Monitor the given port and do something when the port is killed, and
		497	optionally return a guard that can be used to stop monitoring again.
398		498
399	In the first form, the callback is simply called with any number	499	In the first form (callback), the callback is simply called with any
400	of C<@reason> elements (no @reason means that the port was deleted	500	number of C<@reason> elements (no @reason means that the port was deleted
401	"normally"). Note also that I<< the callback B<must> never die >>, so use	501	"normally"). Note also that I<< the callback B<must> never die >>, so use
402	C<eval> if unsure.	502	C<eval> if unsure.
403		503
404	In the second form, the other port will be C<kil>'ed with C<@reason>, iff	504	In the second form (another port given), the other port (C<$rcvport)
405	a @reason was specified, i.e. on "normal" kils nothing happens, while	505	will be C<kil>'ed with C<@reason>, iff a @reason was specified, i.e. on
406	under all other conditions, the other port is killed with the same reason.	506	"normal" kils nothing happens, while under all other conditions, the other
		507	port is killed with the same reason.
407		508
		509	The third form (kill self) is the same as the second form, except that
		510	C<$rvport> defaults to C<$SELF>.
		511
408	In the last form, a message of the form C<@msg, @reason> will be C<snd>.	512	In the last form (message), a message of the form C<@msg, @reason> will be
		513	C<snd>.
		514
		515	As a rule of thumb, monitoring requests should always monitor a port from
		516	a local port (or callback). The reason is that kill messages might get
		517	lost, just like any other message. Another less obvious reason is that
		518	even monitoring requests can get lost (for exmaple, when the connection
		519	to the other node goes down permanently). When monitoring a port locally
		520	these problems do not exist.
409		521
410	Example: call a given callback when C<$port> is killed.	522	Example: call a given callback when C<$port> is killed.
411		523
412	mon $port, sub { warn "port died because of <@_>\n" };	524	mon $port, sub { warn "port died because of <@_>\n" };
413		525
414	Example: kill ourselves when C<$port> is killed abnormally.	526	Example: kill ourselves when C<$port> is killed abnormally.
415		527
416	mon $port, $self;	528	mon $port;
417		529
418	Example: send us a restart message another C<$port> is killed.	530	Example: send us a restart message when another C<$port> is killed.
419		531
420	mon $port, $self => "restart";	532	mon $port, $self => "restart";
421		533
422	=cut	534	=cut
423		535
424	sub mon {	536	sub mon {
425	my ($noderef, $port) = split /#/, shift, 2;	537	my ($noderef, $port) = split /#/, shift, 2;
426		538
427	my $node = $NODE{$noderef} \|\| add_node $noderef;	539	my $node = $NODE{$noderef} \|\| add_node $noderef;
428		540
429	my $cb = shift;	541	my $cb = @_ ? $_[0] : $SELF \|\| Carp::croak 'mon: called with one argument only, but $SELF not set,';
430		542
431	unless (ref $cb) {	543	unless (ref $cb) {
432	if (@_) {	544	if (@_) {
433	# send a kill info message	545	# send a kill info message
434	my (@msg) = ($cb, @_);	546	my (@msg) = @_;
435	$cb = sub { snd @msg, @_ };	547	$cb = sub { snd @msg, @_ };
436	} else {	548	} else {
437	# simply kill other port	549	# simply kill other port
438	my $port = $cb;	550	my $port = $cb;
439	$cb = sub { kil $port, @_ if @_ };	551	$cb = sub { kil $port, @_ if @_ };
…		…
465	=cut	577	=cut
466		578
467	sub mon_guard {	579	sub mon_guard {
468	my ($port, @refs) = @_;	580	my ($port, @refs) = @_;
469		581
		582	#TODO: mon-less form?
		583
470	mon $port, sub { 0 && @refs }	584	mon $port, sub { 0 && @refs }
471	}	585	}
472		586
473	=item lnk $port1, $port2
474
475	Link two ports. This is simply a shorthand for:
476
477	mon $port1, $port2;
478	mon $port2, $port1;
479
480	It means that if either one is killed abnormally, the other one gets
481	killed as well.
482
483	=item kil $portid[, @reason]	587	=item kil $port[, @reason]
484		588
485	Kill the specified port with the given C<@reason>.	589	Kill the specified port with the given C<@reason>.
486		590
487	If no C<@reason> is specified, then the port is killed "normally" (linked	591	If no C<@reason> is specified, then the port is killed "normally" (linked
488	ports will not be kileld, or even notified).	592	ports will not be kileld, or even notified).
…		…
493	Runtime errors while evaluating C<rcv> callbacks or inside C<psub> blocks	597	Runtime errors while evaluating C<rcv> callbacks or inside C<psub> blocks
494	will be reported as reason C<< die => $@ >>.	598	will be reported as reason C<< die => $@ >>.
495		599
496	Transport/communication errors are reported as C<< transport_error =>	600	Transport/communication errors are reported as C<< transport_error =>
497	$message >>.	601	$message >>.
498
499	=back
500
501	=head1 FUNCTIONS FOR NODES
502
503	=over 4
504
505	=item become_public $noderef
506
507	Tells the node to become a public node, i.e. reachable from other nodes.
508
509	The first argument is the (unresolved) node reference of the local node
510	(if missing then the empty string is used).
511
512	It is quite common to not specify anything, in which case the local node
513	tries to listen on the default port, or to only specify a port number, in
514	which case AnyEvent::MP tries to guess the local addresses.
515
516	=cut
517		602
518	=back	603	=back
519		604
520	=head1 NODE MESSAGES	605	=head1 NODE MESSAGES
521		606
…		…
563		648
564	=back	649	=back
565		650
566	=head1 AnyEvent::MP vs. Distributed Erlang	651	=head1 AnyEvent::MP vs. Distributed Erlang
567		652
568	AnyEvent::MP got lots of its ideas from distributed erlang (erlang node	653	AnyEvent::MP got lots of its ideas from distributed Erlang (Erlang node
569	== aemp node, erlang process == aemp port), so many of the documents and	654	== aemp node, Erlang process == aemp port), so many of the documents and
570	programming techniques employed by erlang apply to AnyEvent::MP. Here is a	655	programming techniques employed by Erlang apply to AnyEvent::MP. Here is a
571	sample:	656	sample:
572		657
573	http://www.erlang.se/doc/programming_rules.shtml	658	http://www.Erlang.se/doc/programming_rules.shtml
574	http://erlang.org/doc/getting_started/part_frame.html # chapters 3 and 4	659	http://Erlang.org/doc/getting_started/part_frame.html # chapters 3 and 4
575	http://erlang.org/download/erlang-book-part1.pdf # chapters 5 and 6	660	http://Erlang.org/download/Erlang-book-part1.pdf # chapters 5 and 6
576	http://erlang.org/download/armstrong_thesis_2003.pdf # chapters 4 and 5	661	http://Erlang.org/download/armstrong_thesis_2003.pdf # chapters 4 and 5
577		662
578	Despite the similarities, there are also some important differences:	663	Despite the similarities, there are also some important differences:
579		664
580	=over 4	665	=over 4
581		666
…		…
592		677
593	Erlang uses processes that selctively receive messages, and therefore	678	Erlang uses processes that selctively receive messages, and therefore
594	needs a queue. AEMP is event based, queuing messages would serve no useful	679	needs a queue. AEMP is event based, queuing messages would serve no useful
595	purpose.	680	purpose.
596		681
597	(But see L<Coro::MP> for a more erlang-like process model on top of AEMP).	682	(But see L<Coro::MP> for a more Erlang-like process model on top of AEMP).
598		683
599	=item * Erlang sends are synchronous, AEMP sends are asynchronous.	684	=item * Erlang sends are synchronous, AEMP sends are asynchronous.
600		685
601	Sending messages in erlang is synchronous and blocks the process. AEMP	686	Sending messages in Erlang is synchronous and blocks the process. AEMP
602	sends are immediate, connection establishment is handled in the	687	sends are immediate, connection establishment is handled in the
603	background.	688	background.
604		689
605	=item * Erlang can silently lose messages, AEMP cannot.	690	=item * Erlang can silently lose messages, AEMP cannot.
606		691
…		…
609	and c, and the other side only receives messages a and c).	694	and c, and the other side only receives messages a and c).
610		695
611	AEMP guarantees correct ordering, and the guarantee that there are no	696	AEMP guarantees correct ordering, and the guarantee that there are no
612	holes in the message sequence.	697	holes in the message sequence.
613		698
614	=item * In erlang, processes can be declared dead and later be found to be	699	=item * In Erlang, processes can be declared dead and later be found to be
615	alive.	700	alive.
616		701
617	In erlang it can happen that a monitored process is declared dead and	702	In Erlang it can happen that a monitored process is declared dead and
618	linked processes get killed, but later it turns out that the process is	703	linked processes get killed, but later it turns out that the process is
619	still alive - and can receive messages.	704	still alive - and can receive messages.
620		705
621	In AEMP, when port monitoring detects a port as dead, then that port will	706	In AEMP, when port monitoring detects a port as dead, then that port will
622	eventually be killed - it cannot happen that a node detects a port as dead	707	eventually be killed - it cannot happen that a node detects a port as dead
623	and then later sends messages to it, finding it is still alive.	708	and then later sends messages to it, finding it is still alive.
624		709
625	=item * Erlang can send messages to the wrong port, AEMP does not.	710	=item * Erlang can send messages to the wrong port, AEMP does not.
626		711
627	In erlang it is quite possible that a node that restarts reuses a process	712	In Erlang it is quite possible that a node that restarts reuses a process
628	ID known to other nodes for a completely different process, causing	713	ID known to other nodes for a completely different process, causing
629	messages destined for that process to end up in an unrelated process.	714	messages destined for that process to end up in an unrelated process.
630		715
631	AEMP never reuses port IDs, so old messages or old port IDs floating	716	AEMP never reuses port IDs, so old messages or old port IDs floating
632	around in the network will not be sent to an unrelated port.	717	around in the network will not be sent to an unrelated port.
…		…
638	securely authenticate nodes.	723	securely authenticate nodes.
639		724
640	=item * The AEMP protocol is optimised for both text-based and binary	725	=item * The AEMP protocol is optimised for both text-based and binary
641	communications.	726	communications.
642		727
643	The AEMP protocol, unlike the erlang protocol, supports both	728	The AEMP protocol, unlike the Erlang protocol, supports both
644	language-independent text-only protocols (good for debugging) and binary,	729	language-independent text-only protocols (good for debugging) and binary,
645	language-specific serialisers (e.g. Storable).	730	language-specific serialisers (e.g. Storable).
646		731
647	It has also been carefully designed to be implementable in other languages	732	It has also been carefully designed to be implementable in other languages
648	with a minimum of work while gracefully degrading fucntionality to make the	733	with a minimum of work while gracefully degrading fucntionality to make the
649	protocol simple.	734	protocol simple.
650		735
		736	=item * AEMP has more flexible monitoring options than Erlang.
		737
		738	In Erlang, you can chose to receive I<all> exit signals as messages
		739	or I<none>, there is no in-between, so monitoring single processes is
		740	difficult to implement. Monitoring in AEMP is more flexible than in
		741	Erlang, as one can choose between automatic kill, exit message or callback
		742	on a per-process basis.
		743
		744	=item * Erlang tries to hide remote/local connections, AEMP does not.
		745
		746	Monitoring in Erlang is not an indicator of process death/crashes,
		747	as linking is (except linking is unreliable in Erlang).
		748
		749	In AEMP, you don't "look up" registered port names or send to named ports
		750	that might or might not be persistent. Instead, you normally spawn a port
		751	on the remote node. The init function monitors the you, and you monitor
		752	the remote port. Since both monitors are local to the node, they are much
		753	more reliable.
		754
		755	This also saves round-trips and avoids sending messages to the wrong port
		756	(hard to do in Erlang).
		757
651	=back	758	=back
652		759
653	=head1 SEE ALSO	760	=head1 SEE ALSO
654		761
655	L<AnyEvent>.	762	L<AnyEvent>.

Diff Legend

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

Comparing AnyEvent-MP/MP.pm (file contents): Revision 1.32 by root, Wed Aug 5 19:58:46 2009 UTC vs. Revision 1.37 by root, Fri Aug 7 16:47:23 2009 UTC

Diff Legend

Comparing AnyEvent-MP/MP.pm (file contents):
Revision 1.32 by root, Wed Aug 5 19:58:46 2009 UTC vs.
Revision 1.37 by root, Fri Aug 7 16:47:23 2009 UTC