Lightspeed/Hack/Kernel.pm untested

filter: Statementstmt 0.0% 0 / 220 Branchbran 0.0% 0 / 102 Conditioncond 0.0% 0 / 27 MC/DCmcdc 0.0% 0 / 17 Subroutinesub 0.0% 0 / 13 Podpod 0.0% 0 / 7 totaltotal 0.0% 0 / 386 CC 52 SCAR 60.2
CC
52
Cov
0%
_call_31
650.0
_post_31
462.0
_alias_31
42.0
CRAP 410.1
1 # Declare our package
2 package POE::Component::Lightspeed::Hack::Kernel;
3  
4 # Standard stuff to catch errors
5 use strict qw(subs vars refs); # Make sure we can't mess up
6 use warnings FATAL => 'all'; # Enable warnings to catch errors
7  
8 # Initialize our version
9 our $VERSION = '1.' . sprintf( "%04d", (qw($Revision: 1082 $))[1] );
10  
11 # Hack the planet!
12 package POE::Kernel;
13  
14 # Standard stuff to catch errors
15 use strict qw(subs vars refs); # Make sure we can't mess up
16 use warnings FATAL => 'all'; # Enable warnings to catch errors
17  
18 # The generic lightspeed resolve failure sub
19 sub _explain_lightspeed_failure {
20 my( $self, $tag ) = @_;
21  
22 # Tell carp to go a few levels above us for the stacktrace
23 local $Carp::CarpLevel = 2;
24  
25 if ( ASSERT_DATA ) {
26 _trap "<dt> The Lightspeed destination '$tag' is not valid!";
27 }
28  
29 # Complain away!
30 $! = ESRCH;
31 TRACE_RETVALS and _carp "<rv> malformed destination: $!";
32 ASSERT_RETVALS and _confess "<rv> malformed destination: $!";
33 }
34  
35 sub _alias_31 {
36 my ($self, $name) = @_;
37  
38 if (ASSERT_USAGE) {
39 _confess "<us> undefined alias in alias_set()" unless defined $name;
40 }
41  
42 # Don't overwrite another session's alias.
43 my $existing_session = $self->_data_alias_resolve($name);
44 if ( defined $existing_session ) {
45 if ( $existing_session != ${ $self->[ KR_ACTIVE_SESSION ] } ) {
46 $self->_explain_usage( "alias '$name' is in use by another session" );
47 return EEXIST;
48 }
49 return 0;
50 }
51  
52 # Make sure it doesn't contain any * or / or ,
53 if ( $name =~ tr|*/,|| ) {
54 $self->_explain_usage( "When Lightspeed is loaded, aliases cannot contain '*' or '/' or ','" );
55 return EINVAL;
56 }
57  
58 $self->_data_alias_add( ${ $self->[ KR_ACTIVE_SESSION ] }, $name );
59 return 0;
60 }
61  
62 sub _post_31 {
63 my ($self, $dest_session, $event_name, @etc) = @_;
64  
65 if (ASSERT_USAGE) {
66 _confess "<us> destination is undefined in post()" unless defined $dest_session;
67  
68 # Argh!
69 if ( ! defined $event_name and ( ( ! ref( $dest_session ) and $dest_session =~ m|^poe://|i )
70 or ( ref( $dest_session ) eq 'ARRAY' or ref( $dest_session ) eq 'HASH' or ref( $dest_session ) eq 'POE::Component::Lightspeed::Hack::Session' ) ) ) {
71 _confess "<us> event is undefined in post()" unless defined $event_name;
72 }
73  
74 _carp "<us> The '$event_name' event is one of POE's own. Its effect cannot be achieved by posting it" if exists $POE::Kernel::poes_own_events{$event_name};
75 };
76  
77 # Is this destination session a fake lightspeed one?
78 my $session = $dest_session;
79 if ( ! defined $session ) {
80 return undef;
81 } elsif ( ! ref( $session ) ) {
82 if ( $session =~ m|^poe://|i ) {
83 # Validate this
84 $session = POE::Component::Lightspeed::Router::ValidateDestination( $session );
85  
86 # Sanity check
87 if ( ! defined $session ) {
88 $self->_explain_lightspeed_failure( $dest_session );
89 return;
90 }
91  
92 # Did we get a state?
93 if ( ! defined $session->[ POE::Component::Lightspeed::Constants::DEST_STATE ] ) {
94 # Sanity checks
95 if ( ref( $event_name ) ) {
96 if ( POE::Component::Lightspeed::Router::DEBUG ) {
97 warn 'Missing state in the specifier, as the argument after the destination was not a plain scalar!';
98 }
99 return undef;
100 }
101  
102 # Add it!
103 $session->[ POE::Component::Lightspeed::Constants::DEST_STATE ] = $event_name;
104 } else {
105 # The event name actually is part of the args!
106 unshift( @etc, $event_name );
107 }
108 } else {
109 # Attempt to resolve the destination session reference against various things.
110 $session = $self->_resolve_session( $session );
111 unless ( defined $session ) {
112 $self->_explain_resolve_failure( $dest_session );
113 return;
114 }
115 }
116 } elsif ( ref( $session ) eq 'HASH' or ref( $session ) eq 'ARRAY' ) {
117 # Validate this
118 $session = POE::Component::Lightspeed::Router::ValidateDestination( $session );
119  
120 # Sanity check
121 if ( ! defined $session ) {
122 $self->_explain_lightspeed_failure( $dest_session );
123 return;
124 }
125  
126 # Since we know it's a lightspeed specifier, shift the args
127 unshift( @etc, $event_name );
128 } elsif ( ref( $session ) eq 'POE::Component::Lightspeed::Hack::Session' ) {
129 # Convert it :)
130 $session = [];
131 $session->[ POE::Component::Lightspeed::Constants::DEST_KERNEL ] = $dest_session->remote_kernel();
132 $session->[ POE::Component::Lightspeed::Constants::DEST_SESSION ] = $dest_session->remote_session();
133  
134 # Sanity checks
135 if ( ref( $event_name ) ) {
136 if ( POE::Component::Lightspeed::Router::DEBUG ) {
137 warn 'Missing state in the specifier, as the argument after the destination was not a plain scalar!';
138 }
139 return undef;
140 }
141  
142 # Add it!
143 $session->[ POE::Component::Lightspeed::Constants::DEST_STATE ] = $event_name;
144 } else {
145 # Attempt to resolve the destination session reference against various things.
146 $session = $self->_resolve_session( $session );
147 unless ( defined $session ) {
148 $self->_explain_resolve_failure( $dest_session );
149 return;
150 }
151 }
152  
153 # Send it off to lightspeed
154 if ( ref( $session ) eq 'ARRAY' ) {
155 $self->_data_ev_enqueue(
156 $self->_resolve_session( $POE::Component::Lightspeed::Router::SES_ALIAS ),
157 ${ $self->[ KR_ACTIVE_SESSION ] },
158 'post',
159 ET_POST,
160 [ $session, \@etc ],
161 ( caller )[1,2],
162 ${ $self->[ KR_ACTIVE_EVENT ] },
163 time(),
164 );
165 } else {
166 # Enqueue the event for "now", which simulates FIFO in our
167 # time-ordered queue.
168 $self->_data_ev_enqueue(
169 $session, ${ $self->[ KR_ACTIVE_SESSION ] }, $event_name, ET_POST, \@etc,
170 (caller)[1,2], ${ $self->[ KR_ACTIVE_EVENT ] }, time(),
171 );
172 }
173  
174 # All done!
175 return 1;
176 }
177  
178 sub _lightspeed_post_31 {
179 my( $self, $fake_session, $dest_session, $event_name, $etc ) = @_;
180  
181 # Enqueue the event for "now", which simulates FIFO in our
182 # time-ordered queue.
183 $self->_data_ev_enqueue(
184 $dest_session,
185 $fake_session,
186 $event_name,
187 ET_POST,
188 $etc,
189 $fake_session->remote_file(),
190 $fake_session->remote_line(),
191 $fake_session->remote_state(),
192 time(),
193 );
194  
195 # All done!
196 return 1;
197 }
198  
199 sub _call_31 {
200 my ($self, $dest_session, $event_name, @etc) = @_;
201  
202 if (ASSERT_USAGE) {
203 _confess "<us> destination is undefined in call()" unless defined $dest_session;
204 _confess "<us> event is undefined in call()" unless defined $event_name;
205 _carp "<us> The '$event_name' event is one of POE's own. Its effect cannot be achieved by calling it" if exists $POE::Kernel::poes_own_events{$event_name};
206 };
207  
208 # Is this destination session a fake lightspeed one?
209 my $session = $dest_session;
210 if ( ! defined $session ) {
211 return undef;
212 } elsif ( ! ref( $session ) ) {
213 if ( $session =~ m|^poe://|i ) {
214 # Validate the destination and the RSVP
215 $session = POE::Component::Lightspeed::Router::ValidateDestination( $session );
216 if ( ! defined $session ) {
217 $self->_explain_lightspeed_failure( $dest_session );
218 return;
219 }
220  
221 # If we didn't receive the state, assume this is a call() without rsvp
222 if ( ! defined $session->[ POE::Component::Lightspeed::Constants::DEST_STATE ] ) {
223 # Sanity checks
224 if ( ref( $event_name ) ) {
225 if ( POE::Component::Lightspeed::Router::DEBUG ) {
226 warn 'Missing state in the specifier, as the argument after the destination was not a plain scalar!';
227 }
228 return undef;
229 }
230  
231 # Add it!
232 $session->[ POE::Component::Lightspeed::Constants::DEST_STATE ] = $event_name;
233  
234 # Send it off!
235 $self->_data_ev_enqueue(
236 $self->_resolve_session( $POE::Component::Lightspeed::Router::SES_ALIAS ),
237 ${ $self->[ KR_ACTIVE_SESSION ] },
238 'post',
239 ET_POST,
240 [ $session, \@etc ],
241 ( caller )[1,2],
242 ${ $self->[ KR_ACTIVE_EVENT ] },
243 time(),
244 );
245 } else {
246 my $rsvp = POE::Component::Lightspeed::Router::ValidateDestination( $event_name );
247 if ( ! defined $rsvp ) {
248 $self->_explain_lightspeed_failure( $event_name );
249 return;
250 }
251  
252 # Send it off!
253 $self->_data_ev_enqueue(
254 $self->_resolve_session( $POE::Component::Lightspeed::Router::SES_ALIAS ),
255 ${ $self->[ KR_ACTIVE_SESSION ] },
256 'call',
257 ET_POST,
258 [ $session, $rsvp, \@etc ],
259 ( caller )[1,2],
260 ${ $self->[ KR_ACTIVE_EVENT ] },
261 time(),
262 );
263 }
264  
265 # Always return undef
266 return undef;
267 } else {
268 # Attempt to resolve the destination session reference against various things.
269 $session = $self->_resolve_session( $session );
270 unless ( defined $session ) {
271 $self->_explain_resolve_failure( $dest_session );
272 return;
273 }
274 }
275 } elsif ( ref( $session ) eq 'HASH' or ref( $session ) eq 'ARRAY' ) {
276 # Validate the destination and the RSVP
277 $session = POE::Component::Lightspeed::Router::ValidateDestination( $session );
278 if ( ! defined $session ) {
279 $self->_explain_lightspeed_failure( $dest_session );
280 return;
281 }
282  
283 my $rsvp = POE::Component::Lightspeed::Router::ValidateDestination( $event_name );
284 if ( ! defined $rsvp ) {
285 $self->_explain_lightspeed_failure( $event_name );
286 return;
287 }
288  
289 # Send it off!
290 $self->_data_ev_enqueue(
291 $self->_resolve_session( $POE::Component::Lightspeed::Router::SES_ALIAS ),
292 ${ $self->[ KR_ACTIVE_SESSION ] },
293 'call',
294 ET_POST,
295 [ $session, $rsvp, \@etc ],
296 ( caller )[1,2],
297 ${ $self->[ KR_ACTIVE_EVENT ] },
298 time(),
299 );
300  
301 # Always return undef
302 return undef;
303 } elsif ( ref( $session ) eq 'POE::Component::Lightspeed::Hack::Session' ) {
304 # This is a plain call() without the rsvp
305  
306 # Sanity checks
307 if ( ref( $event_name ) ) {
308 if ( POE::Component::Lightspeed::Router::DEBUG ) {
309 warn 'Malformed state';
310 }
311 return undef;
312 }
313  
314 # Convert it!
315 $session = [];
316 $session->[ POE::Component::Lightspeed::Constants::DEST_KERNEL ] = $dest_session->remote_kernel();
317 $session->[ POE::Component::Lightspeed::Constants::DEST_SESSION ] = $dest_session->remote_session();
318 $session->[ POE::Component::Lightspeed::Constants::DEST_STATE ] = $event_name;
319  
320 # Send it off!
321 $self->_data_ev_enqueue(
322 $self->_resolve_session( $POE::Component::Lightspeed::Router::SES_ALIAS ),
323 ${ $self->[ KR_ACTIVE_SESSION ] },
324 'post',
325 ET_POST,
326 [ $session, \@etc ],
327 ( caller )[1,2],
328 ${ $self->[ KR_ACTIVE_EVENT ] },
329 time(),
330 );
331  
332 # Always return undef
333 return undef;
334 }
335  
336 # Dispatch the event right now, bypassing the queue altogether.
337 # This tends to be a Bad Thing to Do.
338  
339 # -><- The difference between synchronous and asynchronous events
340 # should be made more clear in the documentation, so that people
341 # have a tendency not to abuse them. I discovered in xws that that
342 # mixing the two types makes it harder than necessary to write
343 # deterministic programs, but the difficulty can be ameliorated if
344 # programmers set some base rules and stick to them.
345  
346 # What should we return?
347 if (wantarray) {
348 my @return_value = (
349 ($session == ${ $self->[ KR_ACTIVE_SESSION ] })
350 ? $session->_invoke_state(
351 $session, $event_name, \@etc, (caller)[1,2],
352 ${ $self->[ KR_ACTIVE_EVENT ] }
353 )
354 : $self->_dispatch_event(
355 $session, ${ $self->[ KR_ACTIVE_SESSION ] },
356 $event_name, ET_CALL, \@etc,
357 (caller)[1,2], ${ $self->[ KR_ACTIVE_EVENT ] }, time(), -__LINE__
358 )
359 );
360  
361 $! = 0;
362 return @return_value;
363 }
364  
365 if (defined wantarray) {
366 my $return_value = (
367 $session == ${ $self->[ KR_ACTIVE_SESSION ] }
368 ? $session->_invoke_state(
369 $session, $event_name, \@etc, (caller)[1,2],
370 ${ $self->[ KR_ACTIVE_EVENT ] }
371 )
372 : $self->_dispatch_event(
373 $session, ${ $self->[ KR_ACTIVE_SESSION ] },
374 $event_name, ET_CALL, \@etc,
375 (caller)[1,2], ${ $self->[ KR_ACTIVE_EVENT ] }, time(), -__LINE__
376 )
377 );
378  
379 $! = 0;
380 return $return_value;
381 }
382  
383 if ($session == ${ $self->[ KR_ACTIVE_SESSION ] }) {
384 $session->_invoke_state(
385 $session, $event_name, \@etc, (caller)[1,2],
386 ${ $self->[ KR_ACTIVE_EVENT ] }
387 );
388 }
389 else {
390 $self->_dispatch_event(
391 $session, ${ $self->[ KR_ACTIVE_SESSION ] },
392 $event_name, ET_CALL, \@etc,
393 (caller)[1,2], ${ $self->[ KR_ACTIVE_EVENT ] }, time(), -__LINE__
394 );
395 }
396  
397 $! = 0;
398 return;
399 }
400  
401 sub _lightspeed_call_31 {
402 my( $self, $fake_session, $dest_session, $event_name, $etc ) = @_;
403  
404 # Dispatch the event!
405 my @return_value = (
406 $self->_dispatch_event(
407 $dest_session,
408 $fake_session,
409 $event_name,
410 ET_CALL,
411 $etc,
412 $fake_session->remote_file(),
413 $fake_session->remote_line(),
414 $fake_session->remote_state(),
415 time(),
416 -__LINE__,
417 )
418 );
419  
420 # All done!
421 return \@return_value;
422 }
423  
424 # Scope our evil stuff :)
425 BEGIN {
426 # Turn off strictness for our nasty stuff
427 no strict 'refs';
428  
429 # Oh boy, no warnings too :(
430 no warnings 'redefine';
431  
432 # Now, decide which version we should load...
433 my %post_versions = (
434 '0.31' => \&_post_31,
435 '0.3101' => \&_post_31,
436 );
437 my %call_versions = (
438 '0.31' => \&_call_31,
439 '0.3101' => \&_call_31,
440 );
441 my %lightspeed_post_versions = (
442 '0.31' => \&_lightspeed_post_31,
443 '0.3101' => \&_lightspeed_post_31,
444 );
445 my %lightspeed_call_versions = (
446 '0.31' => \&_lightspeed_call_31,
447 '0.3101' => \&_lightspeed_call_31,
448 );
449 my %alias_versions = (
450 '0.31' => \&_alias_31,
451 '0.3101' => \&_alias_31,
452 );
453  
454 # Make sure we have this version in the dispatch table
455 if ( ! exists $post_versions{ $POE::VERSION } ) {
456 die 'Your version of Lightspeed does not yet support POE-' . $POE::VERSION;
457 }
458  
459 # Do our symbol table hackery
460 *{'POE::Kernel::alias_set'} = $alias_versions{ $POE::VERSION };
461 *{'POE::Kernel::post'} = $post_versions{ $POE::VERSION };
462 *{'POE::Kernel::call'} = $call_versions{ $POE::VERSION };
463 *{'POE::Kernel::lightspeed_fake_post'} = $lightspeed_post_versions{ $POE::VERSION };
464 *{'POE::Kernel::lightspeed_fake_call'} = $lightspeed_call_versions{ $POE::VERSION };
465 *{'POE::Kernel::_explain_lightspeed_failure'} = \&POE::Component::Lightspeed::Kernel::_explain_lightspeed_failure;
466 }
467  
468 # End of module
469 1;
470 __END__