Subversion Repositories DevTools

# Copyright (C) 1998-2004 ERG Transit Systems, All rights reserved

#

# Module name   : installpkg.pl

# Module type   : Makefile system

# Environment(s): n/a

#											

# Description:    Install package definition file.

#		

#	This file is invoked during package installation

#

###############################################################################

#

#   The main purpose of this program is to take packages from dpkg_archive and

#   place them into the build's 'interface' directory in a form that can be used

#   by the rest of the build. This process is complicated by the number of

#   variants in package format. In the pre-JATS2 days the users were encourgaed

#   to dream up there own format for packages. The hard of of this script is

#   dealing with all the known variations. Under JATS2 the default package

#   layout is much easier to implemenet and users generally adhere to it.

#

#   The target 'interface' format is of the form:

#

#           interface/

#               include/

#                   PLATFORM/

#                   PRODUCT/

#                   TARGET/

#               lib/                                    - Should not be populated

#                   PLATFORM/                           - Ideal

#                   PRODUCT/                            - Not practical

#                   TARGET/

#               bin/                                    - Should not be populated

#                   PLATFORM[P|D]/                      - Ideal

#                   PRODUCT[P|D]/                       - Not practical

#                   TARGET[P|D]/

#

#               tools/

#                   bin/

#                       MACHTYPE/

#                   scrips/

#                       MACHTYPE/

#

#               pkg/

#

#               OTHERS

#

#

use strict;

use warnings;

use JatsError;

use DescPkg;

use JatsEnv;

use Cwd;

use File::Basename;

use File::Find;

use File::Path;

use File::Copy;

#

#   Global variables

#

our $GBE_VERBOSE;

our $GBE_MACHTYPE;

my %PLATFORMS = ();

my %dirs_processed = ();

my $symlinks;

my $allow_overwrite = 0;

#...

#

my $INTDIR;                                 # Interface directory (target)

my $BINDIR;                                 # Build directory (Not used)

my $PKG_ROOT=cwd();                         # Package source (CWD)

#

#   Global used for File::Find callback function

#

my $FF_SRC_DIR="";                          # Src subdir base

my $FF_DST_DIR="";                          # Dst subdir base

################################################################################

#

#

#

#   Init the error reporting package

#

ErrorConfig( 'name'    => 'installpkg' );

#

#   Ensure required environment variables are present

#

EnvImport ('GBE_MACHTYPE');

EnvImport ('GBE_VERBOSE');

ErrorConfig( 'verbose' => $GBE_VERBOSE );

#

#   Determine if symlinks are available

#   They may not be available at all, in which case we don't even try

#

$symlinks = eval { symlink("",""); 1 } || 0;

#

#   Report machine information

#

Verbose ("GBE_VERBOSE    : $GBE_VERBOSE" );

Verbose ("GBE_MACHTYPE   : $GBE_MACHTYPE" );

Verbose ("SymLinks       : $symlinks" );

Verbose ("AllowOverwrite : $allow_overwrite" );

Verbose ("Cmd            : @ARGV");

################################################################################

#

#   Parse user arguments

#   Arguments

#       Arg0    - Interface directory

#       Arg1    - Build Directory ( Not Used )

#       Arg2..  - A list of Platform specifications

#                 One for each platform that needs to be processed

#                 Each plaform specification consists of:

#                   --Platform:PlatformName:PlatformParts:Options

#                   Where:

#                       --Platform      - is a leadin switch

#                       PlatformName    - The the target platform

#                       PlatformParts   - A colon seperated list of platform 'parts'

#                                         This consist of: Platform, Product, ... Target

#

$INTDIR = shift @ARGV;

Error("Interface directory not specified") unless( defined $INTDIR );

Error("Interface directory not found: $INTDIR") unless( -d $INTDIR );

$BINDIR = shift @ARGV;

Error("Program directory not specified")   unless( defined $BINDIR );

Error("Program directory not found: $BINDIR") unless( -d $BINDIR );

foreach ( @ARGV )

{

    if ( /^--Platform/ ) {

        Verbose2 ("ARGV = <$_>");

        my ($tmpVar, @platforms) = split /:/, $_;

        my $platform = $platforms[0];

        $PLATFORMS{$platform}{'PARTS'} = \@platforms;

    } elsif ( /^--NoSymlinks/i ) {

        $symlinks = 0;

    } elsif ( /^--AllowOverWrite/i ) {

        $allow_overwrite = 1;

    } else {

        Warning("Unknown argument(ignored): $_");

    }

}

#

# lets review what we have read in

#

foreach my $i ( sort keys %PLATFORMS )

{

    Verbose( "PLATFORMS{$i} = ", join( ',', @{$PLATFORMS{$i}{'PARTS'}} ) );

}

################################################################################

#   Read in the Packages descpkg file

#   The contents are not used. More a sanity test than anything else

#

my $rec = ReadDescpkg ( "descpkg" );

if ( $rec )

{

    Verbose ("Installing the package $rec->{NAME} $rec->{VERSION} $rec->{PROJ}");

}

else

{

    Message ("Installing the package ($PKG_ROOT)");

}

################################################################################

#

#   Lets deal with the top level flat dirs include dir(s)

#

#   For each directory listed in the ModuleList simply duplicate the entire

#   directory to the target location

#

my (@ModuleList) = ( "etc",

                     "swsfiles", 

                     "classes", 

                     "jar",

                     "sar",

                     "sql", 

                     "war", 

                     "scripts", 

                     "infofiles", 

                     "jsp", 

                     "thx", 

                     "rox", 

                     "rpt", 

                     "java", 

                     "achtml", 

                     "epedia", 

                     "doc", 

                     "docs",

                     "devcd",

                     "dat",

                     "mug",

                     "wsdl",                # Store wsdls

                     "include",             # Need the entire directory

                     "MergeModules",        # InstallShield Merge Modules

                     "deployfiles",         # Deployment internals

);

foreach my $i (@ModuleList)

{

    do_dir( $i, $i);

}

################################################################################

#

#   Process a "pkg" directory

#

#   There are two forms of pkg directory

#       1) pkg directory contains ONLY directories of the form pkg.$(GBE_MACHTYPE)

#          These are processed by coying:

#               pkg/pkg.GBE_MACHTYPE -> pkg

#

#       2) pkg without any pkg.* subdirs

#          Copy the entire subtree

#

#       3) Mixture

#          Cannot handle

#

#

my (@ModuleList2) =  ( "pkg" );

foreach my $i (@ModuleList2)

{

    #

    #   Determine the mode of operation

    #   Scan files in the directory for known format

    #

    my @dir_list = glob( "$i/*" );

    my $pkg_count = 0;

    my $other_count = 0;

    foreach ( @dir_list )

    {

        if ( m~/$i\.~ )

        {

            $pkg_count++;

        }

        else

        {

            $other_count++;

        }

    }

    if ( $pkg_count && $other_count )

    {

        Warning( "Cannot handle mixed \"${i}\" directory",

                 "Only machine directory will be copied" );

    }

    if ( $pkg_count )

    {

        #

        #   pkg/pkg.GBE_MACHTYPE -> pkg

        #

        do_dir("$i/$i\.$GBE_MACHTYPE", $i, );

    }

    else

    {

        #

        #   pkg -> pkg

        #

        do_dir($i, $i);

    }

}

################################################################################

#

#   Deal with the complex directories:

#           bin,

#           lib,

#           inc

#           include

#

#   Look for, and process the first of:

#

#   for each item in module list we shall process (if it exists) 

#   the following variants:

#

#       module.<platform>

#       module.<product>

#       module.<target>

#

#       module/<platform>

#       module/<product>

#       module/<target>

#

#   The platform, product and target are all passed on the command

#   line.  They are configured in the build.pl using the BuildProduct

#   directives.

#

#   For the bin dirs we need to consider the 'Debug' and 'Prod' 

#   build types as well as some cots packages that are both.

#

#   For the bin and lib dirs we also need to consider the format:

#       bin/bin.<platform>

#       lib/lib.<platform>

#

#

my %ModuleList3 =   (

                    "lib"           => 1,       # Copy root files

                    "inc"           => 1,       # Copy root files

                    "bin"           => 0,       # Should not be any root files

                    "include"       => 0,       # Root files already processed

                    );

foreach my $i (sort keys %ModuleList3)

{

    my $mDstDir;

    my $bType;

    my $mPart;

    my $mode =  $ModuleList3{$i};

    Verbose ("Processing: [Mode:$mode] $i");

    foreach my $j ( sort keys %PLATFORMS )

    {

        foreach $bType ( 'D', 'P', '' )

        {

            foreach $mPart ( sort @{$PLATFORMS{$j}{'PARTS'}} )

            {

                $mDstDir = "$i/$mPart$bType";

                #

                #   Try various combinations of directories to catter for

                #   all the crazy legacy combinations

                #

                do_dir("$i.$mPart$bType"    ,$mDstDir);

                do_dir("$i/$mPart$bType"    ,$mDstDir);

                do_dir("$i/$i.$mPart$bType" ,$mDstDir);

            }

        }

    }

    #

    # Transfer files in the root directory if required

    #

    # Now lets us deal with the simple case

    # here we are only interested in the top level files

    # sub-dirs are handles separately.

    #

    if ( ($mode & 1) && -d $i)

    {

        Verbose ("Processing: $i - Copy root directory files");

        do_FilesOnly ( $i );

    }

}

################################################################################

#   Deal with toolset extensions

#   These are JATS extensions that are platform specific and not a function of

#   the target. ie: If we are building on a 'win32' piece of hardware then we

#   need the win32 tools, independant of the target platforms

#

#   Use GBE_MACHTYPE to determine correct subdirs

#

my %ModuleList4 =   (

                    "tools/bin"             => 3,       # Copy GBE_MACHTYPE + root files

                    "tools/scripts"         => 4,       # Copy Subdir

                    "gbe"                   => 4,       # JATS General Build Environment

                    );

foreach my $i (sort keys %ModuleList4)

{

    my $mode = $ModuleList4{$i};

    Verbose ("Processing: $i, Machine Type: $GBE_MACHTYPE, Mode: $mode");

    #

    #   Transfer a machine specfic subdir

    #

    if ( $mode & 1 )

    {

        do_dir("$i.$GBE_MACHTYPE", "$i/$GBE_MACHTYPE") ;

        do_dir("$i/$GBE_MACHTYPE", "$i/$GBE_MACHTYPE") ;

    }

    #

    # Transfer files in the root directory if required

    #

    # Now lets us deal with the simple case

    # here we are only interested in the top level files

    # sub-dirs are handles separately.

    #

    if ( ($mode & 2) && -d $i)

    {

        Verbose ("Processing: $i - Copy root directory files");

        do_FilesOnly ( $i );

    }

    #

    #   Copy the entire subtree

    #   Used for non-machine specifc directories

    #

    if ( ($mode & 4) && -d $i)

    {

        Verbose ("Processing: $i - Copy directory tree");

        do_dir($i, $i) ;

    }

}

# done

exit 0;

#------------------------------------------------------------------------------

#------------------------------------------------------------------------------

#------------------------------------------------------------------------------

# subroutines

#------------------------------------------------------------------------------

#------------------------------------------------------------------------------

#------------------------------------------------------------------------------

#-------------------------------------------------------------------------------

# Function        : do_FilesOnly

#

# Description     : Copy all files in the current directory to the target

#                   directory. Assume that the target directory will be called

#                   the same as the source directory

#

#                   Do not process sub directories. These may be handled elsewhere

#

# Inputs          : $dir        - Src and Dst subdir name

#

# Returns         : Nothing

#

sub do_FilesOnly

{

    my ($dir) = @_;

    Verbose2 ("do_FilesOnly: dir=[$dir]");

    # define the type of dir we are working on

    my ($srcDir) = "$PKG_ROOT/$dir";

    my ($dstDir) = "$INTDIR/$dir";

    Verbose2("do_FilesOnly: INTDIR=[$INTDIR]");

    Verbose2("do_FilesOnly: dstDir=[$dstDir]");

    Verbose2("do_FilesOnly: srcDir=[$srcDir]");

    #

    # Create the interface dir if it does not exists

    #

    mkpath ( $dstDir, $GBE_VERBOSE, 0775) unless ( -d $dstDir );

    # Have a valid dst value we now need to get a hold of all the

    # lib scripts files.

    #

    local *DIR;

    opendir ( DIR, $srcDir ) or  Error ("Failed to open dir [$srcDir]");

    #

    # Process all directory entries

    #

    while (defined(my $_item = readdir(DIR)))

    {

        next if ( $_item eq '.' );

        next if ( $_item eq '..' );

        my $srcFile = "$srcDir/$_item";

        if ( -d $srcFile )

        {

            Verbose2 ("NOT processing dir item [$srcFile]");

        }

        else

        {

            FileLinkCopy ($srcFile, "$dstDir/$_item" );

        }

    }

    closedir DIR;

    # done

    return 1;

}

#-------------------------------------------------------------------------------

# Function        : do_dir

#

# Description     : Transfer an entire subdirectory tree

#                   Can detect that the tree has already been processed

#

# Inputs          : $src            - Source subdir (within PKG_ROOT)

#                   $dst            - Target path (within INTDIR)

#

# Returns         : Nothing

#

sub do_dir

{

    my ($src, $dst) = @_;

    Verbose2 ("do_dir: src=[$src], dst=[$dst]");

    #

    #   Prevent processing of the same source directory by multiple

    #   operations. Need only do them once

    #

    if ( $dirs_processed{$src} )

    {

        Verbose2 ("do_dir: Already processed");

        return 1;

    }

    $dirs_processed{$src} = 1;

    #

    #   Only if it exists

    #   Do the test in this function to simplify processing

    #

    unless ( -d $src )

    {

        Verbose2 ("do_dir: Directory not found");

        return 0;

    }

    #

    #   Setup values for the File::Find callback

    #   These need to be global due to the way that File::Find works

    #

    $FF_SRC_DIR = "$PKG_ROOT/$src";

    $FF_DST_DIR = "$INTDIR/$dst";

    Verbose2("do_dir: FF_SRC_DIR=[$FF_SRC_DIR]");

    Verbose2("do_dir: FF_DST_DIR=[$FF_DST_DIR]");

    #

    #   Handle directories that are really symbolic links

    #   This will only occur on system that handle symlinks

    #   May not always want to use symlinks.

    #

    if ( $symlinks && -l $FF_SRC_DIR )

    {

        Verbose2("do_dir: symlink $FF_SRC_DIR,$FF_DST_DIR");

        unless (symlink $FF_SRC_DIR, $FF_DST_DIR  )

        {

            Error("Failed to create symlink",

                  "Src: $FF_SRC_DIR",

                  "Dst: $FF_DST_DIR");

        }

        return 1;

    }

    #

    # Create the interface dir if it does not exists

    #

    mkpath ( $FF_DST_DIR, $GBE_VERBOSE, 0775)

        unless ( -d $FF_DST_DIR );

    File::Find::find( \&pkgFind2, $FF_SRC_DIR);

    # done

    return 1;

}

#-------------------------------------------------------------------------------

sub pkgFind2

#

# Description     : Callback function: Process a directory

#                   Target name is NOT the same as the source name

#

#                   The function is called for each file to be processed

#                   The name of the file is extracted from $File::Find::name

#

#                   Processes

#                       Directory: Create same directory in the target

#                       File     : Link/Copy file to the target

#

# Inputs          : None passed

#                   Globals are used

#

# Returns         :

#

#------------------------------------------------------------------------------

{

    Verbose2("pkgFind2:");

    my $item = "$File::Find::name";                     # Full source path

    my $dest_path = $FF_DST_DIR . substr ( $item, length ($FF_SRC_DIR) ); # Full destination path

    Verbose2 ("---- Src = [$item]");

    Verbose2 ("---- Dst = [$dest_path]");

    if ( -d $item )

    {

        #

        #   Create a directory

        #

        mkpath ( $dest_path, $GBE_VERBOSE, 0775) unless( -d $dest_path );

        #

        #   Flag the subdir as being processed

        #   Prevent multiple copy operations (and warnings)

        #

        my $subdir = substr ( $item, 1 + length ($PKG_ROOT) );

        $dirs_processed{$subdir} = 1;

    }

    else

    {

        #

        #   Copy/Link the file

        #

        FileLinkCopy ( $item, $dest_path);

    }

    return 1;

}

#-------------------------------------------------------------------------------

# Function        : FileLinkCopy

#

# Description     : Copy a file to a destination

#                   If possible create a symlink (Not always be possible)

#                   If the file is copied, then chmod it.

#

# Inputs          : $srcFile                 - Source path (Full)

#                   $dstFile                 - Destination path (Full)

#

#

# Globals         : symlinks                - Set if Symlinks are available

#                                             Will be cleared if the operation

#                                             failed, forcing copy

#

# Returns         : Nothing

#                   Will terminate, with a message, on error

#

sub FileLinkCopy

{

    my ($srcFile, $dstFile ) = @_;

    my $done;

    (my $file = $srcFile) =~ s~.*/~~;       # Filename. Just to be pretty

    #

    #   Delete target file. If it exists

    #       Don't warn if we are allowed to overwrite files

    #       This is done for sandbox and local_archive packages

    #

    if ( -f $dstFile )

    {

        unlink ($dstFile );

        Message("overwriting existing dpkg_archive item [$file] --> [$dstFile]\n")

            unless ( $allow_overwrite );

    }

    #

    #   Try a symlink first

    #

    if ( $symlinks )

    {

        Verbose("linking file [$file] --> [$dstFile]...ok");

        unless (symlink ($srcFile, $dstFile)  )

        {

            #

            #   Symlink has failed

            #   Flag: Don't symlink anymore

            #

            $symlinks = 0;

            Verbose ("Failed to create symlink from: [$file] --> [$dstFile]");

        }

        else

        {

            $done = 1;

        }

    }

    #

    #   Try a copy

    #

    unless ( $done )

    {

        if(File::Copy::copy($srcFile, $dstFile))

        {

            Verbose("copying file [$file] --> [$dstFile]...ok");

            CORE::chmod oct("0755"), $dstFile;

        }

        else

        {

            Error("copying file [$file] --> [$dstFile]: $!");

        }

    }

}

############ EOF ###############################################################