blib/lib/Asyncore.pm untested

filter: Statementstmt 0.0% 0 / 238 Branchbran 0.0% 0 / 82 Conditioncond 0.0% 0 / 26 MC/DCmcdc 0.0% 0 / 15 Subroutinesub 0.0% 0 / 42 Podpod 0.0% 0 / 31 totaltotal 0.0% 0 / 434 CC 41 SCAR 36.1
CC
41
Cov
0%
poll
182.0
init
30.0
loop
20.0
CRAP 37.0
1 package Asyncore;
2 {
3 $Asyncore::VERSION = '0.08';
4 }
5  
6 #==============================================================================
7 #
8 # FILE: Asyncore.pm
9 #
10 # DESCRIPTION: porting in Perl of asyncore.py (python 2.7)
11 #
12 # FILES: ---
13 # BUGS: ---
14 # NOTES: ---
15 # AUTHOR: (Sebastiano Piccoli), <sebastiano.piccoli@gmail.com>
16 # COMPANY:
17 # VERSION: 0.08
18 # CREATED: 26/06/12 20:27:28 CEST
19 # REVISION: ---
20 #==============================================================================
21  
22 use strict;
23 use warnings;
24  
25 use IO::Select;
26 use Socket;
27 use Carp;
28  
29 our $socket_map;
30  
31 if (not $socket_map) {
32 $socket_map = {}
33 }
34  
35 sub _read {
36 my $obj = shift;
37
38 eval {
39 $obj->handle_read_event();
40 };
41 if ($@) {
42 $obj->handle_error($@);
43 }
44 }
45  
46 sub _write {
47 my $obj = shift;
48
49 eval {
50 $obj->handle_write_event();
51 };
52 if ($@) {
53 $obj->handle_error($@);
54 }
55 }
56  
57 sub _exception {
58 my $obj = shift;
59
60 eval {
61 $obj->handle_expt_event();
62 };
63 if ($@) {
64 $obj->handle_error($@);
65 }
66 }
67  
68 sub poll {
69 my($timeout, $map) = @_;
70
71 if (not $map) {
72 $map = $socket_map;
73 }
74
75 if ($map) {
76 my $r = new IO::Select;
77 my $w = new IO::Select;
78 my $e = new IO::Select;
79 foreach my $fd (keys %{ $map }) {
80 my $obj = $map->{$fd};
81 my $is_r = $obj->readable();
82 my $is_w = $obj->writable();
83
84 if ($is_r) {
85 $r->add($obj->{_socket});
86 }
87 if ($is_w and not $obj->{_accepting}) {
88 $w->add($obj->{_socket});
89  
90 }
91 if ($is_r or $is_w) {
92 $e->add($obj->{_socket});
93 }
94 }
95 if (not @$r and not @$w and not @$e) {
96 sleep($timeout);
97 return
98 }
99
100 my($rr, $rw, $he);
101 eval {
102 # rr, wr: ready for reading/writing. he: has exception
103 ($rr, $rw, $he) = IO::Select->select($r, $w, $e, $timeout);
104 };
105 if ($@) {
106 croak "$@";
107 }
108
109 foreach my $fd (@$rr) {
110 next if !defined(fileno($fd));
111 my $obj = $map->{fileno($fd)};
112 if (not $obj) {
113 next;
114 }
115 _read($obj);
116 }
117
118 foreach my $fd (@$rw) {
119 next if !defined(fileno($fd));
120 my $obj = $map->{fileno($fd)};
121 if (not $obj) {
122 next;
123 }
124 _write($obj);
125 }
126
127 foreach my $fd (@$he) {
128 my $obj = $map->{$fd->fileno()};
129 if (not $obj) {
130 next;
131 }
132 _exception($obj);
133 }
134 }
135 }
136  
137 sub loop {
138 my($timeout, $use_poll, $map, $count) = @_;
139
140 if (not $timeout) {
141 $timeout = 30;
142 }
143  
144 if (not $map) {
145 $map = $socket_map;
146 }
147  
148 #if ($use_poll and hasattr(select, 'poll') {
149 #$poll_fun = $poll2
150 #}
151 #else {
152 #$poll_fun = $poll
153 #}
154  
155 if (not $count) {
156 while ($map) {
157 #$poll_fun($timeout, $map)
158 poll($timeout, $map)
159 }
160 }
161 else {
162 while (($map) and ($count > 0)) {
163 #$poll_fun($timeout, $map);
164 $count--;
165 }
166 }
167 }
168  
169  
170  
171 package Asyncore::Dispatcher;
172 {
173 $Asyncore::Dispatcher::VERSION = '0.08';
174 }
175  
176 #==============================================================================
177 #
178 # FILE: Asyncore.pm
179 # PACKAGE: Asyncore::Dispatcher
180 #
181 # DESCRIPTION:
182 #
183 # FILES: ---
184 # BUGS: ---
185 # NOTES: ---
186 # AUTHOR: (Sebastiano Piccoli), <sebastiano.piccoli@gmail.com>
187 # COMPANY:
188 # VERSION: 0.8
189 # CREATED: 26/06/12 20:27:28 CEST
190 # REVISION: ---
191 #==============================================================================
192  
193 use strict;
194 use warnings;
195  
196 use Socket;
197 use Fcntl;
198 use Carp;
199 use Errno;
200  
201 sub new {
202 my $class = shift;
203 my $self = {};
204 bless $self, $class;
205 return $self->init(@_);
206 }
207  
208 sub init {
209 my($self, $sock, $map) = @_;
210  
211 if (not $map) {
212 $self->{_map} = $socket_map;
213 }
214 else {
215 $self->{_map} = $map;
216 }
217  
218 $self->{_fileno} = 0;
219
220 if ($sock) {
221 # Set to nonblocking just to make sure for cases where we
222 # get a socket from a blocking source
223 fcntl($sock, F_SETFL, O_NONBLOCK);
224 $self->set_socket($sock, $map);
225 $self->{_connected} = 1;
226
227 if (not getpeername($sock)) {
228 if ($!{ENOTCONN} || $!{EINVAL}) {
229 # Handle the case where we got an unconnected socket
230 $self->{_connected} = 0;
231 }
232 else {
233 # Handle the case where the socket is broken in some unknown
234 # way, alert the user and remove it from the map (to prevent
235 # polling of broken sockets)
236 $self->del_channel($map);
237
238 }
239 }
240 }
241 else {
242 $self->{_socket} = 0;
243 }
244
245 return $self;
246 }
247  
248 sub add_channel {
249 my($self, $map) = @_;
250  
251 if (not $map) {
252 $map = $self->{_map}
253 }
254  
255 $map->{$self->{_fileno}} = $self;
256 }
257  
258 sub del_channel {
259 my($self, $map) = @_;
260  
261 if (not $map) {
262 $map = $self->{_map}
263 }
264
265 my $fd = $self->{_fileno};
266 foreach my $mfd (keys %{ $map }) {
267 if ($mfd == $fd) {
268 delete $map->{$mfd};
269 }
270 }
271
272 $self->{_fileno} = undef;
273 }
274  
275 sub create_socket {
276 my($self, $family, $type) = @_;
277
278 if (not $family) {
279 $family = AF_INET;
280 }
281 if (not $type) {
282 $type = SOCK_STREAM; # tcp
283 }
284 # SOCK_DGRAM (udp), SOCK_RAW (icmp)
285
286 my $sock;
287 my $proto = getprotobyname("tcp"); # fixme
288 socket($sock, AF_INET, SOCK_STREAM, $proto) || croak "$!";
289 fcntl($sock, F_SETFL, O_NONBLOCK);
290
291 $self->set_socket($sock);
292 }
293  
294 sub set_socket {
295 my($self, $sock, $map) = @_;
296  
297 $self->{_socket} = $sock;
298 $self->{_fileno} = fileno($sock);
299 $self->add_channel($map);
300 }
301
302 sub readable {
303 my $self = shift;
304
305 return 1;
306 }
307  
308 sub writable {
309 my $self = shift;
310
311 return 1;
312 }
313  
314 sub bind {
315 my($self, $port) = @_;
316
317 my $sock = $self->{_socket};
318 my $iaddr = gethostbyname('localhost');
319 bind($sock, sockaddr_in($port, $iaddr));
320 }
321  
322 sub listen {
323 my($self, $num) = @_;
324  
325 $self->{_accepting} = 1;
326  
327 my $sock = $self->{_socket};
328 listen($sock, $num);
329 }
330  
331 sub connect {
332 my($self, $addr, $port) = @_;
333  
334 $self->{_connected} = 0;
335 $self->{_connecting} = 1;
336  
337 my $sock = $self->{_socket};
338 my $iaddr = inet_aton($addr);
339 my $paddr = sockaddr_in($port, $iaddr);
340 # In the case of a non-blocking socket connection cannot be completed
341 # immediately. connect is a form of write so select() or poll() can be
342 # used to determine when it's possible to write.
343 unless (connect($sock, $paddr)) {
344 if ($!{EINPROGRESS}) {
345 return;
346 }
347 }
348
349 $self->{_addr} = $addr;
350 $self->{_port} = $port;
351 $self->handle_connect_event();
352 }
353  
354 sub accept {
355 my $self = shift;
356
357 my $conn;
358 my $sock = $self->{_socket};
359
360 if (not accept($conn, $sock)) {
361 if ($!{EWOULDBLOCK} || $!{ECONNABORTED} || $!{EAGAIN}) {
362 # Handle the case where we cannot accept connection
363 return;
364 }
365 else {
366 carp 'Unknown error in accept()';
367 }
368 }
369
370 return $conn;
371 }
372  
373 sub send {
374 my($self, $data) = @_;
375
376 my $sock = $self->{_socket};
377
378 my $result;
379 eval {
380 send($sock, $data, 0);
381 };
382 if ($@) {
383 croak "$@";
384 }
385  
386 return $result;
387 }
388  
389 sub receive {
390 my($self, $buffer_size) = @_;
391
392 my $data;
393 my $sock = $self->{_socket};
394 recv($sock, $data, $buffer_size, 0);
395
396 if (not $data) {
397 $self->handle_close();
398 return '';
399 }
400 else {
401 return $data;
402 }
403
404 # check error todo
405 }
406  
407 sub close {
408 my $self = shift;
409
410 $self->{_connected} = 0;
411 $self->{_accepting} = 0;
412 $self->{_connecting} = 0;
413
414 my $sock = $self->{_socket};
415 close($sock);
416 }
417  
418 sub handle_close {
419 my $self = shift;
420
421 $self->close();
422 }
423  
424 sub handle_read_event {
425 my $self = shift;
426
427 if ($self->{_accepting}) {
428 $self->handle_accept();
429 }
430 elsif (not $self->{_connected}) {
431 if ($self->{_connecting}) {
432 $self->handle_connect_event();
433 }
434 $self->handle_read();
435 }
436 else {
437 $self->handle_read();
438 }
439 }
440  
441 sub handle_connect_event {
442 my $self = shift;
443
444 # some preliminary check todo
445
446 $self->handle_connect();
447 $self->{_connected} = 1;
448 $self->{_connecting} = 0;
449 }
450  
451 sub handle_write_event {
452 my $self = shift;
453
454 if ($self->{_accepting}) {
455 return;
456 }
457
458 if (not $self->{_connected}) {
459 if ($self->{_connecting}) {
460 $self->handle_connect_event();
461 }
462 }
463 $self->handle_write();
464 }
465  
466 sub handle_expt_event {
467 my $self = shift;
468
469 my $err = $self->{_socket}->getsockopt();
470 if ($err != 0) {
471 $self->handle_close();
472 }
473 else {
474 $self->handle_expt();
475 }
476 }
477  
478 sub handle_error {
479 my($self, $error) = @_;
480
481 warn $error;
482
483 $self->handle_close();
484 }
485  
486 sub handle_expt {
487 # overrided
488 }
489  
490 sub handle_read {
491 # overrided
492 }
493  
494 sub handle_write {
495 # overrided
496 }
497  
498 sub handle_connect {
499 # overrided
500 }
501  
502 sub handle_accept {
503 # overrided
504 }
505  
506  
507 1;
508  
509 __END__