#!/usr/bin/perl
# BEGIN BPS TAGGED BLOCK {{{
#
# COPYRIGHT:
#
# This software is Copyright (c) 1996-2015 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,                               'v|verbose',
    'install!',
    'with-MYSQL', 'with-PG', 'with-SQLITE', 'with-ORACLE',
    'with-FASTCGI', 'with-MODPERL1', 'with-MODPERL2', 'with-STANDALONE',

    'with-DEVELOPER',

    'with-GPG',
    'with-ICAL',
    'with-GRAPHVIZ',
    'with-GD',
    'with-DASHBOARDS',
    'with-USERLOGO',
    'with-HTML-DOC',

    'list-deps',
    'siteinstall!',
    'help|h',
);

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-ICAL' => 1,
    'with-GRAPHVIZ' => 0,
    'with-GD' => 0,
    'with-DASHBOARDS' => 1,
    'with-USERLOGO' => 1,
    'with-HTML-DOC' => 0,
);
$args{$_} = $default{$_} foreach grep !exists $args{$_}, keys %default;

{
  my $section;
  my %always_show_sections = (
    perl => 1,
    users => 1,
  );

  sub section {
    my $s = shift;
    $section = $s;
    print "$s:\n" unless $args{'list-deps'};
  }

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

    unless ( $args{'list-deps'} ) {
        if ( $args{'v'} or not $test or $always_show_sections{$section} ) {
            print "\t$msg ...";
            print $test ? "found" : "MISSING";
            print "\n";
        }

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

sub conclude {
    my %missing_by_type = @_;

    unless ( $args{'list-deps'} ) {
        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 ];
}

$deps{'CORE'} = [ text_to_hash( << '.') ];
Apache::Session 1.53
CGI 3.38
CGI::Cookie 1.20
CGI::Emulate::PSGI
CGI::PSGI 0.12
Class::Accessor::Fast
Crypt::Eksblowfish
CSS::Squish 0.06
Data::GUID
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.897
Email::Address::List 0.02
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
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
JSON
LWP::Simple
List::MoreUtils
Locale::Maketext 1.06
Locale::Maketext::Fuzzy 0.11
Locale::Maketext::Lexicon 0.32
Log::Dispatch 2.30
Mail::Header 2.12
Mail::Mailer 1.57
MIME::Entity 5.504
Module::Refresh 0.03
Module::Versions::Report 1.05
Net::CIDR
Plack 1.0002
Plack::Handler::Starlet
Regexp::Common
Regexp::Common::net::CIDR
Regexp::IPv6
Role::Basic 0.12
Scalar::Util
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
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( << '.') ];
Crypt::SSLeay
Getopt::Long
LWP::Protocol::https
LWP::UserAgent 6.0
Mozilla::CA
Net::SSL
Pod::Usage
.

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

$deps{'DEVELOPER'} = [ text_to_hash( << '.') ];
Email::Abstract
File::Find
File::Which
Locale::PO
Log::Dispatch::Perl
Mojo::DOM
Plack::Middleware::Test::StashWarnings 0.08
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
FCGI::ProcManager
.

$deps{'MODPERL1'} = [ text_to_hash( << '.') ];
Apache::DBI 0.92
Apache::Request
.

$deps{'MODPERL2'} = [ text_to_hash( << '.') ];
Apache::DBI
.

$deps{'MYSQL'} = [ text_to_hash( << '.') ];
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
PerlIO::eol
.

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

$deps{'ICAL'} = [ text_to_hash( << '.') ];
Data::ICal
.

$deps{'DASHBOARDS'} = [ text_to_hash( << '.') ];
MIME::Types
URI 1.59
URI::QueryParam
.

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

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

$deps{'USERLOGO'} = [ text_to_hash( << '.') ];
Convert::Color
.

$deps{'HTML-DOC'} = [ text_to_hash( <<'.') ];
HTML::Entities
Pod::Simple 3.24
.

my %AVOID = (
    'DBD::Oracle' => [qw(1.23)],
    'Devel::StackTrace' => [qw(1.28 1.29)],
);

if ($args{'download'}) {
    download_mods();
}


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 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;

    if ( $args{'list-deps'} ) {
        print $module, ': ', $version || 0, "\n"; 
    }
    else {
        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 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 ) {
        my $configured = 1;
        {
            local @INC = @INC;
            if ( $ENV{'HOME'} ) {
                unshift @INC, "$ENV{'HOME'}/.cpan";
            }
            $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);
        }

        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 $@;

        print <<END;
Failed to load module CPAN.

-------- 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 situatation:

1) use a different tool to install dependencies by running setting the following
   shell environment variable and rerunning this tool:
    RT_FIX_DEPS_CMD='/usr/bin/perl -MCPAN -e"install %s"'
2) Attempt to configure CPAN by running:
   `/usr/bin/perl -MCPAN -e shell` program from shell.
   If this fails, you may have to manually upgrade CPAN (see below)
3) Try to update the CPAN client. Download it from:
   http://search.cpan.org/dist/CPAN and try again
4) Install each dependency manually by downloading them one by one from
   http://search.cpan.org

END
        exit(1);
    }

    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 (bin)", defined getgrnam("bin"));
  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.

the "RT_FIX_DEPS_CMD" environment variable, if set, will be used instead of
the standard CPAN shell by --install to install any required modules.  it will
be called with the module name, or, if "RT_FIX_DEPS_CMD" contains a "%s", will
replace the "%s" with the module name before calling the program.

=head1 OPTIONS

=over

=item install

    install missing modules

=item verbose

list the status of all dependencies, rather than just the missing ones.

-v is equal to --verbose

=item specify dependencies

=over

=item --with-mysql

database interface for mysql

=item --with-pg

database interface for postgresql

=item --with-oracle

database interface for oracle

=item --with-sqlite

database interface and driver for sqlite (unsupported)

=item --with-fastcgi

libraries needed to support the fastcgi handler

=item --with-modperl1

libraries needed to support the modperl 1 handler

=item --with-modperl2

libraries needed to support the modperl 2 handler

=item --with-developer

tools needed for RT development

=back

=back

