ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent-MP/MP.pm
(Generate patch)

Comparing AnyEvent-MP/MP.pm (file contents):
Revision 1.78 by root, Thu Sep 3 20:16:36 2009 UTC vs.
Revision 1.87 by root, Fri Sep 11 02:32:23 2009 UTC

41 41
42 bin/aemp - stable. 42 bin/aemp - stable.
43 AnyEvent::MP - stable API, should work. 43 AnyEvent::MP - stable API, should work.
44 AnyEvent::MP::Intro - explains most concepts. 44 AnyEvent::MP::Intro - explains most concepts.
45 AnyEvent::MP::Kernel - mostly stable. 45 AnyEvent::MP::Kernel - mostly stable.
46 AnyEvent::MP::Global - stable API, protocol not yet final. 46 AnyEvent::MP::Global - stable but incomplete, protocol not yet final.
47 47
48 stay tuned. 48stay tuned.
49 49
50=head1 DESCRIPTION 50=head1 DESCRIPTION
51 51
52This module (-family) implements a simple message passing framework. 52This module (-family) implements a simple message passing framework.
53 53
61 61
62=over 4 62=over 4
63 63
64=item port 64=item port
65 65
66A port is something you can send messages to (with the C<snd> function). 66Not to be confused with a TCP port, a "port" is something you can send
67messages to (with the C<snd> function).
67 68
68Ports allow you to register C<rcv> handlers that can match all or just 69Ports allow you to register C<rcv> handlers that can match all or just
69some messages. Messages send to ports will not be queued, regardless of 70some messages. Messages send to ports will not be queued, regardless of
70anything was listening for them or not. 71anything was listening for them or not.
71 72
82 83
83Nodes are either public (have one or more listening ports) or private 84Nodes are either public (have one or more listening ports) or private
84(no listening ports). Private nodes cannot talk to other private nodes 85(no listening ports). Private nodes cannot talk to other private nodes
85currently. 86currently.
86 87
87=item node ID - C<[a-za-Z0-9_\-.:]+> 88=item node ID - C<[A-Z_][a-zA-Z0-9_\-.:]*>
88 89
89A node ID is a string that uniquely identifies the node within a 90A node ID is a string that uniquely identifies the node within a
90network. Depending on the configuration used, node IDs can look like a 91network. Depending on the configuration used, node IDs can look like a
91hostname, a hostname and a port, or a random string. AnyEvent::MP itself 92hostname, a hostname and a port, or a random string. AnyEvent::MP itself
92doesn't interpret node IDs in any way. 93doesn't interpret node IDs in any way.
96Nodes can only talk to each other by creating some kind of connection to 97Nodes can only talk to each other by creating some kind of connection to
97each other. To do this, nodes should listen on one or more local transport 98each other. To do this, nodes should listen on one or more local transport
98endpoints - binds. Currently, only standard C<ip:port> specifications can 99endpoints - binds. Currently, only standard C<ip:port> specifications can
99be used, which specify TCP ports to listen on. 100be used, which specify TCP ports to listen on.
100 101
101=item seeds - C<host:port> 102=item seed nodes
102 103
103When a node starts, it knows nothing about the network. To teach the node 104When a node starts, it knows nothing about the network. To teach the node
104about the network it first has to contact some other node within the 105about the network it first has to contact some other node within the
105network. This node is called a seed. 106network. This node is called a seed.
106 107
107Seeds are transport endpoint(s) of as many nodes as one wants. Those nodes 108Apart from the fact that other nodes know them as seed nodes and they have
109to have fixed listening addresses, seed nodes are perfectly normal nodes -
110any node can function as a seed node for others.
111
112In addition to discovering the network, seed nodes are also used to
113maintain the network and to connect nodes that otherwise would have
114trouble connecting. They form the backbone of an AnyEvent::MP network.
115
108are expected to be long-running, and at least one of those should always 116Seed nodes are expected to be long-running, and at least one seed node
109be available. When nodes run out of connections (e.g. due to a network 117should always be available. They should also be relatively responsive - a
110error), they try to re-establish connections to some seednodes again to 118seed node that blocks for long periods will slow down everybody else.
111join the network.
112 119
113Apart from being sued for seeding, seednodes are not special in any way - 120=item seeds - C<host:port>
114every public node can be a seednode. 121
122Seeds are transport endpoint(s) (usually a hostname/IP address and a
123TCP port) of nodes thta should be used as seed nodes.
124
125The nodes listening on those endpoints are expected to be long-running,
126and at least one of those should always be available. When nodes run out
127of connections (e.g. due to a network error), they try to re-establish
128connections to some seednodes again to join the network.
115 129
116=back 130=back
117 131
118=head1 VARIABLES/FUNCTIONS 132=head1 VARIABLES/FUNCTIONS
119 133
136our $VERSION = $AnyEvent::MP::Kernel::VERSION; 150our $VERSION = $AnyEvent::MP::Kernel::VERSION;
137 151
138our @EXPORT = qw( 152our @EXPORT = qw(
139 NODE $NODE *SELF node_of after 153 NODE $NODE *SELF node_of after
140 configure 154 configure
141 snd rcv mon mon_guard kil reg psub spawn 155 snd rcv mon mon_guard kil reg psub spawn cal
142 port 156 port
143); 157);
144 158
145our $SELF; 159our $SELF;
146 160
215L<AnyEvent::MP::Global> module, which will then use it to keep 229L<AnyEvent::MP::Global> module, which will then use it to keep
216connectivity with at least one node at any point in time. 230connectivity with at least one node at any point in time.
217 231
218=back 232=back
219 233
220Example: become a distributed node using the locla node name as profile. 234Example: become a distributed node using the local node name as profile.
221This should be the most common form of invocation for "daemon"-type nodes. 235This should be the most common form of invocation for "daemon"-type nodes.
222 236
223 configure 237 configure
224 238
225Example: become an anonymous node. This form is often used for commandline 239Example: become an anonymous node. This form is often used for commandline
474 488
475Monitor the given port and do something when the port is killed or 489Monitor the given port and do something when the port is killed or
476messages to it were lost, and optionally return a guard that can be used 490messages to it were lost, and optionally return a guard that can be used
477to stop monitoring again. 491to stop monitoring again.
478 492
493In the first form (callback), the callback is simply called with any
494number of C<@reason> elements (no @reason means that the port was deleted
495"normally"). Note also that I<< the callback B<must> never die >>, so use
496C<eval> if unsure.
497
498In the second form (another port given), the other port (C<$rcvport>)
499will be C<kil>'ed with C<@reason>, if a @reason was specified, i.e. on
500"normal" kils nothing happens, while under all other conditions, the other
501port is killed with the same reason.
502
503The third form (kill self) is the same as the second form, except that
504C<$rvport> defaults to C<$SELF>.
505
506In the last form (message), a message of the form C<@msg, @reason> will be
507C<snd>.
508
509Monitoring-actions are one-shot: once messages are lost (and a monitoring
510alert was raised), they are removed and will not trigger again.
511
512As a rule of thumb, monitoring requests should always monitor a port from
513a local port (or callback). The reason is that kill messages might get
514lost, just like any other message. Another less obvious reason is that
515even monitoring requests can get lost (for example, when the connection
516to the other node goes down permanently). When monitoring a port locally
517these problems do not exist.
518
479C<mon> effectively guarantees that, in the absence of hardware failures, 519C<mon> effectively guarantees that, in the absence of hardware failures,
480after starting the monitor, either all messages sent to the port will 520after starting the monitor, either all messages sent to the port will
481arrive, or the monitoring action will be invoked after possible message 521arrive, or the monitoring action will be invoked after possible message
482loss has been detected. No messages will be lost "in between" (after 522loss has been detected. No messages will be lost "in between" (after
483the first lost message no further messages will be received by the 523the first lost message no further messages will be received by the
484port). After the monitoring action was invoked, further messages might get 524port). After the monitoring action was invoked, further messages might get
485delivered again. 525delivered again.
486 526
487Note that monitoring-actions are one-shot: once messages are lost (and a 527Inter-host-connection timeouts and monitoring depend on the transport
488monitoring alert was raised), they are removed and will not trigger again. 528used. The only transport currently implemented is TCP, and AnyEvent::MP
529relies on TCP to detect node-downs (this can take 10-15 minutes on a
530non-idle connection, and usually around two hours for idle conenctions).
489 531
490In the first form (callback), the callback is simply called with any 532This means that monitoring is good for program errors and cleaning up
491number of C<@reason> elements (no @reason means that the port was deleted 533stuff eventually, but they are no replacement for a timeout when you need
492"normally"). Note also that I<< the callback B<must> never die >>, so use 534to ensure some maximum latency.
493C<eval> if unsure.
494
495In the second form (another port given), the other port (C<$rcvport>)
496will be C<kil>'ed with C<@reason>, if a @reason was specified, i.e. on
497"normal" kils nothing happens, while under all other conditions, the other
498port is killed with the same reason.
499
500The third form (kill self) is the same as the second form, except that
501C<$rvport> defaults to C<$SELF>.
502
503In the last form (message), a message of the form C<@msg, @reason> will be
504C<snd>.
505
506As a rule of thumb, monitoring requests should always monitor a port from
507a local port (or callback). The reason is that kill messages might get
508lost, just like any other message. Another less obvious reason is that
509even monitoring requests can get lost (for example, when the connection
510to the other node goes down permanently). When monitoring a port locally
511these problems do not exist.
512 535
513Example: call a given callback when C<$port> is killed. 536Example: call a given callback when C<$port> is killed.
514 537
515 mon $port, sub { warn "port died because of <@_>\n" }; 538 mon $port, sub { warn "port died because of <@_>\n" };
516 539
611the package, then the package above the package and so on (e.g. 634the package, then the package above the package and so on (e.g.
612C<MyApp::Chat::Server>, C<MyApp::Chat>, C<MyApp>) until the function 635C<MyApp::Chat::Server>, C<MyApp::Chat>, C<MyApp>) until the function
613exists or it runs out of package names. 636exists or it runs out of package names.
614 637
615The init function is then called with the newly-created port as context 638The init function is then called with the newly-created port as context
616object (C<$SELF>) and the C<@initdata> values as arguments. 639object (C<$SELF>) and the C<@initdata> values as arguments. It I<must>
640call one of the C<rcv> functions to set callbacks on C<$SELF>, otherwise
641the port might not get created.
617 642
618A common idiom is to pass a local port, immediately monitor the spawned 643A common idiom is to pass a local port, immediately monitor the spawned
619port, and in the remote init function, immediately monitor the passed 644port, and in the remote init function, immediately monitor the passed
620local port. This two-way monitoring ensures that both ports get cleaned up 645local port. This two-way monitoring ensures that both ports get cleaned up
621when there is a problem. 646when there is a problem.
622 647
648C<spawn> guarantees that the C<$initfunc> has no visible effects on the
649caller before C<spawn> returns (by delaying invocation when spawn is
650called for the local node).
651
623Example: spawn a chat server port on C<$othernode>. 652Example: spawn a chat server port on C<$othernode>.
624 653
625 # this node, executed from within a port context: 654 # this node, executed from within a port context:
626 my $server = spawn $othernode, "MyApp::Chat::Server::connect", $SELF; 655 my $server = spawn $othernode, "MyApp::Chat::Server::connect", $SELF;
627 mon $server; 656 mon $server;
641 670
642sub _spawn { 671sub _spawn {
643 my $port = shift; 672 my $port = shift;
644 my $init = shift; 673 my $init = shift;
645 674
675 # rcv will create the actual port
646 local $SELF = "$NODE#$port"; 676 local $SELF = "$NODE#$port";
647 eval { 677 eval {
648 &{ load_func $init } 678 &{ load_func $init }
649 }; 679 };
650 _self_die if $@; 680 _self_die if $@;
685 ? $action[0]() 715 ? $action[0]()
686 : snd @action; 716 : snd @action;
687 }; 717 };
688} 718}
689 719
720=item cal $port, @msg, $callback[, $timeout]
721
722A simple form of RPC - sends a message to the given C<$port> with the
723given contents (C<@msg>), but adds a reply port to the message.
724
725The reply port is created temporarily just for the purpose of receiving
726the reply, and will be C<kil>ed when no longer needed.
727
728A reply message sent to the port is passed to the C<$callback> as-is.
729
730If an optional time-out (in seconds) is given and it is not C<undef>,
731then the callback will be called without any arguments after the time-out
732elapsed and the port is C<kil>ed.
733
734If no time-out is given, then the local port will monitor the remote port
735instead, so it eventually gets cleaned-up.
736
737Currently this function returns the temporary port, but this "feature"
738might go in future versions unless you can make a convincing case that
739this is indeed useful for something.
740
741=cut
742
743sub cal(@) {
744 my $timeout = ref $_[-1] ? undef : pop;
745 my $cb = pop;
746
747 my $port = port {
748 undef $timeout;
749 kil $SELF;
750 &$cb;
751 };
752
753 if (defined $timeout) {
754 $timeout = AE::timer $timeout, 0, sub {
755 undef $timeout;
756 kil $port;
757 $cb->();
758 };
759 } else {
760 mon $_[0], sub {
761 kil $port;
762 $cb->();
763 };
764 }
765
766 push @_, $port;
767 &snd;
768
769 $port
770}
771
690=back 772=back
691 773
692=head1 AnyEvent::MP vs. Distributed Erlang 774=head1 AnyEvent::MP vs. Distributed Erlang
693 775
694AnyEvent::MP got lots of its ideas from distributed Erlang (Erlang node 776AnyEvent::MP got lots of its ideas from distributed Erlang (Erlang node
846L<AnyEvent::MP::Kernel> - more, lower-level, stuff. 928L<AnyEvent::MP::Kernel> - more, lower-level, stuff.
847 929
848L<AnyEvent::MP::Global> - network maintainance and port groups, to find 930L<AnyEvent::MP::Global> - network maintainance and port groups, to find
849your applications. 931your applications.
850 932
933L<AnyEvent::MP::LogCatcher> - simple service to display log messages from
934all nodes.
935
851L<AnyEvent>. 936L<AnyEvent>.
852 937
853=head1 AUTHOR 938=head1 AUTHOR
854 939
855 Marc Lehmann <schmorp@schmorp.de> 940 Marc Lehmann <schmorp@schmorp.de>

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines