Subversion Repositories DevTools

#! /usr/bin/perl
########################################################################
# Copyright (C) 1998-2005 ERG Limited, All rights reserved
#
# Module name   : jats_deploy.pl
# Module type   : Makefile system
# Compiler(s)   : n/a
# Environment(s):
#
# Description   : This script is run via the JATS wrapper script
#                 The script will setup an environment suitable for the
#                 processing of the deployfile.pl script
#
#                 NOTE:
#                 Appears to be the start of something.
#                   Don't know where Deploy.cfg is generated or what it
#                   might contain.
#
#                   Dosn't actually call the deployfile. Perhaps that was the
#                   next step.
#
#......................................................................#

require 5.006_001;
use strict;
use warnings;
use JatsError;

use Data::Dumper;                           # Debug only
use Pod::Usage;                             # required for help support
use Getopt::Long;
use Cwd;

my $VERSION = "1.0.0";                      # Update this

#
#   Options
#
my $opt_debug   = $ENV{'GBE_DEBUG'};        # Allow global debug
my $opt_verbose = $ENV{'GBE_VERBOSE'};      # Allow global verbose
my $opt_help = 0;
my $opt_manual = 0;

#
#   Globals
#
my $GBE_PERL     = $ENV{'GBE_PERL'};        # Essential ENV variables
my $GBE_CORE     = $ENV{'GBE_CORE'};
my $USER         = $ENV{'USER'};
my $GBE_MACHTYPE = $ENV{'GBE_MACHTYPE'};

#
#   Imported Globals (configuration)
#
our @deploy_cf_args;
our $ScmBuildName;
our $ScmBuildPackage;
our $ScmBuildVersion;
our $ScmBuildVersionFull;
our $ScmBuildProject;
our $ScmBuildPreviousVersion;
our $ScmSrcDir;
our @BUILDPLATFORMS;
our %ScmBuildAliases;
our @DEFBUILDPLATFORMS;
our %ScmBuildPlatforms;
our %BUILDPLATFORM_PARTS;

#
#   Working variables
#
my $deployfile;

#-------------------------------------------------------------------------------
# Function        : Mainline Entry Point
#
# Description     :
#
# Inputs          :
#
my $result = GetOptions (
                "help+"         => \$opt_help,              # flag, multiple use allowed
                "manual"        => \$opt_manual,            # flag, multiple use allowed
                "verbose+"      => \$opt_verbose,           # flag, multiple use allowed
                );

                #
                #   UPDATE THE DOCUMENTATION AT THE END OF THIS FILE !!!
                #

#
#   Process help and manual options
#
pod2usage(-verbose => 0, -message => "Version: $VERSION")  if ($opt_help == 1  || ! $result);
pod2usage(-verbose => 1)  if ($opt_help == 2 );
pod2usage(-verbose => 2)  if ($opt_manual || ($opt_help > 2));

#
#   Configure the error reporting process now that we have the user options
#
ErrorConfig( 'name'    =>'DEPLOY',
             'verbose' => $opt_verbose,
             'debug'   => $opt_debug
             );

#
#   Validate user options
#

#
#   Locate the JATS generated data file
#   This will be in the "interface" directory, or if this directory does not
#   exist the file will be found in the current directory. The name of the
#   interface directory is not well defined. It may be called interface
#   but it may not. It will be one directory below the build directory.
#
#   The data file can be "require"ed directly by Perl.
#
my $idir;
opendir (DIR, "." ) or Error( "Cannot open the current directory");
while ( $_ = readdir( DIR ) )
{
    next if ( $_ =~ m/\./ );
    next unless ( -d $_ );
    if ( -f "$_/Build.cfg" )
    {
        Verbose ("Search for Build.cfg in: $_");
        Warning( "Multiple interface directories located" )
            if ( $idir );
        $idir = $_;
    }
}
closedir DIR;
Error ("No suitable interface directory located") unless defined($idir);

#
#   Read in the general Build.cfg data and the Deploy.cfg data
#
#for (qw(Build.cfg Deploy.cfg))
for (qw( Build.cfg ))
{
    my $fname = $_;
    $fname = "$idir/$_" unless ( -f $_ );
    Verbose ("Check for: $fname");
    Error( "Cannot locate $fname") unless ( -f $fname );
    require $fname;
}

#
#   Display useful information
#
if ( $opt_verbose )
{
    print "Build Parameters\n";
    print "     ScmBuildName             $::ScmBuildName\n";
    print "     ScmBuildPackage          $::ScmBuildPackage\n";
    print "     ScmBuildVersion          $::ScmBuildVersion\n";
    print "     ScmBuildProject          $::ScmBuildProject\n";
    print "     ScmBuildVersionFull      $::ScmBuildVersionFull\n";
    print "     ScmBuildPreviousVersion  $::ScmBuildPreviousVersion\n";
    print "     ScmSrcDir                $::ScmSrcDir\n";
    

    print "\nBuildDeploy Arguments\n";
    foreach (@::deploy_cf_args )
    {
        print "     $_\n";
    }
}

#
#   Locate the deployfile.pl
#   This MUST be in the directory specified ScmSrcDir or the build directory
#
foreach ( ".", $::ScmSrcDir )
{
    next unless( -f "$_/deployfile.pl" );
    Warning("Multiple deployfile.pl file found") if ( $deployfile );
    $deployfile = "$_/deployfile.pl";
}

Error("deployfile.pl not found")
    unless ( $deployfile );
Verbose("Deployment script: $deployfile" );

#
#   Invoke the deployfile.pl for each required platform
#   The platforms have been specified by the user on the command line
#
#   There are some special processing rules (largely to look like make )
#
#       all         - process all default platforms
#       XXXX        - process production and debug for XXXX
#       XXXX_debug  - process debug for XXXX
#       XXXX_prod   - process production for XXXX
#
if ( $#ARGV < 0  )
{
    #
    #   Display a list of available comamnd targets
    #
    print "Available platforms include:\n";
    print "     all, debug, prod\n";
    print "     " . join ( ', ', @::DEFBUILDPLATFORMS) . "\n";

    print "\n";
    Warning("Nothing to do" );
}

foreach my $platform ( @ARGV )
{
    my $gdebug = 1;
    my $gprod = 1;
    my @platform_list;

    #
    #   Extract _prod and _debug information
    #
    $gprod = 0  if ( $platform =~ m/_debug$/ );
    $gdebug = 0 if ( $platform =~ m/_prod$/ );
    $platform =~ s/_debug$|_prod$//;

    #
    #   Create a list of platforms to process
    #
    if ( $platform eq 'all' ) {
        @platform_list = @::DEFBUILDPLATFORMS;
        Verbose ("Alias of all: @platform_list");

    } elsif ( defined $::ScmBuildAliases{$platform} ) {
        #
        #   Remove options from the Alias list to leave platforms
        #
        @platform_list = grep{!/^--/} split( ' ', $::ScmBuildAliases{$platform});
        Verbose ("Alias of $platform: @platform_list");

    } else {
        my $found;
        foreach  ( @::BUILDPLATFORMS )
        {
            if ( $_ eq $platform )
            {
                $found++;
                last;
            }
        }
        Error( "Platform not known: $platform")
            unless ( $found );

        push @platform_list, $platform;
    }

    #
    #   Process each platform in the list
    #   These may need to be done for both the debug and production flavor
    #   Examine the platform arguments to pickup build specified limits
    #
    foreach my $platform ( @platform_list )
    {
        #
        #   Process platform arguments looking for OnlyProd and OnlyDebug
        #   This will then modify the global user request
        #
        my $debug = $gdebug;
        my $prod = $gprod;

        my @platform_ops = split( "$;", $::ScmBuildPlatforms{$platform} );
        foreach  ( @platform_ops )
        {
            $prod = 0 if ( m/^--OnlyDebug/ );
            $debug = 0 if ( m/^--OnlyProd/ )
        }
        Verbose( "Platform: $platform, debug:$debug, Prod:$prod");
        process_platform( $platform, "D" ) if ( $debug );
        process_platform( $platform, "P" ) if ( $prod );
        Warning ("Nothing to do for: $platform") unless ( $debug || $prod );
    }
}

#-------------------------------------------------------------------------------
# Function        : process_platform
#
# Description     : Perform processing for one platform
#
# Inputs          : $platform       - platform to process
#                   $type           - P or D
#
# Returns         : Nothing
#
sub process_platform
{
    my( $platform, $type ) = @_;
    my @parts = @{$BUILDPLATFORM_PARTS{$platform}};

    my $target = $parts[-1];            # Last one is the target
    my $product = $parts[1];            # 2nd one is the product

    print "---- Processing $platform ($product, $target), $type\n";
    

    system ( $GBE_PERL,
            '-w',  $deployfile,                 # File to process
                    '-r', '.' ,                         # Root directory
                    '-n', $::ScmBuildName,              # Package Name
                    '-d', lc($::ScmBuildName),          # Directory
                    '-v', $::ScmBuildVersionFull,       # Build version
                    '-t', $type,                        # Build type
                    '-o', $::ScmBuildPreviousVersion,   # Previous Version
                    '-m', $platform,                    # Platform
                    '-g', $target,                      # Target
                    '-k', $product );                   # Product

}

#-------------------------------------------------------------------------------
#   Documentation
#

=pod

=head1 NAME

jats_deploy - Process deployfile.pl's

=head1 SYNOPSIS

  jats deploy [options] action

 Options:
    -help              - brief help message
    -help -help        - Detailed help message
    -man               - Full documentation
    -verbose           - Generate verbose output

 Actions:
    all                 - Debug and Production builds
    debug               - Debug build of all platform
    prod                - Production build of all platforms
    other*              - Specify a single platform. Optional _prod or _debug

=head1 OPTIONS

=over 8

=item B<-help>

Print a brief help message and exits.

=item B<-help -help>

Print a detailed help message with an explanation for each option.

=item B<-man>

Prints the manual page and exits.

=item B<-verbose>

Incresed the level of output generated by the program.

=back

=head1 DESCRIPTION

This program is the primary tool for the invocation of the deployfile.pl scripts

In normal operation the program will:

=over 8

=item Setup the environment

Read the deploy.cfg file from the interface directory.

=item Locate and execute the deployfile.pl

This file MUST be located in the primary source directory. The same directory
as the top level makefile.

=cut