File Coverage

blib/lib/Inferno/RegMgr.pm

Criterion	Covered	Total	%
statement	16	18	88.8
branch			n/a
condition			n/a
subroutine	6	6	100.0
pod			n/a
total	22	24	91.6

package Inferno::RegMgr;

use warnings;
use strict;
use Carp;

# update POD & Changes & README
use version; our $VERSION = qv('0.1.7');

# update DEPENDENCIES in POD & Makefile.PL & README
use Scalar::Util qw( weaken refaddr );
use IO::Stream;     # to import consts like CONNECTED
use EV;


use constant RETRY => 1;    # sec, delay between re-connections


sub new {
    my ($class, $reg) = @_;
    my $self = {
        registry        => $reg,
        is_connected    => 0,
        io              => undef,
        t               => undef,
        tasks           => {},
    };
    bless $self, $class;
    $self->_open_event();
    return $self;
}

sub _open_event {
    my ($self) = @_;
    weaken( my $this = $self );
    $self->{io} = $self->{registry}->open_event({
        cb      => sub { $this->_cb_event(@_) },
    });
    weaken( $self->{io} );
    return;
}

sub _cb_event {
    my ($self, $e, $err) = @_;
    if ($e & CONNECTED) {
        $self->{is_connected} = 1;
        for my $task (values %{ $self->{tasks} }) {
            $task->START();
        }
    }
    if ($e & IN) {
        for my $task (values %{ $self->{tasks} }) {
            $task->REFRESH();
        }
    }
    if ($e & EOF) {
        $self->{is_connected} = 0;
        for my $task (values %{ $self->{tasks} }) {
            $task && $task->STOP();
        }
    }
    if ($e & EOF || $err) {
        weaken( my $this = $self );
        $self->{t} = EV::timer RETRY, 0, sub { $this->_open_event() };
    }
    return;
}

sub attach {
    my ($self, $task) = @_;
    croak 'already attached' if defined $task->{manager};
    weaken( $task->{manager} = $self );
    $self->{tasks}{ refaddr($task) } = $task;
    if ($self->{is_connected}) {
        $task->START();
    }
    return;
}

sub detach {
    my ($self, $task) = @_;
    croak 'not attached to this manager' if $task->{manager} != $self;
    if ($self->{is_connected}) {
        $task->STOP();
    }
    undef $task->{manager};
    delete $self->{tasks}{ refaddr($task) };
    return;
}

sub DESTROY {
    my ($self) = @_;
    for my $task (values %{ $self->{tasks} }) {
        # $task can be already freed if DESTROY called while global destruction
        $task && $self->detach($task);
    }
    if (defined $self->{io}) {
        $self->{io}->close();
    }
    $self->{t} = undef;
    return;
}


1; # Magic true value required at end of module
__END__