POE/Component/LookupClient.pm

## ------------------------------------------------------------------------
##  $Id: LookupClient.pm,v 1.2 2003/07/01 13:05:01 joko Exp $
## ------------------------------------------------------------------------
##  $Log: LookupClient.pm,v $
##  Revision 1.2  2003/07/01 13:05:01  joko
##  major changes, tried to clean up shutdown phase - the watchdog-mech didn't work out well..... - what's about IKC's monitor? does it work on Linux?
##
##  Revision 1.1  2003/06/29 01:35:29  joko
##  initial commit
##
## ------------------------------------------------------------------------


package POE::Component::LookupClient;

use strict;
use warnings;

use POE qw( Session Component::IKC::Client );
use Data::Dumper;


sub new {
  my $classname = shift;
  my @args = @_;
  
  my $self = {};
  bless $self, $classname;

  $self->{options} = { @args };

  #my $event_handler = lookupd->new();
  POE::Session->create( 
    object_states => [
      $self => [qw( _start _stop boot_intercom start_session waste_time watchdog )]
    ]
  );

}

# This is not a POE method. It's a plain OO one.
sub debug {
  my $self = shift;
  my $msg = shift;
  $msg ||= '';
  print STDERR __PACKAGE__ . ": " . $msg, "\n";
}

# Controller's event handlers

sub _start {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("_start");
  
  #$kernel->alias_set("controller");

  #$kernel->post( controller => 'start_daemon' );
  #$kernel->yield( 'boot_storage' );
  $kernel->yield( 'boot_intercom' );
  #$_[HEAP]->{subsession} = POE::Session->create( inline_states => { _start => sub { print "WORKER!", "\n"; } } );
  #$_[HEAP]->{subsession}->yield(

};

sub _stop {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("_stop");
};

sub boot_intercom {

  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("boot_intercom");

  # Client component - encapsulates some session(s) and/or wheel(s)?
  
  $self->{options}->{host} ||= "localhost";
  $self->{options}->{port} ||= 30;
  
  #create_ikc_client( host => $host, port => 30, name => 'Client', on_connect => $self->{options}->{on_connect} );
  create_ikc_client( 
    host => $self->{options}->{host}, 
    port => $self->{options}->{port}, 
    #name => 'Client', 
    #on_connect => sub { $self->build(); },
    on_connect => sub { $self->build(); },
    #subscribe => [qw( poe://LookupService/ServiceRegistrar )],
    #subscribe => [qw( poe://LookupService/ServiceRegistrar )],
  );
  
  #$kernel->post( IKC => 'monitor', '*' => { register => 'start_session' });
  #$kernel->post( IKC => 'monitor', 'LookupService' => { register => 'start_session' });
  #$kernel->post( IKC => 'subscribe', [qw( poe://LookupService/ServiceRegistrar )], 'poe:start_session' );
  
  # start up the watchdog which monitors the required IKC intercom session
  #$kernel->yield('waste_time');
  #$kernel->delay('watchdog', 2);

};

sub start_session {
  #my $self = shift;
  print STDERR "start_session", "\n";
}

sub build {
  my $self = shift;
  print "build", "\n";
  # create sessions that depend on the foreign kernel.
  POE::Component::LookupClient::Session->new();
}

sub watchdog {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("watchdog");

  #$kernel->post( IKC => 'monitor', '*' => { register => 'start_session' });

  #if (not defined $kernel->alias_resolve('DeviceClient')) {
  if (not defined $kernel->alias_resolve('IKC')) {
    print STDERR "Session died, trying to restart!", "\n";
    #$kernel->yield('boot_intercom');
    return;
  }
  
  $kernel->delay('watchdog', 2);
};

#------------------------------------------------------------------------------
# This event keeps this POE kernel alive.
# (stolen from POE::Component::IKC::Server, but not used 'til now...)
sub waste_time {
    my($kernel, $heap)=@_[KERNEL, HEAP];
    return if $heap->{'is a child'};

    unless($heap->{'been told we are parent'}) {
        warn "$$: Telling everyone we are the parent\n";
        $heap->{'been told we are parent'}=1;
        $kernel->signal($kernel, '__parent');
    }
    if($heap->{'die'}) {
        #DEBUG and warn "$$: Orderly shutdown\n";
    } else {
        $kernel->yield('watchdog');
        $kernel->delay('waste_time', 60);
    }
    return;
}


package POE::Component::LookupClient::Session;

use strict;
use warnings;

use POE qw( Session );
use Data::Dumper;


sub new {
  my $classname = shift;
  my @args = @_;
  
  my $self = {};
  bless $self, $classname;

  $self->{options} = { @args };

  POE::Session->create( 
    object_states => [
      $self => [qw( _start _stop on_response on_subscribe register_lease renew_lease remote_shutdown remote_timeout )]
    ]
  );

}


# This is not a POE method. It's a plain OO one.
sub debug {
  my $self = shift;
  my $msg = shift;
  $msg ||= '';
  print STDERR __PACKAGE__ . ": " . $msg, "\n";
}

# Controller's event handlers

sub _start {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("_start");

  #$kernel->alias_set('');
  #$kernel->post();
  
  # set up communication channel for asynchronous responses
  $kernel->alias_set('DeviceClient');
  $kernel->post('IKC', 'publish', 'DeviceClient', [qw( on_response )]);

  #$kernel->post( IKC => 'subscribe', [qw( poe://LookupService/ServiceRegistrar )], 'poe:start_session' );

  $kernel->post( IKC => 'subscribe', [qw( poe://LookupService/ServiceRegistrar )], 'on_subscribe' );

  # try to register on startup?
  #$kernel->yield('register_lease');
  
};

sub _stop {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("_stop");

  # try to re-register if session dies?
  #$kernel->yield('register_lease');
  
  #$kernel->alias_remove('DeviceClient');

  #$self = undef;
};


# Subscription receipt callback, see "perldoc POE::Component::IKC::Responder".
sub on_subscribe {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("on_subscribe");
  # register lease on subscription
  $kernel->yield('register_lease');
}

# Main response dispatcher, this should dispatch to local states programmatically.
sub on_response {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  #$self->debug("response");
  
  $heap->{'cancel timeout'} = 1;
  
  my $payload = $_[ARG0];
  $payload ||= '';
  
  # If registration succeeded, start the renewal cycle.
  if ($payload eq 'REG_OK') {
    $self->debug("Starting lease renewal loop.");
    #$kernel->post( IKC => 'monitor', '*' => { shutdown => 'remote_shutdown' });
    $kernel->yield( 'renew_lease' );

  } elsif ($payload eq 'LEASE_OK') {
    $self->debug("Received 'LEASE_OK'.");
    #$kernel->yield( 'renew_lease' );

  # 1. otherwise dump anything sent to us for debugging purposes
  # 2. destroy lease in any case on unknown payload
  } else {
    #print Dumper($payload);
    $heap->{'destroy lease'} = 1;
    #$kernel->alarm_remove_all();
  
  }
  
};

sub register_lease {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("register_lease");
  
  my $ONE_arg = "Hello World!";
  
  # V1 - without subscription
  #$kernel->post('IKC', 'post', "poe://LookupService/ServiceRegistrar/register_lease", $ONE_arg);
  # V2 - with subscription
  $kernel->post( "poe://LookupService/ServiceRegistrar", "register_lease", $ONE_arg );
}

sub renew_lease {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  
  if ($heap->{'destroy lease'}) {
    #$heap->{'destroy lease'} = 0;
    #$kernel->delay_set('remote_timeout');
    $self->debug("destroyed lease");
    #undef $self;
    #$kernel->alias_remove('DeviceClient');
    #undef $_[SESSION];
    #$kernel->post( 'IKC' => 'shutdown' );
    # clear delayed posts
    #$kernel->delay('renew_lease');
    #$kernel->delay('remote_timeout');
    return;
  }
  
  $self->debug("renew_lease");

  # check if remote kernel(s) are still around
  #$kernel->post('IKC', 'call', 'poe://LookupService/IKC/ping', '', 'poe:remote_timeout');
  #$kernel->post('IKC', 'call', 'poe://LookupService/IKC/ping', undef, 'poe:remote_timeout');
  #$kernel->post('poe://remote/IKC', 'ping', 'poe:remote_timeout');
  #$kernel->delay('remote_timeout', 5);   # timeout

  my $ONE_arg = '';
  #$kernel->post('IKC', 'post', "poe://LookupService/ServiceRegistrar/renew_lease", $ONE_arg);
  # V1 - without subscription
  $kernel->post('IKC', 'call', "poe://LookupService/ServiceRegistrar/renew_lease", $ONE_arg, 'poe:on_response');
  
  # V2 - with subscription
  #my $resp = $kernel->call( "poe://LookupService/ServiceRegistrar", "renew_lease", $ONE_arg);
  #print $resp, "\n";

  # V3 - have we been able to post?
  #my $resp = $kernel->call('IKC', 'call', "poe://LookupService/ServiceRegistrar/renew_lease", $ONE_arg, 'poe:response');
  #print "resp: $resp", "\n";

  # and again...
  $kernel->delay('renew_lease', 15);
  #$kernel->delay_set('renew_lease', 15);
  #$kernel->delay_add('renew_lease', 15);

  # timeout!?
  #$kernel->delay('remote_timeout', 20);
  $kernel->delay_add('remote_timeout', 20);
  #$kernel->delay_set('remote_timeout', 5);
  #$kernel->delay_set('remote_timeout', 20);

}

sub remote_shutdown {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("remote_shutdown");
}

sub remote_timeout {
  
  #my ($pong) = $_[ARG0];
  #return if $pong;            # all is cool
  
  my ($self, $kernel, $heap) = @_[OBJECT, KERNEL, HEAP];

#=pod
  if ($heap->{'cancel timeout'}) {
    $heap->{'cancel timeout'} = 0;
    return;
  }
#=cut

  $self->debug("remote_timeout");

  $heap->{'destroy lease'} = 1;

  # YOW!  Remote kernel timed out.  RUN AROUND SCREAMING!
  print STDERR "# YOW!  Remote kernel timed out.  RUN AROUND SCREAMING!", "\n";

  # free all resources that keep this session running
  $kernel->delay('renew_lease');
  $kernel->delay('remote_timeout');
  
  #$kernel->post( 'IKC' => 'shutdown' );
  
  #$kernel->alias_remove('DeviceClient');

  #$kernel->alias_remove('DeviceClient');
  #$kernel->yield('renew_lease');

  #sub POE::Component::IKC::Responder::DEBUG { return 1; }
  #$kernel->post( 'IKC' => 'unregister' );
  
  #print Dumper($kernel->alias_list());

  $kernel->post( IKC => 'retract', 'DeviceClient' => [qw( on_response )]);
  #$kernel->post( IKC => 'retract', 'me' => [qw( on_response )]);
  $kernel->post( IKC => 'unsubscribe', [qw( poe://LookupService/ServiceRegistrar )]);
  $kernel->post( IKC => 'unregister', [qw( poe://LookupService )]);
  #$kernel->post( IKC => 'unsubscribe', [qw( poe://me )]);
  #$kernel->post( IKC => 'unregister', [qw( poe://me )]);
  #$kernel->run_one_timeslice();
  #$kernel->run_one_timeslice();
  #$kernel->run_one_timeslice();
  #return;
  
  $kernel->post( 'IKC' => 'shutdown' );
  #$kernel->run_one_timeslice();
  #$kernel->run_one_timeslice();

  $kernel->alias_remove('DeviceClient');
  #$kernel->run_one_timeslice();
  #$kernel->run_one_timeslice();

}

1;
__END__
1	joko	1.1	## ------------------------------------------------------------------------
2	joko	1.3	## $Id: LookupClient.pm,v 1.2 2003/07/01 13:05:01 joko Exp $
3	joko	1.1	## ------------------------------------------------------------------------
4	joko	1.2	## $Log: LookupClient.pm,v $
5	joko	1.3	## Revision 1.2 2003/07/01 13:05:01 joko
6			## major changes, tried to clean up shutdown phase - the watchdog-mech didn't work out well..... - what's about IKC's monitor? does it work on Linux?
7			##
8	joko	1.2	## Revision 1.1 2003/06/29 01:35:29 joko
9			## initial commit
10			##
11	joko	1.1	## ------------------------------------------------------------------------
12
13
14			package POE::Component::LookupClient;
15
16			use strict;
17			use warnings;
18
19			use POE qw( Session Component::IKC::Client );
20			use Data::Dumper;
21
22
23			sub new {
24			my $classname = shift;
25			my @args = @_;
26
27			my $self = {};
28			bless $self, $classname;
29
30			$self->{options} = { @args };
31
32			#my $event_handler = lookupd->new();
33			POE::Session->create(
34			object_states => [
35	joko	1.2	$self => [qw( _start _stop boot_intercom start_session waste_time watchdog )]
36	joko	1.1	]
37			);
38
39			}
40
41			# This is not a POE method. It's a plain OO one.
42			sub debug {
43			my $self = shift;
44			my $msg = shift;
45			$msg \|\|= '';
46			print STDERR __PACKAGE__ . ": " . $msg, "\n";
47			}
48
49			# Controller's event handlers
50
51			sub _start {
52			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
53			$self->debug("_start");
54
55			#$kernel->alias_set("controller");
56
57			#$kernel->post( controller => 'start_daemon' );
58			#$kernel->yield( 'boot_storage' );
59			$kernel->yield( 'boot_intercom' );
60			#$_[HEAP]->{subsession} = POE::Session->create( inline_states => { _start => sub { print "WORKER!", "\n"; } } );
61			#$_[HEAP]->{subsession}->yield(
62
63			};
64
65			sub _stop {
66			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
67			$self->debug("_stop");
68			};
69
70			sub boot_intercom {
71
72			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
73			$self->debug("boot_intercom");
74
75			# Client component - encapsulates some session(s) and/or wheel(s)?
76
77	joko	1.3	$self->{options}->{host} \|\|= "localhost";
78			$self->{options}->{port} \|\|= 30;
79
80	joko	1.1	#create_ikc_client( host => $host, port => 30, name => 'Client', on_connect => $self->{options}->{on_connect} );
81			create_ikc_client(
82	joko	1.3	host => $self->{options}->{host},
83			port => $self->{options}->{port},
84	joko	1.2	#name => 'Client',
85			#on_connect => sub { $self->build(); },
86	joko	1.1	on_connect => sub { $self->build(); },
87	joko	1.2	#subscribe => [qw( poe://LookupService/ServiceRegistrar )],
88			#subscribe => [qw( poe://LookupService/ServiceRegistrar )],
89			);
90
91			#$kernel->post( IKC => 'monitor', '*' => { register => 'start_session' });
92			#$kernel->post( IKC => 'monitor', 'LookupService' => { register => 'start_session' });
93			#$kernel->post( IKC => 'subscribe', [qw( poe://LookupService/ServiceRegistrar )], 'poe:start_session' );
94
95			# start up the watchdog which monitors the required IKC intercom session
96			#$kernel->yield('waste_time');
97			#$kernel->delay('watchdog', 2);
98	joko	1.1
99			};
100
101	joko	1.2	sub start_session {
102			#my $self = shift;
103			print STDERR "start_session", "\n";
104			}
105
106	joko	1.1	sub build {
107			my $self = shift;
108	joko	1.2	print "build", "\n";
109	joko	1.1	# create sessions that depend on the foreign kernel.
110			POE::Component::LookupClient::Session->new();
111			}
112
113	joko	1.2	sub watchdog {
114			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
115			$self->debug("watchdog");
116
117			#$kernel->post( IKC => 'monitor', '*' => { register => 'start_session' });
118
119			#if (not defined $kernel->alias_resolve('DeviceClient')) {
120			if (not defined $kernel->alias_resolve('IKC')) {
121			print STDERR "Session died, trying to restart!", "\n";
122			#$kernel->yield('boot_intercom');
123			return;
124			}
125
126			$kernel->delay('watchdog', 2);
127			};
128
129			#------------------------------------------------------------------------------
130			# This event keeps this POE kernel alive.
131			# (stolen from POE::Component::IKC::Server, but not used 'til now...)
132			sub waste_time {
133			my($kernel, $heap)=@_[KERNEL, HEAP];
134			return if $heap->{'is a child'};
135
136			unless($heap->{'been told we are parent'}) {
137			warn "$$: Telling everyone we are the parent\n";
138			$heap->{'been told we are parent'}=1;
139			$kernel->signal($kernel, '__parent');
140			}
141			if($heap->{'die'}) {
142			#DEBUG and warn "$$: Orderly shutdown\n";
143			} else {
144			$kernel->yield('watchdog');
145			$kernel->delay('waste_time', 60);
146			}
147			return;
148			}
149
150
151	joko	1.1
152
153			package POE::Component::LookupClient::Session;
154
155			use strict;
156			use warnings;
157
158			use POE qw( Session );
159			use Data::Dumper;
160
161
162			sub new {
163			my $classname = shift;
164			my @args = @_;
165
166			my $self = {};
167			bless $self, $classname;
168
169			$self->{options} = { @args };
170
171			POE::Session->create(
172			object_states => [
173	joko	1.2	$self => [qw( _start _stop on_response on_subscribe register_lease renew_lease remote_shutdown remote_timeout )]
174	joko	1.1	]
175			);
176
177			}
178
179
180			# This is not a POE method. It's a plain OO one.
181			sub debug {
182			my $self = shift;
183			my $msg = shift;
184			$msg \|\|= '';
185			print STDERR __PACKAGE__ . ": " . $msg, "\n";
186			}
187
188			# Controller's event handlers
189
190			sub _start {
191			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
192			$self->debug("_start");
193
194			#$kernel->alias_set('');
195			#$kernel->post();
196
197			# set up communication channel for asynchronous responses
198			$kernel->alias_set('DeviceClient');
199	joko	1.2	$kernel->post('IKC', 'publish', 'DeviceClient', [qw( on_response )]);
200
201			#$kernel->post( IKC => 'subscribe', [qw( poe://LookupService/ServiceRegistrar )], 'poe:start_session' );
202
203			$kernel->post( IKC => 'subscribe', [qw( poe://LookupService/ServiceRegistrar )], 'on_subscribe' );
204
205			# try to register on startup?
206			#$kernel->yield('register_lease');
207	joko	1.1
208			};
209
210			sub _stop {
211			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
212			$self->debug("_stop");
213	joko	1.2
214			# try to re-register if session dies?
215			#$kernel->yield('register_lease');
216
217			#$kernel->alias_remove('DeviceClient');
218
219			#$self = undef;
220	joko	1.1	};
221
222	joko	1.2
223			# Subscription receipt callback, see "perldoc POE::Component::IKC::Responder".
224			sub on_subscribe {
225			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
226			$self->debug("on_subscribe");
227			# register lease on subscription
228			$kernel->yield('register_lease');
229			}
230
231	joko	1.1	# Main response dispatcher, this should dispatch to local states programmatically.
232	joko	1.2	sub on_response {
233	joko	1.1	my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
234			#$self->debug("response");
235
236	joko	1.2	$heap->{'cancel timeout'} = 1;
237
238	joko	1.1	my $payload = $_[ARG0];
239			$payload \|\|= '';
240
241			# If registration succeeded, start the renewal cycle.
242			if ($payload eq 'REG_OK') {
243	joko	1.2	$self->debug("Starting lease renewal loop.");
244			#$kernel->post( IKC => 'monitor', '*' => { shutdown => 'remote_shutdown' });
245	joko	1.1	$kernel->yield( 'renew_lease' );
246
247			} elsif ($payload eq 'LEASE_OK') {
248			$self->debug("Received 'LEASE_OK'.");
249			#$kernel->yield( 'renew_lease' );
250
251			# 1. otherwise dump anything sent to us for debugging purposes
252			# 2. destroy lease in any case on unknown payload
253			} else {
254			#print Dumper($payload);
255			$heap->{'destroy lease'} = 1;
256	joko	1.2	#$kernel->alarm_remove_all();
257	joko	1.1
258			}
259
260			};
261
262			sub register_lease {
263			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
264			$self->debug("register_lease");
265	joko	1.2
266	joko	1.1	my $ONE_arg = "Hello World!";
267
268			# V1 - without subscription
269			#$kernel->post('IKC', 'post', "poe://LookupService/ServiceRegistrar/register_lease", $ONE_arg);
270			# V2 - with subscription
271	joko	1.2	$kernel->post( "poe://LookupService/ServiceRegistrar", "register_lease", $ONE_arg );
272	joko	1.1	}
273
274			sub renew_lease {
275			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
276
277			if ($heap->{'destroy lease'}) {
278	joko	1.2	#$heap->{'destroy lease'} = 0;
279			#$kernel->delay_set('remote_timeout');
280	joko	1.1	$self->debug("destroyed lease");
281	joko	1.2	#undef $self;
282			#$kernel->alias_remove('DeviceClient');
283			#undef $_[SESSION];
284			#$kernel->post( 'IKC' => 'shutdown' );
285			# clear delayed posts
286			#$kernel->delay('renew_lease');
287			#$kernel->delay('remote_timeout');
288	joko	1.1	return;
289			}
290
291			$self->debug("renew_lease");
292	joko	1.2
293			# check if remote kernel(s) are still around
294			#$kernel->post('IKC', 'call', 'poe://LookupService/IKC/ping', '', 'poe:remote_timeout');
295			#$kernel->post('IKC', 'call', 'poe://LookupService/IKC/ping', undef, 'poe:remote_timeout');
296			#$kernel->post('poe://remote/IKC', 'ping', 'poe:remote_timeout');
297			#$kernel->delay('remote_timeout', 5); # timeout
298
299	joko	1.1	my $ONE_arg = '';
300			#$kernel->post('IKC', 'post', "poe://LookupService/ServiceRegistrar/renew_lease", $ONE_arg);
301			# V1 - without subscription
302	joko	1.2	$kernel->post('IKC', 'call', "poe://LookupService/ServiceRegistrar/renew_lease", $ONE_arg, 'poe:on_response');
303
304	joko	1.1	# V2 - with subscription
305			#my $resp = $kernel->call( "poe://LookupService/ServiceRegistrar", "renew_lease", $ONE_arg);
306			#print $resp, "\n";
307	joko	1.2
308			# V3 - have we been able to post?
309			#my $resp = $kernel->call('IKC', 'call', "poe://LookupService/ServiceRegistrar/renew_lease", $ONE_arg, 'poe:response');
310			#print "resp: $resp", "\n";
311
312	joko	1.1	# and again...
313			$kernel->delay('renew_lease', 15);
314	joko	1.2	#$kernel->delay_set('renew_lease', 15);
315			#$kernel->delay_add('renew_lease', 15);
316
317			# timeout!?
318			#$kernel->delay('remote_timeout', 20);
319			$kernel->delay_add('remote_timeout', 20);
320			#$kernel->delay_set('remote_timeout', 5);
321			#$kernel->delay_set('remote_timeout', 20);
322
323			}
324
325			sub remote_shutdown {
326			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
327			$self->debug("remote_shutdown");
328			}
329
330			sub remote_timeout {
331
332			#my ($pong) = $_[ARG0];
333			#return if $pong; # all is cool
334
335			my ($self, $kernel, $heap) = @_[OBJECT, KERNEL, HEAP];
336
337			#=pod
338			if ($heap->{'cancel timeout'}) {
339			$heap->{'cancel timeout'} = 0;
340			return;
341			}
342			#=cut
343
344			$self->debug("remote_timeout");
345
346			$heap->{'destroy lease'} = 1;
347
348			# YOW! Remote kernel timed out. RUN AROUND SCREAMING!
349			print STDERR "# YOW! Remote kernel timed out. RUN AROUND SCREAMING!", "\n";
350
351			# free all resources that keep this session running
352			$kernel->delay('renew_lease');
353			$kernel->delay('remote_timeout');
354
355			#$kernel->post( 'IKC' => 'shutdown' );
356
357			#$kernel->alias_remove('DeviceClient');
358
359			#$kernel->alias_remove('DeviceClient');
360			#$kernel->yield('renew_lease');
361
362			#sub POE::Component::IKC::Responder::DEBUG { return 1; }
363			#$kernel->post( 'IKC' => 'unregister' );
364
365			#print Dumper($kernel->alias_list());
366
367			$kernel->post( IKC => 'retract', 'DeviceClient' => [qw( on_response )]);
368			#$kernel->post( IKC => 'retract', 'me' => [qw( on_response )]);
369			$kernel->post( IKC => 'unsubscribe', [qw( poe://LookupService/ServiceRegistrar )]);
370			$kernel->post( IKC => 'unregister', [qw( poe://LookupService )]);
371			#$kernel->post( IKC => 'unsubscribe', [qw( poe://me )]);
372			#$kernel->post( IKC => 'unregister', [qw( poe://me )]);
373			#$kernel->run_one_timeslice();
374			#$kernel->run_one_timeslice();
375			#$kernel->run_one_timeslice();
376			#return;
377
378			$kernel->post( 'IKC' => 'shutdown' );
379			#$kernel->run_one_timeslice();
380			#$kernel->run_one_timeslice();
381
382			$kernel->alias_remove('DeviceClient');
383			#$kernel->run_one_timeslice();
384			#$kernel->run_one_timeslice();
385
386	joko	1.1	}
387
388			1;
389			__END__
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26