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	## ------------------------------------------------------------------------
2	## $Id: LookupClient.pm,v 1.2 2003/07/01 13:05:01 joko Exp $
3	## ------------------------------------------------------------------------
4	## $Log: LookupClient.pm,v $
5	## 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	## Revision 1.1 2003/06/29 01:35:29 joko
9	## initial commit
10	##
11	## ------------------------------------------------------------------------
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	$self => [qw( _start _stop boot_intercom start_session waste_time watchdog )]
36	]
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	$self->{options}->{host} \|\|= "localhost";
78	$self->{options}->{port} \|\|= 30;
79
80	#create_ikc_client( host => $host, port => 30, name => 'Client', on_connect => $self->{options}->{on_connect} );
81	create_ikc_client(
82	host => $self->{options}->{host},
83	port => $self->{options}->{port},
84	#name => 'Client',
85	#on_connect => sub { $self->build(); },
86	on_connect => sub { $self->build(); },
87	#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
99	};
100
101	sub start_session {
102	#my $self = shift;
103	print STDERR "start_session", "\n";
104	}
105
106	sub build {
107	my $self = shift;
108	print "build", "\n";
109	# create sessions that depend on the foreign kernel.
110	POE::Component::LookupClient::Session->new();
111	}
112
113	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
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	$self => [qw( _start _stop on_response on_subscribe register_lease renew_lease remote_shutdown remote_timeout )]
174	]
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	$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
208	};
209
210	sub _stop {
211	my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
212	$self->debug("_stop");
213
214	# try to re-register if session dies?
215	#$kernel->yield('register_lease');
216
217	#$kernel->alias_remove('DeviceClient');
218
219	#$self = undef;
220	};
221
222
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	# Main response dispatcher, this should dispatch to local states programmatically.
232	sub on_response {
233	my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
234	#$self->debug("response");
235
236	$heap->{'cancel timeout'} = 1;
237
238	my $payload = $_[ARG0];
239	$payload \|\|= '';
240
241	# If registration succeeded, start the renewal cycle.
242	if ($payload eq 'REG_OK') {
243	$self->debug("Starting lease renewal loop.");
244	#$kernel->post( IKC => 'monitor', '*' => { shutdown => 'remote_shutdown' });
245	$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	#$kernel->alarm_remove_all();
257
258	}
259
260	};
261
262	sub register_lease {
263	my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
264	$self->debug("register_lease");
265
266	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	$kernel->post( "poe://LookupService/ServiceRegistrar", "register_lease", $ONE_arg );
272	}
273
274	sub renew_lease {
275	my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
276
277	if ($heap->{'destroy lease'}) {
278	#$heap->{'destroy lease'} = 0;
279	#$kernel->delay_set('remote_timeout');
280	$self->debug("destroyed lease");
281	#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	return;
289	}
290
291	$self->debug("renew_lease");
292
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	my $ONE_arg = '';
300	#$kernel->post('IKC', 'post', "poe://LookupService/ServiceRegistrar/renew_lease", $ONE_arg);
301	# V1 - without subscription
302	$kernel->post('IKC', 'call', "poe://LookupService/ServiceRegistrar/renew_lease", $ONE_arg, 'poe:on_response');
303
304	# V2 - with subscription
305	#my $resp = $kernel->call( "poe://LookupService/ServiceRegistrar", "renew_lease", $ONE_arg);
306	#print $resp, "\n";
307
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	# and again...
313	$kernel->delay('renew_lease', 15);
314	#$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	}
387
388	1;
389	__END__
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26