POE/Component/LookupClient.pm

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