#!/usr/bin/perl
# BEGIN BPS TAGGED BLOCK {{{
#
# COPYRIGHT:
#
# This software is Copyright (c) 1996-2022 Best Practical Solutions, LLC
#                                          <sales@bestpractical.com>
#
# (Except where explicitly superseded by other copyright notices)
#
#
# LICENSE:
#
# This work is made available to you under the terms of Version 2 of
# the GNU General Public License. A copy of that license should have
# been provided with this software, but in any event can be snarfed
# from www.gnu.org.
#
# This work is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301 or visit their web page on the internet at
# http://www.gnu.org/licenses/old-licenses/gpl-2.0.html.
#
#
# CONTRIBUTION SUBMISSION POLICY:
#
# (The following paragraph is not intended to limit the rights granted
# to you to modify and distribute this software under the terms of
# the GNU General Public License and is only of importance to you if
# you choose to contribute your changes and enhancements to the
# community by submitting them to Best Practical Solutions, LLC.)
#
# By intentionally submitting any modifications, corrections or
# derivatives to this work, or any other work intended for use with
# Request Tracker, to Best Practical Solutions, LLC, you confirm that
# you are the copyright holder for those contributions and you grant
# Best Practical Solutions,  LLC a nonexclusive, worldwide, irrevocable,
# royalty-free, perpetual, license to use, copy, create derivative
# works based on those contributions, and sublicense and distribute
# those contributions and any derivatives thereof.
#
# END BPS TAGGED BLOCK }}}
#
# This is just a basic script that checks to make sure that all
# the modules needed by RT before you can install it.
#

use strict;
use warnings;
no warnings qw(numeric redefine);
use Getopt::Long;
use Cwd qw(abs_path);
my %args;
my %deps;
my @orig_argv = @ARGV;
# Save our path because installers or tests can change cwd
my $script_path = abs_path($0);

GetOptions(
    \%args,
    'install!',
    'with-MYSQL', 'with-PG', 'with-SQLITE', 'with-ORACLE',
    'with-FASTCGI', 'with-MODPERL2', 'with-STANDALONE',

    'with-DEVELOPER',

    'with-GPG',
    'with-GRAPHVIZ',
    'with-GD',
    'with-EXTERNALAUTH',

    'with-S3', 'with-DROPBOX',

    'siteinstall!',
    'help|h',

    # No-ops, for back-compat
    'v|verbose', 'with-ICAL', 'with-DASHBOARDS', 'with-USERLOGO',
);

if ( $args{help} ) {
    require Pod::Usage;
    Pod::Usage::pod2usage( { verbose => 2 } );
    exit;
}

# Set up defaults
my %default = (
    'with-CORE'         => 1,
    'with-CLI'          => 1,
    'with-MAILGATE'     => 1,
    'with-DEVELOPER'    => 0,
    'with-GPG'          => 1,
    'with-SMIME'        => 1,
    'with-GRAPHVIZ'     => 1,
    'with-GD'           => 0,
    'with-EXTERNALAUTH' => 0,
    'with-S3'           => (uc(q{database}) eq 'S3'),
    'with-DROPBOX'      => (uc(q{database}) eq 'DROPBOX'),
);
$args{$_} = $default{$_} foreach grep {!exists $args{$_}} keys %default;

$args{'with-EXTERNALAUTH-TESTS'}
    = $args{'with-EXTERNALAUTH'} && $args{'with-DEVELOPER'};

$deps{'CORE'} = [ text_to_hash( << '.') ];
Apache::Session 1.53
Business::Hours
CGI 3.38
CGI::Cookie 1.20
CGI::Emulate::PSGI
CGI::PSGI 0.12
Class::Accessor::Fast
Clone
Convert::Color
Crypt::Eksblowfish
CSS::Minifier::XS
CSS::Squish 0.06
Data::GUID
Data::ICal
Data::Page::Pageset
Date::Extract 0.02
Date::Manip
DateTime 0.44
DateTime::Format::Natural 0.67
DateTime::Locale 0.40
DBI 1.37
DBIx::SearchBuilder 1.65
Devel::GlobalDestruction
Devel::StackTrace 1.19
Digest::base
Digest::MD5 2.27
Digest::SHA
Email::Address 1.912
Email::Address::List 0.06
Encode 2.64
Errno
File::Glob
File::ShareDir
File::Spec 0.8
File::Temp 0.19
HTML::Entities
HTML::FormatText::WithLinks 0.14
HTML::FormatText::WithLinks::AndTables 0.06
HTML::Mason 1.43
HTML::Mason::PSGIHandler 0.52
HTML::Quoted
HTML::RewriteAttributes 0.05
HTML::Scrubber 0.08
HTTP::Message 6.0
IPC::Run3
JavaScript::Minifier::XS
JSON
List::MoreUtils
Locale::Maketext 1.06
Locale::Maketext::Fuzzy 0.11
Locale::Maketext::Lexicon 0.32
Log::Dispatch 2.30
LWP::Simple
Mail::Header 2.12
Mail::Mailer 1.57
MIME::Entity 5.504
MIME::Types
Module::Refresh 0.03
Module::Versions::Report 1.05
Net::CIDR
Net::IP
Parallel::ForkManager
Plack 1.0002
Plack::Handler::Starlet
Pod::Select
Regexp::Common
Regexp::Common::net::CIDR
Regexp::IPv6
Role::Basic 0.12
Scalar::Util
Scope::Upper
Storable 2.08
Symbol::Global::Name 0.04
Sys::Syslog 0.16
Text::Password::Pronounceable
Text::Quoted 2.07
Text::Template 1.44
Text::WikiFormat 0.76
Text::Wrapper
Time::HiRes
Time::ParseDate
Tree::Simple 1.04
UNIVERSAL::require
URI 1.59
URI::QueryParam
XML::RSS 1.05
.
set_dep( CORE => 'Symbol::Global::Name' => 0.05 ) if $] >= 5.019003;
set_dep( CORE => CGI => 4.00 ) if $] > 5.019003;

$deps{'MAILGATE'} = [ text_to_hash( << '.') ];
Getopt::Long
LWP::Protocol::https
LWP::UserAgent 6.02
Mozilla::CA
Pod::Usage
.

$deps{'CLI'} = [ text_to_hash( << '.') ];
Getopt::Long 2.24
HTTP::Request::Common
LWP 6.02
Term::ReadKey
Term::ReadLine
Text::ParseWords
.

$deps{'DEVELOPER'} = [ text_to_hash( << '.') ];
Email::Abstract
File::Find
File::Which
HTML::Entities
Locale::PO
Log::Dispatch::Perl
Mojolicious
Plack::Middleware::Test::StashWarnings 0.08
Pod::Simple 3.24
Set::Tiny
String::ShellQuote 0 # needed for gnupg-incoming.t
Test::Builder 0.90 # needed for is_passing
Test::Deep 0 # needed for shredder tests
Test::Email
Test::Expect 0.31
Test::LongString
Test::MockTime
Test::NoWarnings
Test::Pod
Test::Warn
Test::WWW::Mechanize 1.30
Test::WWW::Mechanize::PSGI
WWW::Mechanize 1.52
XML::Simple
.

$deps{'FASTCGI'} = [ text_to_hash( << '.') ];
FCGI 0.74
.

$deps{'MYSQL'} = [ text_to_hash( << '.') ];
DBIx::SearchBuilder 1.68
DBD::mysql 2.1018
.

$deps{'ORACLE'} = [ text_to_hash( << '.') ];
DBD::Oracle
.

$deps{'PG'} = [ text_to_hash( << '.') ];
DBIx::SearchBuilder 1.66
DBD::Pg 1.43
.

$deps{'SQLITE'} = [ text_to_hash( << '.') ];
DBD::SQLite 1.00
.

$deps{'GPG'} = [ text_to_hash( << '.') ];
File::Which
GnuPG::Interface 1.02
PerlIO::eol
.

$deps{'SMIME'} = [ text_to_hash( << '.') ];
Crypt::X509
File::Which
String::ShellQuote
.

$deps{'GRAPHVIZ'} = [ text_to_hash( << '.') ];
GraphViz
IPC::Run 0.90
.

$deps{'GD'} = [ text_to_hash( << '.') ];
GD
GD::Graph 1.47
GD::Text
.

$deps{'EXTERNALAUTH'} = [ text_to_hash( <<'.') ];
Net::SSLeay
Net::LDAP
.

$deps{'EXTERNALAUTH-TESTS'} = [ text_to_hash( <<'.') ];
Net::LDAP::Server::Test
.

$deps{'S3'} = [ text_to_hash( <<'.') ];
Amazon::S3
.

$deps{'DROPBOX'} = [ text_to_hash( <<'.') ];
File::Dropbox
.

my %AVOID = (
    'DBD::Oracle'       => [qw(1.23)],
    'Devel::StackTrace' => [qw(1.28 1.29)],
    'DateTime::Locale'  => [qw(1.00 1.01)],
    'DBD::mysql'        => [qw(4.042)],
    'Mojolicious'         => [qw(8.54)],
);

check_perl_version();

check_users();

my %Missing_By_Type = ();
foreach my $type ( sort grep {$args{$_}} keys %args ) {
    next unless ( $type =~ /^with-(.*?)$/ ) and $deps{$1};

    $type = $1;
    section("$type dependencies");

    my @missing;
    my @deps = @{ $deps{$type} };

    my %missing = test_deps(@deps);

    if ( $args{'install'} ) {
        for my $module ( keys %missing ) {
            resolve_dep( $module, $missing{$module}{version} );
            my $m = $module . '.pm';
            $m =~ s!::!/!g;
            if ( delete $INC{$m} ) {
                my $symtab = $module . '::';
                no strict 'refs';
                for my $symbol ( keys %{$symtab} ) {
                    next if substr( $symbol, -2, 2 ) eq '::';
                    delete $symtab->{$symbol};
                }
            }
            delete $missing{$module}
                if test_dep( $module, $missing{$module}{version}, $AVOID{$module} );
        }
    }

    $Missing_By_Type{$type} = \%missing if keys %missing;
}

if ( $args{'install'} && keys %Missing_By_Type ) {
    exec( $script_path, @orig_argv, '--no-install' );
} else {
    conclude(%Missing_By_Type);
}

sub section {
    my $s = shift;
    print "$s:\n";
}

sub print_found {
    my $msg   = shift;
    my $test  = shift;
    my $extra = shift;

    print "\t$msg ...";
    print $test ? "found" : "MISSING";
    print "\n";

    print "\t\t$extra\n" if defined $extra;
}

sub conclude {
    my %missing_by_type = @_;

    unless ( keys %missing_by_type ) {
        print "\nAll dependencies have been found.\n";
        return;
    }

    print "\nSOME DEPENDENCIES WERE MISSING.\n";

    for my $type ( keys %missing_by_type ) {
        my $missing = $missing_by_type{$type};

        print "$type missing dependencies:\n";
        for my $name ( keys %$missing ) {
            my $module  = $missing->{$name};
            my $version = $module->{version};
            my $error   = $module->{error};
            print_found(
                $name . ( $version && !$error ? " >= $version" : "" ),
                0, $module->{error} );
        }
    }

    print "\nPerl library path for /usr/bin/perl:\n";
    print "    $_\n" for @INC;

    exit 1;
}

sub text_to_hash {
    my %hash;
    for my $line ( split /\n/, $_[0] ) {
        my ( $key, $value ) = $line =~ /(\S+)\s*(\S*)/;
        $value ||= '';
        $hash{$key} = $value;
    }

    return %hash;
}

sub set_dep {
    my ( $name, $module, $version ) = @_;
    my %list = @{ $deps{$name} };
    $list{$module} = ( $version || '' );
    $deps{$name} = [%list];
}

sub test_deps {
    my @deps = @_;

    my %missing;
    while (@deps) {
        my $module  = shift @deps;
        my $version = shift @deps;
        my ( $test, $error ) = test_dep( $module, $version, $AVOID{$module} );
        my $msg = $module . ( $version && !$error ? " >= $version" : '' );
        print_found( $msg, $test, $error );

        $missing{$module} = { version => $version, error => $error }
            unless $test;
    }

    return %missing;
}

sub test_dep {
    my $module  = shift;
    my $version = shift;
    my $avoid   = shift;

    no warnings 'deprecated';
    eval "{ local \$ENV{__WARN__}; use $module $version () }";
    if ( my $error = $@ ) {
        return 0 unless wantarray;

        $error =~ s/\n(.*)$//s;
        $error =~ s/at \(eval \d+\) line \d+\.$//;
        undef $error if $error =~ /this is only/;

        my $path = $module;
        $path =~ s{::}{/}g;
        undef $error
            if defined $error
            and $error =~ /^Can't locate $path\.pm in \@INC/;

        return ( 0, $error );
    }

    if ($avoid) {
        my $version = $module->VERSION;
        if ( grep {$version eq $_} @$avoid ) {
            return 0 unless wantarray;
            return ( 0,
                "It's known that there are problems with RT and version '$version' of '$module' module. If it's the latest available version of the module then you have to downgrade manually."
            );
        }
    }

    return 1;
}

sub check_cpan {
    unless ( eval {require CPAN; 1} ) {
        print <<END;
Failed to load CPAN module.

-------- Error ---------
$@
------------------------

When we tried to start installing RT's perl dependencies, we were
unable to load the CPAN client. This module is usually distributed
with Perl. This usually indicates that your vendor has shipped an
unconfigured or incorrectly configured CPAN client.  The error above
may (or may not) give you a hint about what went wrong.

You have several choices about how to install dependencies in
this situation:

1) Install the package from your vendor that provides the 'CPAN' perl
   module, then re-run this command.  The package is likely named
   `perl-CPAN` or similar.

2) Use a different tool to install CPAN dependencies; set the
   RT_FIX_DEPS_CMD environment to that tool and re-run this command.
   For instance, using the standalone `cpanm` tool:

       curl -L -o cpanm https://cpanmin.us/
       chmod +x cpanm
       RT_FIX_DEPS_CMD=./cpanm make fixdeps

3) Try to update the CPAN client. Download it from:
   http://search.cpan.org/dist/CPAN , install it, and try again.

4) Install each dependency manually by downloading them one by one from
   http://search.cpan.org

END
        exit(1);
    }

    local @INC = @INC;
    if ( $ENV{'HOME'} ) {
        unshift @INC, "$ENV{'HOME'}/.cpan";
    }
    my $configured = eval { require CPAN::MyConfig }
        || eval { require CPAN::Config };
    unless ($configured) {
        print <<END;
You haven't configured the CPAN shell yet.
Please run `/usr/bin/perl -MCPAN -e shell` to configure it.
END
        exit(1);
    }
}


sub resolve_dep {
    my $module  = shift;
    my $version = shift;

    unless ( defined $args{siteinstall} ) {
        require Config;
        my %uniq;
        my @order = grep {
            (          $_ eq $Config::Config{sitelibexp}
                    or $_ eq $Config::Config{privlibexp}
                )
                and not $uniq{$_}++
        } @INC;
        if (    $] < 5.011
            and @order == 2
            and $order[0] eq $Config::Config{sitelibexp}
            and $order[1] eq $Config::Config{privlibexp} )
        {

            print "\n";
            print "Patched perl, with site_perl before core in \@INC, detected.\n";
            print "Installing dual-life modules into site_perl so they are not\n";
            print "later overridden by the distribution's package.\n";

            $args{siteinstall} = 1;
        } else {
            $args{siteinstall} = 0;
        }
    }

    print "\nInstall module $module\n";

    my $ext = $ENV{'RT_FIX_DEPS_CMD'} || $ENV{'PERL_PREFER_CPAN_CLIENT'};
    unless ($ext) {
        check_cpan();

        my $installdirs = $CPAN::Config->{makepl_arg} ||= "";
        $installdirs =~ s/(\bINSTALLDIRS=\S+|$)/ INSTALLDIRS=site/
            if $args{siteinstall};
        local $CPAN::Config->{makepl_arg} = $installdirs;

        my $rv = eval { require CPAN; CPAN::Shell->install($module) };
        return $rv unless $@;
    }

    if ( $ext =~ /\%s/ ) {
        $ext =~ s/\%s/$module/g;    # sprintf( $ext, $module );
    } else {
        $ext .= " $module";
    }
    print "\t\tcommand: '$ext'\n";
    return scalar `$ext 1>&2`;
}

sub check_perl_version {
    section("perl");
    eval { require 5.010_001 };
    if ($@) {
        print_found(
            "5.10.1", 0,
            sprintf(
                "RT requires Perl v5.10.1 or newer. Your current Perl is v%vd",
                $^V )
        );
        exit(1);
    } else {
        print_found( sprintf( ">=5.10.1(%vd)", $^V ), 1 );
    }
}

sub check_users {
    section("users");
    print_found( "rt group (www)",      defined getgrnam("www") );
    print_found( "bin owner (root)",   defined getpwnam("root") );
    print_found( "libs owner (root)", defined getpwnam("root") );
    print_found( "libs group (root)", defined getgrnam("root") );
    print_found( "web owner (www)",    defined getpwnam("www") );
    print_found( "web group (www)",   defined getgrnam("www") );
}

1;

__END__

=head1 NAME

rt-test-dependencies - test rt's dependencies

=head1 SYNOPSIS

    rt-test-dependencies
    rt-test-dependencies --install
    rt-test-dependencies --with-mysql --with-fastcgi

=head1 DESCRIPTION

By default, C<rt-test-dependencies> determines whether you have
installed all the perl modules RT needs to run.

With B<--install>, it attempts to install any missing dependencies.
If the C<RT_FIX_DEPS_CMD> environment variable is set, it will be used
instead of the standard CPAN shell to install any required modules.
The command will be called with the module to install -- or, if
C<RT_FIX_DEPS_CMD> contains a C<%s>, will replace the C<%s> with the
module name before calling the program.

=head1 OPTIONS

=head2 General options

=over

=item B<--install>

Attempt to install missing modules

=item B<--siteinstall> / B<--no-siteinstall>

By default, RT detects if you are running a version of Perl prior to
5.11, which has been patched by your distribution to alter the search
order for modules.  In such cases, C<--install> attempts to install
modules into the right place such that they cannot be accidentally
downgraded by the distribution.  Use B<--siteinstall> to force this
behavior, or B<--no-siteinstall> to prohibit it.  These options have
no effect when used with Perl 5.11 or above.

=back

=head2 Configuration options

=over

=item B<--with-mysql>

=item B<--with-pg>

=item B<--with-oracle>

=item B<--with-sqlite>

These configure which backend database to add dependencies for.


=item C<--with-standalone>

=item B<--with-fastcgi>

=item B<--with-modperl2>

These configure which interface between the webserver and RT to add
dependencies for.


=item B<--with-developer>

Add dependencies needed to develop RT and run its tests.


=item B<--with-gpg>

Add dependencies for GPG encryption and decryption of email.

=item B<--with-graphviz>

Add dependencies for visualizing dependencies between tickets.

=item B<--with-gd>

Add dependencies for creating charts and graphs from search results.

=item B<--with-externalauth>

Add dependencies to integrating with LDAP and other external
authentication sources.

=item B<--with-s3>

Add dependencies for storing large attachments in Amazon S3.

=item B<--with-dropbox>

Add dependencies for storing large attachments in Dropbox.

=back

