WebSVN – DevTools – Diff – /core_devl/branches/gitBuilder/TOOLS/buildlib.pl

 our $BUILDNAME_PACKAGE;                         # Name
 our $BUILDNAME_VERSION;                         # Version
 our $BUILDNAME_PROJECT;                         # Project(optional)
 our $BUILDNAME_SUFFIX;                          # Project (available)
 our $DEPLOY_PATCH           = 0;                # Deplyment patch number
-our $BUILDSIGNATURE;                            # Source signature
+our $BUILDSIGNATURE;                            # Source signature - generated
+my  $CheckSignature;                            # Check signature
 our %BUILDALIAS_DELAY       = ();               # Delayed aliases
 our %BUILDALIAS_TARGETS     = ();               # BuildAlias from --Targets
 our %BUILDALIAS             = ();               # BuildAlias
 our %BUILDPRODUCT           = ();               # BuildProduct
 our $BUILDPHASE             = 0;                # In Build Phase
 our @CLOBBERDIRS            = ();               # Directories to clobber
 our @REMOVEDIRS             = ();               # Directories to remove - if empty
 our %BUILD_KNOWNFILES       = ();               # Files that will be known
 our @BUILDEXCLUDE           = ();               # Platforms to be excluded
+our @BUILDARGUMENTS         = ();               # Build Atguments
 our $Makelib                = "";
 our $GBE_CORE;                                  # Root of JATS
 our $InterfaceVersion;                          # Interface directory format version
 our $ScmRoot;                                   # Package Root
     Require( "$::GBE_CONFIG/PLATFORM", "PLATFORM_CFG.PM"  );
 #.. Parse command line
+#
     $ScmBuildSrc = $0;                          # Name of the build file
-    $Cwd = shift @ARGV;
-    $Cwd =~ tr~\\/~/~s;;                        # Need / in path, Remove doubles
+    shift @ARGV;                                # No longer used
-    $::ScmRoot = StripDrive($Cwd);
+    $::ScmRoot = $CwdFull;                      # $CwdFull does not have a driver letter. $CwdFull does
     $Makelib = shift @ARGV;                     # Only for legacy build.pl files
     Verbose ("Command Line: @ARGV");
     my $result = GetOptions( "help|h:+"      => \$opt_help,
                              "man:3"         => \$opt_help,
                              "package"       => \$NoPackageError,
                              "nopackages"    => \$IgnorePkgs,
                              "forcebuildpkg" => \$ForceBuildPkg,
                              "force!"        => \$ForceBuild,
                              "generic!"      => \$GenericBuild,
+                             "signature:s"   => \$CheckSignature,
                              );
     Usage() if ( $opt_help || !$result );
     Debug( "Host:          ", $ScmHost );
-    Debug( "Cwd:           ", $Cwd );
+    Debug( "Cwd:           ", $CwdFull );
+    Debug( "ScmRoot:       ", $::ScmRoot );
     Debug( "Makelib:       ", $Makelib );
     Debug( "BuildFile:     ", $ScmBuildSrc );
     Debug( "Debug:         ", $::ScmDebug );
     Debug( "Verbose:       ", $::ScmVerbose );
     Debug( "Expert:        ", $Expert );
+                    {
                         push @pargs, '--NotDefault' if ( $notdefault );
                         push @pargs, '--FunctionName=BuildAlias';
                         BuildPlatforms( $platform, @pargs );
+                    }
+                    else
+                    {
+                        my @badArgs = grep (/^--/, @pargs) ;
+                        if (@badArgs) {
+                            Warning("Platform arguments in define mode are ignored:($platform)", @badArgs);
+                        }
+                    }
+                }
+                #
                 #   Start collecting args for the next platform
+                #
         #   If there are NO additive expressions in the alias, then
         #   assume all the active targets
+        #
         unless (keys %add) {
             %add = map { $_ => 1 } @BUILD_ACTIVEPLATFORMS;
-Debug0("Adding: @BUILD_ACTIVEPLATFORMS");
+        }
         foreach ( keys %remove) {
             delete $add { $_};
+        }
 sub BuildArgument
+{
     my( $platform, @arguments ) = @_;
-    my( @platforms );
     Debug( "BuildArgument($platform, @arguments)" );
-    Error( "BuildArgument must appear before BuildName()..." )
+    Error( "BuildArgument must appear before BuildName()..." ) if ( $BUILDNAME ne "" );
-        if ( $BUILDNAME ne "" );
+    #
-    #   Allow a wildcard to apply a single argument to all platforms
+    #   Just save the arguments for later processing
-    #   Should only be used AFTER all the platforms have been specified
+    #
-    if ( $platform eq '*' )
+    push @BUILDARGUMENTS, \@_;
-    {
-        @platforms = @BUILDPLATFORMS;          # Simple Wildcard
-    }
-    else
-    {
-        @platforms = ExpandPlatforms( $platform );  # aliasing
-    }
+}
+#-------------------------------------------------------------------------------
+# Function        : ProcessBuildArgument
+#
+# Description     : Process BuildArgument operations
+#                   This needs to be done AFTER aliases have been created (cleaned up )
+#
+# Inputs          : Global data: @BUILDARGUMENTS
+#
+# Returns         :
+#
+sub ProcessBuildArgument
+{
-    foreach my $platform ( @platforms )
+    foreach my $set ( @BUILDARGUMENTS )
+    {
+        my ($platform, @arguments ) = @{$set};
+        my @platforms;
+        #
+        #   Allow a wildcard to apply a single argument to all platforms
+        #   Should only be used AFTER all the platforms have been specified
+        #
+        if ( $platform eq '*' )
+        {
-        next if ( $platform =~ /^--/ );         # argument, ignore
+            @platforms = @BUILDPLATFORMS;          # Simple Wildcard
+        }
+        else
+        {
+            @platforms = ExpandPlatforms( $platform );  # aliasing
+        }
+        foreach my $platform ( @platforms )
+        {
+            next if ( $platform =~ /^--/ );         # argument, ignore
-        PlatformArgument( $platform, @arguments );
+            PlatformArgument( $platform, @arguments );
+        }
+    }
+}
 sub BuildPlatforms
+    #
     #   Expand the user specified platforms to allow the use of BuildAlias
     #   The (bad) side effect of this is that platform options get reorganised
     #       PLATFORM,--Uses=ANOTHER  ==> PLATFORM --Uses=ANOTHER
+    #
-    #   Insert markers(++) into @aruments to mark when to process collected data
+    #   Insert markers(++) into @arguments to mark when to process collected data
     #   Insert before each PLATFORM and at the end of the list
     #   platform specifier or the end of the list. Scan the arguments
+    #
     @arguments = ExpandPlatforms( @arguments );
     my @new_args;
     Log( "DeployPatch. $DEPLOY_PATCH" ) if ($DEPLOY_PATCH);
     Log( "Project .... $BUILDNAME_PROJECT" )if ($BUILDNAME_PROJECT);
     Log( "Project .... ****** Specifically supressed ******" )unless ($BUILDNAME_PROJECT);
     Log( "DateTime ... $::CurrentTime" );
     Log( "AutoBuild... Enabled:$::GBE_ABT" ) if defined($::GBE_ABT) ;
-    Log( "Build dir... $Cwd" ) if defined($::GBE_ABT) || $::GBE_DPKG_SBOX;
+    Log( "Build dir... $CwdFull" ) if defined($::GBE_ABT) || $::GBE_DPKG_SBOX;
     Log( "Build Mach.. $::GBE_HOSTNAME" ) if defined($::GBE_ABT);
+    Log( "Build Cmd .. $CmdSwitch") if $CmdSwitch;
     Log( "PERL ....... $::GBE_PERL" );
     Log( "BIN  ....... $::GBE_BIN" );
     Log( "TOOLS ...... $::GBE_TOOLS" );
     Log( "CONFIG ..... $::GBE_CONFIG" );
             #   Flag for jmake to do very little
+            #
             CreateBuildPlatformEntry('Internal', 0, undef, 'NOBUILD');
             $IgnorePkgs = 1;
             $NoBuild = 1;
+            $genToolsetActive = 0;
             Log( "Build for .. ". PrintPlatforms(['NOBUILD - ' . $msg], $sep));
         } else {
             Error( $msg );
+        }
 # Returns         :
+#
 sub needToolset
+{
     my $toolsetNeeded;
+    return 0 if $SignatureOnly;
     $toolsetNeeded = 1 if (!defined($::GBE_ABT));
     if (!$toolsetNeeded && defined($::GBE_BUILDFILTER) ) {
         $toolsetNeeded = grep( /^TOOLSET$/, split( ' ', $::GBE_BUILDFILTER ) );
+    }
     Debug( "Name:      $name" );
     Debug( "Version:   $version" );
     DataDirective("LinkPkgArchive");            # This directive allowed here
-   if ( $IgnorePkgs )
+    if ( $IgnorePkgs )
-   {
+    {
-       Log( "LinkPkgArchive .. $name ($version) - Ignored" );
+        Log( "LinkPkgArchive .. $name ($version) - Ignored" );
-       return;
+        return;
-   }
+    }
+    #
     #   Ensure that we have do not have multiple definitions
+    #
     if ( PackageEntry::Exists( $name, $version ) )
     my $ifaceDir = catdir($::GBE_SANDBOX, 'sandbox_dpkg_archive', $name, $version . '.int');
     $ifaceDir = TagFileRead($ifaceDir);
     $ifaceDir =~ s~\\~/~g;
     $ifaceDir =~ s~GBE_SANDBOX/~$::GBE_SANDBOX/~;
     my $pkgSigFile = catfile( $ifaceDir, 'Package.sig');
-Debug0 ('SigFile:', $ifaceDir ,$pkgSigFile);
     # Temp: Remove when we no longer have package-versions
     return unless -f $pkgSigFile;
     Error("Package signature not found for $name/$version", "You must 'build' the package before using it")
         unless ( -f $pkgSigFile);
         #       Note: The .lnk file may be present, but it won't point to anything valid until
         #             the package has been built.
+        #
         if ($in_sandbox)
+        {
+            #
+            #   In the build system we do NOT want to consume packages from within the sandbox
+            #   because they may be partially formed. They need to be consumed from a published
+            #   archive.
+            #
+            #   In development its OK to consume locally generated packages
+            #
+            next if (defined($::GBE_ABT));
             my $pkgLinkFile = $pkg;
             $pkgLinkFile =~ s~pkgsig$~lnk~;
             if ( -f $pkgLinkFile )
+            {
     Debug( "Name:      $name" );
     Debug( "Version:   $version" );
     DataDirective("BuildPkgArchive");           # This directive allowed here
-   if ( $IgnorePkgs )
+    if ( $IgnorePkgs )
-   {
+    {
-       Log( "BuildPkgArchive . $name ($version) - Ignored" );
+        Log( "BuildPkgArchive . $name ($version) - Ignored" );
-       return;
+        return;
-   }
+    }
+    #
     #   Ensure that we have do not have multiple definitions
+    #
     if ( PackageEntry::Exists( $name, $version ) )
         #       If the package is a 'local' package then force transfer
         #       If the user has specified --cache then force transfer
         #       If package is newer that copy, then force transfer
         #       If copy does not exist, then force a transfer
+        #
-        my $tag_dir = "$Cwd/$BUILDINTERFACE/BuildTags";
+        my $tag_dir = "$CwdFull/$BUILDINTERFACE/BuildTags";
         my $tag_file = "$tag_dir/${name}_${version}.tag";
         my $arglist = GenerateInstallArgumentList();
         my $package_installed;
         $package_installed = 1
+                #
                 #   Determine all the Platforms, Products and Targets
                 #   that need to be installed
+                #
-                System( "cd $pkg; $::GBE_PERL $::GBE_TOOLS/installpkg.pl $Cwd/$BUILDINTERFACE $Cwd @opts $arglist");
+                System( "cd $pkg; $::GBE_PERL $::GBE_TOOLS/installpkg.pl $CwdFull/$BUILDINTERFACE $CwdFull @opts $arglist");
                 Error( "Package installation error" ) if ( $? != 0 );
+            }
             else
+            {
                 Error ("Unknown package format for package $name/$version found in $pkg");
+#
 sub CreateInterfacePackage
+{
     foreach my $platform ( @BUILD_ACTIVEPLATFORMS )
+    {
-        my $entry = PackageEntry::Interface( "$::Cwd/$BUILDINTERFACE" );
+        my $entry = PackageEntry::Interface( "$CwdFull/$BUILDINTERFACE" );
+        #
         #   Locate include and lib bits within the interface
         #   This is much simpler than for a LinkPkgArchive as the form
         #   has been sanitized
             $platform_filter = "";
+        }
         else
+        {
             $platform_filter = "";
-            $platform_filter = $::GBE_BUILDFILTER
+            $platform_filter = uc $::GBE_BUILDFILTER
                 if ( defined($::GBE_BUILDFILTER) );
+        }
         Debug( "GeneratePlatformList: Filter:$platform_filter" );
+        #
                 push @{$BUILDINFO{$aliasTarget}{USERALIAS}}, $alias;
+            }
+        }
+    }
     CleanUp_Aliases();
+    ProcessBuildArgument();
+    #
     #   Create dummy package to describe the Interface directory
+    #
     CreateInterfacePackage();
     return if ( $Clobber );
     if ( ! $ForceBuild  )
+    {
         my @build_warn;
-        my $bstamp = -M "$Cwd/$ScmBuildSrc";
+        my $bstamp = -M "$CwdFull/$ScmBuildSrc";
-        my $tstamp = -M "$Cwd/Makefile.gbe";
+        my $tstamp = -M "$CwdFull/Makefile.gbe";
         push @build_warn, "Missing: Makefile.gbe" unless ( defined $tstamp );
         push @build_warn, "Modified build file ($ScmBuildSrc)" if ( $tstamp && $bstamp < $tstamp );
+        #
     my $link_file;
     my $tag;
     my $root_path;
+    #
+    #   In the build system we do NOT want to consume packages from within the sandbox
+    #   because they may be partially formed. They need to be consumed from a published
+    #   archive.
+    #
+    #   If we are in an ABT sandbox, then don't create a link file
+    #
+    return if (defined($::GBE_ABT));
+    #
     #   Determine the path (and name) of the target archive
     #   Use sandbox_dpkg_archive if it exists
     #   Use local_dpkg_acrhive for backward compatability (should be removed after JATS 2.64.2+)
+    #
     if ( $target_archive = $::GBE_DPKG_SBOX )
+    {
         $target_archive_name = "sandbox_dpkg_archive";
         $tag = "Sandbox";
         $link_file  = 'sandbox' . ${BUILDNAME_SUFFIX} . '.lnk';
-        $root_path = 'GBE_SANDBOX' . substr($Cwd, length($::GBE_SANDBOX));
+        $root_path = 'GBE_SANDBOX' . substr($CwdFull, length($::GBE_SANDBOX));
         Verbose2("Root Path: $::GBE_SANDBOX, $root_path");
+    }
     elsif ( $target_archive = $::GBE_DPKG_LOCAL )
+    {
         $target_archive_name = "local_dpkg_archive";
         $link_file = "$BUILDVERSION.lnk";
         $tag = "Local";
-        $root_path = $Cwd;
+        $root_path = $CwdFull;
+    }
     else
+    {
         Verbose("Cannot locate local or sandbox archive")
             unless $Clobber;
+        #
         #   File with path to the interface directory
         #   Relative to the base of the sandbox
+        #
-        FileCreate($int_path, catdir('GBE_SANDBOX',RelPath($Cwd,$::GBE_SANDBOX),$BUILDINTERFACE ));
+        FileCreate($int_path, CatPaths('GBE_SANDBOX',RelPath($CwdFull,$::GBE_SANDBOX),$BUILDINTERFACE ));
+        #
         #   Indicate packages not build on this machine
+        #
         unlink $nob_path;           # Delete the NoBuild marker
     #   The file is created later in the build proccess, but the makefile generation
     #   needs to have a known path to the file.
+    #
     #   It will be a file that is 'known' to JATS
+    #
-    $descpkgPath = BuildAddKnownFile ( $NoBuild ? $Cwd : $Srcdir, 'descpkg' );
+    $descpkgPath = BuildAddKnownFile ( $NoBuild ? $CwdFull : $Srcdir, 'descpkg' );
     #.. Build support files
+    #
     DeleteCfg();
     BuildConfig();
         #       Due to the normal way that makelib.pl is executed,
         #       the following substitutions are done.
+        #
         @ARGV = ();
         $0 = "makefile.pl ";
-        push @ARGV, "$Cwd";                         # current working directory
+        push @ARGV, "$CwdFull";                         # current working directory
         push @ARGV, "$::GBE_TOOLS/makelib.pl";      # makelib.pl image
         push @ARGV, "--interface=$BUILDINTERFACE"
             if ($BUILDINTERFACE);
         Debug( "ARGV:      @ARGV" );
+{
     Message("Generate Package Signature");
     #   Generate the package signature using the new method
     #       Quick parse the build and makefiles
+    #
-    $BUILDSIGNATURE = JatsSignatureBuilder::GeneratePackageSignature ($Cwd, catfile($Cwd, $BUILDINTERFACE));
+    $BUILDSIGNATURE = JatsSignatureBuilder::GeneratePackageSignature ($CwdFull, catfile($CwdFull, $BUILDINTERFACE));
+    #
+    #   In the build system,
+    #   Check that all builds actually create the same signature. If not then it indicates something is wrong
+    #   with the signature generation process across machines.
+    #
+    if (defined $CheckSignature)
+    {
+        if ($CheckSignature ne $BUILDSIGNATURE ) {
+            Error ("Package Signature check failure",
+                   "Generated Signature: $BUILDSIGNATURE",
+                   "Check Signature    : $CheckSignature"
+                  );
+        }
+    }
+    #
     #   See if the package exists in one of the package stores
     #   Look in each package archive directory
+    #
     push @desc, "Version:       $BUILDVERSION";
     push @desc, "Signature:     $BUILDSIGNATURE" if defined $BUILDSIGNATURE;
     push @desc, "Released By:   $::USER";
     push @desc, "Released On:   $::CurrentTime";
     push @desc, "Build Machine: $::GBE_HOSTNAME";
-    push @desc, "Path:          $Cwd";
+    push @desc, "Path:          $CwdFull";
     push @desc, "Jats Version:  $::GBE_VERSION";
     push @desc, "Jats Path:     $::GBE_CORE";
     push @desc, "";
     push @desc, "Build Dependencies:";
     push @desc, "";
                      file will be copied locally.
     -[no]force     - Force build even if build.pl is not newer
                      Default: -force
     -[no]generic   - Build system sanity test
                      Default: Do not test
+    -signature=xx  - Check package signature
  Sticky settings:
     -all           - Build for all platforms ignoring GBE_BUILDFILTER
     -expert[=n]    - Relaxing dependency checks on the user makefiles
 The default is to not perform the test.
 This option is intended to be used by the automated build system.
+=item B<-signature=xxxx>
+If used, this option will perform a sanity test on the packages signature. It will
+ensure that the generated package signature is the same as that provided.
+The default is to not perform the test.
+This option is intended to be used by the automated build system.
 =item B<-all>
 This option will cause the build process to generate makefiles for all
 possible build targets ignoring the use of GBE_BUILDFILTER.

Subversion Repositories DevTools

(root)/core_devl/branches/gitBuilder/TOOLS/buildlib.pl – Rev 7319 → 7320