AnyEvent-MP/MP/Node.pm

=head1 NAME

AnyEvent::MP::Node - a single processing node (CPU/process...)

=head1 SYNOPSIS

   use AnyEvent::MP::Node;

=head1 DESCRIPTION

=cut

package AnyEvent::MP::Node;

use common::sense;

use AE ();
use AnyEvent::Util ();
use AnyEvent::Socket ();

use AnyEvent::MP::Transport ();

use base Exporter::;

our $VERSION = '0.0';

sub new {
   my ($class, $noderef) = @_;

   bless { noderef => $noderef }, $class
}

package AnyEvent::MP::Node::Direct;

use base "AnyEvent::MP::Node";

sub send {
   my ($self, $msg) = @_;

   if ($self->{transport}) {
      $self->{transport}->send ($msg);
   } elsif ($self->{queue}) {
      push @{ $self->{queue} }, $msg;
   } else {
      $self->{queue} = [$msg];
      $self->connect;
   }
}

sub kill {
   my ($self, $port, @reason) = @_;

   $self->send (["", kil => $port, @reason]);
}

sub monitor {
   my ($self, $portid, $cb) = @_;

   return $cb->("node failed conenction")
      if $self->{failed};

   my $list = $self->{lmon}{$portid} ||= [];

   $self->send (["", mon1 => $portid])
      unless @$list;

   push @$list, $cb;
}

sub unmonitor {
   my ($self, $portid, $cb) = @_;

   my $list = $self->{lmon}{$portid}
      or return;

   @$list = grep $_ != $cb, @$list;

   unless (@$list) {
      $self->send (["", mon0 => $portid]);
      delete $self->{monitor}{$portid};
   }
}

sub set_transport {
   my ($self, $transport) = @_;

   $self->clr_transport
      if $self->{transport};

   if (
      exists $self->{remote_uniq}
      && $self->{remote_uniq} ne $transport->{remote_uniq}
   ) {
      # uniq changed, different node
      $self->fail ("node restart detected");
   }

   delete $self->{trial};
   delete $self->{next_connect};
   delete $self->{failed};

   $self->{remote_uniq} = $transport->{remote_uniq};
   $self->{transport}   = $transport;

   $transport->send ($_)
      for @{ delete $self->{queue} || [] };
}

sub fail {
   my ($self, @reason) = @_;

   delete $self->{queue};

   $self->{failed} = 1;

   if (my $mon = delete $self->{lmon}) {
      $_->(@reason) for map @$_, values %$mon;
   }
}

sub clr_transport {
   my ($self, @reason) = @_;

   delete $self->{transport};
   $self->connect;
}

sub connect {
   my ($self) = @_;

   Scalar::Util::weaken $self;

   $self->{retry} ||= [split /,/, $self->{noderef}];

   my $endpoint = shift @{ $self->{retry} };

   if (defined $endpoint) {
      $self->{trial}{$endpoint} ||= do {
         my ($host, $port) = AnyEvent::Socket::parse_hostport $endpoint
            or return $AnyEvent::MP::Base::WARN->("$self->{noderef}: not a resolved node reference.");

         my ($w, $g);

         $w = AE::timer $AnyEvent::MP::Base::CONNECT_TIMEOUT, 0, sub {
            delete $self->{trial}{$endpoint};
         };
         $g = AnyEvent::MP::Transport::mp_connect
            $host, $port,
            sub {
               delete $self->{trial}{$endpoint}
                  unless @_;
               $g = shift;
            };
         ;

         [$w, \$g]
      };
   } else {
      delete $self->{retry};
      $self->fail (transport_error => $self->{noderef}, "unable to connect");
   }

   $self->{next_connect} = AE::timer $AnyEvent::MP::Base::CONNECT_INTERVAL, 0, sub {
      $self->connect;
   };
}

package AnyEvent::MP::Node::Self;

use base "AnyEvent::MP::Node";

sub set_transport {
   die "FATAL error, set_transport was called";
}

sub send {
   local $AnyEvent::MP::Base::SRCNODE = $_[0];
   AnyEvent::MP::Base::_inject (@{ $_[1] });
}

sub kill {
   my ($self, $port, @reason) = @_;

   delete $AnyEvent::MP::Base::PORT{$port};
   delete $AnyEvent::MP::Base::PORT_DATA{$port};

   my $mon = delete $AnyEvent::MP::Base::LMON{$port}
      or !@reason
      or $AnyEvent::MP::Base::WARN->("unmonitored local port $port died with reason: @reason");

   $_->(@reason) for values %$mon;
}

sub monitor {
   my ($self, $portid, $cb) = @_;

   return $cb->()
      unless exists $AnyEvent::MP::Base::PORT{$portid};

   $AnyEvent::MP::Base::LMON{$portid}{$cb+0} = $cb;
}

sub unmonitor {
   my ($self, $portid, $cb) = @_;

   delete $AnyEvent::MP::Base::LMON{$portid}{$cb+0};
}

=head1 SEE ALSO

L<AnyEvent>.

=head1 AUTHOR

 Marc Lehmann <schmorp@schmorp.de>
 http://home.schmorp.de/

=cut

1

Revision:	1.10
Committed:	Tue Aug 4 23:35:51 2009 UTC (17 years, 1 month ago) by root
Branch:	MAIN
Changes since 1.9:	+1 -0 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	=head1 NAME
2
3			AnyEvent::MP::Node - a single processing node (CPU/process...)
4
5			=head1 SYNOPSIS
6
7			use AnyEvent::MP::Node;
8
9			=head1 DESCRIPTION
10
11			=cut
12
13			package AnyEvent::MP::Node;
14
15			use common::sense;
16
17			use AE ();
18	root	1.6	use AnyEvent::Util ();
19	root	1.1	use AnyEvent::Socket ();
20
21			use AnyEvent::MP::Transport ();
22
23			use base Exporter::;
24
25			our $VERSION = '0.0';
26
27			sub new {
28			my ($class, $noderef) = @_;
29
30			bless { noderef => $noderef }, $class
31			}
32
33			package AnyEvent::MP::Node::Direct;
34
35			use base "AnyEvent::MP::Node";
36
37			sub send {
38			my ($self, $msg) = @_;
39
40			if ($self->{transport}) {
41			$self->{transport}->send ($msg);
42			} elsif ($self->{queue}) {
43			push @{ $self->{queue} }, $msg;
44			} else {
45			$self->{queue} = [$msg];
46			$self->connect;
47			}
48			}
49
50	root	1.7	sub kill {
51			my ($self, $port, @reason) = @_;
52
53			$self->send (["", kil => $port, @reason]);
54			}
55
56	root	1.6	sub monitor {
57			my ($self, $portid, $cb) = @_;
58
59	root	1.8	return $cb->("node failed conenction")
60	root	1.6	if $self->{failed};
61
62			my $list = $self->{lmon}{$portid} \|\|= [];
63
64			$self->send (["", mon1 => $portid])
65			unless @$list;
66
67			push @$list, $cb;
68			}
69
70			sub unmonitor {
71			my ($self, $portid, $cb) = @_;
72
73			my $list = $self->{lmon}{$portid}
74			or return;
75
76			@$list = grep $_ != $cb, @$list;
77
78			unless (@$list) {
79			$self->send (["", mon0 => $portid]);
80			delete $self->{monitor}{$portid};
81			}
82			}
83
84	root	1.1	sub set_transport {
85			my ($self, $transport) = @_;
86
87	root	1.6	$self->clr_transport
88			if $self->{transport};
89
90	root	1.1	if (
91			exists $self->{remote_uniq}
92			&& $self->{remote_uniq} ne $transport->{remote_uniq}
93			) {
94	root	1.8	# uniq changed, different node
95			$self->fail ("node restart detected");
96	root	1.1	}
97
98	root	1.8	delete $self->{trial};
99			delete $self->{next_connect};
100			delete $self->{failed};
101
102	root	1.1	$self->{remote_uniq} = $transport->{remote_uniq};
103			$self->{transport} = $transport;
104
105			$transport->send ($_)
106			for @{ delete $self->{queue} \|\| [] };
107			}
108
109	root	1.8	sub fail {
110			my ($self, @reason) = @_;
111
112			delete $self->{queue};
113	root	1.1
114	root	1.6	$self->{failed} = 1;
115
116	root	1.8	if (my $mon = delete $self->{lmon}) {
117			$_->(@reason) for map @$_, values %$mon;
118	root	1.6	}
119	root	1.8	}
120
121			sub clr_transport {
122			my ($self, @reason) = @_;
123	root	1.4
124	root	1.8	delete $self->{transport};
125	root	1.4	$self->connect;
126	root	1.1	}
127
128			sub connect {
129			my ($self) = @_;
130
131			Scalar::Util::weaken $self;
132
133	root	1.9	$self->{retry} \|\|= [split /,/, $self->{noderef}];
134	root	1.1
135			my $endpoint = shift @{ $self->{retry} };
136
137			if (defined $endpoint) {
138			$self->{trial}{$endpoint} \|\|= do {
139			my ($host, $port) = AnyEvent::Socket::parse_hostport $endpoint
140	root	1.9	or return $AnyEvent::MP::Base::WARN->("$self->{noderef}: not a resolved node reference.");
141	root	1.1
142			my ($w, $g);
143
144	root	1.5	$w = AE::timer $AnyEvent::MP::Base::CONNECT_TIMEOUT, 0, sub {
145	root	1.1	delete $self->{trial}{$endpoint};
146			};
147			$g = AnyEvent::MP::Transport::mp_connect
148			$host, $port,
149			sub {
150			delete $self->{trial}{$endpoint}
151			unless @_;
152			$g = shift;
153			};
154			;
155
156			[$w, \$g]
157			};
158			} else {
159			delete $self->{retry};
160	root	1.10	$self->fail (transport_error => $self->{noderef}, "unable to connect");
161	root	1.1	}
162
163	root	1.5	$self->{next_connect} = AE::timer $AnyEvent::MP::Base::CONNECT_INTERVAL, 0, sub {
164	root	1.1	$self->connect;
165			};
166			}
167
168			package AnyEvent::MP::Node::Self;
169
170			use base "AnyEvent::MP::Node";
171
172			sub set_transport {
173			die "FATAL error, set_transport was called";
174			}
175
176			sub send {
177	root	1.6	local $AnyEvent::MP::Base::SRCNODE = $_[0];
178			AnyEvent::MP::Base::_inject (@{ $_[1] });
179			}
180
181	root	1.7	sub kill {
182			my ($self, $port, @reason) = @_;
183
184			delete $AnyEvent::MP::Base::PORT{$port};
185	root	1.8	delete $AnyEvent::MP::Base::PORT_DATA{$port};
186	root	1.7
187			my $mon = delete $AnyEvent::MP::Base::LMON{$port}
188	root	1.8	or !@reason
189			or $AnyEvent::MP::Base::WARN->("unmonitored local port $port died with reason: @reason");
190	root	1.7
191			$_->(@reason) for values %$mon;
192			}
193
194	root	1.6	sub monitor {
195			my ($self, $portid, $cb) = @_;
196
197			return $cb->()
198			unless exists $AnyEvent::MP::Base::PORT{$portid};
199
200			$AnyEvent::MP::Base::LMON{$portid}{$cb+0} = $cb;
201			}
202
203			sub unmonitor {
204			my ($self, $portid, $cb) = @_;
205
206			delete $AnyEvent::MP::Base::LMON{$portid}{$cb+0};
207	root	1.1	}
208
209			=head1 SEE ALSO
210
211			L<AnyEvent>.
212
213			=head1 AUTHOR
214
215			Marc Lehmann <schmorp@schmorp.de>
216			http://home.schmorp.de/
217
218			=cut
219
220			1
221