WebSVN – DevTools – Diff – //deployfiles/trunk/src/tools/scripts/deploylib.pm



use File::Path;
use Cwd;
use Carp;
use DBI;
use LWP::UserAgent;
 
use DeployUtils::RmPkgInfo;
use BuildConfig;
use Exporter();
 
use ArrayHashUtils;
use JatsError;
use JatsSystem;
 
#-------------------------------------------------------------------------------
#   Export variables and function into the users name space
#-------------------------------------------------------------------------------
our @ISA    = qw(Exporter);

                    &convertFile
 
                    &getErgAfcBaseDir
                    &getGenericNameNoVersionForLib
                    &getGenericNameForLib
                    &createZip
 
                    %TargetDstDirStructure
                    %LocalSrcDirStructure
                    %BuildPkgArchive
                    $MachType

 
#------------------------------------------------------------------------------
# Initialization actions
#------------------------------------------------------------------------------
 
#
#   Init the error and message subsystem
#
ErrorConfig( 'name'    => 'DEPLOYLIB' ,
             'debug'   => $ENV{GBE_DEBUG},
             'verbose' => $ENV{GBE_VERBOSE},
             );
 
 
#------------------------------------------------------------------------------
# Package Interface Subroutines
#
# The following functions are used by the Makefile.pl scripts.  Programmers

    #  	Previous (old) version number                                  (-o)
    #  	Platform                                                       (-m)
    # 	Product (optional)                                             (-k)
    #  	Machine Type (optional)                                        (-g)
    
 
 
    $CurrentDir = cwd;
 
    my ($i);
    Getopt::Std::getopts ('v:n:r:t:m:d:p:o:k:g:');
    if ( $opt_n )
    {
        $PkgName      = $opt_n;
    }
    else
    {
        Error("Package Name not supplied!");
    }
 
    if ( $opt_r )
    {
        # lets change to root dir and get fully qualified path from cwd and return back

 
        $SandBoxName      = File::Basename::basename($RootDir);
    }
    else
    {
        Error("GBE_ROOT not supplied!");
    }
 
    if ( $opt_t )
    {
        $BuildType = $opt_t;
    }
    else
    {
        Error("GBE_TYPE not supplied!");
    }
 
    #
    #   Target machine type ( Underlying machine type in a Product Family)
    #   If not provided, the assume that its the same as the platform (compat)

        {
            $MachType = 'win32';
        }
        else
        {
            Error("Unknown target [$opt_g] supplied!");
        }
    }
 
    #
    #   Platform

    {
        $Platform = $opt_m;
    }
    else
    {
        Error("Platform not supplied!");
    }
 
    #
    #   Setup Product
    #   If not defined then use the platform

    {
        $TargetBaseDir = $opt_d;
    }
    else
    {
        Error("Package base directory not supplied!");
    }
 
    if ( $opt_p )
    {
        my $pNum = sprintf("%02s", $opt_p);

        {
            $PkgPatchNum = $pNum;
        }
        else
        {
            Error("-p command line arg [$opt_p] has invalid format",
                     "Required format is an integer value.");
        }
    }
 
    if ($opt_v)
    {

            {
                $ProjectAcronym   = $s2b;
            }
            else
            {
                Error("-v command line arg [$opt_v] has invalid format",
                      "Required format is N.N.N-B.ppp where:",
                      "    N is an integer",
                      "    B is an integer",
                      "    ppp is the project acronym",
                      "Check propject acronym.");
            }
        }
        elsif( "$opt_v" =~ m/^[0-9]*\.[0-9]*\.[0-9]*\.[a-z][a-z][a-z]$/ ) # N.N.N.ppp 
        {
            my ($tmpVar) = $opt_v;

            {
                $ProjectAcronym   = $s4;
            }
            else
            {
                Error("-v command line arg [$opt_v] has invalid format",
                      "Required format is N.N.N.ppp where:",
                      "    N is an integer",
                      "    ppp is the project acronym",
                      "Check propject acronym.");
            }
        }
        else
        {
            Error("-v command line arg [$opt_v] has invalid format",
                  "Allowed formats are N.N.N-B.ppp and N.N.N.ppp where:",
                  "    N is an integer",
                  "    B is an integer",
                  "    ppp is the project acronym",
                  "Check propject acronym.");
 
        }
 
        $PkgVersionUser  = $opt_v;
    }
    else
    {
        Error("Package Version not supplied!");
    }
 
 
    # lets check to see if we have a previous version 
    if ($opt_o)

    #   InstallShield files are provided via a package
    #   Ensure that a suitable package has been provided
    #
    if ( ! -d  $PKG_UTIL_DIR )
    {
        Error("No deployment support files found",
              "These MUST be provided by a dependant package in build.pl");
    }
 
 
    $Username     = getlogin || getpwuid($<);
 

            }
        }
 
    }
 
    Information("------------------------------------------------------------");
 
 
    # lets generate the patch id if we are building a patch
    #
    if ( "x$PkgPatchNum" ne "x" )
    {
        Information("This is a PATCH build...");
 
        $PkgPatchName = uc ($PkgName);
 
 
        my ($_tmpStr) = sprintf("%s%s", $PkgPatchName, 

        #
        $PkgOutputFile = "na"; 
    }
    else
    {
        Information("This is a normal RELEASE build...");
        $PkgReleaseNote = "$ReleaseDir" . "/" .
                                                                "$PkgName" . "-" . 
                                                                "$PkgVersion" . "." .
                                                                "$ProjectAcronym" . "-" .
                                                                "$Platform";

                         "$ProjectAcronym" . "-" .
                         "$Platform" . "-" .
                         "$BuildType\.pkg";
    }
 
    Information("------------------------------------------------------------");
 
 
    # lets just show what we have determined.
    #
    Information("Current environment definitions (Increase Verbose Level to see all definitions)...");
 
    Verbose("DeployFiles      =[$PKG_UTIL_DIR]");
 
    Information("PkgName          =[$PkgName]");
    Information("PkgVersionUser   =[$PkgVersionUser]");
 
    Information("PkgVersion       =[$PkgVersion]");
    Information("PkgVersionStr    =[$PkgVersionStr]");
 
    Information("PkgBuildNum      =[$PkgBuildNum]");
 
    if ( "x$PkgPatchID" ne "x" )
    {
        Information("PkgPatchName     =[$PkgPatchName]");
        Information("PkgPatchNum      =[$PkgPatchNum]");
        Information("PkgPatchID       =[$PkgPatchID]");
        Information("PkgPatchTmpDir   =[$PkgPatchTmpDir]");
    }
 
    Information("PkgReleaseNote   =[$PkgReleaseNote]") unless ($autobuild);
    Information("PkgReleaseNote   =[Generated later by ABT]") if ($autobuild);
    Information("PkgLabel         =[$PkgLabel]");
 
    Information("PkgPreviousVersionStr=[$PkgPreviousVersionStr]");
 
    Information("ProjectAcronym   =[$ProjectAcronym]");
    Information("BuildType        =[$BuildType]");
    Information("MachType         =[$MachType]");
    Information("Platform         =[$Platform]");
    Information("Product          =[$Product]");
    Information("Target           =[$Target]");
    Verbose("BuildParts       =[" . join(',',$BuildFileInfo->getPlatformParts($Platform)) . "]");
    
    Information("CurrentDir       =[$CurrentDir]");
    Information("RootDir          =[$RootDir]");
    Information("SandBoxName      =[$SandBoxName]");
    Information("Username         =[$Username]");
 
    Information("TargetBaseDir    =[$TargetBaseDir]");
    Information("TargetHomeDir    =[$TargetHomeDir]");
 
    Information("PkgBaseDir       =[$PkgBaseDir]");
    Information("SrcDir           =[$SrcDir]");
    Information("PkgDir           =[$PkgDir]");
    Information("ReleaseDir       =[$ReleaseDir]");
 
    Verbose("InterfaceDir     =[$InterfaceDir]");
    Verbose("DpkgScriptsDir   =[$DpkgScriptsDir]");
    Verbose("DpkgBinDir(s)    =[");
    foreach $i (@{$DpkgBinDirList{'_ALL_'}})
    {
        Verbose("                   $DpkgBinDir/$i");
    }
    Verbose("                  ]");
 
 
    Verbose("DpkgLibDir(s)    =[");
    foreach $i (@{$DpkgLibDirList{'_ALL_'}})
    {
        Verbose("                   $DpkgLibDir/$i");
    }
    Verbose("                  ]");
 
 
    Verbose("DpkgEtcDir       =[$DpkgEtcDir]");
    Verbose("DpkgJarDir       =[$DpkgJarDir]");
    Verbose("DpkgSarDir       =[$DpkgSarDir]");
    Verbose("DpkgWarDir       =[$DpkgWarDir]");
    Verbose("DpkgSqlDir       =[$DpkgSqlDir]");
    Verbose("DpkgJspDir       =[$DpkgJspDir]");
    Verbose("DpkgRoxDir       =[$DpkgRoxDir]");
    Verbose("DpkgRptDir       =[$DpkgRptDir]");
    Verbose("DpkgAcHtmlDir    =[$DpkgAcHtmlDir]");
    Verbose("DpkgIncludeDir   =[$DpkgIncludeDir]");
    Verbose("DpkgDevcdDir     =[$DpkgDevcdDir]");
    Verbose("DpkgDatDir       =[$DpkgDatDir]");
    Verbose("DpkgThxDir       =[$DpkgThxDir]");
    Verbose("DpkgMugDir       =[$DpkgMugDir]");
    Verbose("DpkgDocDir       =[$DpkgDocDir]");
 
    Verbose("DpkgInfoFilesDir =[$DpkgInfoFilesDir]");
    Verbose("DpkgPkgDir       =[$DpkgPkgDir]");
 
    Verbose("PkgInfoFile      =[$PkgInfoFile]");
    Verbose("ProtoTypeFile    =[$ProtoTypeFile]");
 
    foreach $i ( $BuildFileInfo->getDpkgArchiveList() )
    {
        my $moduleInfo = $BuildFileInfo->getDpkgArchiveInfo($i);
        
        Verbose(  "Build Dependency =" .
                  "[$moduleInfo->{type}] " .
                  "[$i] " .
                  "[$moduleInfo->{version}] " .
                  "[$moduleInfo->{proj}]");
    }
 
    if ( "$MachType" eq "sparc" )
    {
        Information("PkgOutputFile    =[$PkgOutputFile]");
    }
 
    Information("PkgOverview      =[$PKG_OVERVIEW]");
 
 
    # Lets evaluate TargetDstDirStructure to expand any vars
    foreach $i ( keys %TargetDstDirStructure )
    {
        if ( $TargetDstDirStructure{$i} =~ /\$/ )
        {
            Debug("-n", "Expanding TargetDstDirStructure [$TargetDstDirStructure{$i}] to ");
            $TargetDstDirStructure{$i} = eval "sprintf " . qq/"$TargetDstDirStructure{$i}"/;
            print("[$TargetDstDirStructure{$i}]\n");
        }
    }
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to setPkgDescription() function.",
 
              "Check deploy config.");
    }
    my ($lpkgDesc) = shift;
   
    # we use what was defined in deployfile if
    # the RM details are not available

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
                  "setPkgName() function. ",
                  "Check deploy config.");
    }
    $PkgNameLong = shift;
 
    # done

    # if TargetBaseDir is empty then init has not been called yet so we can set 
    # base dir, if however it is not null then init has been called and setting
    # base dir after init causes problems in some cases.
    if ( $TargetBaseDir ne "" )
    {
        Error("setErgAfcBaseDir() cannot be called after Init(), place before Init() in deployfile.pl");
    }
 
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
                  "setErgBaseDir() function. ",
                  "Check deploy config.");
    }
 
    my ($newDir) = @_;
    $ERGAFC_BASEDIR = "$newDir";

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 0 )
    {
        Error("Incorrect number of params passed to " .
                  "getErgBaseDir() function. ",
                  "Check deploy config.");
    }
 
    return "$ERGAFC_BASEDIR";
}

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
                  "setPkgOverview() function. ",
                  "Check deploy config.");
    }
 
    my ($mStr) = @_;
    $PKG_OVERVIEW = "$mStr";

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 0 )
    {
        Error("Incorrect number of params passed to " .
                  "getPkgOverview() function. ",
                  "Check deploy config.");
    }
 
    return "$PKG_OVERVIEW";
}

    my @files;
 
    # lets just check to see if we can execute this function on this machine.
    if ( "$MachType" eq "sparc" )
    {
        Warning("addInstallshieldFiles() not supported on this machine type.");
        return 1;
    }
 
    foreach my $i ( @_ )
    {
        @files = glob("$PKG_UTIL_DIR/$i.*");
        foreach my $j ( @files )
        {
            $j = basename($j);
            Verbose("Adding Installshield file $j");
            push(@PKG_ISHIELD_FILES, $j);
        }
    }
    return 1;
}   # addInstallshieldFiles

    my @dir_tree_exclude;
    my @dir_tree_include;
    my $flatten = 0;
    my $dstDir;
 
    Information("Installing all Prepared pkg files...");
    
    #
    #   Process the arguments and extract parameters and options
    #
    foreach ( @_ )
    {
        if ( m/^--Srcdir=(.*)/ ) {
            Error("installAllDpkgArchivePkgFiles2: Multiple --Srcdir not allowed")
                if ( $src_base_dir );
            $src_base_dir = "$InterfaceDir/$1";
            $src_base_dir =~ s~/\.$~~;
            $src_base_dir =~ s~/$~~;
 
        } elsif ( /^--Dstdir=(.*)/ ) {
            Error("installAllDpkgArchivePkgFiles2: Multiple target directories not allowed")
                if ( $dstDir );
            $dstDir = $1;
 
        } elsif ( m/^--NoRecurse/ ) {
            $recurse = 0;

 
        } elsif ( /^--NoFlatten/ ) {
            $flatten = 0;
 
        } elsif ( m/^--/ ) {
            Error("installAllDpkgArchivePkgFiles2: Unknown option: $_")
 
        } else {
            Error("installAllDpkgArchivePkgFiles2: Multiple target directories not allowed")
                if ( $dstDir );
 
            #   Convert the symbolic target directory name into a real path
            
            $dstDir = getTargetDstDirValue($_, "A");

    #
    #   Ensure that we have a valid source directory
    #   Data taken from the 'pkg' directory unless otherwise specified by the user
    #
    $src_base_dir = $DpkgPkgDir unless $src_base_dir;
    Error("installAllDpkgArchivePkgFiles2: Package directory not found: $src_base_dir")
        unless ( -d $src_base_dir );
 
    #
    #   Ensure that the user has specified a target directory
    #
    Error("installAllDpkgArchivePkgFiles2: No target directories specified")
        unless ( $dstDir );
 
    #
    #   Build up a list of files to copy
    #   Creating a list allows:

        #   Split into directory and file as we may need to make the directory
        #   since the copy operation will not
        #
        my $dir;                                # Target directory
        my $tfile;                              # Target path
       (my $fname = $sfile )=~ s~^.*/+~~;       # Filename(only)
 
        unless ( $flatten )
        {
            $sfile =~ m~^(.*/)~;
            $dir = "$dstDir/$1";

        }
 
        #
        #   Ensure the target directory is present
        #
 
 
 
        make_directory ( $dir, 0775 );
 
 
        #
        #   Copy the file
        #   Ensure that the target file does not already exist
        #   This is most likely to occur when flattening the directory structure

        my $m_sfile = "$src_base_dir$sfile";
        my $m_tfile = "$dstDir/$tfile";
 
        if ( -f $m_tfile  )
        {
            Error("Failed to copy file [$m_sfile] to [$m_tfile]: File already exists");
        }
 
        if( File::Copy::copy("$m_sfile", "$m_tfile") )
        {
            Verbose("Copied [$fname] to [$m_tfile] ...");
        }
        else
        {
            Error("Failed to copy file [$m_sfile] to [$m_tfile]: $!");
        }
    }
 
    return 1;
}

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveDevcdFiles() function. ",
              "Check deploy config.");
    }
 
    Information("Installing all Prepared Day 0 devcd files...");
 
 
    my ($targetTag) = @_;
    
    # lets check to see if the target tag exists

            }
 
            my ($tmp_dItem) = $i;
            $tmp_dItem =~ s/$tmp_SrcDir/$tmp_DstDir/;
 
            if ( -d $i )
            {
 
 
 
                make_directory ( $tmp_dItem, 0775 );
 
 
            }
            else
            {
                if(File::Copy::copy( $i , $tmp_dItem ))
                {
                    Verbose("Copied [$base] to [$tmp_dItem] ...");
                }
                else
                {
                    Error("Failed to copy pkg file [$tmp_dItem] to [$i]: $!");
                }
            }
        }
    }
 

    $tmp_dItem =~ s/$tmp_SrcDir/$tmp_DstDir/;
 
    # we need to determine what type of item we are dealing with file we are dealing with
    if ( -d "$item")
    {
 
 
 
        make_directory( $tmp_dItem, 0775 );
 
 
    }
    else
    {
        if(File::Copy::copy("$item", "$tmp_dItem"))
        {
            Verbose("Copied [$base] to [$tmp_dItem] ...");
        }
        else
        {
            Error("Failed to copy pkg file [$tmp_dItem] to [$item]: $!"); 
        }
    }
}
 
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveFiles() function. ",
              "Check deploy config.");
    }
 
    my ($targetType, $targetTag) = @_;
 
    # lets check to see if the target tag exists

    elsif ( "$targetType" eq "rpt" )        { $src_dir = $DpkgRptDir; }
    elsif ( "$targetType" eq "doc" )        { $src_dir = $DpkgDocDir; }
    elsif ( "$targetType" eq "jsp" )        { $src_dir = $DpkgJspDir; }
#    elsif ( "$targetType" eq "achtml" )     { $src_dir = $DpkgAcHtmlDir; }
    else  {
        Error("installAllDpkgArchiveFiles() passed unknown target type [$targetType].");
    }
 
    opendir(DIR, $src_dir) or
            Error("Can't opendir $src_dir: $!");
 
 
    # lets process what we have found
    #
    my ($file);

        {
            my ($m_fLoc) = "$src_dir/$file";
 
            if(File::Copy::copy("$m_fLoc", "$targetValue"))
            {
                Verbose("Copied [$targetType] item [$file] to [$targetValue] ...");
            }
            else
            {
                Error("Failed to copy [$targetType] item [$m_fLoc]: $!"); 
            }
        }
    }
 
    closedir(DIR);

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveAcHtmlFiles() function. ",
              "Check deploy config.");
    }
    my ($targetType, $targetTag) = @_;
 
    # lets check to see if the target tag exists
    # if does not the process with log an error.

    # lets check to see if the source type dir actually exists
    #
    my($m_sDirLoc)  = "$DpkgAcHtmlDir/$targetType";
    if( ! -d "$m_sDirLoc" )
    {
        Error("Failed to locate [$targetType] AcHtml dir [$m_sDirLoc].");
    }
 
    # know everything exists so lets do the biz.
    #
    # now we need to copy all the files.
    #
    local *DIR;
    opendir(DIR, $m_sDirLoc) or 
        Error("Can't opendir $m_sDirLoc: $!");
 
    my ($m_fLoc) = "";
    my ($file) = "";
    while (defined($file = readdir(DIR)))
    {

             $file !~ /^..$/ )
        {
            $m_fLoc = "$m_sDirLoc/$file";
            if(File::Copy::copy("$m_fLoc", "$targetValue"))
            {
                Verbose("Copied AcHtml [$targetType] item [$file] to [$targetValue] ...");
            }
            else
            {
                Error("Failed to copy AcHtml [$targetType] item [$m_fLoc]: $!");
            }
        }
    }
 
    closedir(DIR);

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveInfoFilesFiles() function. ",
              "Check deploy config.");
    }
 
    my ($targetTag) = @_;
    
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveSqlFiles() function. ",
              "Check deploy config.");
    }
 
    my ($targetTag) = @_;
    
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveWarFiles() function. " ,
              "Check deploy config.");
    }
 
    my ($targetTag) = @_;
    
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveJarFiles() function. " ,
              "Check deploy config.");
    }
 
    my ($targetTag) = @_;
    
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveEtcFiles() function. " ,
              "Check deploy config.");
    }
 
    my ($targetTag) = @_;
    
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveScriptsFiles() function. " ,
              "Check deploy config.");
    }
 
    my ($targetTag) = @_;
    
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveIncludeFiles() function. " ,
              "Check deploy config.");
    }
 
    my ($targetTag) = @_;
    
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveIncludeFiles() function. " ,
              "Check deploy config.");
    }
 
    my ($targetTag) = @_;
    
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 0 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveJspFiles() function. " ,
              "Check deploy config.");
    }
 
    return installAllDpkgArchiveFiles ('jsp', '--NoTag');
}
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 3 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveFile() function. " ,
              "Check deploy config.");
    }
 
    my ($targetType, $sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

    elsif ( "$targetType" eq "thx" )        { $m_srcFileLocation = "$DpkgThxDir/$sfile";  }
    elsif ( "$targetType" eq "mug" )        { $m_srcFileLocation = "$DpkgMugDir/$sfile";  }
    elsif ( "$targetType" eq "rpt" )        { $m_srcFileLocation = "$DpkgRptDir/$sfile";  }
    elsif ( "$targetType" eq "doc" )        { $m_srcFileLocation = "$DpkgDocDir/$sfile";  }
    else  {
        Error("installDpkgArchiveFile() passed unknown target type [$targetType].");
    }
    
    
    # we will check to see if the file exists.
    #
    if ( -f "$m_srcFileLocation" )
    {
        # now we need to copy the file. 
        if(File::Copy::copy("$m_srcFileLocation", "$m_dstFileLocation"))
        {
            Verbose("Copied [$targetType] item [$sfile] to [$m_dstFileLocation] ...");
        }
        else
        {
            Error("Failed to copy [$targetType] item [$sfile]: $!"); 
        }
    }
    else
    {
        Error("Dpkg_archive [$targetType] item [$sfile] does not exist.");
    }
 
    return 1;
}
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 3 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveAcHtmlFile() function. " ,
              "Check deploy config.");
    }
    my ($targetType, $sfile, $targetTag) = @_;
 
    # lets check to see if the source type and file actually exist
    #
    my($m_sDirLoc)  = "$DpkgAcHtmlDir/$targetType";
    if( ! -d "$m_sDirLoc" )
    {
        Error("Failed to locate [$targetType] AcHtml dir [$m_sDirLoc].");
    }
 
    # lets check to see if the file exists
    #
    my($m_sFileLoc) = "$DpkgAcHtmlDir/$targetType/$sfile";
    if( ! -f "$m_sFileLoc" )
    {
        Error("Failed to locate [$targetType] AcHtml file [$m_sFileLoc].");
    }
 
    # lets check to see if the target tag exists
    # if does not the process with log an error.
    #

    # know everything exists so lets do the biz.
    #
    # now we need to copy the file.
    if(File::Copy::copy("$m_sFileLoc", "$targetValue"))
    {
        Verbose("Copied [$targetType] AcHtml item [$sfile] to [$targetValue] ...");
    }
    else
    {
        Error("Failed to copy [$targetType] AcHtml item [$sfile]: $!");
    }
    
    return 1;
}
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveRptFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveRoxFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveDatFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveThxFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveMugFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveInfoFilesFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveSqlFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveWarFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveJarFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveSarFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveEtcFile() function. " ,
              "Check deploy config.");
    }
 
    my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveScriptsFile() function. " ,
              "Check deploy config.");
    }
 
   my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveIncludeFile() function. " ,
              "Check deploy config.");
    }
 
   my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveDocFile() function. " ,
              "Check deploy config.");
    }
 
   my ($sfile, $targetTag) = @_;
 
    # lets check to see if the target tag exists

    #
    foreach  ( @_ )
    {
        if ( m/^--SelectFrom=(.*)/ ) {
            $select = $1;
            Error("installDpkgArchiveBinFile: Selector not known: $_")
                unless ( defined $DpkgLibDirList{$select} );
 
        } elsif ( m/^--/ ) {
            Warning ("installDpkgArchiveBinFile: Unknown option ignored: $_")
 
        } else {
            push @args, $_;
        }
    }

 
    # correct number of parameters?
    my ($fref, $targetTag) = @_;
    if ( $#args != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveBinFile() function. " ,
              "Check deploy config.");
    }
 
    # lets check to see if the target tag exists
    # if does not the process with log an error.
    #

        foreach $i (@{$DpkgBinDirList{$select}})
        {
            $m_DpkgBinDir = "$DpkgBinDir" . "/$i";
            if ( ! -d "$m_DpkgBinDir" )
            {
                Debug("Directory [$m_DpkgBinDir] not found.");
                next;
            }
 
            # lets define the absolute location of the file
            $m_srcFileLocation = "$m_DpkgBinDir/$sfile";

            if ( -f "$m_srcFileLocation" )
            {
                # now we need to copy the file.
                if(File::Copy::copy("$m_srcFileLocation", "$m_dstFileLocation"))
                {
                    Verbose("Copied Bin [$sfile] to [$m_dstFileLocation] ...");
                    $foundFileFlag = "true";
                 
                    # no need to go further, we have found the file.
                    #
                    last;
                }
                else
                {
                    Error("Failed to copy binary [$sfile]: $!");
                }
            }
            # else we have not found the file yet!
        }
 
        # if we do not find the file at all we need to inform
        # the user.
        #
        if ( "$foundFileFlag" eq "false" )
        {
            Error("Dpkg_archive bin file [$sfile] does not exist or is not in correct directory structure.");
        }
    }
    
    return 1;
}

#       processing.
#
#       Added optional 3rd parameter & if set to NoLinks then no generic named
#       libs will be created
#
# Inputs          :     $sfile              - Name of source file OR
#                                             A --Filter specification ( below)
#                                             A reference to a list of files OR
#                       $targetTag          - Symbolic name of target
#                       $links              - Optional. 'nolinks' will supress generic named libs
#                       Options             - Optional options
#
# Options:
#                   --NoLink                - same as 3rd arg == nolinks
#                   --Link                  - Default
#                   --SelectFrom=xxxx       - Limits foile source selection
#                                             By default all LIB sources are searched.
#                                             The selector should be a Platform, Product
#                                             ,Target or MachineType
#
# SourceFile options:
#                   Source files may be a filter rule which will expand to
#                   one or more files.
#                       --FilterIn=xx
#                       --FilterInRE=xx
#                       --FilterOut=xx
#                       --FilterOutRE=xx
#
#                     Notes:    --FilterIn=xxxx, --FilterOut=xxx
#                               xxx is a simple Shell style filter where:
#                                   * means one or more charters        '*.EXE'
#                                   ? means a single character          '*.?'
#                                   [abc] means either a or b or c      'file.[ch]'
#
#                               --FilterInRE=xxx, --FilterOutRE=xxx
#                               xxx is a Regular Expression. There are harder to use but very
#                               powerful. ie '.*\.EXE$'
#
#                               The 'In' filters are applied before the 'Out' filters.
#
#                               Multiple options may be joined with a comma.
#
# Returns         :     Nothing of use
#                       Will not return if the file is not found
#
#------------------------------------------------------------------------------

        } elsif ( m/^--Link/ ) {
            $links = 1;
 
        } elsif ( m/^--SelectFrom=(.*)/ ) {
            $select = $1;
            Error("installDpkgArchiveLibFile: Selector not known: $_")
                unless ( defined $DpkgLibDirList{$select} );
 
        } elsif ( m/^--Filter.*=/ ) {
            push @args, $_;
 
        } elsif ( m/^--/ ) {
            Warning ("installDpkgArchiveLibFile: Unknown option ignored: $_")
 
        } else {
            push @args, $_;
        }
    }

 
    # correct number of parameters?
    my ($fref, $targetTag) = @_;
    if ( $#args != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installDpkgArchiveLibFile() function. " ,
              "Check deploy config.");
    }
 
    #
    # Check to see if the target tag exists
    # If does not the process with log an error.

    {
        push @one_file, $fref;
        $fref = \@one_file;
    }
 
    #
    #   If the source file contains a pattern, then expand the pattern
    #   This may result in multiple files.
    #   Note: Allow for a single entry of the form
    #           --Filterin=xxx,---FilterOut=yyy
    #
    my @flist;
    my @dir_tree_exclude;
    my @dir_tree_include;
    foreach my $element ( @$fref )
    {
        foreach  ( split /,/ , $element )
        {
            if ( /^--FilterOut=(.*)/ ) {
                push @dir_tree_exclude, glob2pat($1);
 
            } elsif ( /^--FilterOutRE=(.*)/ ) {
                push @dir_tree_exclude, $1;
 
            } elsif ( /^--FilterIn=(.*)/ ) {
                push @dir_tree_include, glob2pat($1);
 
            } elsif ( /^--FilterInRE=(.*)/ ) {
                push @dir_tree_include, $1;
 
            } elsif ( m/^--/ ) {
                Warning( "installDpkgArchiveLibFile: Unknown Filter option ignored: $_");
 
            } else {
                push @flist, $_;
            }
        }
    }
 
    #
    #   If any patterns have been found, then expand them
    #
    if ( @dir_tree_exclude || @dir_tree_include )
    {
        foreach my $i (@{$DpkgLibDirList{$select}})
        {
            my @elements = ExpandDirTree( "$DpkgLibDir/$i", \@dir_tree_exclude, \@dir_tree_include, 0 );
 
            #
            #   Clean off any leading / from each filename then add to a list
            #   Remove any duplicates that were found
            #
            map { $_ =~ s~^/~~ } @elements;
            UniquePush \@flist, @elements;
        }
    }
 
 
    #
    #   Process each file
    #
    foreach my $sfile ( @flist )
    {
 
        # we exclude .dll files if this is a sparc build
        #
        if ( "$MachType" eq "sparc"  &&
             $sfile =~ m/\.dll/
           )
        {
            Verbose("Excluding item [$sfile] from build, as we do not deliver dlls for this machine type [$MachType].");
            return 1;
        }
 
        # we exclude .so files if this is a win32 build
        #
        if ( "$MachType" eq "win32"  &&
             $sfile =~ m/\.so/
           )
        {
            Verbose("Excluding item [$sfile] from build, as we do not deliver sosss for this machine type [$MachType].");
            return 1;
        }
 
        my ($libName) = $sfile;
        if ( "$MachType" eq "sparc" )

        {
 
            $m_DpkgLibDir = "$DpkgLibDir" . "/$i";
            if ( ! -d "$m_DpkgLibDir" )
            {
                Debug("Directory [$m_DpkgLibDir] not found.");
                next;
            }
 
 
            $m_srcFileLocation = "$m_DpkgLibDir/$sfile";
            $m_dstFileLocation = "$targetValue/$sfile";
 
 
            # we only want debug items in a debug build
            #
            if(excludeItemFromBuild($sfile))
            {
                Verbose("Excluding item [$sfile] from build as not compatible with build type [$BuildType].");
                $ExcludedFlag = "true";
            }
            else
            {
                # we need to ensure that only a single version/entry of the lib exists in the lib list

                        $count++;
                    }
        
                    if ( $count > 1 )
                    {
                        Error("Detected multiple references of lib [$libName] in lib list, check item [$sfile].");
                    }
                }
 
                # we will check to see if the file exists.
                #
                if ( -f "$m_srcFileLocation" )
                {
                    # now we need to copy the file.
 
                    # we also want to create a generically named copy
                    # of the library. ie:
                    #       libraryP.nn.nn.nn.dll -> library.dll, libraryP.dll
                    #       libraryP.so.nn.nn.nn  -> library.so, libraryP.so
                    #
                    my ($gName)    = $sfile;
                    my ($nVerName) = $sfile;
                    $gName = removeBuildTypeFromItemName($sfile);
                    $gName = removeVersionNumberFromItemName($gName);
                    $nVerName = removeVersionNumberFromItemName($sfile);
 
                    if(File::Copy::copy("$m_srcFileLocation", "$m_dstFileLocation"))
                    {
                        Verbose("Copied Lib [$sfile] to [$m_dstFileLocation] ...");
                        $foundFileFlag = "true";
 
                        if ( $links && ( "x$PkgPatchID" eq "x" || "$MachType" eq "win32") )
                        {
                            # normal build or if we are building win32 we want generic names

                    }
                    else
                    {
                        # here found the file but we had some trouble
                        #
                        Error("Failed to copy lib [$m_srcFileLocation]: $!");
                    }
 
                }
                # else have not found the file yet!
            }

        # if we do not find the file at all we need to inform
        # the user.
        #
        if ( "$foundFileFlag" eq "false" && $ExcludedFlag eq "false" )
        {
            Error("Dpkg_archive lib file [$sfile] does not exist or is not in correct directory structure.");
        }
    }
 
    return 1;
}

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 3 )
    {
        Error("Incorrect number of params passed to " .
              "installPkgAddConfigFile() function. " ,
              "Check deploy config.");
    }
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("installPkgAddConfigFile() not supported on this machine type.");
        return 1;
    }
 
 
    my ($sDirTag, $sfile, $tfile) = @_;

 
    # we must have a filename.
    #
    if ( "x$sfile" eq "x" )
    {
        Error("Source filename not supplied. Check deploy config.");
    }
 
 
    # lets check to see if the local src dir tag exists
    # if does not the process with log an error.

 
    # lets check to see if the source file exists
    #
    if ( ! -f "$sDirValue/$sfile" )
    {
        Error("Failed to find local source file [$sDirValue/$sfile].");
    }
 
    if ( ! -f "$ProtoTypeFile" )
    {
        Error("Prototype file [$ProtoTypeFile] does not exist.",
              "Ensure createPrototypeFile() function has been called before executing installPkgAddConfigFile() function.",
              "Check deploy config.");
    }
 
    
    # lets determine which prototype file we are going to
    # use

 
    # lets copy the file
    #
    if(File::Copy::copy("$sDirValue/$sfile", "$dFileName"))
    {
        Verbose("Copied [$sfile] to [$dFileName] ...");
    }
    else
    {
        Error("Failed to copy local source file [$sDirValue/$sfile]: $!"); 
    }
 
   
    # now we need to update the prototype file
    #
    local *FILE;
    open ( FILE, ">> $ProtoTypeFile") or
        Error("Failed to open file [$ProtoTypeFile].");
    printf FILE ("i $tfile=$sfile\n");
    close (FILE);
 
 
    return 1;

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 4 )
    {
        Error("Incorrect number of params passed to " .
              "installPkgAddConfigFile() function. " ,
              "Check deploy config.");
    }
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("installPkgAddConfigFile() not supported on this machine type.");
        return 1;
    }
 
 
    my ($sDirTag, $sfile, $tfile, $class) = @_;
 
    if ( $class ne "sed" && $class ne "build" && $class ne "awk" && $class ne "preserve" )
    {
        Error("Class Name for System Class File can only be one of sed, build, awk or preserve");
    }
 
    # we must have a filename.
    #
    if ( "x$sfile" eq "x" )
    {
        Error("Source filename not supplied. Check deploy config.");
    }
 
 
    # lets check to see if the local src dir tag exists
    # if does not the process with log an error.

 
    # lets check to see if the source file exists
    #
    if ( ! -f "$sDirValue/$sfile" )
    {
        Error("Failed to find local source file [$sDirValue/$sfile].");
    }
 
    if ( ! -f "$ProtoTypeFile" )
    {
        Error("Prototype file [$ProtoTypeFile] does not exist.",
              "Ensure createPrototypeFile() function has been called before executing installPkgAddConfigFile() function.",
              "Check deploy config.");
    }
 
    
    # lets determine which prototype file we are going to
    # use

 
    # lets copy the file
    #
    if(File::Copy::copy("$sDirValue/$sfile", "$dFileName"))
    {
        Verbose("Copied [$sfile] to [$dFileName] ...");
    }
    else
    {
        Error("Failed to copy local source file [$sDirValue/$sfile]: $!"); 
    }
 
   
    # now we need to update the prototype file
    #
    local *FILE;
    open ( FILE, ">> $ProtoTypeFile") or
        Error("Failed to open file [$ProtoTypeFile].");
    printf FILE ("e $class $tfile=$sfile ? ? ?\n");
    close (FILE);
 
 
    return 1;

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 6 )
    {
        Error("Incorrect number of params passed to " .
              "updatePrototypeFileAddItem() function. " ,
              "Check deploy config.");
    }
 
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("updatePrototypeFileAddItem() not supported on this machine type.");
        return 1;
    }
 
    my ($sTag, $dTag, $perms, $uid, $gid, $type) = @_;
 

 
    # lets check the valid types
    $type = uc($type);
    if ( "$type" !~ /S/ )
    {
        Error("Invalid type field supplied in updatePrototypeFileAddItem(). Check deploy config.");
    }
 
    # now we need to update the prototype file
    #
    local *FILE;
    open ( FILE, ">> $protoTypeFile") or
        Error("Failed to open file [$protoTypeFile].");
  
    my($m_Str)=""; 
    if ( "$type" eq "S" )
    {
        $m_Str = "s none $sTag=$ERGAFC_BASEDIR/$dTag $perms $uid $gid";
        Verbose("Updated prototype file with entry [$m_Str]");
    }
    else
    {
        $m_Str = "f none $sTag=$ERGAFC_BASEDIR/$dTag $perms $uid $gid";
        Verbose("Updated prototype file with entry [$m_Str]");
    }
    printf FILE ("$m_Str\n");
    close (FILE);
 
    return 1;

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 6 && ($#_+1) != 7 )
    {
        Error("Incorrect number of params passed to " .
              "updatePrototypeFileAddItem2() function. " ,
              "Check deploy config.");
    }
 
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("updatePrototypeFileAddItem2() not supported on this machine type.");
        return 1;
    }
 
    # class must be last as it is optional
    my ($sTag, $dTag, $perms, $uid, $gid, $type, $class) = @_;

 
    # lets check the valid types
    $type = uc($type);
    if ( "$type" !~ /S/ && "$type" !~ /I/ && "$type" !~ /E/ )
    {
        Error("Invalid type field supplied in updatePrototypeFileAddItem2(). Check deploy config.");
    }
 
    # now we need to update the prototype file
    #
    local *FILE;
    open ( FILE, ">> $protoTypeFile") or
        Error("Failed to open file [$protoTypeFile].");
  
    my($m_Str)="";
    if ( "$type" eq "S" )
    {
        $m_Str = "s $class $sTag=$dTag $perms $uid $gid";
        Verbose("Updated prototype file with entry [$m_Str]");
    }
    elsif ( "$type" eq "E" )
    {
        $m_Str = "e $class $sTag=$dTag $perms $uid $gid";
        Verbose("Updated prototype file with entry [$m_Str]");
    }
    else
    {
        $m_Str = "i $sTag=$dTag";
        Verbose("Updated prototype file with entry [$m_Str]");
    }
    printf FILE ("$m_Str\n");
    close (FILE);
 
    return 1;

    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("addPath2Prototype() not supported on this machine type.");
        return 1;
    }
 
    # class must be last as it is optional
    my ($path, $perms, $uid, $gid, $class) = @_;

    $perms  = "?"       if ( ($#_+1) < 2 );
    $uid    = "?"       if ( ($#_+1) < 3 );
    $gid    = "?"       if ( ($#_+1) < 4 );
    $class  = "none"    if ( ($#_+1) < 5 );
 
    Information("addPathToPrototype adding path [$path $perms $uid $gid $class]");
 
    # lets determine which prototype file we are going to
    # use
    my ($protoTypeFile);
    $protoTypeFile = "$ProtoTypeFile";
 
    # now we need to update the prototype file
    #
    local *FILE;
    open ( FILE, "+<$protoTypeFile") or Error("Failed to open file [$protoTypeFile].");
 
    # set up has of all paths to be added
    my ( %pathDirs );
    my ( $workPath );
    my ( $i );

        if ( /^d ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*)/ )
        {
            # if this dir entry is defined in our paths to add we need to remove the entry
            if ( defined($pathDirs{$2}) )
            {
                Warning("addPath2Prototype: Path [$2] already exists in prototype file");
                delete($pathDirs{$2});
            }
        }
    }
 
    my $protoLine;
    # now we write the remaining dirs in the hash 
    foreach $i ( sort keys(%pathDirs) )
    {
        $protoLine = sprintf("d %s %s %s %s %s", $class, $i, $perms, $uid, $gid);
        Verbose("addPath2Prototype: Adding Dir entry [$protoLine]");
        printf FILE "$protoLine\n"; 
    }
 
    close FILE;
    return 1;

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 3 )
    {
        Error("Incorrect number of params passed to " .
              "createAfcRcScriptLink() function. " ,
              "Check deploy config.");
    }
 
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("createAfcRcScriptLink() not supported on this machine type.");
        return 1;
    }
 
    my ($startPrefix, $stopPrefix, $scriptPath) = @_;
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 4 )
    {
        Error("Incorrect number of params passed to " .
              "createAfcRcScriptLink() function. " ,
              "Check deploy config.");
    }
 
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("createAfcRcScriptLink() not supported on this machine type.");
        return 1;
    }
 
    my ($startPrefix, $stopPrefix, $targetTag, $scriptPath) = @_;
 

        {
            $cmd = "cd $tDir; ln -s $sName $gName";
            $retVal = system("$cmd");
            if ( $retVal != 0 )
            {
                Error("Failed to create generic link [$gName] to [$tDir/$sName]: $retVal");
            }
            else
            {
                Verbose("Created generic link [$gName] to [$tDir/$sName] ...");
            }
        }
    }
    else
    {

 
        # we have a match, lets create the copy.
        #
        if(File::Copy::copy("$sLoc", "$tDir/$gName"))
        {
            Verbose("Created generic lib copy [$tDir/$gName]...");
        }
        else
        {
            Error("Failed to create generic lib copy [$gName] from [$sLoc]: $!");
        }
    }
 
    return 1;
}

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
              "installAllDpkgArchiveBinFiles() function. " ,
              "Check deploy config.");
    }
 
    my ($targetTag) = @_;
 
    # lets check to see if the target tag exists

    #
    my ($i);
    my ($m_DpkgBinDir);
    foreach $i (@{$DpkgBinDirList{'_ALL_'}})
    {
        $m_DpkgBinDir = "$DpkgBinDir/$i";
        if ( ! -d $m_DpkgBinDir )
        {
            Verbose("Directory [$m_DpkgBinDir] not found.");
            next;
        }
 
        local *DIR;
        opendir(DIR, $m_DpkgBinDir) or 
            Error("can't opendir $m_DpkgBinDir : $!");
 
        my ($file);
        while (defined($file = readdir(DIR))) 
        {
            if ( $file !~ /^\.$/  &&     # we do not want the . and .. entries.

                 $file !~ /\.pdb$/ )
            {
                my ($m_fLoc) = "$m_DpkgBinDir/$file"; 
                if(File::Copy::copy("$m_fLoc", "$targetValue"))
                {
                    Verbose("Copied [$file] to [$targetValue] ...");
                }
                else
                {
                    Error("Failed to copy bin [$m_fLoc]: $!"); 
                }
            }
        }
        closedir(DIR);
    }

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1  )
    {
        Error("Incorrect number of params passed to rmDirectory() function.");
    }
 
    my ($startingPoint) = @_;
    
    Verbose("Recursively removing Directory tree [$startingPoint]");
 
    foreach my $item ( glob("$startingPoint/*"), glob("$startingPoint/.*") ) 
    {
        if ( $item !~ /^$startingPoint\/\.$/  && $item !~ /^$startingPoint\/\.\.$/ ) 
        {

                rmDirectory("$item");
            }
            else
            {
                unlink("$item");
                Debug("Removed file [$item].");
            }
        }
    }
 
    # lets clean the starting point.

    if ( "$base" ne "." && "$base" ne ".." )
    {
        my $retVal = rmdir("$startingPoint");
        if( $retVal )
        {
            Debug("Removed dir [$startingPoint].");
        }
        else
        {
            Error("Failed to remove dir [$startingPoint] : $!");
        }
    }
    return 1;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#------------------------------------------------------------------------------
sub CreateTargetDirStructure
#
# Description:
#       This sub-routine create the target stucture based on what the user has

#       In this function we also check to see if all the LocalSrcDirStructure
#       directories exist. We warn if they do not.
#
#------------------------------------------------------------------------------
{
    Information("Cleaning any previous target file items...");
 
    my ($i);
    my ($m_dirD);
 
    # lets clean.

        rmDirectory("$m_dirD");
    }
 
    # lets create.
    #
    Information ("Creating target directory structure...");
 
 
 
 
 
 
 
 
 
 
    make_directory( "$PkgBaseDir/$TargetBaseDir", 0777, "Create target dir");
    foreach $i ( sort {$a cmp $b} values %TargetDstDirStructure )
    {
        make_directory("$PkgBaseDir/$TargetBaseDir/$i", 0777);
    }
 
 
    # lets determine if we have a InstallShield config dir
    #

        #
        if ( -f "$m_ishieldProjFile" )
        {
            if ( ! -d "$m_ishieldDir" )
            {
                Error ("Local InstallShield config dir [$m_ishieldDir] does not exist.",
                       "Please create before continuing.");
            }
            else
            {
                # we populate the ishield config dir with the ishieldlib files
                #
                my ($i);
                Verbose("Installing Standard ishieldlib files from [$PKG_UTIL_DIR] to [$m_ishieldDir]");
                foreach $i ( @PKG_ISHIELD_FILES )
                {
                    # first we remove the file (as previously it install read-only).
                    unlink("$m_ishieldDir/$i");
                    if( File::Copy::copy("$PKG_UTIL_DIR/$i", "$m_ishieldDir") )
                    {
                        Verbose("Copied [$PKG_UTIL_DIR/$i] to [$m_ishieldDir] ...");
                    }
                    else
                    {
                        Error("Failed to copy info file [$PKG_UTIL_DIR/$i] to [$m_ishieldDir] : $!");
                    }
                }
 
 
                # we also want to deliver the patch rule files
                # if this build is a patch build.
                #
                if ( "x$PkgPatchNum" ne "x" )
                {
                    Verbose("Installing Patch ishieldlib files from [$PKG_UTIL_DIR] to [$m_ishieldDir]");
                    foreach $i ( @PATCH_ISHIELD_FILES )
                    {
                        # first we remove the file (as previously it install read-only).
                        unlink("$m_ishieldDir/$i");
                        if( File::Copy::copy("$PKG_UTIL_DIR/$i", "$m_ishieldDir") )
                        {
                            Verbose("Copied [$PKG_UTIL_DIR/$i] to [$m_ishieldDir] ...");
                        }
                        else
                        {
                            Error("Failed to copy info file [$PKG_UTIL_DIR/$i] to [$m_ishieldDir] : $!");
                        }
                    }
                }
 
 

                #
                # we assume our source dir is the interface/etc dir and our
                # dst dir is the PkgBaseDir
                #
                my ($m_islibImgFile) = "";
                Verbose("Installing ishield image files from [$DpkgEtcDir] to [$m_ishieldDir]");
                foreach $i ( @PKG_ISHIELD_IMG_FILES )
                {
                    $m_islibImgFile = "$DpkgEtcDir/$ProjectAcronym" . "_" . $i;
                    if ( -f "$m_islibImgFile" )
                    {
                        if( File::Copy::copy("$m_islibImgFile", "$PkgBaseDir") )
                        {
                            Verbose("Copied [$m_islibImgFile] to [$PkgBaseDir] ...");
                        }
                        else
                        {
                            Error("Failed to copy info file [$m_islibImgFile] to " .
                                     "[$PkgBaseDir] : $!");
                        }
                    }
                    else
                    {

                        $m_islibImgFile = "$DpkgEtcDir/mas" . "_" . $i;
                        if ( -f "$m_islibImgFile" )
                        {
                            if( File::Copy::copy("$m_islibImgFile", "$PkgBaseDir") )
                            {
                                Verbose("Copied [$m_islibImgFile] to [$PkgBaseDir] ...");
                            }
                            else
                            {
                                Error("Failed to copy info file [$m_islibImgFile] to " .
                                         "[$PkgBaseDir] : $!");
                            } 
                        } 
                        else
                        {
                            Warning("Failed to locate ishieldlib image [xxx_$i], no image copied, " .
                                    "check depolylib config.");
                        }
                    }
                }
 
            }
        }
        else
        {
            Warning("Did not detect InstallShield project file [$m_ishieldProjFile]");
            Warning("Not installing InstallShield library files.");
        }
    }
 
    # done.
    return 1;

 
    # lets open the file.
    #
    local *FILE;
    open ( FILE, "> $outFile") or
        Error("Failed to open file [$outFile].");
 
    # lets populate the pkgdef file.
 
    printf FILE ("// This is an automatically generated include file.\n");
    printf FILE ("// Please do not modify, and please do not check into ClearCase.\n");

    foreach $i ( values %LocalSrcDirStructure )
    {
        my ($m_Dir) = "$SrcDir/$i";
        if ( ! -d "$m_Dir" )
        {
            Warning ("Local src dir [$m_Dir] does not exist.");
        }
    }
 
    return 1;
}

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 ) 
    {
        Error("Incorrect number of params passed to " .
                  "getLocalDirValue() function.");
    }
 
    my ($m_key, $m_type) = @_;
    if (exists  $LocalSrcDirStructure{$m_key} )    

            return "$LocalSrcDirStructure{$m_key}";
        }
    }
    else
    {
        Error("Local src tag [$m_key] does not exist in " .
             "LocalSrcDirStructure. " ,
             "Check deploy configuration.");
    }
 
    return 1;
}
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 ) 
    {
        Error("Incorrect number of params passed to " .
                  "getTargetDstDirValue() function.");
    }
 
    my ($m_key, $m_type) = @_;
    my $tdir;

    {
        $tdir = $TargetBaseDir . '/' . $TargetDstDirStructure{$m_key};
    }
    else
    {
        Error("Target destination dir tag [$m_key] does not exist in " .
             "TargetDstDirStructure. " ,
             "Check deploy configuration.");
    }
 
 
    #
    #   If an absolute path is required than add the PkgBaseDir

    #
    if ( "$m_type" eq "A" ) {
        $tdir = "$PkgBaseDir/$tdir";
    } elsif ( "$m_type" eq "R" )  {
    } else {
        Error("getTargetDstDirValue: Bad call. Unknown type: $m_type");
    }
 
    return $tdir;
}
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 0 )
    {
        Error("Incorrect number of params passed to " .
              "createPatch() function.",
              "Check deploy config.");
    }
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("createPatch() not supported on this machine type.");
        return 1;
    }
 
    # lets just check to see if we can execute this function on
    # for  this build.
    #
    if ( "x$PkgPatchNum" eq "x" )
    {
        Warning("createPatch() can only be called during a PATCH build.");
        return 1;
    }
 
    # we need to create the patch directory that contains
    #
    Information("Creating patch ...");
 
    my ( $m_pkgmkCmd );
    my ( $m_pkgtransCmd );
    $m_pkgmkCmd = "pkgmk -o " .
                  "-f $PkgBaseDir/prototype " .

    # lets execute the package commands.
    my ($retVal);
    $retVal = system("$m_pkgmkCmd");
    if ( $retVal != 0 )
    {
        Error("Failed to complete command [$m_pkgmkCmd].");
    }
 
    # we need to generate a README file to help during installation
    #
    generatePatchREADME();
 
 
    my ($m_Cmd)    = ""; 
    my ($m_tmpDir) = "$PkgPatchTmpDir/$PkgPatchID";
 
    Information("Creating staging area of patch...");
    $m_Cmd = "cd $PkgBaseDir && mkdir -p $m_tmpDir;";
    system($m_Cmd);
 
    Information("Copying patch contents to staging area of patch...");
    $m_Cmd = "cd $PkgBaseDir && cp -r $PkgName $m_tmpDir;";
    system($m_Cmd);
 
    # we need to copy the patch install utility files from
    # their resting place.

    my ($i);
    foreach $i ( @PATCH_UTIL_FILES )
    {
        if( File::Copy::copy("$PATCH_UTIL_DIR/$i", "$PkgPatchTmpDir") )
        {
            Verbose("Copied [$PATCH_UTIL_DIR/$i] to [$PkgPatchTmpDir] ...");
            system("chmod 0755 $PkgPatchTmpDir/$i");
        }
        else
        {
            Error("Failed to copy info file [$PATCH_UTIL_DIR/$i] to [$PkgPatchTmpDir] : $!");
        }
    }
 
    # Lets put the readme in place
    #
    if( File::Copy::copy("$PkgPatchReadme", "$PkgPatchTmpDir") )
    {
        Verbose("Copied [$PkgPatchReadme] to [$PkgPatchTmpDir] ...");
    }
    else
    {
        Error("Failed to copy info file [$PkgPatchReadme] to [$PkgPatchTmpDir] : $!");
    }
 
    Information("Copying patch contents to staging area of patch...");
    $m_Cmd = "cd $PkgBaseDir && cp -r $PkgName $m_tmpDir;";
    system($m_Cmd);
 
    my ($m_oFile) = "$PkgPatchID-$ProjectAcronym\.tgz";
    Information("Creating a gzip'd compressed tar (.tgz) output file [$m_oFile]...");
    my ($base) = File::Basename::basename($PkgPatchTmpDir);
    $m_Cmd = "cd $PkgBaseDir && tar cvf - $base | gzip > $m_oFile";
    system($m_Cmd);
 
    return 1;

#
#------------------------------------------------------------------------------
{
    local *FILE;
    open ( FILE, "> $PkgPatchReadme") or
        Error("Failed to open file [$PkgPatchReadme].");
 
    printf FILE ("This is a patch for $PkgName $PkgVersion\n");
    printf FILE ("---------------------------------------------------------------\n");
    printf FILE ("\n");
    printf FILE ("Installing patch (as the 'root' user) :\n");

 
    my ($m_sfile) = $file;
    $file =~ s/$PkgBaseDir//;
 
    open ( FILE, ">> $PkgPatchReadme") or
         Error("Failed to open file [$deplylib::PkgPatchReadme].");
 
    # lets populate the prototype file.
    printf FILE ("* $file\n");
 
    close (FILE);

#       The type of package is machine specific. The subroutine will invoke a
#       machine specfic function to do the real work.
#
#------------------------------------------------------------------------------
{
    Information("createPackage");
    # correct number of parameters?
    if ( ($#_+1) != 0 )
    {
        Error("Incorrect number of params passed to " .
              "createPackage() function. ",
              "Check deploy config.");
    }
 
    # lets just check to see if we can execute this function on
    # this machine.
    #

        # lets just check to see if we can execute this function on
        # for  this build.
        #
        if ( $PkgPatchNum )
        {
            Warning("createPackage() can only be called during a RELEASE build.");
            return 1;
        }
 
        #
        #   Ensure the Release directory is present
        #
        make_directory( $ReleaseDir, 0777 );
 
 
 
 
 
 
        # Ensure that the package descriptor is transferred
        #
        my ($m_copydesc) = "cp $SrcDir/descpkg $ReleaseDir";
        system($m_copydesc);
 
        # Invoke the machine specific package builder by name
        # Need to relax strictness. Yes we do know what we are doing here
        #
        no strict "refs";
        &$createRoutine( @_ ) || Error("Unspecified error building package");
        use strict "refs";
    }
    else
    {
        Verbose("createPackage() not supported on this machine type: $MachType.");
    }
    return 1;
}
 
 

#       The type of package is machine specific. The subroutine will invoke a
#       machine specfic function to do the real work.
#
#------------------------------------------------------------------------------
{
    Verbose("createPackage_sparc");
 
    # we need to copy the package utility files from
    # their resting place.
    #
    foreach my $i ( @PKG_UTIL_FILES )
    {
        if( File::Copy::copy("$PKG_UTIL_DIR/$i", "$PkgBaseDir") )
        {
            Verbose("Copied [$PKG_UTIL_DIR/$i] to [$PkgBaseDir] ...");
            updatePrototypeFileAddItem2("$i", "$i", "", "", "", "I");
            system("chmod 0755 $PkgBaseDir/$i");
        }
        else
        {
            Error("Failed to copy info file [$PKG_UTIL_DIR/$i] to [$PkgBaseDir] : $!");
        }
    }
 
 
    my ( $m_pkgmkCmd );

    # lets execute the package commands.
    my ($retVal);
    $retVal = system("$m_pkgmkCmd");
    if ( $retVal != 0 )
    {
        Error("Failed to complete command [$m_pkgmkCmd].");
    }
 
    $retVal = system("$m_pkgtransCmd");
    system("$m_pkgtransCmd");
    if ( $retVal != 0 )
    {
        Error("Failed to complete command [$m_pkgtransCmd].");
    }
 
    # lets compress the output to save some space.
    #
    Information("Compressing $PkgOutputFile");
    my ($m_compressCmd) = "cd $PkgBaseDir; gzip $PkgOutputFile; mv ${PkgOutputFile}.gz $ReleaseDir";
    system($m_compressCmd);
 
    return 1;
}

#
#       Do have the option of creating a WinCE specific packager
#
#------------------------------------------------------------------------------
{
    Verbose("createPackage_WinCE");
    createPackage_win32(@_);
}
 
#------------------------------------------------------------------------------
sub createPackage_win32

#       This sub-routine is used to create a package.
#       Invoke the isbuild.pl utility to build the install shield project
#
#------------------------------------------------------------------------------
{
    Verbose("createPackage_win32");
    #
    #   Locate MergeModules in external packages
    #   These will be used by the InstallShield compiler
    #
    my @mm_dirs;

    #   This must be a flat directory structure. ie: all files in the
    #   subdirectory called MergeModule.
    #
    $tdir = "$RootDir/MergeModules";
    push @mm_dirs, $tdir if ( -d $tdir );
    Verbose ("Discovered MergeModules in: $tdir") if ( -d $tdir );
 
    #
    #   Check for Merge Modules in the Interface directory
    #   This will be pulled in via a BuildPkgArchive
    #
    $tdir = "$InterfaceDir/MergeModules";
    push @mm_tld, $tdir if ( -d $tdir );
    Verbose ("Discovered MergeModules in: $tdir") if ( -d $tdir );
 
    #
    #   Check in LinkPkgArchive locations too
    for my $entry ( $BuildFileInfo->getBuildPkgRules() )
    {
        next unless ( $entry->{'TYPE'} eq 'link' );
        $tdir = $entry->{'ROOT'} . '/MergeModules';
        push @mm_tld, $tdir if ( -d $tdir );
        Verbose ("Discovered MergeModules in: $tdir") if ( -d $tdir );
    }
 
    #
    #   Expand the merge module subdirectory tree into
    #   suitable paths:

        next unless ( -f $prog );
        $prog_found = 1;
        last;
    }
 
    Error("isbuild.pl not found") unless $prog_found;
    Verbose("isbuild: $prog");
    my $rv = system ( $ENV{GBE_PERL}, $prog,
                            "-project=../$PkgName.ism",
                            "-version=$PkgVersionUser",
                            "-out=$ReleaseDir",
                            "-workdir=$InterfaceDir",
                            map { "-mergemodule=$_" } @mm_dirs
                             );
    Error ("InstallShield Builder Error" ) if ( $rv );
    return 1;
}
 
#------------------------------------------------------------------------------
sub createPrototypeFile

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
              "createPrototypeFile() function",
              "Check deploy config.");
    }
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("createPrototypeFile() not supported on this machine type.");
        return 1;
    }
 
    # lets take the passed in args.
    my ($uid, $gid) = @_;

 
    # we need to locate the prototype file
    if ( -f "$protoTypeFile" )
    {
        unlink("$protoTypeFile");
        Verbose("Removing prototype file [$protoTypeFile].");
    }
 
    # lets open the prototype file.
    #    
    local *FILE;
    open ( FILE, "> $protoTypeFile") or
        Error("Failed to open file [$protoTypeFile].");
 
    # lets populate the prototype file.
    printf FILE ("i pkginfo\n");
 
    if ( "x$TargetBaseDir" ne "x." )

    # be installing 
    File::Find::find(\&prototypeFind, "$targetBaseDir");
 
    # lets populate the prototype file with a newline.
    open ( FILE, ">> $protoTypeFile") or
        Error("Failed to open file [$protoTypeFile].");
    printf FILE ("\n");
    close (FILE);
 
 
    # lets put the pre-deinfed generic entries into the 

                  " >> $protoTypeFile";
 
    my ($retVal) = system("cd $pkgBaseDir; $m_cmd");
    if ( $retVal != 0 )
    {
        Error("Failed to create prototype file [$protoTypeFile].");
    }
 
    Information("Created prototype file [$protoTypeFile].");
 
    return 1;
}
 
#------------------------------------------------------------------------------

            {
                $file =~ s/$tDir/$TargetBaseDir/;
            }
 
            open ( FILE, ">> $pfile") or
                 Error("Failed to open file [$pfile].");
 
            # lets populate the prototype file.
            printf FILE (" $file");
            close (FILE);
        }

#       This sub-routine is used to add additonal genericinformation
#       used by the patch.
#
#------------------------------------------------------------------------------
{
    Information("Adding patch information files to patch build...");
 
    # we need to determine whiich file we are dealing with
    my ($protoTypeFile);
    $protoTypeFile = "$ProtoTypeFile";
 
    # lets open the prototype file.
    #
    local *FILE;
    open ( FILE, ">> $protoTypeFile") or
        Error("Failed to open file [$protoTypeFile].");
 
 
    # we need to copy the install informational files from
    # their resting place.
    my ($i);
    foreach $i ( @PATCH_INFO_FILES )
    {
        if( File::Copy::copy("$PATCH_UTIL_DIR/$i", "$PkgBaseDir") )
        {
            Verbose("Copied [$PATCH_UTIL_DIR/$i] to [$PkgBaseDir] ...");
            printf FILE ("i $i\n"); 
        }
        else
        {
            Error("Failed to copy info file [$PATCH_UTIL_DIR/$i]: $!");
        }
    }
    close FILE;
    
    return 1;

#       include the i.replace file in the PKG_INFO_FILES List
#
#------------------------------------------------------------------------------
{
 
    Information("useReplaceClass: Adding replace class to installer");
 
    $PkgInfoClasses = $PkgInfoClasses . " " . "replace";
    push(@PKG_UTIL_FILES, "i.replace");
}
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) == 0 )
    {
        Error("Incorrect number of params passed to " .
              "createPkginfoFile() function",
              "Check deploy config.");
    }
 
    Information("addPkgInfoClasses() Adding classes \"" . join(" ", @_) . "\" to CLASSES List");
 
    $PkgInfoClasses = $PkgInfoClasses . " " . join(" ", @_);
}
 
 

#------------------------------------------------------------------------------
{
    # lets just check to see if we can execute this function on this machine.
    if ( "$MachType" ne "sparc" )
    {
        Verbose("addPkgInfoField() not supported on this machine type.");
        return 1;
    }
    # lets open the pkginfo file.   
    local *FILE;
    open ( FILE, ">> $PkgInfoFile") or Error("Failed to open file [$PkgInfoFile].");
 
    foreach my $i ( @_ )
    {
        print FILE "$i\n";
    }

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
                  "updatePrototypeFileItemClass() function. Check deploy config.");
    }
 
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("updatePrototypeFileItemClass() not supported on this machine type.");
        return 1;
    }
 
 
    # lets setup the passed values.

    my ($tmpProtoTypeFile) = "/tmp/xx_prototypefile.$$";
 
    # lets open the prototype file if it exists
    #
    open (PFILE, "< $ProtoTypeFile") or
        Error("Failed to open prototype file [$ProtoTypeFile].");
 
    open (PFILETMP, "> $tmpProtoTypeFile") or
        Error("Failed to open tmp prototype file [$tmpProtoTypeFile].");
 
    while ( <PFILE> )
    {
        chomp;
        # The path section will normally contain "path [mode]" or path=path

    close PFILETMP;
 
    # now we need to copy the file.
    if(File::Copy::copy("$tmpProtoTypeFile", "$ProtoTypeFile"))
    {
        Verbose("Updated file $m_item to class $class");
        unlink($tmpProtoTypeFile);
    }
    else
    {
        Error("Failed to copy lib [$tmpProtoTypeFile]: $!");
    }
 
    return 1;
 
}

    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("updatePrototypeFileItemClass() not supported on this machine type.");
        return 1;
    }
 
    Error("Must call useReplaceClass() before calling setReplaceClassFiles()") if ( $PkgInfoClasses !~ /replace/ );
 
    my ($tmpProtoTypeFile) = "/tmp/xx_prototypefile.$$";
 
    # lets open the prototype file if it exists
    #
    open (PFILE, "< $ProtoTypeFile") or
        Error("Failed to open prototype file [$ProtoTypeFile].");
 
    open (PFILETMP, "> $tmpProtoTypeFile") or
        Error("Failed to open tmp prototype file [$tmpProtoTypeFile].");
 
    my $line;
    while ( $line = <PFILE> )
    {
        chomp $line;

    close PFILETMP;
 
    # now we need to copy the file.
    if(File::Copy::copy("$tmpProtoTypeFile", "$ProtoTypeFile"))
    {
        Verbose("Updated prototype file entries to class replace");
        unlink($tmpProtoTypeFile);
    }
    else
    {
        Error("Failed to copy lib [$tmpProtoTypeFile]: $!");
    }
 
    return 1;
 
}

#------------------------------------------------------------------------------
{
    # lets check to see if our description has been set
    if ( $PkgDesc eq "" )
    {
        Error("Package description not set. " .
                 "Use setPkgDescription('my package description') function.");
    }
 
    # lets check to see if our long name has been set
    if ( $PkgNameLong eq "" )
    {
        Error("Package name not set. Use setPkgName('my package long name') function.");
    }
 
 
    # lets just check to see if we can execute this function on
    # this machine.

 
    # we need to locate the pkginfo file
    if ( -f "$pkginfoFile" )
    {
        unlink("$pkginfoFile");
        Verbose("Removing pkginfo file [$pkginfoFile].");
    }
 
    # lets open the pkginfo file.
    #    
    local *FILE;
    open ( FILE, "> $pkginfoFile") or
        Error("Failed to open file [$pkginfoFile].");
 
    # lets populate the pkginfo file.
    printf FILE ("PKG=$PkgName\n");
 
 

    close FILE;
 
 
    # lets close the pkginfo file.
    close (FILE);
    Information("Created pkginfo file [$pkginfoFile].");
 
    return 1;
}
 
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 4 )
    {
        Error("Incorrect number of params passed to " .
                  "updatePrototypeFileItemOwner() function. Check deploy config.");
    }
 
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("chmod() not supported on this machine type.");
        return 1;
    }
 
 
    # lets setup the passed values.

 
 
    # lets open the prototype file if it exists
    #
    open (PFILE, "< $ProtoTypeFile") or
        Error("Failed to open prototype file [$ProtoTypeFile].");
 
    open (PFILETMP, "> $tmpProtoTypeFile") or
        Error("Failed to open tmp prototype file [$tmpProtoTypeFile].");
 
    my ($inLine);
    while ( <PFILE> )
    {
        $inLine = $_;

    close PFILETMP;
 
    # now we need to copy the file.
    if(File::Copy::copy("$tmpProtoTypeFile", "$ProtoTypeFile"))
    {
        Verbose("Copied [$tmpProtoTypeFile] to [$ProtoTypeFile] ...");
        unlink($tmpProtoTypeFile);
    }
    else
    {
        Error("Failed to copy lib [$tmpProtoTypeFile]: $!");
    }
 
    return 1;
 
}

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 3 )
    {
        Error("Incorrect number of params passed to " .
                  "chmod() function. Check deploy config.");
    }
 
 
    # lets setup the passed values.

 
    # lets just check to see if the perms are in correct format.
    #
    if ( "$m_ownPerms" !~ m/^[0-9][0-9][0-9][0-9]$/ )
    {
        Error("chmod() does not support [$m_ownPerms] permission, use format 0755 etc.");
        return 1;
    }
 
    # lets get the absolute src dir value
    my ($m_sDirAbsoluteValue) = getTargetDstDirValue($m_sDirTag, "A");

    # check to see if item exists
    #
    if ( ! -f "$item" && 
         ! -d "$item" )
    {
        Error("Failed to find item [$item]. Check deploy config."); 
    }
    Verbose("chmod: Changing permisions of file [$m_sfile] in dirtag [$m_sDirTag] to [$m_ownPerms]");
    chmodFile("$item", $m_ownPerms);
 
    return 1;
}
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
                  "chmodRecursive() function. Check deploy config.");
    }
 
    # lets setup the passed values.
    my ($m_sDirTag, $m_ownPerms) = @_;
 
    # lets just check to see if the perms are in correct format.
    #
    if ( "$m_ownPerms" !~ m/^[0-9][0-9][0-9][0-9]$/ )
    {
        Error("chmod() does not support [$m_ownPerms] permission, use format 0755 etc.");
        return 1;
    }
 
 
    # lets get the absolute src dir value

    # check to see if item exists
    #
    if ( ! -f "$m_sDirAbsoluteValue" &&
         ! -d "$m_sDirAbsoluteValue" )
    {
        Error("Failed to find item [$m_sDirAbsoluteValue]. " .
                  "Check deploy config."); 
    }
 
 
    # if its a not a dir
    #
    if ( ! -d "$m_sDirAbsoluteValue" && -f "$m_sDirAbsoluteValue" )
    {
        Warning("chmodRecursive: This should not happen as dirtag [$m_sDirTag] is a file, changings perms to [$m_ownPerms] anyway");
        chmodFile("$m_sDirAbsoluteValue", $m_ownPerms);
    }
    else
    {
        # it must be a dir
        Verbose("chmodRecursive: Recursively setting perms on dirtag [$m_sDirTag] to [$m_ownPerms]");
        chmodDir("$m_sDirAbsoluteValue", $m_ownPerms);
    }
 
    return 1;
}

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
                  "chmodDir() function.");
    }
 
    my ($startingPoint, $perms) = @_;
 
    Verbose("chmodDir: Recursively setting permsision of [$startingPoint] to [$perms]");
 
    local *DIR;
    opendir(DIR, $startingPoint) or
        Error("can't opendir $startingPoint: $!");
 
    my ($item);
    while (defined($item = readdir(DIR)))
    {
        if ( "$item" !~ /^\.$/  &&

 
    my ($cmd) = "CORE::chmod $perms, $item";
    my ($noItems) = CORE::chmod oct($perms), $item;
    if ( $noItems == 0 )
    {
        Error("Failed to complete command [$cmd], retVal=[$noItems]");
    }
    else
    {
        Debug("Executed command: [$cmd]");
    }
 
    return 1;
}
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 3 )
    {
        Error("Incorrect number of params passed to " .
                  "createSymbolicLink() function. Check deploy config.");
    }
 
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("createSymbolicLink() not supported on this machine type.");
        return 1;
    }
 
 
    # lets setup the passed values.

 
    # lets see if the source item exists
    #
    if ( ! -f "$m_sDirAbsoluteValue/$m_srcStr" )
    {
        Error("Failed to locate item [$m_sDirAbsoluteValue/$m_srcStr], link not created.");
    }
 
 
 
    my ($cmd) = "cd $m_sDirAbsoluteValue; ln -s $m_srcStr $m_linkStr";
    system("$cmd");
    if ( $? != 0 )
    {
        Error("Failed to complete command: [$cmd]");
    }
    else
    {
        Verbose("Executed command: [$cmd]");
    }
 
    return 1;
}
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 3 )
    {
        Error("Incorrect number of params passed to " .
                  "createPrototypeFile2() function. Check deploy config.");
    }
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("createPrototypeFile2() not supported on this machine type.");
        return 1;
    }
 
    # lets take the passed in args.
    my ($uid, $gid, $mask) = @_;

 
    # we need to locate the prototype file
    if ( -f "$protoTypeFile" )
    {
        unlink("$protoTypeFile");
        Verbose("Removing prototype file [$protoTypeFile].");
    }
 
    # lets open the prototype file.
    #    
    local *FILE;
    open ( FILE, "> $protoTypeFile") or
        Error("Failed to open file [$protoTypeFile].");
    # lets populate the prototype file.
    printf FILE ("!default $mask $uid $gid\n");
    printf FILE ("i pkginfo\n");
    close (FILE);
 

    File::Find::find(\&prototype2Find, "$targetBaseDir");
 
 
    # lets populate the prototype file with a newline.
    open ( FILE, ">> $protoTypeFile") or
        Error("Failed to open file [$protoTypeFile].");
    printf FILE ("\n");
    close (FILE);
 
 
    Information("Created prototype file [$protoTypeFile].");
 
    return 1;
}
 
#-------------------------------------------------------------------------------
# Function        : createZip
#
# Description     : Create a ZIp file of a given directory
#
# Inputs          : --Recurse               - Recurse subdirs
#                   --NoRecurse             - Done recurse subdirs
#                   --Dirnames              - Record Dir names
#                   --NoDirnames            - Don't record dirnames
#                   --NoQuiet               - Display the operatios
#                   --Dir=xxxx              - Symbolic Directory to zip
#                   --ZipDir=ttt            - Symbolic target directory
#                   --ZipFile=yyyy          - Zipfile to create
#
# Returns         : Will not return on error
#                   Requires 'zip' to be provided by a 'package' such as InfoZip
#
sub createZip
{
    my $recurse = 1;
    my $dirnames = 0;
    my $quiet = 1;
    my $sdir;
    my $tdir;
    my $tfile;
 
    #
    #   Only on Windows at the moment.
    #   Perhaps Unix should create a .gz file
    #
    Warning ("createZip not supported on $MachType. Operation skipped")
        unless ( "$MachType" eq "win32" );
 
    #
    #   Process user arguments
    #
    foreach ( @_ )
    {
        if ( m/^--Recurse/ ) {
            $recurse = 1;
 
        } elsif ( m/^--NoRecurse/) {
            $recurse = 0;
 
        } elsif ( m/^--Dirnames/ ) {
            $dirnames = 1;
 
        } elsif ( m/^--NoDirnames/ ) {
            $dirnames = 0;
 
        } elsif ( m/^--NoQuiets/ ) {
            $quiet = 0;
 
        } elsif ( m/^--Dir=(.*)/ ) {
            $sdir = $1;
 
        } elsif ( m/^--ZipDir=(.*)/ ) {
            $tdir = $1;
            
        } elsif ( m/^--ZipFile=(.*)/ ) {
            $tfile = $1;
            
        } else {
            Warning("createZip: Unknown argument ignored: $_");
 
        }
    }
 
    #
    #   Convert the source directory TAG into a real directory
    #
    Error ("createZip: Source directory not specified") unless ( $sdir );
    my $sdir_a = getTargetDstDirValue($sdir, "A");
 
    #
    #   Convert the destination directory tag into a real directory
    #
    Error ("createZip: Target directory not specified") unless ( $tdir );
    Error ("createZip: Target filename not specified") unless ( $tfile );
    my $tdir_a = getTargetDstDirValue($tdir, "A");
 
    #
    #   Locate the 'zip' uitilty
    #
    my $prog = LocateProgInPath( 'zip' );
    Error ("createZip: Cannot locate ZIP executable",
            "May need to use the 'infozip' package") unless ( $prog );
 
    #
    #   Generate command file
    #
    my $args = '-9';
    $args .= 'q' unless ( (! $quiet) || IsVerbose(1));
    $args .= 'r' if ( $recurse );
    $args .= 'j' unless ( $dirnames );
 
    #
    #   Zip up the files
    #
    Information ("Create Zip File: [$tdir] $tfile");
    chdir ( $sdir_a ) || Error ("Cannot cd to $sdir_a");
    my $rv = System ($prog, $args, "$tdir_a/$tfile", "." );
    chdir($CurrentDir) || Error ("Cannot cd to $CurrentDir");
 
    Error ("createZip: Zip file not created") if ( $rv );
}
 
 
#------------------------------------------------------------------------------
sub prototype2Find
#
#    Description:

        # files so we need to exclude them
        if ( "$file" ne "$ProtoTypeFileName" &&
             "$file" ne "$PkgInfoFileName")
        {
            open ( FILE, ">> $pfile") or
                Error("Failed to open file [$pfile].");
 
            if ( -f "$m_sfile" )
            {
                printf FILE ("f none $file=$file $m_MASK $m_UID $m_GID\n");
            }

#------------------------------------------------------------------------------
{
   # correct number of parameters?
    if ( ($#_+1) != 2 )
    {
        Error("Incorrect number of params passed to " .
                  "convertFile() function. Check deploy config.");
    }
    my ($m_targetDirTag, $m_nfile) = @_;
 
 

    local *IFILE;
    local *TFILE;
    if ( -f "$m_ifileLoc" )
    {
        open (IFILE, "< $m_ifileLoc" ) or
            Error("Failed to open file [$m_ifileLoc] : $!");
 
        open (TFILE, "> $m_tfileLoc" ) or
            Error("Failed to open file [$m_tfileLoc] : $!");
 
        while ( <IFILE> ) 
        {
            chomp;
            print TFILE "$_\n";
        }
    }
    else
    {
        Error("Deploy file [$m_ifileLoc] does not exist.");
    }
 
    close IFILE;
    close TFILE;
 
 
    # lets replace our original file with the new one
    #
    if(File::Copy::move("$m_tfileLoc", "$m_ifileLoc"))
    {
        Information("Renamed [$m_tfileLoc] to [$m_ifileLoc] ...");
    }
    else
    {
        Error("Failed to crename file [$m_tfileLoc] to [$m_ifileLoc]: $!");
    }
 
    return 1;
}
 
 
#-------------------------------------------------------------------------------
# Function        : installDeployFile
#
 
# Description     : This sub-routine is used to copy a local deployment file into
#                   the target destination dir.
#
# Inputs          : m_srcDirTag             - Tag for Source Dir name
#                                             Tag defined in %LocalSrcDirStructure
#                   m_sfile                 - Name of the source file
#                   m_targetDirTag          - Tag for the target directory
#                                             Tag defined in %TargetDstDirStructure
#                   m_nfile                 - Target filename
#                                             Must be specified. If set to "", then
#                                             the source filename will be used.
#
# Returns         : True
#
#------------------------------------------------------------------------------
 
sub installDeployFile
{
    # correct number of parameters?
    if ( ($#_+1) != 4 )
    {
        Error("Incorrect number of params passed to " .
                  "installDeployFile() function. Check deploy config.");
    }
 
    my ($m_srcDirTag, $m_sfile, $m_targetDirTag, $m_nfile) = @_;
 

    if ( -f "$m_sfileLoc" )
    {
        # now we need to copy the file. 
        if(File::Copy::copy("$m_sfileLoc", "$m_nfileLoc"))
        {
            Verbose("Copied [$m_sfile] to [$m_nfileLoc] ...");
 
            # now we need to ensure the item is writable as it
            # has come from our VOB that is by definition read-only
            #
            CORE::chmod oct("0755"), $m_nfileLoc;
 
        }
        else
        {
            Error("Failed to copy lib [$m_sfileLoc]: $!"); 
        }
    }
    else
    {
        Error("Deploy file [$m_sfileLoc] does not exist.");
    }
 
    return 1;
}
 

#------------------------------------------------------------------------------
{
   # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
                  "getGenericNameForLib() function. Check deploy config.");
    }
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("getGenericNameForLib() not supported on this machine type.");
        return "";
    }
 
 
    my($itemName) = @_;

    # first we need to check to see if it belongs in this build
    #
    my ($gName) = "";
    if(excludeItemFromBuild($itemName))
    {
        Verbose("Excluding item [$itemName] from build as not compatible with build type " .
                "[$BuildType].");
        return "";  # file should be excluded.
    }
    else
    {

#------------------------------------------------------------------------------
{
   # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
                  "getGenericNameNoVersionForLib() function. Check deploy config.");
    }
 
    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "sparc" )
    {
        Verbose("getGenericNameNoVersionForLib() not supported on this machine type.");
        return "";
    }
 
 
    my($itemName) = @_;

    # first we need to check to see if it belongs in this build
    #
    my ($gName) = "";
    if(excludeItemFromBuild($itemName))
    {
        Verbose("Excluding item [$itemName] from build as not compatible with build type " .
                "[$BuildType].");
        return "";  # file should be excluded.
    }
    else
    {

#------------------------------------------------------------------------------
{
   # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
                  "getGenericNameNoVersionForXML() function. Check deploy config.");
    }
 
    my($itemName) = @_;
    my ($gName) = "";

        # if we match lets deal with it.
        $nfile =~ s/_[0-9]+_[0-9]+_[0-9]+\.xml$/\.xml/;
    }
    else
    {
        Warning("Filename [$nfile] does not contain required format [myfile_N_N_N.xml].");
    }
    return "$nfile";
}
 
 

#------------------------------------------------------------------------------
{
    # correct number of parameters?
    if ( ($#_+1) != 1 )
    {
        Error("Incorrect number of params passed to " .
                  "createDpkgArchive() function. Check deploy config.");
    }
 
    my ($desc) = @_;
 
    # lets just check to see if we can execute this function on
    # for  this build.
    #
    if ( "x$PkgPatchNum" ne "x" )
    {
        Verbose("createDpkgArchive() can only be called during a RELEASE build.");
        return 1;
    }
 
 
    # 1. we create a dpkg_archive top level dir within the output directory
    #
    my ($m_tmpDir) = "$PkgBaseDir/dpkg_archive";
 
 
    make_directory( $m_tmpDir, 0777 );
 
 
 
    # 2. we create a sub-directory with the package name
    #
    $m_tmpDir = "$PkgBaseDir/dpkg_archive/$TargetBaseDir";
 
 
    make_directory( $m_tmpDir, 0777 );
 
 
 
    # 3. we create a sub-directory with the package version number
    #
    my ($m_tmpDir2) = "$PkgBaseDir/dpkg_archive/$TargetBaseDir/" .
                      "$PkgVersion" .  "." . "$ProjectAcronym";
 
 
    make_directory( $m_tmpDir2, 0777 );
 
 
 
 
    # 4. we replacate the contents of the original outputdir/package name
    #    to do this we shall execute a find starting within the original package target dir
    #    any copy all items we find to the new location under the dpkg_archive/package/version dir.

 
    # now we need to update the prototype file
    #
    local *FILE;
    open ( FILE, ">> $m_DescPkgFile") or
        Error("Failed to open file [$m_DescPkgFile].");
    printf FILE ("$PkgName, $PkgVersion.$ProjectAcronym - $desc\n");
    close (FILE);
   
 
    # done.
    Information("createDpkgArchive() completed.");
 
    return 1;
}
 
 

        my ($m_sfile) = $item;
        $item =~ s/$PkgBaseDir\/$TargetBaseDir/$PkgBaseDir\/dpkg_archive\/$TargetBaseDir\/$PkgVersion\.$ProjectAcronym/;
 
        if(File::Copy::copy("$m_sfile", "$item"))
        {
            Verbose("Copied [$base] to [$item] ...");
        }
        else
        {
            Error("Failed to copy pkg file [$m_sfile] to [$item]: $!");
        }
    }
    else
    {
        # we have found a dir
        my ($m_sDir) = $item;
        $item =~ s~$PkgBaseDir/$TargetBaseDir~$PkgBaseDir/dpkg_archive/$TargetBaseDir/$PkgVersion\.$ProjectAcronym~;
 
 
 
 
 
        make_directory( $item, 0777 );
 
 
    }
}
 
 
 

#
#    Description:
#        This is called to update the RM class objects with details from RM database
#------------------------------------------------------------------------------
{
    #
    #   If this script is invoked by the AutoBuildTool, then we may not be able
    #   to create a Release Note as the RM entry may not be available. More over
    #   the ABT will create a release note as the package is made official
    #
    if ( $autobuild )
    {
        Debug('getRmDetails: AutoBuild Environment supresses function');
        return;
    }
 
 
    if ( ! defined($RmPkgDetails) )
    {
        # Set defaults for elements in RM if not found
        DeployUtils::RmPkgInfo->DefaultDescription($PkgDesc);
        DeployUtils::RmPkgInfo->DefaultLabel($PkgLabel);

        {
            $RmPvPkgDetails = DeployUtils::RmPkgInfo->new( { PKG_NAME => $PkgName, 
                                                             PKG_VERSION => $PkgPreviousVersionStr } );
            if ( $RmPvPkgDetails->foundDetails() )
            {
                sub MultiLineVerb
                {
                    my ($prefix, $text ) = @_;
                    my $zap = 0;
 
                    foreach my $line ( split /[\r\n]+/, $text  )
                    {
                        Verbose($prefix . "[" . $line . "]");
                        unless ( $zap )
                        {
                            $prefix = ' ' x length($prefix);
                            $zap = 1;
                        }
                    }
                }
 
                Information("Retrieved Package Details from Release Manager");
                if ( IsVerbose(1) )
                {
                    MultiLineVerb("RM pkg_name       = ",  $RmPkgDetails->pkg_name()       );
                    MultiLineVerb("RM pkg_id         = ",  $RmPkgDetails->pkg_id()         );
                    MultiLineVerb("RM pv_id          = ",  $RmPkgDetails->pv_id()          );
                    MultiLineVerb("RM pv_description = ",  $RmPkgDetails->pv_description() );
                    MultiLineVerb("RM pv_overview    = ",  $RmPkgDetails->pv_overview()    );
                    MultiLineVerb("RM pv_reason      = ",  $RmPkgDetails->pv_reason()      );
                    MultiLineVerb("RM pv_label       = ",  $RmPkgDetails->pv_label()       );
                    MultiLineVerb("RM previousPv_id  = ",  $RmPvPkgDetails->pv_id()        );
                    MultiLineVerb("RM pv_dlocked     = ",  $RmPvPkgDetails->pv_dlocked()   );
                }
            }
            else
            {
                # our package does not exist in release manager
                Warning("Could not retrieve package $PkgName $PkgVersionUser previous version " .
                        "details from Release Manager.")
            }
        }
        else
        {
            # our package does not exist in release manager 
            Warning("Package $PkgName $PkgVersionUser does not exist in the Release Manager",
                    "Please check configuration.")
        }
    }
}  
 
 
 
# This is now depricated
sub generateReleaseNote
{
    Error("generateReleaseNote is depricated please use generateHtmlReleaseNote");
    return 1;
}
 
 
 

    #   to create a Release Note as the RM entry may not be available. More over
    #   the ABT will create a release note as the package is made official
    #
    if ( $autobuild )
    {
        Warning('AutoBuild Environment. Release notes generated later');
        return;
    }
 
    #
    #   Ensure the Release directory is present
    #
 
 
    make_directory( $ReleaseDir, 0777 );
 
 
 
    if ( ! getRmReleaseNote() )
    {
        Error("No Release Manager details, release note not generated.");
    }
}
 
 
 

    # let's update the release contents now
    #
    generateProductContents();
 
 
    Information("Retrieving Release Notes From Release Manager...Please wait...");
 
    my $user_agent = LWP::UserAgent->new( timeout => 30 );
    my $response = $user_agent->get('http://erg:8002/ManagerSuite/Release_Manager/_adhoc_release_notes.asp?pv_id='. $RmPkgDetails->pv_id(), 
                                    ':content_file' => "$PkgReleaseNote\.html");
    if ( $response->is_success )
    {
        Verbose("Retrieved Release Manager HTML Release note [$PkgReleaseNote\.html]");
        return 1;
    }
    else
    {
        Warning("Unable to retrieve Release Manager Release Notes");
        return 0;
    }
}
 
#------------------------------------------------------------------------------

 
        if ( defined ( $depObj ) )
        {
            if ( $depObj->pkg_version() ne "$versionStr" )
            {
                Warning("Dependency difference, [$i] Local version $versionStr, RM version " . $depObj->pkg_version());
                $retValue = 1;
            }
        }  
        else
        {
            Warning("Dependency difference, [$i] Cannot locate archive in Release Manager database.");
            $retValue = 1;
        }
    }
 
    # lets check to see if we detected a difference 
    if ( $retValue != 0 )
    { 
        Error("Difference detected between the local build.pl and Release Manager config.",
              "Please check Release Manager configuration.");
    }
 
 
 
    # now we check release manager details against our local ones

            $versionStr .= "\.$moduleInfo->{proj}" if ( $moduleInfo->{proj} ne "" );
            my $depObj = $RmPkgDetails->getDependencyObject($i);
 
            if ( $depObj->pkg_version() ne "$versionStr" )
            {
                Warning("Dependency difference, [$i] local version $versionStr, RM version " . $depObj->pkg_version());
                $retValue = 1;
            }
        }  
        else
        {
            Warning("Dependency difference, cannot locate archive [$i] in local build.pl.");
            $retValue = 1;
        }
    }
 
    # lets check to see if we detected a difference 
    if ( $retValue != 0 )
    { 
        Error("Difference detected between Release Manager config and the local build.pl. ",
               "Please check the local configuration.");
    }
 
    return 1;
}
 

    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "win32" )
    {
        Information("createPerlSvcWin32() not supported on this machine type.");
        return 1;
    }
 
 
    my ($m_srcDirTag, $m_sfile, $m_targetDirTag, $m_ofile, @m_libDirTags) = @_;

    }
    if ( -d $DpkgScriptsDir )
    {
        $_libStr = $_libStr . "$DpkgScriptsDir";
    }
    Verbose("additional places to look for perl modules, [$_libStr]");
 
 
    # lets get the target dir value
    my ($m_srcDirValue) = getLocalDirValue($m_srcDirTag, "A");
 

    # lets execute the package commands.
    my ($retVal);
    $retVal = system("$_cmdStr");
    if ( $retVal != 0 )
    {
        Error("Failed to complete command [$_cmdStr].");
    }
 
    # done.
    return 1;
}

    # lets just check to see if we can execute this function on
    # this machine.
    #
    if ( "$MachType" ne "win32" )
    {
        Information("createPerlAppWin32() not supported on this machine type.");
        return 1;
    }
 
 
    my ($m_srcDirTag, $m_sfile, $m_targetDirTag, $m_ofile, @m_libDirTags) = @_;

    }
    if ( -d $DpkgScriptsDir )
    {
        $_libStr = $_libStr . "$DpkgScriptsDir";
    }
    Verbose("additional places to look for perl modules, [$_libStr]");
 
 
    # lets get the target dir value
    my ($m_srcDirValue) = getLocalDirValue($m_srcDirTag, "A");
 

    # lets execute the package commands.
    my ($retVal);
    $retVal = system("$_cmdStr");
    if ( $retVal != 0 )
    {
        Error("Failed to complete command [$_cmdStr].");
    }
 
    # done.
    return 1;
}

    {
        # lets zap the product contents
        # only if the release manager entry is not locked.
        if ( $RmPkgDetails->pv_dlocked() ne "Y" )
        {
           Error("Failed to zap product contents.")
                if ( ! $RmPkgDetails->zapProductContents( $Platform ) );
        }
 
 
        # lets get a listing of the products contents
        #
        File::Find::find( \&ProductContentsFind, "$PkgBaseDir/$TargetBaseDir");
    }
    else
    {
        Warning("Unable to load product contents because we do not have a connection to Release Manager.");
    }
 
 
    # done
    return 1;

        {
            $cksumStr  = `cksum "$item"`;
            $retVal    = $? / 256;
            if ( $retVal != 0 )
            {
                Error("Failed to determine cksum for product content item [$item].") 
            }
            else
            {
                chomp($cksumStr);
                $cksumStr =~ s/^\s+|\s+$//g;

 
            # we only mess with the product contents
            # if the package is not released.
            if ( $RmPkgDetails->pv_dlocked() ne "Y" )
            {
                Error("Failed to insert product content item.")
                     if ( ! $RmPkgDetails->insertProductContentItem( $Target, $cksumPath, $cksumName, '', $cksumSize, $cksumValue) );
            }
            else
            {
                Verbose("product item - $Target, $cksumPath, $cksumName, '', $cksumSize, $cksumValue");
            }
        }
        else
        {
            $cksumPath =~ s/$/\//;
            if ( $RmPkgDetails->pv_dlocked() ne "Y" )
            {
               Error("Failed to insert product content item.")
                     if ( ! $RmPkgDetails->insertProductContentItem( $Target, $cksumPath, '', '', 0, '') );
            }
            else
            {
                Verbose("product dir - $Target, $cksumPath, '', '', 0, ''");
            }
        }
    }
}
 
#-------------------------------------------------------------------------------
# Function        : make_directory
#
# Description     : Create a directory if it does not already exist
#                   Simple function to provide user messages on the way
#                   Will create a complete path. There is no need to
#                   break it into bits.
#
# Inputs          : name        - path to the directory
#                   umask       - umask
#                   text        - User text (optional)
#
# Returns         :
#
 
sub make_directory
{
    my ($name, $umask, $text ) = @_;
 
    Error ("make_directory needs a umask") unless ( $umask );
    Error ("make_directory needs a path") unless ( $name );
    $text = "Create directory"  unless ( $text );
 
    my $umask_text = sprintf( "0%o", $umask );
 
    unless ( -d $name )
    {
        Verbose ( "$text: $name [$umask_text]");
        mkpath ( $name, 0, $umask);
    }
    else
    {
        Verbose2 ( "$text: $name [$umask_text] - already exists");
    }
}
 
#------------------------------------------------------------------------------
1;

Rev 1532	Rev 1534
Line 36...	Line 36...
36	`use File::Path;`	36	`use File::Path;`
37	`use Cwd;`	37	`use Cwd;`
38	`use Carp;`	38	`use Carp;`
39	`use DBI;`	39	`use DBI;`
40	`use LWP::UserAgent;`	40	`use LWP::UserAgent;`
41	`use DeployUtils::Logger;`	-
42	`use DeployUtils::RmPkgInfo;`	41	`use DeployUtils::RmPkgInfo;`
43	`use BuildConfig;`	42	`use BuildConfig;`
44	`use Exporter();`	43	`use Exporter();`
-		44
45	`use ArrayHashUtils;`	45	`use ArrayHashUtils;`
-		46	`use JatsError;`
-		47	`use JatsSystem;`
46		48
47	`#-------------------------------------------------------------------------------`	49	`#-------------------------------------------------------------------------------`
48	`# Export variables and function into the users name space`	50	`# Export variables and function into the users name space`
49	`#-------------------------------------------------------------------------------`	51	`#-------------------------------------------------------------------------------`
50	`our @ISA = qw(Exporter);`	52	`our @ISA = qw(Exporter);`
Line 122...	Line 124...
122	`&convertFile`	124	`&convertFile`
123		125
124	`&getErgAfcBaseDir`	126	`&getErgAfcBaseDir`
125	`&getGenericNameNoVersionForLib`	127	`&getGenericNameNoVersionForLib`
126	`&getGenericNameForLib`	128	`&getGenericNameForLib`
-		129	`&createZip`
127		130
128	`%TargetDstDirStructure`	131	`%TargetDstDirStructure`
129	`%LocalSrcDirStructure`	132	`%LocalSrcDirStructure`
130	`%BuildPkgArchive`	133	`%BuildPkgArchive`
131	`$MachType`	134	`$MachType`
Line 282...	Line 285...
282		285
283	`#------------------------------------------------------------------------------`	286	`#------------------------------------------------------------------------------`
284	`# Initialization actions`	287	`# Initialization actions`
285	`#------------------------------------------------------------------------------`	288	`#------------------------------------------------------------------------------`
286		289
-		290	`#`
-		291	`# Init the error and message subsystem`
-		292	`#`
-		293	`ErrorConfig( 'name' => 'DEPLOYLIB' ,`
-		294	`'debug' => $ENV{GBE_DEBUG},`
-		295	`'verbose' => $ENV{GBE_VERBOSE},`
-		296	`);`
-		297
287		298
288	`#------------------------------------------------------------------------------`	299	`#------------------------------------------------------------------------------`
289	`# Package Interface Subroutines`	300	`# Package Interface Subroutines`
290	`#`	301	`#`
291	`# The following functions are used by the Makefile.pl scripts. Programmers`	302	`# The following functions are used by the Makefile.pl scripts. Programmers`
Line 328...	Line 339...
328	`# Previous (old) version number (-o)`	339	`# Previous (old) version number (-o)`
329	`# Platform (-m)`	340	`# Platform (-m)`
330	`# Product (optional) (-k)`	341	`# Product (optional) (-k)`
331	`# Machine Type (optional) (-g)`	342	`# Machine Type (optional) (-g)`
332		343
333	`setLogLevel($ENV{DEPLOYLIB_DEBUG}) if ( defined($ENV{DEPLOYLIB_DEBUG}) && $ENV{DEPLOYLIB_DEBUG} >= 1 && $ENV{DEPLOYLIB_DEBUG} <= 5);`	-
334		-
335	`$CurrentDir = cwd;`	344	`$CurrentDir = cwd;`
336		345
337	`my ($i);`	346	`my ($i);`
338	`Getopt::Std::getopts ('v:n:r:t:m:d:p:o:k:g:');`	347	`Getopt::Std::getopts ('v:n:r:t:m:d:p:o:k:g:');`
339	`if ( $opt_n )`	348	`if ( $opt_n )`
340	`{`	349	`{`
341	`$PkgName = $opt_n;`	350	`$PkgName = $opt_n;`
342	`}`	351	`}`
343	`else`	352	`else`
344	`{`	353	`{`
345	`LogError("Package Name not supplied!");`	354	`Error("Package Name not supplied!");`
346	`}`	355	`}`
347		356
348	`if ( $opt_r )`	357	`if ( $opt_r )`
349	`{`	358	`{`
350	`# lets change to root dir and get fully qualified path from cwd and return back`	359	`# lets change to root dir and get fully qualified path from cwd and return back`
Line 354...	Line 363...
354		363
355	`$SandBoxName = File::Basename::basename($RootDir);`	364	`$SandBoxName = File::Basename::basename($RootDir);`
356	`}`	365	`}`
357	`else`	366	`else`
358	`{`	367	`{`
359	`LogError("GBE_ROOT not supplied!");`	368	`Error("GBE_ROOT not supplied!");`
360	`}`	369	`}`
361		370
362	`if ( $opt_t )`	371	`if ( $opt_t )`
363	`{`	372	`{`
364	`$BuildType = $opt_t;`	373	`$BuildType = $opt_t;`
365	`}`	374	`}`
366	`else`	375	`else`
367	`{`	376	`{`
368	`LogError("GBE_TYPE not supplied!");`	377	`Error("GBE_TYPE not supplied!");`
369	`}`	378	`}`
370		379
371	`#`	380	`#`
372	`# Target machine type ( Underlying machine type in a Product Family)`	381	`# Target machine type ( Underlying machine type in a Product Family)`
373	`# If not provided, the assume that its the same as the platform (compat)`	382	`# If not provided, the assume that its the same as the platform (compat)`
Line 388...	Line 397...
388	`{`	397	`{`
389	`$MachType = 'win32';`	398	`$MachType = 'win32';`
390	`}`	399	`}`
391	`else`	400	`else`
392	`{`	401	`{`
393	`LogError("Unknown target [$opt_g] supplied!");`	402	`Error("Unknown target [$opt_g] supplied!");`
394	`}`	403	`}`
395	`}`	404	`}`
396		405
397	`#`	406	`#`
398	`# Platform`	407	`# Platform`
Line 402...	Line 411...
402	`{`	411	`{`
403	`$Platform = $opt_m;`	412	`$Platform = $opt_m;`
404	`}`	413	`}`
405	`else`	414	`else`
406	`{`	415	`{`
407	`LogError("Platform not supplied!");`	416	`Error("Platform not supplied!");`
408	`}`	417	`}`
409		418
410	`#`	419	`#`
411	`# Setup Product`	420	`# Setup Product`
412	`# If not defined then use the platform`	421	`# If not defined then use the platform`
Line 417...	Line 426...
417	`{`	426	`{`
418	`$TargetBaseDir = $opt_d;`	427	`$TargetBaseDir = $opt_d;`
419	`}`	428	`}`
420	`else`	429	`else`
421	`{`	430	`{`
422	`LogError("Package base directory not supplied!");`	431	`Error("Package base directory not supplied!");`
423	`}`	432	`}`
424		433
425	`if ( $opt_p )`	434	`if ( $opt_p )`
426	`{`	435	`{`
427	`my $pNum = sprintf("%02s", $opt_p);`	436	`my $pNum = sprintf("%02s", $opt_p);`
Line 429...	Line 438...
429	`{`	438	`{`
430	`$PkgPatchNum = $pNum;`	439	`$PkgPatchNum = $pNum;`
431	`}`	440	`}`
432	`else`	441	`else`
433	`{`	442	`{`
434	`LogError("-p command line arg [$opt_p] has invalid format,\n" .`	443	`Error("-p command line arg [$opt_p] has invalid format",`
435	`"required format is an integer value.");`	444	`"Required format is an integer value.");`
436	`}`	445	`}`
437	`}`	446	`}`
438		447
439	`if ($opt_v)`	448	`if ($opt_v)`
440	`{`	449	`{`
Line 452...	Line 461...
452	`{`	461	`{`
453	`$ProjectAcronym = $s2b;`	462	`$ProjectAcronym = $s2b;`
454	`}`	463	`}`
455	`else`	464	`else`
456	`{`	465	`{`
457	`LogError("-v command line arg [$opt_v] has invalid format, " .`	466	`Error("-v command line arg [$opt_v] has invalid format",`
458	`"required format is N.N.N-B.ppp where N is an integer and ppp is the project acronym.\n" .`	467	`"Required format is N.N.N-B.ppp where:",`
-		468	`" N is an integer",`
-		469	`" B is an integer",`
-		470	`" ppp is the project acronym",`
459	`"Check propject acronym.");`	471	`"Check propject acronym.");`
460	`}`	472	`}`
461	`}`	473	`}`
462	`elsif( "$opt_v" =~ m/^[0-9]\.[0-9]\.[0-9]*\.[a-z][a-z][a-z]$/ ) # N.N.N.ppp`	474	`elsif( "$opt_v" =~ m/^[0-9]\.[0-9]\.[0-9]*\.[a-z][a-z][a-z]$/ ) # N.N.N.ppp`
463	`{`	475	`{`
464	`my ($tmpVar) = $opt_v;`	476	`my ($tmpVar) = $opt_v;`
Line 473...	Line 485...
473	`{`	485	`{`
474	`$ProjectAcronym = $s4;`	486	`$ProjectAcronym = $s4;`
475	`}`	487	`}`
476	`else`	488	`else`
477	`{`	489	`{`
478	`LogError("-v command line arg [$opt_v] has invalid format, " .`	490	`Error("-v command line arg [$opt_v] has invalid format",`
479	`"required format is N.N.N.ppp where N is an integers and ppp is the project acronym.\n" .`	491	`"Required format is N.N.N.ppp where:",`
-		492	`" N is an integer",`
-		493	`" ppp is the project acronym",`
480	`"Check propject acronym.");`	494	`"Check propject acronym.");`
481	`}`	495	`}`
482	`}`	496	`}`
483	`else`	497	`else`
484	`{`	498	`{`
485	`LogError("-v command line arg [$opt_v] has invalid format, " .`	499	`Error("-v command line arg [$opt_v] has invalid format",`
-		500	`"Allowed formats are N.N.N-B.ppp and N.N.N.ppp where:",`
-		501	`" N is an integer",`
486	`"possible formats include:\n\n" .`	502	`" B is an integer",`
487	`"\tN.N.N-B.ppp where N and B are integers and ppp is the project acronym,\n" .`	503	`" ppp is the project acronym",`
488	`"\tN.N.N.ppp where N is an integer and ppp is the project acronym, B=0.\n");`	504	`"Check propject acronym.");`
-		505
489	`}`	506	`}`
490		507
491	`$PkgVersionUser = $opt_v;`	508	`$PkgVersionUser = $opt_v;`
492	`}`	509	`}`
493	`else`	510	`else`
494	`{`	511	`{`
495	`LogError("Package Version not supplied!");`	512	`Error("Package Version not supplied!");`
496	`}`	513	`}`
497		514
498		515
499	`# lets check to see if we have a previous version`	516	`# lets check to see if we have a previous version`
500	`if ($opt_o)`	517	`if ($opt_o)`
Line 531...	Line 548...
531	`# InstallShield files are provided via a package`	548	`# InstallShield files are provided via a package`
532	`# Ensure that a suitable package has been provided`	549	`# Ensure that a suitable package has been provided`
533	`#`	550	`#`
534	`if ( ! -d $PKG_UTIL_DIR )`	551	`if ( ! -d $PKG_UTIL_DIR )`
535	`{`	552	`{`
536	`LogError('-x', "No deployment support files found");`	553	`Error("No deployment support files found",`
537	`LogError( "These MUST be provided by a dependant package in build.pl");`	554	`"These MUST be provided by a dependant package in build.pl");`
538	`}`	555	`}`
539		556
540		557
541	`$Username = getlogin \|\| getpwuid($<);`	558	`$Username = getlogin \|\| getpwuid($<);`
542		559
Line 631...	Line 648...
631	`}`	648	`}`
632	`}`	649	`}`
633		650
634	`}`	651	`}`
635		652
636	`LogNorm("------------------------------------------------------------");`	653	`Information("------------------------------------------------------------");`
637		654
638		655
639	`# lets generate the patch id if we are building a patch`	656	`# lets generate the patch id if we are building a patch`
640	`#`	657	`#`
641	`if ( "x$PkgPatchNum" ne "x" )`	658	`if ( "x$PkgPatchNum" ne "x" )`
642	`{`	659	`{`
643	`LogNorm("This is a PATCH build...");`	660	`Information("This is a PATCH build...");`
644		661
645	`$PkgPatchName = uc ($PkgName);`	662	`$PkgPatchName = uc ($PkgName);`
646		663
647		664
648	`my ($_tmpStr) = sprintf("%s%s", $PkgPatchName,`	665	`my ($_tmpStr) = sprintf("%s%s", $PkgPatchName,`
Line 669...	Line 686...
669	`#`	686	`#`
670	`$PkgOutputFile = "na";`	687	`$PkgOutputFile = "na";`
671	`}`	688	`}`
672	`else`	689	`else`
673	`{`	690	`{`
674	`LogNorm("This is a normal RELEASE build...");`	691	`Information("This is a normal RELEASE build...");`
675	`$PkgReleaseNote = "$ReleaseDir" . "/" .`	692	`$PkgReleaseNote = "$ReleaseDir" . "/" .`
676	`"$PkgName" . "-" .`	693	`"$PkgName" . "-" .`
677	`"$PkgVersion" . "." .`	694	`"$PkgVersion" . "." .`
678	`"$ProjectAcronym" . "-" .`	695	`"$ProjectAcronym" . "-" .`
679	`"$Platform";`	696	`"$Platform";`
Line 691...	Line 708...
691	`"$ProjectAcronym" . "-" .`	708	`"$ProjectAcronym" . "-" .`
692	`"$Platform" . "-" .`	709	`"$Platform" . "-" .`
693	`"$BuildType\.pkg";`	710	`"$BuildType\.pkg";`
694	`}`	711	`}`
695		712
696	`LogNorm("------------------------------------------------------------");`	713	`Information("------------------------------------------------------------");`
697		714
698		715
699	`# lets just show what we have determined.`	716	`# lets just show what we have determined.`
700	`#`	717	`#`
701	`LogNorm("Current environment definitions (Increase Debug Level to see all definitions)...");`	718	`Information("Current environment definitions (Increase Verbose Level to see all definitions)...");`
702		719
703	`LogInfo("DeployFiles =[$PKG_UTIL_DIR]");`	720	`Verbose("DeployFiles =[$PKG_UTIL_DIR]");`
704		721
705	`LogNorm("PkgName =[$PkgName]");`	722	`Information("PkgName =[$PkgName]");`
706	`LogNorm("PkgVersionUser =[$PkgVersionUser]");`	723	`Information("PkgVersionUser =[$PkgVersionUser]");`
707		724
708	`LogNorm("PkgVersion =[$PkgVersion]");`	725	`Information("PkgVersion =[$PkgVersion]");`
709	`LogNorm("PkgVersionStr =[$PkgVersionStr]");`	726	`Information("PkgVersionStr =[$PkgVersionStr]");`
710		727
711	`LogNorm("PkgBuildNum =[$PkgBuildNum]");`	728	`Information("PkgBuildNum =[$PkgBuildNum]");`
712		729
713	`if ( "x$PkgPatchID" ne "x" )`	730	`if ( "x$PkgPatchID" ne "x" )`
714	`{`	731	`{`
715	`LogNorm("PkgPatchName =[$PkgPatchName]");`	732	`Information("PkgPatchName =[$PkgPatchName]");`
716	`LogNorm("PkgPatchNum =[$PkgPatchNum]");`	733	`Information("PkgPatchNum =[$PkgPatchNum]");`
717	`LogNorm("PkgPatchID =[$PkgPatchID]");`	734	`Information("PkgPatchID =[$PkgPatchID]");`
718	`LogNorm("PkgPatchTmpDir =[$PkgPatchTmpDir]");`	735	`Information("PkgPatchTmpDir =[$PkgPatchTmpDir]");`
719	`}`	736	`}`
720		737
721	`LogNorm("PkgReleaseNote =[$PkgReleaseNote]") unless ($autobuild);`	738	`Information("PkgReleaseNote =[$PkgReleaseNote]") unless ($autobuild);`
722	`LogNorm("PkgReleaseNote =[Delayed by ABT]") if ($autobuild);`	739	`Information("PkgReleaseNote =[Generated later by ABT]") if ($autobuild);`
723	`LogNorm("PkgLabel =[$PkgLabel]");`	740	`Information("PkgLabel =[$PkgLabel]");`
724		741
725	`LogNorm("PkgPreviousVersionStr=[$PkgPreviousVersionStr]");`	742	`Information("PkgPreviousVersionStr=[$PkgPreviousVersionStr]");`
726		743
727	`LogNorm("ProjectAcronym =[$ProjectAcronym]");`	744	`Information("ProjectAcronym =[$ProjectAcronym]");`
728	`LogNorm("BuildType =[$BuildType]");`	745	`Information("BuildType =[$BuildType]");`
729	`LogNorm("MachType =[$MachType]");`	746	`Information("MachType =[$MachType]");`
730	`LogNorm("Platform =[$Platform]");`	747	`Information("Platform =[$Platform]");`
731	`LogNorm("Product =[$Product]");`	748	`Information("Product =[$Product]");`
732	`LogNorm("Target =[$Target]");`	749	`Information("Target =[$Target]");`
733	`LogInfo("BuildParts =[" . join(',',$BuildFileInfo->getPlatformParts($Platform)) . "]");`	750	`Verbose("BuildParts =[" . join(',',$BuildFileInfo->getPlatformParts($Platform)) . "]");`
734		751
735	`LogNorm("CurrentDir =[$CurrentDir]");`	752	`Information("CurrentDir =[$CurrentDir]");`
736	`LogNorm("RootDir =[$RootDir]");`	753	`Information("RootDir =[$RootDir]");`
737	`LogNorm("SandBoxName =[$SandBoxName]");`	754	`Information("SandBoxName =[$SandBoxName]");`
738	`LogNorm("Username =[$Username]");`	755	`Information("Username =[$Username]");`
739		756
740	`LogNorm("TargetBaseDir =[$TargetBaseDir]");`	757	`Information("TargetBaseDir =[$TargetBaseDir]");`
741	`LogNorm("TargetHomeDir =[$TargetHomeDir]");`	758	`Information("TargetHomeDir =[$TargetHomeDir]");`
742		759
743	`LogNorm("PkgBaseDir =[$PkgBaseDir]");`	760	`Information("PkgBaseDir =[$PkgBaseDir]");`
744	`LogNorm("SrcDir =[$SrcDir]");`	761	`Information("SrcDir =[$SrcDir]");`
745	`LogNorm("PkgDir =[$PkgDir]");`	762	`Information("PkgDir =[$PkgDir]");`
746	`LogNorm("ReleaseDir =[$ReleaseDir]");`	763	`Information("ReleaseDir =[$ReleaseDir]");`
747		764
748	`LogInfo("InterfaceDir =[$InterfaceDir]");`	765	`Verbose("InterfaceDir =[$InterfaceDir]");`
749	`LogInfo("DpkgScriptsDir =[$DpkgScriptsDir]");`	766	`Verbose("DpkgScriptsDir =[$DpkgScriptsDir]");`
750	`LogInfo("DpkgBinDir(s) =[");`	767	`Verbose("DpkgBinDir(s) =[");`
751	`foreach $i (@{$DpkgBinDirList{'_ALL_'}})`	768	`foreach $i (@{$DpkgBinDirList{'_ALL_'}})`
752	`{`	769	`{`
753	`LogInfo(" $DpkgBinDir/$i");`	770	`Verbose(" $DpkgBinDir/$i");`
754	`}`	771	`}`
755	`LogInfo(" ]");`	772	`Verbose(" ]");`
756		773
757		774
758	`LogInfo("DpkgLibDir(s) =[");`	775	`Verbose("DpkgLibDir(s) =[");`
759	`foreach $i (@{$DpkgLibDirList{'_ALL_'}})`	776	`foreach $i (@{$DpkgLibDirList{'_ALL_'}})`
760	`{`	777	`{`
761	`LogInfo(" $DpkgLibDir/$i");`	778	`Verbose(" $DpkgLibDir/$i");`
762	`}`	779	`}`
763	`LogInfo(" ]");`	780	`Verbose(" ]");`
764		781
765		782
766	`LogInfo("DpkgEtcDir =[$DpkgEtcDir]");`	783	`Verbose("DpkgEtcDir =[$DpkgEtcDir]");`
767	`LogInfo("DpkgJarDir =[$DpkgJarDir]");`	784	`Verbose("DpkgJarDir =[$DpkgJarDir]");`
768	`LogInfo("DpkgSarDir =[$DpkgSarDir]");`	785	`Verbose("DpkgSarDir =[$DpkgSarDir]");`
769	`LogInfo("DpkgWarDir =[$DpkgWarDir]");`	786	`Verbose("DpkgWarDir =[$DpkgWarDir]");`
770	`LogInfo("DpkgSqlDir =[$DpkgSqlDir]");`	787	`Verbose("DpkgSqlDir =[$DpkgSqlDir]");`
771	`LogInfo("DpkgJspDir =[$DpkgJspDir]");`	788	`Verbose("DpkgJspDir =[$DpkgJspDir]");`
772	`LogInfo("DpkgRoxDir =[$DpkgRoxDir]");`	789	`Verbose("DpkgRoxDir =[$DpkgRoxDir]");`
773	`LogInfo("DpkgRptDir =[$DpkgRptDir]");`	790	`Verbose("DpkgRptDir =[$DpkgRptDir]");`
774	`LogInfo("DpkgAcHtmlDir =[$DpkgAcHtmlDir]");`	791	`Verbose("DpkgAcHtmlDir =[$DpkgAcHtmlDir]");`
775	`LogInfo("DpkgIncludeDir =[$DpkgIncludeDir]");`	792	`Verbose("DpkgIncludeDir =[$DpkgIncludeDir]");`
776	`LogInfo("DpkgDevcdDir =[$DpkgDevcdDir]");`	793	`Verbose("DpkgDevcdDir =[$DpkgDevcdDir]");`
777	`LogInfo("DpkgDatDir =[$DpkgDatDir]");`	794	`Verbose("DpkgDatDir =[$DpkgDatDir]");`
778	`LogInfo("DpkgThxDir =[$DpkgThxDir]");`	795	`Verbose("DpkgThxDir =[$DpkgThxDir]");`
779	`LogInfo("DpkgMugDir =[$DpkgMugDir]");`	796	`Verbose("DpkgMugDir =[$DpkgMugDir]");`
780	`LogInfo("DpkgDocDir =[$DpkgDocDir]");`	797	`Verbose("DpkgDocDir =[$DpkgDocDir]");`
781		798
782	`LogInfo("DpkgInfoFilesDir =[$DpkgInfoFilesDir]");`	799	`Verbose("DpkgInfoFilesDir =[$DpkgInfoFilesDir]");`
783	`LogInfo("DpkgPkgDir =[$DpkgPkgDir]");`	800	`Verbose("DpkgPkgDir =[$DpkgPkgDir]");`
784		801
785	`LogInfo("PkgInfoFile =[$PkgInfoFile]");`	802	`Verbose("PkgInfoFile =[$PkgInfoFile]");`
786	`LogInfo("ProtoTypeFile =[$ProtoTypeFile]");`	803	`Verbose("ProtoTypeFile =[$ProtoTypeFile]");`
787		804
788	`foreach $i ( $BuildFileInfo->getDpkgArchiveList() )`	805	`foreach $i ( $BuildFileInfo->getDpkgArchiveList() )`
789	`{`	806	`{`
790	`my $moduleInfo = $BuildFileInfo->getDpkgArchiveInfo($i);`	807	`my $moduleInfo = $BuildFileInfo->getDpkgArchiveInfo($i);`
791		808
792	`LogInfo( "Build Dependency =" .`	809	`Verbose( "Build Dependency =" .`
793	`"[$moduleInfo->{type}] " .`	810	`"[$moduleInfo->{type}] " .`
794	`"[$i] " .`	811	`"[$i] " .`
795	`"[$moduleInfo->{version}] " .`	812	`"[$moduleInfo->{version}] " .`
796	`"[$moduleInfo->{proj}]");`	813	`"[$moduleInfo->{proj}]");`
797	`}`	814	`}`
798		815
799	`if ( "$MachType" eq "sparc" )`	816	`if ( "$MachType" eq "sparc" )`
800	`{`	817	`{`
801	`LogNorm("PkgOutputFile =[$PkgOutputFile]");`	818	`Information("PkgOutputFile =[$PkgOutputFile]");`
802	`}`	819	`}`
803		820
804	`LogNorm("PkgOverview =[$PKG_OVERVIEW]");`	821	`Information("PkgOverview =[$PKG_OVERVIEW]");`
805		822
806		823
807	`# Lets evaluate TargetDstDirStructure to expand any vars`	824	`# Lets evaluate TargetDstDirStructure to expand any vars`
808	`foreach $i ( keys %TargetDstDirStructure )`	825	`foreach $i ( keys %TargetDstDirStructure )`
809	`{`	826	`{`
810	`if ( $TargetDstDirStructure{$i} =~ /\$/ )`	827	`if ( $TargetDstDirStructure{$i} =~ /\$/ )`
811	`{`	828	`{`
812	`LogDebug("-n", "Expanding TargetDstDirStructure [$TargetDstDirStructure{$i}] to ");`	829	`Debug("-n", "Expanding TargetDstDirStructure [$TargetDstDirStructure{$i}] to ");`
813	`$TargetDstDirStructure{$i} = eval "sprintf " . qq/"$TargetDstDirStructure{$i}"/;`	830	`$TargetDstDirStructure{$i} = eval "sprintf " . qq/"$TargetDstDirStructure{$i}"/;`
814	`print("[$TargetDstDirStructure{$i}]\n");`	831	`print("[$TargetDstDirStructure{$i}]\n");`
815	`}`	832	`}`
816	`}`	833	`}`
817		834
Line 841...	Line 858...
841	`#------------------------------------------------------------------------------`	858	`#------------------------------------------------------------------------------`
842	`{`	859	`{`
843	`# correct number of parameters?`	860	`# correct number of parameters?`
844	`if ( ($#_+1) != 1 )`	861	`if ( ($#_+1) != 1 )`
845	`{`	862	`{`
846	`LogError("Incorrect number of params passed to " .`	863	`Error("Incorrect number of params passed to setPkgDescription() function.",`
847	`"setPkgDescription() function. " .`	-
848	`"Check deploy config.");`	864	`"Check deploy config.");`
849	`}`	865	`}`
850	`my ($lpkgDesc) = shift;`	866	`my ($lpkgDesc) = shift;`
851		867
852	`# we use what was defined in deployfile if`	868	`# we use what was defined in deployfile if`
853	`# the RM details are not available`	869	`# the RM details are not available`
Line 892...	Line 908...
892	`#------------------------------------------------------------------------------`	908	`#------------------------------------------------------------------------------`
893	`{`	909	`{`
894	`# correct number of parameters?`	910	`# correct number of parameters?`
895	`if ( ($#_+1) != 1 )`	911	`if ( ($#_+1) != 1 )`
896	`{`	912	`{`
897	`LogError("Incorrect number of params passed to " .`	913	`Error("Incorrect number of params passed to " .`
898	`"setPkgName() function. " .`	914	`"setPkgName() function. ",`
899	`"Check deploy config.");`	915	`"Check deploy config.");`
900	`}`	916	`}`
901	`$PkgNameLong = shift;`	917	`$PkgNameLong = shift;`
902		918
903	`# done`	919	`# done`
Line 917...	Line 933...
917	`# if TargetBaseDir is empty then init has not been called yet so we can set`	933	`# if TargetBaseDir is empty then init has not been called yet so we can set`
918	`# base dir, if however it is not null then init has been called and setting`	934	`# base dir, if however it is not null then init has been called and setting`
919	`# base dir after init causes problems in some cases.`	935	`# base dir after init causes problems in some cases.`
920	`if ( $TargetBaseDir ne "" )`	936	`if ( $TargetBaseDir ne "" )`
921	`{`	937	`{`
922	`LogError("setErgAfcBaseDir() cannot be called after Init(), place before Init() in deployfile.pl");`	938	`Error("setErgAfcBaseDir() cannot be called after Init(), place before Init() in deployfile.pl");`
923	`}`	939	`}`
924		940
925	`# correct number of parameters?`	941	`# correct number of parameters?`
926	`if ( ($#_+1) != 1 )`	942	`if ( ($#_+1) != 1 )`
927	`{`	943	`{`
928	`LogError("Incorrect number of params passed to " .`	944	`Error("Incorrect number of params passed to " .`
929	`"setErgBaseDir() function. " .`	945	`"setErgBaseDir() function. ",`
930	`"Check deploy config.");`	946	`"Check deploy config.");`
931	`}`	947	`}`
932		948
933	`my ($newDir) = @_;`	949	`my ($newDir) = @_;`
934	`$ERGAFC_BASEDIR = "$newDir";`	950	`$ERGAFC_BASEDIR = "$newDir";`
Line 948...	Line 964...
948	`#------------------------------------------------------------------------------`	964	`#------------------------------------------------------------------------------`
949	`{`	965	`{`
950	`# correct number of parameters?`	966	`# correct number of parameters?`
951	`if ( ($#_+1) != 0 )`	967	`if ( ($#_+1) != 0 )`
952	`{`	968	`{`
953	`LogError("Incorrect number of params passed to " .`	969	`Error("Incorrect number of params passed to " .`
954	`"getErgBaseDir() function. " .`	970	`"getErgBaseDir() function. ",`
955	`"Check deploy config.");`	971	`"Check deploy config.");`
956	`}`	972	`}`
957		973
958	`return "$ERGAFC_BASEDIR";`	974	`return "$ERGAFC_BASEDIR";`
959	`}`	975	`}`
Line 969...	Line 985...
969	`#------------------------------------------------------------------------------`	985	`#------------------------------------------------------------------------------`
970	`{`	986	`{`
971	`# correct number of parameters?`	987	`# correct number of parameters?`
972	`if ( ($#_+1) != 1 )`	988	`if ( ($#_+1) != 1 )`
973	`{`	989	`{`
974	`LogError("Incorrect number of params passed to " .`	990	`Error("Incorrect number of params passed to " .`
975	`"setPkgOverview() function. " .`	991	`"setPkgOverview() function. ",`
976	`"Check deploy config.");`	992	`"Check deploy config.");`
977	`}`	993	`}`
978		994
979	`my ($mStr) = @_;`	995	`my ($mStr) = @_;`
980	`$PKG_OVERVIEW = "$mStr";`	996	`$PKG_OVERVIEW = "$mStr";`
Line 993...	Line 1009...
993	`#------------------------------------------------------------------------------`	1009	`#------------------------------------------------------------------------------`
994	`{`	1010	`{`
995	`# correct number of parameters?`	1011	`# correct number of parameters?`
996	`if ( ($#_+1) != 0 )`	1012	`if ( ($#_+1) != 0 )`
997	`{`	1013	`{`
998	`LogError("Incorrect number of params passed to " .`	1014	`Error("Incorrect number of params passed to " .`
999	`"getPkgOverview() function. " .`	1015	`"getPkgOverview() function. ",`
1000	`"Check deploy config.");`	1016	`"Check deploy config.");`
1001	`}`	1017	`}`
1002		1018
1003	`return "$PKG_OVERVIEW";`	1019	`return "$PKG_OVERVIEW";`
1004	`}`	1020	`}`
Line 1025...	Line 1041...
1025	`my @files;`	1041	`my @files;`
1026		1042
1027	`# lets just check to see if we can execute this function on this machine.`	1043	`# lets just check to see if we can execute this function on this machine.`
1028	`if ( "$MachType" eq "sparc" )`	1044	`if ( "$MachType" eq "sparc" )`
1029	`{`	1045	`{`
1030	`LogInfo("addInstallshieldFiles() not supported on this machine type.");`	1046	`Warning("addInstallshieldFiles() not supported on this machine type.");`
1031	`return 1;`	1047	`return 1;`
1032	`}`	1048	`}`
1033		1049
1034	`foreach my $i ( @_ )`	1050	`foreach my $i ( @_ )`
1035	`{`	1051	`{`
1036	`@files = glob("$PKG_UTIL_DIR/$i.*");`	1052	`@files = glob("$PKG_UTIL_DIR/$i.*");`
1037	`foreach my $j ( @files )`	1053	`foreach my $j ( @files )`
1038	`{`	1054	`{`
1039	`$j = basename($j);`	1055	`$j = basename($j);`
1040	`LogNorm("Adding Installshield file $j");`	1056	`Verbose("Adding Installshield file $j");`
1041	`push(@PKG_ISHIELD_FILES, $j);`	1057	`push(@PKG_ISHIELD_FILES, $j);`
1042	`}`	1058	`}`
1043	`}`	1059	`}`
1044	`return 1;`	1060	`return 1;`
1045	`} # addInstallshieldFiles`	1061	`} # addInstallshieldFiles`
Line 1149...	Line 1165...
1149	`my @dir_tree_exclude;`	1165	`my @dir_tree_exclude;`
1150	`my @dir_tree_include;`	1166	`my @dir_tree_include;`
1151	`my $flatten = 0;`	1167	`my $flatten = 0;`
1152	`my $dstDir;`	1168	`my $dstDir;`
1153		1169
1154	`LogNorm("Installing all Prepared pkg files...");`	1170	`Information("Installing all Prepared pkg files...");`
1155		1171
1156	`#`	1172	`#`
1157	`# Process the arguments and extract parameters and options`	1173	`# Process the arguments and extract parameters and options`
1158	`#`	1174	`#`
1159	`foreach ( @_ )`	1175	`foreach ( @_ )`
1160	`{`	1176	`{`
1161	`if ( m/^--Srcdir=(.*)/ ) {`	1177	`if ( m/^--Srcdir=(.*)/ ) {`
1162	`LogError("installAllDpkgArchivePkgFiles2: Multiple --Srcdir not allowed")`	1178	`Error("installAllDpkgArchivePkgFiles2: Multiple --Srcdir not allowed")`
1163	`if ( $src_base_dir );`	1179	`if ( $src_base_dir );`
1164	`$src_base_dir = "$InterfaceDir/$1";`	1180	`$src_base_dir = "$InterfaceDir/$1";`
-		1181	`$src_base_dir =~ s~/\.$~~;`
-		1182	`$src_base_dir =~ s~/$~~;`
1165		1183
1166	`} elsif ( /^--Dstdir=(.*)/ ) {`	1184	`} elsif ( /^--Dstdir=(.*)/ ) {`
1167	`LogError("installAllDpkgArchivePkgFiles2: Multiple target directories not allowed")`	1185	`Error("installAllDpkgArchivePkgFiles2: Multiple target directories not allowed")`
1168	`if ( $dstDir );`	1186	`if ( $dstDir );`
1169	`$dstDir = $1;`	1187	`$dstDir = $1;`
1170		1188
1171	`} elsif ( m/^--NoRecurse/ ) {`	1189	`} elsif ( m/^--NoRecurse/ ) {`

Subversion Repositories DevTools

(root)//deployfiles/trunk/src/tools/scripts/deploylib.pm – Rev 1532 → 1534