File Coverage

blib/lib/Net/DNS/Async/Simple.pm

Criterion	Covered	Total	%
statement	55	59	93.2
branch	13	20	65.0
condition	4	8	50.0
subroutine	8	8	100.0
pod	1	1	100.0
total	81	96	84.3

package Net::DNS::Async::Simple;
$Net::DNS::Async::Simple::VERSION = '1.161090';
use Modern::Perl;
use Net::DNS::Async;
use Net::DNS::Resolver;
use Storable;
use Data::Dumper;

sub massDNSLookup {
    my $list = shift
        or die 'Net::DNS::Async::Simple: one argument required';
    die 'Net::DNS::Async::Simple: first required argument must be an ARRAY reference'
        if not ref $list or ref $list ne 'ARRAY';
    my $asyncs = {};

    my $callback = sub {
        my ($index, $response) = @_;
        my $item = $list->[$index];
        if(not $response) {     #timeout
            $item->{timeout} = 1;
            return;
        }
        my @answers = $response->answer;
        if(not scalar @answers) {
            $item->{error} = "returned no answers via";
            return;
        }
        foreach my $answer (@answers) {
            $item->{NetDNSAnswer} = {};
            foreach my $key (keys %$answer) {
                my $value = $answer->{$key};
                if(ref $value) {
                    $item->{NetDNSAnswer}->{$key} = Storable::dclone($value);
                } else {
                    $item->{NetDNSAnswer}->{$key} = $value;
                }
            }
            if(ref $answer eq 'Net::DNS::RR::A') {
                $item->{name} = $answer->name;
                $item->{address} = $answer->address;
            } elsif(ref $answer eq 'Net::DNS::RR::PTR') {
                $item->{ptrdname} = $answer->ptrdname;
            }
        }
    };

    my $i = 0;
    while($list->[$i]) {
        my $item = $list->[$i];
        my $j = $i;
        local $Data::Dumper::Sortkeys = 1;
        my $nameServerInfo = $item->{nameServers} || [];
        my $nameServerKey = Data::Dumper::Dumper $nameServerInfo;
        if(not $asyncs->{$nameServerKey}) {
            $asyncs->{$nameServerKey} = Net::DNS::Async->new(QueueSize => 20, Retries => 3);
            if($item->{nameServers}) {
                $asyncs->{$nameServerKey}->{Resolver} = Net::DNS::Resolver->new(
                    nameservers => $item->{nameServers}
                );
            }
        }
        if($list->[$j]->{query}->[0] and $list->[$j]->{query}->[1]) {
            $asyncs->{$nameServerKey}->add(
                sub {
                    $callback->($j, @_)
                }, @{$list->[$j]->{query}}
            );
        }
        $i++;
    }
    foreach my $nameServerKey (keys %{$asyncs}) {
        $asyncs->{$nameServerKey}->await;
    }
    return undef;
}

1;

__END__