File Coverage

lib/Mojo/Downloader.pm

Criterion	Covered	Total	%
statement	13	15	86.6
branch			n/a
condition			n/a
subroutine	5	5	100.0
pod			n/a
total	18	20	90.0

package Mojo::Downloader;

# ABSTRACT: a simple download tool
use Momo;

use File::Basename qw(dirname);
use YAML qw(Dump);
use Mojo::UserAgent;
use Coro;
use Coro::Semaphore;
use AnyEvent;
use Storable;

extends 'Mojo::EventEmitter';

our $VERSION = 0.2;

has ua => sub { Mojo::UserAgent->new };
has interval     => 1;
has cv           => sub {
    my $condvar = AnyEvent->condvar;
    $condvar->cb( sub { shift->recv } );
    $condvar;
};
has max_currency => 10;
has sem          => sub { Coro::Semaphore->new( shift->max_currency ) };
has cookie_file  => sub { $ENV{MOJO_COOKIE_FILE} };

sub new {
    my ( $class, @args ) = @_;
    my $self = $class->SUPER::new(@args);
    if ( $self->cookie_file and -s $self->cookie_file > 0 ) {
        eval { $self->ua->cookie_jar( retrieve $self->cookie_file ) };
        die "cookie_file must save as Storable mode" if $@;
    }
    $self->on(
        download => sub {
            my ( $ua, $tx, $file, $r ) = @_;
            my $url           = $tx->req->url;
            my $content_lenth = $tx->res->headers->content_length;
            if ( $tx->success ) {
                if ( defined $file and -e dirname($file) ) {
                    $tx->res->content->asset->move_to($file);
                    if ( -s $file == $content_lenth ) {
                        print "downloaded $url => $file success!\n";
                        $r->{$file} = 1 if ref $r eq ref {};
                    }
                    else {
                        warn "file => $file not fully downloaded \n";
                    }
                }
            }
            else {
                warn "download url => " . $tx->req->url . " ".$tx->res->code."failed";
            }
        }
    );

    return $self;
}

sub set_max_currency {
    my ( $self, $limit ) = @_;
    $self->sem( Coro::Semaphore->new($limit) );
    $self->max_currency($limit);
}

sub run{
    shift->cv->recv;
}

sub _async_request {
    my ( $self, $url, $options ) = @_;

    $options ||= {};
    my $on_header = delete $options->{on_header};
    my $on_body   = delete $options->{on_body};
    my $cookies   = delete $options->{cookies};
    my $form      = delete $options->{form};
    my $method    = delete $options->{method};
    my $headers   = delete $options->{headers};
    my $file      = delete $options->{file};

    my $results = $options->{results};
    $method  ||= 'get';
    $headers ||= {};
    $form    ||= {};

    if ($url) {
        $self->ua->cookie_jar($cookies) if ref $cookies;
        async_pool {
            $self->sem->down;
            $self->cv->begin;
            $self->ua->$method(
                $url => $headers => form => $form => sub {
                    my ( $ua, $tx ) = @_;
                    Coro::AnyEvent::sleep($self->interval) if $self->interval;
                    $self->emit(
                        download => $ua,
                        $file, $tx, $options->{results}
                    );
                    $self->sem->up;
                    $self->cv->end;
                }
            );
        };
    }
    return sub { $self->cv->recv };
}

sub download {
    my ( $self, $url, $file ) = @_;
    return $self->_async_request( $url, { file => $file } );
}

1;

__END__