view release on metacpan or  search on metacpan

lib/AnyEvent/ConnPool.pm  view on Meta::CPAN

            croak "Check param should be a hash reference.";
        }
        if (!$opts{check}->{cb}) {
            croak 'Missing cb param.';
        }
        
        if (ref $opts{check}->{cb} ne 'CODE') {
            croak 'Cb param should be a code reference.';
        }
        if (!$opts{check}->{interval}) {
            croak 'Missing interval param.';
        }
        # TODO: Add interval parameter validation
        
        $self->{check} = $opts{check};
    }

    if ($opts{size}) {
        #TODO: add validation for size

        $self->{size} = $opts{size};
    }

    bless $self, $class;

    if ($opts{init}) {
        $self->init();
    }
    
    if ($opts{dispatcher}) {
        return $self->dispatcher();
    }   
    return $self;
}


=item B<init>

Initializes pool.

=cut

sub init {
    my ($self, $conn_count) = @_;
    
    if ($self->{init}) {
        croak "Can't initialize already initilized pool.";
    }
    
    $conn_count ||= delete $self->{size};

    unless ($conn_count) {
        croak "Can't initilize empty pool";
    }
    
    for (1 .. $conn_count) {
        $self->add();
    }
    
    if ($self->{check}) {
        my $guard; $guard = AnyEvent->timer (
            after       =>  $self->{check}->{interval},
            interval    =>  $self->{check}->{interval},
            cb          =>  sub {
                my $temp_guard = $guard;
                for (my $i = 0; $i < $self->{count}; $i++) {
                    my $conn = $self->{_payload}->[$i];
                    eval {
                        $self->{check}->{cb}->($conn);
                        1;
                    } or do {
                        carp "Error occured: $@";
                    };
                }
            },
        );
    }

    $self->{init} = 1;
    return 1;
}


=item B<dispatcher>

Returns dispatcher object instead of pool object. It allows you to call connection's method directly, if you don't care about pool mechanism.
And it's simple.

    my $dispatcher = $connpool->dispatcher();
    $dispatcher->selectall_arrayref(...);
    # equivalent to:
    $connpool->get()->conn()->selectall_arrayref(...);

=cut

sub dispatcher {
    my ($self) = @_;

    my $dispatcher = {
        _pool   =>  $self,
    };

    bless $dispatcher, 'AnyEvent::ConnPool::Dispatcher';
    return $dispatcher;
}


=item B<pool_from_dispatcher>

Returns pool object from dispatcher object. You can call it by 3 ways:

    my $pool = AnyEvent::ConnPool::pool_from_dispatcher($dispatcher);
    my $pool = AnyEvent::ConnPool->pool_from_dispatcher($dispatcher);
    my $pool = $connpool->pool_from_dispatcher($dispatcher);

=cut

sub pool_from_dispatcher {
    my ($p1, $p2) = @_;
    my $dispatcher = undef;