view release on metacpan or  search on metacpan

lib/App/cpan2arch/GetMetadata.pm  view on Meta::CPAN

    $self->_psub;

    $_mua_mcpan = $self->_get_mua('mcpan');

    return $self;
}

# Create a Mojo::UserAgent instance.
method _get_mua ($type)
{
    return undef if $type ne 'mcpan' && $type ne 'arch';

    # Caching support
    my $has_muac = do {
        try {
            require Mojo::UserAgent::Cached;
            Mojo::UserAgent::Cached->VERSION('1.25');
        }
        catch ($e) {
            # Use Mojo::UA as fallback.
            require Mojo::UserAgent;

            $self->_pdbg("Mojo::UserAgent::Cached is not installed\n\n");
            undef;
        }
    };
    my $has_chi = do {
        if ( defined $has_muac ) {
            try {
                require CHI;
                CHI->VERSION('0.61');
            }
            catch ($e) {
                $self->_pdbg("CHI is not installed\n\n");
                undef;
            }
        }
    };

    my %env  = $self->env;
    my %opts = $self->opts;
    my $mua;

    if ( defined $has_muac && defined $has_chi ) {
        require Mojo::Log;

        # Silence logger
        my $logger;
        $logger = Mojo::Log->new( path => '/dev/null' ) unless $env{debug};

        $mua = Mojo::UserAgent::Cached->new(
            $env{debug}
            ? ()
            : ( logger => $logger ),
        );

        # Use CHI as the cache backend.
        {
            my $path =
                $type eq 'mcpan'
              ? $env{cache_mcpan_path}
              : $env{cache_arch_path};

            my $chi;

            $chi = CHI->new(
                driver     => 'File',
                root_dir   => $path,
                expires_in => $env{cache_expiration},
            ) unless $env{cache_ignore};

            if ( defined $chi ) {
                $chi->clear
                  if defined $opts{clear}
                  || ( $type eq 'mcpan' && defined $opts{clear_mcpan} )
                  || ( $type eq 'arch'  && defined $opts{clear_arch} );
            }

            $mua->cache_agent($chi) unless $env{cache_ignore};
        }
    }
    else {
        $mua = Mojo::UserAgent->new;
    }

    $mua->transactor->name( $env{user_agent} ) if defined $mua;

    return $mua;
}

method _get_module ($module)
{
    $self->_psub;

    my $prog = $self->prog;
    my $url  = $_endpoints{module} . "$module?fields=distribution";
    my $json;

    my $res = do {
        try {
            my %env = $self->env;
            local $ENV{MUAC_NOCACHE} = true if $env{cache_ignore};

            $_mua_mcpan->get($url)->result;
        }
        catch ($e) {
            warn $e;
            undef;
        }
    };

    if ( defined $res && $res->is_success ) {
        $self->_pdbg("\n");
        $json = $res->json;
    }

    if ( !defined $json ) {
        warn "$prog: failed to fetch $module module\n";
        $self->_pdbg("\n");

        return undef;