path: root/Bugzilla/Install/CPAN.pm

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This Source Code Form is "Incompatible With Secondary Licenses", as
# defined by the Mozilla Public License, v. 2.0.

package Bugzilla::Install::CPAN;

use 5.10.1;
use strict;
use warnings;

use parent qw(Exporter);
our @EXPORT = qw(
    BZ_LIB

    check_cpan_requirements 
    set_cpan_config
    install_module 
);

use Bugzilla::Constants;
use Bugzilla::Install::Requirements qw(have_vers);
use Bugzilla::Install::Util qw(bin_loc install_string);

use Config;
use CPAN;
use Cwd qw(abs_path);
use File::Path qw(rmtree);

# These are required for install-module.pl to be able to install
# all modules properly.
use constant REQUIREMENTS => (
    {
        module  => 'CPAN',
        package => 'CPAN',
        version => '1.81',
    },
    {
        # When Module::Build isn't installed, the YAML module allows
        # CPAN to read META.yml to determine that Module::Build first
        # needs to be installed to compile a module.
        module  => 'YAML',
        package => 'YAML',
        version => 0,
    },
    {
        # Many modules on CPAN are now built with Dist::Zilla, which
        # unfortunately means they require this version of EU::MM to install.
        module  => 'ExtUtils::MakeMaker',
        package => 'ExtUtils-MakeMaker',
        version => '6.31',
    },
);

# We need the absolute path of ext_libpath, because CPAN chdirs around
# and so we can't use a relative directory.
#
# We need it often enough (and at compile time, in install-module.pl) so 
# we make it a constant.
use constant BZ_LIB => abs_path(bz_locations()->{ext_libpath});

# CPAN requires nearly all of its parameters to be set, or it will start
# asking questions to the user. We want to avoid that, so we have
# defaults here for most of the required parameters we know about, in case
# any of them aren't set. The rest are handled by set_cpan_defaults().
use constant CPAN_DEFAULTS => {
    auto_commit => 0,
    # We always force builds, so there's no reason to cache them.
    build_cache => 0,
    build_requires_install_policy => 'yes',
    cache_metadata => 1,
    colorize_output => 1,
    colorize_print => 'bold',
    index_expire => 1,
    scan_cache => 'atstart',

    inhibit_startup_message => 1,

    bzip2 => bin_loc('bzip2'),
    curl => bin_loc('curl'),
    gzip => bin_loc('gzip'),
    links => bin_loc('links'),
    lynx => bin_loc('lynx'),
    make => bin_loc('make'),
    pager => bin_loc('less'),
    tar => bin_loc('tar'),
    unzip => bin_loc('unzip'),
    wget => bin_loc('wget'),

    urllist => ['http://www.cpan.org/'],
};

sub check_cpan_requirements {
    my ($original_dir, $original_args) = @_;

    _require_compiler();

    my @install;
    foreach my $module (REQUIREMENTS) {
        my $installed = have_vers($module, 1);
        push(@install, $module) if !$installed;
    }

    return if !@install;

    my $restart_required;
    foreach my $module (@install) {
        $restart_required = 1 if $module->{module} eq 'CPAN';
        install_module($module->{module}, 1);
    }

    if ($restart_required) {
        chdir $original_dir;
        exec($^X, $0, @$original_args);
    }
}

sub _require_compiler {
    my @errors;

    my $cc_name = $Config{cc};
    my $cc_exists = bin_loc($cc_name);

    if (!$cc_exists) {
        push(@errors, install_string('install_no_compiler'));
    }

    my $make_name = $CPAN::Config->{make};
    my $make_exists = bin_loc($make_name);

    if (!$make_exists) {
        push(@errors, install_string('install_no_make'));
    }

    die @errors if @errors;
}

sub install_module {
    my ($name, $test) = @_;
    my $bzlib = BZ_LIB;

    # Make Module::AutoInstall install all dependencies and never prompt.
    local $ENV{PERL_AUTOINSTALL} = '--alldeps';
    # This makes Net::SSLeay not prompt the user, if it gets installed.
    # It also makes any other MakeMaker prompts accept their defaults.
    local $ENV{PERL_MM_USE_DEFAULT} = 1;

    # Certain modules require special stuff in order to not prompt us.
    my $original_makepl = $CPAN::Config->{makepl_arg};
    # This one's a regex in case we're doing Template::Plugin::GD and it
    # pulls in Template-Toolkit as a dependency.
    if ($name =~ /^Template/) {
        $CPAN::Config->{makepl_arg} .= " TT_ACCEPT=y TT_EXTRAS=n";
    }
    elsif ($name eq 'XML::Twig') {
        $CPAN::Config->{makepl_arg} = "-n $original_makepl";
    }
    elsif ($name eq 'SOAP::Lite') {
        $CPAN::Config->{makepl_arg} .= " --noprompt";
    }

    my $module = CPAN::Shell->expand('Module', $name);
    if (!$module) {
        die install_string('no_such_module', { module => $name }) . "\n";
    }

    print install_string('install_module', 
              { module => $name, version => $module->cpan_version }) . "\n";

    if ($test) {
        CPAN::Shell->force('install', $name);
    }
    else {
        CPAN::Shell->notest('install', $name);
    }

    # If it installed any binaries in the Bugzilla directory, delete them.
    if (-d "$bzlib/bin") {
        File::Path::rmtree("$bzlib/bin");
    }

    $CPAN::Config->{makepl_arg} = $original_makepl;
}

sub set_cpan_config {
    my $do_global = shift;
    my $bzlib = BZ_LIB;

    # We set defaults before we do anything, otherwise CPAN will
    # start asking us questions as soon as we load its configuration.
    eval { require CPAN::Config; };
    _set_cpan_defaults();

    # Calling a senseless autoload that does nothing makes us
    # automatically load any existing configuration.
    # We want to avoid the "invalid command" message.
    open(my $saveout, ">&", "STDOUT");
    open(STDOUT, '>', '/dev/null');
    eval { CPAN->ignore_this_error_message_from_bugzilla; };
    undef $@;
    close(STDOUT);
    open(STDOUT, '>&', $saveout);

    my $dir = $CPAN::Config->{cpan_home};
    if (!defined $dir || !-w $dir) {
        # If we can't use the standard CPAN build dir, we try to make one.
        $dir = "$ENV{HOME}/.cpan";
        mkdir $dir;

        # If we can't make one, we finally try to use the Bugzilla directory.
        if (!-w $dir) {
            print STDERR install_string('cpan_bugzilla_home'), "\n";
            $dir = "$bzlib/.cpan";
        }
    }
    $CPAN::Config->{cpan_home} = $dir;
    $CPAN::Config->{build_dir} = "$dir/build";
    # We always force builds, so there's no reason to cache them.
    $CPAN::Config->{keep_source_where} = "$dir/source";
    # This is set both here and in defaults so that it's always true.
    $CPAN::Config->{inhibit_startup_message} = 1;
    # Automatically install dependencies.
    $CPAN::Config->{prerequisites_policy} = 'follow';
    
    # Unless specified, we install the modules into the Bugzilla directory.
    if (!$do_global) {
        require Config;

        $CPAN::Config->{makepl_arg} .= " LIB=\"$bzlib\""
            . " INSTALLMAN1DIR=\"$bzlib/man/man1\""
            . " INSTALLMAN3DIR=\"$bzlib/man/man3\""
            # The bindirs are here because otherwise we'll try to write to
            # the system binary dirs, and that will cause CPAN to die.
            . " INSTALLBIN=\"$bzlib/bin\""
            . " INSTALLSCRIPT=\"$bzlib/bin\""
            # INSTALLDIRS=perl is set because that makes sure that MakeMaker
            # always uses the directories we've specified here.
            . " INSTALLDIRS=perl";
        $CPAN::Config->{mbuild_arg} = " --install_base \"$bzlib\""
            . " --install_path lib=\"$bzlib\""
            . " --install_path arch=\"$bzlib/$Config::Config{archname}\"";
        $CPAN::Config->{mbuild_install_arg} = $CPAN::Config->{mbuild_arg};

        # When we're not root, sometimes newer versions of CPAN will
        # try to read/modify things that belong to root, unless we set
        # certain config variables.
        $CPAN::Config->{histfile} = "$dir/histfile";
        $CPAN::Config->{use_sqlite} = 0;
        $CPAN::Config->{prefs_dir} = "$dir/prefs";

        # Unless we actually set PERL5LIB, some modules can't install
        # themselves, like DBD::mysql, DBD::Pg, and XML::Twig.
        my $current_lib = $ENV{PERL5LIB} ? $ENV{PERL5LIB} . ':' : '';
        $ENV{PERL5LIB} = $current_lib . $bzlib;
    }
}

sub _set_cpan_defaults {
    # If CPAN hasn't been configured, we try to use some reasonable defaults.
    foreach my $key (keys %{CPAN_DEFAULTS()}) {
        $CPAN::Config->{$key} = CPAN_DEFAULTS->{$key}
            if !defined $CPAN::Config->{$key};
    }

    my @missing;
    # In newer CPANs, this is in HandleConfig. In older CPANs, it's in
    # Config.
    if (eval { require CPAN::HandleConfig }) {
        @missing = CPAN::HandleConfig->missing_config_data;
    }
    else {
        @missing = CPAN::Config->missing_config_data;
    }

    foreach my $key (@missing) {
        $CPAN::Config->{$key} = '';
    }
}

1;

__END__

=head1 NAME

Bugzilla::Install::CPAN - Routines to install Perl modules from CPAN.

=head1 SYNOPSIS

 use Bugzilla::Install::CPAN;

 set_cpan_config();
 install_module('Module::Name');

=head1 DESCRIPTION

This is primarily used by L<install-module> to do the "hard work" of
installing CPAN modules.

=head1 SUBROUTINES

=over

=item C<set_cpan_config>

Sets up the configuration of CPAN for this session. Must be called
before L</install_module>. Takes one boolean parameter. If true,
L</install_module> will install modules globally instead of to the
local F<lib/> directory. On most systems, you have to be root to do that.

=item C<install_module>

Installs a module from CPAN. Takes two arguments:

=over

=item C<$name> - The name of the module, just like you'd pass to the
C<install> command in the CPAN shell.

=item C<$test> - If true, we run tests on this module before installing,
but we still force the install if the tests fail. This is only used
when we internally install a newer CPAN module.

=back

Note that calling this function prints a B<lot> of information to
STDOUT and STDERR.

=back

=head1 B<Methods in need of POD>

=over

=item check_cpan_requirements

=back