POE/Component/LookupClient.pm

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