WebSVN – DevTools – Diff – /core_devl/trunk/TOOLS/jats_sandbox.pl

 use JatsSystem;
 use FileUtils;
 use JatsBuildFiles;
 use JatsVersionUtils;
 use ArrayHashUtils;
+use ToolsetFiles;
 use Pod::Usage;                             # required for help support
 use Getopt::Long qw(:config require_order); # Stop on non-option
+use Digest;
 my $VERSION = "1.0.0";                      # Update this
+#
 #   Options
+#
 my $opt_exact = 0;                          # Exact (escrow) build
 my $opt_toPackage;                          # Control recursion
 my $opt_fromPackage;                        # Control recursion
 my @opt_justPackage;                        # Control recursion
 my @opt_ignorePackage;                      # Control recursion
+my $opt_allSandbox;                         # Extend scope to entire sandbox
+my $opt_processUsedBy;                      # Process dependants(consumers) not dependents(children)
+my $opt_keepgoing;                          # Ignore errors
+my $opt_reScan;                             # Rescan for buildfiles
+#
 #   Globals - Provided by the JATS environment
+#
 my $USER            = $ENV{'USER'};
+#
 my @stopped = ();                         # Stopped entries
 my @build_order = ();                     # Build Ordered list of entries
 my %extern_deps;                          # Hash of external dependencies
 my %packages;                             # Hash of packages
+my $currentPkgTag;                        # Tag of the current package - if any
 #-------------------------------------------------------------------------------
 # Function        : Mainline Entry Point
+#
 # Description     :
 create_sandbox()                        if ( $cmd =~ m/^create$/ );
 delete_sandbox()                        if ( $cmd =~ m/^delete$/ );
 info(@ARGV)                             if ( $cmd =~ m/^info$/ );
 populate(@ARGV)                         if ( $cmd =~ m/^populate$/  );
 buildfilter(@ARGV)                      if ( $cmd =~ m/^buildfilter$/  );
+skipBuild(0, @ARGV)                     if ( $cmd =~ m/^skip$/  );
+skipBuild(1, @ARGV)                     if ( $cmd =~ m/^unskip$/  );
+fingerPrintPkg(@ARGV)                   if ( $cmd =~ m/^finger/i );
 Error ("Unknown sandbox command: $cmd");
 exit 1;
+    }
     exit 0;
+}
 #-------------------------------------------------------------------------------
+# Function        : skipBuild
+#
+# Description     : Mark the building of a package for skipping
+#
+# Inputs          : Mode -: Skip, 1:Unskip
+#                   User commaand line
+#
+# Returns         : Nothing
+#
+sub skipBuild
+{
+    my ($mode, @cmd_opts ) = @_;
+    my $machine;
+    Getopt::Long::Configure('pass_through');
+    getOptionsFromArray ( \@cmd_opts,
+                        'machine!' => \$machine,
+                        ) || Error ("Invalid command line" );
+    SubCommandHelp( $opt_help, "Skip Build") if ($opt_help );
+    Error ("Command must be executed from within a Sandbox") unless ( $GBE_SANDBOX );
+    #
+    #   Determine Sandbox information
+    #   Populate global variables
+    #
+    calc_sandbox_info(1);
+    #
+    #   Display only
+    #
+    unless( @cmd_opts)
+    {
+        foreach my $pkg (keys %packages)
+        {
+            my $fe = $packages{$pkg};
+            next unless $fe->{buildSkip};
+            my $skipMsg = ($fe->{buildSkip}) ? ' (Build Skipped)' : ' (Build Suppressed)';
+            if ($fe->{buildCurrent}) {
+                $skipMsg .= ' (Current Package)';
+            }
+            Message( ' Name: ' . $fe->{dname} . $skipMsg );
+        }
+        exit 0;
+    }
+    foreach ( @cmd_opts )
+    {
+        #
+        #   Locate the package
+        #
+        my $pe;
+        if ($currentPkgTag && ($_ eq '.'))
+        {
+            if (exists $packages{$currentPkgTag})
+            {
+                $pe = $packages{$currentPkgTag};
+            }
+        }
+        unless ($pe) {
+            foreach my $pkg (keys %packages)
+            {
+                my $entry = $packages{$pkg};
+                if ($entry->{dname} eq $_ || $entry->{fname} eq $_ )
+                {
+                    $pe = $entry;
+                    last;
+                }
+            }
+        }
+        unless ($pe) {
+            Warning("No package found matching: $_");
+            next;
+        }
+        my $skipFile;
+        if ($machine) {
+            $skipFile = catdir($GBE_SANDBOX, 'sandbox_dpkg_archive', '_skip.' . $GBE_MACHTYPE . '.' . $pe->{dname});
+        } else {
+            $skipFile = catdir($GBE_SANDBOX, 'sandbox_dpkg_archive', '_skip.'. $pe->{dname});
+        }
+        Verbose("SkipFile: $skipFile");
+        if ($mode)
+        {
+            unlink $skipFile;
+        }
+        else
+        {
+            TouchFile($skipFile);
+        }
+    }
+    exit 0;
+}
+#-------------------------------------------------------------------------------
 # Function        : info
+#
 # Description     : Display Sandbox information
+#
 # Inputs          : Command line args
+#
 sub info
+{
     my (@cmd_opts ) = @_;
     my $show = 0;
+    my $showUsage = 0;
+    my $showFingerPrint = 0;
     Getopt::Long::Configure('pass_through');
     getOptionsFromArray ( \@cmd_opts,
-                           'verbose:+'  => \$show,
+                          'verbose:+'   => \$show,
+                          'usedby'      => \$showUsage,
+                          'fingerprint' => \$showFingerPrint,
                         ) || Error ("Invalid command line" );
     SubCommandHelp( $opt_help, "Sandbox Information") if ($opt_help || $#cmd_opts >=0 );
+    $showUsage = 1 if ($show >= 2);
+    #
     #   Determine Sandbox information
     #   Populate global variables
+    #
-    calc_sandbox_info(1);
+    calc_sandbox_info();
+    #
     #   Display information
+    #
     Message ("Type       : " . ($opt_exact ? 'Exact' : 'Development') );
+    Message ("Scope      : " . ($opt_allSandbox ? 'Entire Sandbox' : $packages{$currentPkgTag}{dname} ));
     Message ("Base       : $GBE_SANDBOX");
     Message ("Archive    : $GBE_DPKG_SBOX");
     Message ("BuildFilter: $GBE_BUILDFILTER" . ( (-f $GBE_SANDBOX . '/buildfilter')  ? ' - Local to sandbox' : ''));
     Message ("Build Order");
     foreach my $pname ( @stopped )
+    {
-        Message( "    Level:" . "-"  . " Name: " . $pname . ' (Stopped)');
+        Message( "    Level:" . "-"  . " [---] Name: " . $pname . ' (Stopped)');
+    }
     foreach my $fe ( @build_order )
+    {
-        Message( "    Level:" . $fe->{level} . " Name: " . $fe->{dname} . ($fe->{buildActive} ? '' : ' (Build Suppressed)'));
-        Message( DisplayPath ("        Path: $fe->{dir}" )) if $show;
+        displayHeader($fe, { indent => '    ', testFingerPrint =>  $showFingerPrint, showIcons => 1});
         if ( $show )
+        {
+            Message( DisplayPath ("        Path: $fe->{dir}" ));
             foreach my $idep ( sort values %{$fe->{'ideps'}} )
+            {
                 Message ("        I:$idep");
+            }
             foreach my $edep ( sort keys %{$fe->{'edeps'}} )
+            {
                 my ($ppn,$ppv) = split( $; , $edep);
                 Message ("        E:$ppn $ppv");
+            }
+        }
+        if ($showUsage && exists($fe->{'usedBy'}))
+        {
+            foreach my $edep ( sort {uc($a) cmp uc($b)} @{$fe->{'usedBy'}} )
+            {
+                Message ("        U:$packages{$edep}{dname}");
+            }
+        }
+    }
+    #
     #   External dependencies flags
     #       * - Package does not exist in dpkg_archive
     #       + - Multiple versions of this package are used
     Message("External Dependencies");
-    foreach my $de ( sort keys %extern_deps )
+    foreach my $de ( sort {uc($a) cmp uc($b)} keys %extern_deps )
+    {
         my @vlist = keys %{$extern_deps{$de}};
         my $flag = $#vlist ? '+' : '';
-        foreach my $pve ( @vlist )
+        foreach my $pve ( sort {uc($a) cmp uc($b)} @vlist )
+        {
             my ($pn,$pv) = split( $; , $pve );
             my $exists = check_package_existance($pn,$pv  ) ? '' : '*';
             my $flags = sprintf ("%4.4s", $flag . $exists);
             Message ("${flags}${pn} ${pv}");
-            if ( $show )
+            if ( $show || $showUsage )
+            {
-                foreach my $pkg ( @{$extern_deps{$de}{$pve}} )
+                foreach my $pkg ( sort {uc($a) cmp uc($b)} @{$extern_deps{$de}{$pve}} )
+                {
                     my $ppn = join ('.', split( $; , $pkg));
                     Message ("        U:$ppn");
+                }
+            }
+    }
     exit (0);
+}
 #-------------------------------------------------------------------------------
+# Function        : fingerPrintPkg
+#
+# Description     : Various finger print operations on the current package
+#
+# Inputs          : @ARGV   - Arguments
+#
+# Returns         : WIll not return
+#
+sub fingerPrintPkg
+{
+    my ( @cmd_opts ) = @_;
+    my $opt_generate;
+    my $opt_delete;
+    Getopt::Long::Configure('pass_through');
+    getOptionsFromArray ( \@cmd_opts,
+                          'generate!' => \$opt_generate,
+                          'delete!'   => \$opt_delete,
+                        ) || Error ("Invalid command line" );
+    SubCommandHelp( $opt_help, "Sandbox Finger Print") if ($opt_help );
+    Error ("Command must be executed from within a Sandbox") unless ( $GBE_SANDBOX );
+    #
+    #   Determine Sandbox information
+    #   Populate global variables
+    #
+    calc_sandbox_info(1);
+    #
+    #   Determine the named packages, or use the current package
+    #
+    my @pkgList;
+    if (@cmd_opts)
+    {
+        @pkgList = @cmd_opts;
+    }
+    else
+    {
+        if ( $currentPkgTag )
+        {
+            if (exists $packages{$currentPkgTag})
+            {
+                push @pkgList, $packages{$currentPkgTag}{fname};
+            }
+        }
+    }
+    Error ("Command must be used within a package, or with named packages.")
+        unless @pkgList;
+    #
+    #   Process all required packages
+    #
+    foreach my $pkgName ( @pkgList)
+    {
+        #
+        #   Locate the package
+        #
+        my $pe;
+        foreach my $pkg (keys %packages)
+        {
+            my $entry = $packages{$pkg};
+            if ($entry->{dname} eq $pkgName || $entry->{fname} eq $pkgName )
+            {
+                $pe = $entry;
+                last;
+            }
+        }
+        unless ( $pe ) {
+            Warning ("Cannot locate package: $pkgName");
+            next;
+        }
+        #
+        #   Recalculate finger print
+        #
+        my $tagFile = getPkgFingerPrintFile($pe);
+        if ($opt_generate)
+        {
+            my $ifaceDir = getpkgInterface($pe);
+            if ($ifaceDir)
+            {
+                Message ("Generate Fingerprint");
+                FileCreate( $tagFile, genPkgFingerPrint($pe,'Generation') );
+            }
+            else
+            {
+                Warning("Package has not been built. Cannot generate fingerprint: $pkgName");
+            }
+        }
+        elsif ($opt_delete)
+        {
+            unlink $tagFile;
+            Message ("Fingerprint file removed");
+        }
+        else
+        {
+            #
+            #   Test the finger print on the current package
+            #
+            if ( -e $tagFile )
+            {
+                if ( TagFileMatch($tagFile, genPkgFingerPrint($pe, 'Test')) )
+                {
+                    Message ("Fingerprint match");
+                }
+                else
+                {
+                    Message("Fingerprint missmatch");
+                }
+            }
+            else
+            {
+                Message ("Package does not have a fingerprint file");
+            }
+        }
+    }
+    exit (0);
+}
+#-------------------------------------------------------------------------------
 # Function        : check_package_existance
+#
 # Description     : Determine if a given package-version exists
+#
 # Inputs          : $name           - Package Name
+        }
+    }
    return 0;
+}
+#-------------------------------------------------------------------------------
+# Function        : getpkgInterface
+#
+# Description     : Locate the packages interface directory
+#
+# Inputs          : $fe     - Package Entry
+#
+# Returns         : Undef if not found
+#                   Path to the packages interface directory
+#
+sub getpkgInterface
+{
+    my ($fe) = @_;
+    #
+    #   Determine the packages 'interface' directory
+    #
+    my $pSuffix = ($fe->{prj}) ? ( '.' . $fe->{prj}) : '';
+    my $ifaceDir = catdir($GBE_SANDBOX, 'sandbox_dpkg_archive', $fe->{name}, 'sandbox' . $pSuffix . '.int');
+    return unless -f $ifaceDir;
+    $ifaceDir = TagFileRead($ifaceDir);
+    $ifaceDir =~ s~\\~/~g;
+    $ifaceDir =~ s~GBE_SANDBOX/~$GBE_SANDBOX/~;
+    return $ifaceDir;
+}
 #-------------------------------------------------------------------------------
 # Function        : calc_sandbox_info
+#
 # Description     : Examine the sandbox and determine all the important
 #                       $opt_toPackage
 #                       $opt_fromPackage
 #                       @opt_justPackage
 #                       @opt_ignorePackage
+#
-# Inputs          : info                - True: Just for info
+# Inputs          : quiet       undef - noisy
-#                                               Keep supressed packages
+#                               1 - quiet
+#
 # Returns         : Will exit if not in a sandbox
 #                   Populates global variables
 #                       @build_order - build ordered array of build entries
+#
 sub calc_sandbox_info
+{
-    my ($info) = @_;
+    my ($quiet) = @_;
+    my $cacheFile = $GBE_DPKG_SBOX . '/location_cache';
+    #
     #   Start from the root of the sandbox
+    #
     Error ("Command must be executed from within a Sandbox") unless ( $GBE_SANDBOX );
+    my $startDir = Getcwd();
     chdir ($GBE_SANDBOX) || Error ("Cannot chdir to $GBE_SANDBOX");
+    #
+    #   Retain subdir so we can figure out a starting package
+    #
+    $startDir = '' unless ($startDir =~ s~^$GBE_SANDBOX/~~);
+    #
     #   Locate all packages within the sandbox
     #   These will be top-level directories - one per package
+    #
-    my @dirlist;
     my @build_list;
+    my $currentRootFingerPrint = calc_rootFingerPrint();
-    foreach my $pname ( glob("*") )
+    if (-f $cacheFile && !$opt_reScan)
+    {
+        #
-        next if ( $pname =~ m~^\.~ );
+        #   Read in the location cache
-        next if ( $pname =~ m~dpkg_archive$~ );
+        #   Greatly speeds up the location process
+        #
+        open( my $lf, '<', $cacheFile) || Error ("Read error: $cacheFile. $!");
+        #
-        next if ( $pname =~ m~^CVS$~ );
+        #   Check root directory signature
+        #       Has the user added or removed packages from the sandbox
+        #
-        next unless ( -d $pname );
+        my $rootFingerPrint = <$lf>;
-        Verbose ("Package discovered: $pname");
+        $rootFingerPrint =~ s~\s*$~~;
-        if ( -f "$pname/stop" || -f "$pname/stop.$GBE_MACHTYPE" )
+        if ($rootFingerPrint eq $currentRootFingerPrint )
+        {
+            while (<$lf>)
+            {
+                my @locationEntry = split($;, $_);
+                my $pname = $locationEntry[0];
+                #
+                #   Locate the build files in each package
+                #   Scan the build files and extract dependancy information
+                #
+                my $bscanner = BuildFileScanner( $pname, 'build.pl',
+                                                         '--LocateAll',
+                                                         '--LimitDepth=3',
+                                                         '--ScanDependencies' );
+                unless ($bscanner->setLocation($_)) {
+                    Verbose("Build file missing: Force full scan");
+                    @build_list = ();
+                    last;
+                }
-            push @stopped, $pname;
+                $bscanner->scan();
+                my @blist = $bscanner->getInfo();
+                unless ($quiet) {
-            Warning("Package contains stop file: $pname");
+                    Warning ("Package does not have build files: $pname") unless ( @blist );
+                    Warning ("Package has multiple build files: $pname") if ( $#blist > 0 );
-            next;
+                }
+                push @build_list, @blist;
+            }
+        }
+        close $lf;
+    }
+    unless (@build_list)
+    {
+        Message ("Scanning sandbox for build files");
+        FileCreate($cacheFile, $currentRootFingerPrint );
+        my @locationData;
+        foreach my $pname ( glob("*") )
+        {
+            next if ( $pname =~ m~^\.~ );
+            next if ( $pname =~ m~dpkg_archive$~ );
+            next if ( $pname =~ m~^CVS$~ );
+            next unless ( -d $pname );
+            Verbose ("Package discovered: $pname");
+            if ( -f "$pname/stop" || -f "$pname/stop.$GBE_MACHTYPE" )
+            {
-        push @dirlist, $pname;
+                push @stopped, $pname;
+                Warning("Package contains stop file: $pname");
+                next;
+            }
+            #
+            #   Locate the build files in each package
+            #   Scan the build files and extract dependancy information
+            #
+            my $bscanner = BuildFileScanner( $pname, 'build.pl',
+                                                     '--LocateAll',
+                                                     '--LimitDepth=3',
+                                                     '--ScanDependencies' );
+            $bscanner->scan();
+            my @blist = $bscanner->getInfo();
+            unless ($quiet) {
+                Warning ("Package does not have build files: $pname") unless ( @blist );
+                Warning ("Package has multiple build files: $pname") if ( $#blist > 0 );
+            }
+            push @build_list, @blist;
+            push @locationData, $bscanner->getLocation();
+        }
+        #
-        #   Locate the build files in each package
-        #   Scan the build files and extract dependancy information
+        #   Save (cache) location information
+        #
-        my $bscanner = BuildFileScanner( $pname, 'build.pl',
-                                                 '--LocateAll',
-                                                 $opt_exact ? '--ScanExactDependencies' : '--ScanDependencies' );
-        $bscanner->scan();
-        my @blist = $bscanner->getInfo();
+        FileAppend($cacheFile, @locationData);
-        Warning ("Package does not have build files: $pname") unless ( @blist );
-        Warning ("Package has multiple build files: $pname") if ( $#blist > 0 );
-        push @build_list, @blist;
+    }
+    #
     #   Process each build file and extract
     #       Name of the Package
     ErrorDoExit();
 #DebugDumpData ("depends", \%depends );
+    #
-    #   Determine the build order
-    #
-    @build_order = ();
-    my $more = 1;
-    my $level = 0;
-    #
     #   Remove any dependencies to 'external' packages
     #   These will not be met internally and can be regarded as constant
+    #
     #   Split 'depends' into internal (ideps) and external (edeps)
     #       edeps : External Dependencies
+        }
+    }
 #DebugDumpData ("depends", \%depends );
+    #
     #   Determine package build order
     #       Scan the list of packages in the build set and determine
     #       those with no dependencies. These can be built.
     #       Remove those packages as dependents from all packages
     #       Repeat.
+    #
+    #
+    #   Determine the build order
+    #
+    @build_order = ();
+    my $more = 1;
+    my $level = 0;
     my %found    = map { $_ => 1 } @opt_ignorePackage;
     my %notFound = map { $_ => 1 } @opt_justPackage;
     my $scan_start = 0;
     my $scan_stop = 0;
     my $scan_active = ($opt_fromPackage) ? 0 : 1;
         my @build;
+        #
         #   Locate packages with no dependencies
+        #
-        foreach my $key ( keys %depends )
+        foreach my $key ( sort {lc($a) cmp lc($b)} keys %depends )
+        {
             next if ( keys( %{$depends{$key}{depends}} ) );
             push @build, $key;
+        }
                         delete $found{$pname};
+                    }
+                }
+            }
+            #
+            #   Test for a skip marker
+            #
+            my $skipFile = catdir($GBE_SANDBOX, 'sandbox_dpkg_archive', '_skip.'. $fe->{dname});
+            my $skipMachFile = catdir($GBE_SANDBOX, 'sandbox_dpkg_archive', '_skip.' . $GBE_MACHTYPE . '.' . $fe->{dname});
+            if ( -f $skipFile || -f $skipMachFile )
+            {
+                Warning("Package marked for skip: $fe->{dname}, $fe->{dir}") unless $quiet;
+                $scan_add = 0;
+                $fe->{buildSkip} = 1;
+            }
             $fe->{level} = $level;
             $fe->{buildActive} = $scan_add;
             $packages{$build} = $fe;
-            push (@build_order, $fe) if ( $scan_add || $info );
+            push (@build_order, $fe);
             delete $depends{$build};
             delete $fe->{depends};                          # remove now its not needed
+        }
         foreach my $key ( keys %depends )
     ReportError ("Specified ExactPackages not found: ", keys( %notFound) ) if ( %notFound );
     ReportError ("Specified IgnorePackages not found: ", keys( %found) ) if ( %found );
     ErrorDoExit();
+    #
+    #   Just to be sure to be sure
+    #
+    if ( keys %depends )
+    {
+        #DebugDumpData ("depends", \%depends );
+        Error( "Internal algorithm error: Bad dependancy walk",
+               "Possible circular dependency");
+    }
+    #
+    #   Determine FULL internal dependency list for each package
+    #       Walk packages in build order so that we can leverage the calculations
+    #       already done.
+    #
+    foreach my $fe ( @build_order )
+    {
+        my @pkgBuildOrder;
+        my %pkgSeen;
+        my $key = $fe->{tag};
+        if (exists $packages{$key}{'ideps'})
+        {
+            foreach ( keys %{$packages{$key}{'ideps'}} )
+            {
+                foreach my $ikey (@{$packages{$_}{'AllIdepsOrder'}})
+                {
+                    push @pkgBuildOrder, $ikey unless $pkgSeen{$ikey};
+                    $pkgSeen{$ikey} = 1;
+                }
+            }
+        }
+        push @pkgBuildOrder, $key;
+        $fe->{'AllIdepsOrder'} = \@pkgBuildOrder;
+        #
+        #   Is this package in the current directory
+        #
+        if ($startDir)
+        {
+            my $matchBase = $startDir . '/';
+            if ($matchBase =~ m~^$fe->{dir}/~)
+            {
+                $fe->{buildCurrent} = 1;
+                $currentPkgTag = $key;
+            }
+        }
+    }
+    #
+    #   Now that we have a full dependency list for each package we can calculate a full
+    #   usage list. This is a complete list of all package that depend on a package both directly
+    #   and inderectly. Useful for regression testing
+    #
+    foreach my $fe ( @build_order )
+    {
+        foreach my $itag (@{$fe->{'AllIdepsOrder'}})
+        {
+            next if ($itag eq $fe->{tag});
+            push @{$packages{$itag}{usedBy}}, $fe->{tag};
+        }
+    }
+    #
+    #   If the CWD is within a package then limit the build to that package and
+    #   its dependents, unless user specifies entire sandbox.
+    #
+    if ($currentPkgTag && ! $opt_allSandbox )
+    {
+        if (!$opt_processUsedBy )
+        {
+            #
+            #   Reform the build_order to reflect the current sandbox
+            #   The @build_order is an array of package entries
+            #   The per-package build order is an array of keys
+            #
+            my @pkgOrder;
+            foreach ( @{$packages{$currentPkgTag}{AllIdepsOrder}})
+            {
+                push @pkgOrder,  $packages{$_} ;
+            }
+            # Reform the build order based on original level
+            #   Simply done to look pretty - and be consistient when compared with the entire sandbox
+            @build_order = sort {$a->{level} <=> $b->{level}} @pkgOrder;
+        }
+        else
+        {
+            #
+            #   Reform the build order to reflect the consumers of the current package
+            #   This does not include the current package. The assumption is that the package
+            #   has been built.
+            #
+            #   The @build_order is an array of package entries
+            #   The per-package build order is an array of keys
+            #
+            my @pkgOrder;
+            foreach ( @{$packages{$currentPkgTag}{'usedBy'}})
+            {
+                push @pkgOrder,  $packages{$_} ;
+            }
+            # Reform the build order based on original level
+            #   Simply done to look pretty - and be consistient when compared with the entire sandbox
+            @build_order = sort {$a->{level} <=> $b->{level}} @pkgOrder;
+        }
+    }
+    else
+    {
+        $opt_allSandbox = 1;
+    }
+    #
     #   Calculate the external dependencies
     #       Only process packages that are a part of the build
+    #
     #   extern_deps structure
     #       Hash key: 'tag'   - Index into packages
     #                 Key  : Name;Version
     #                 Value: Array of: 'tags' (Index into packages)
     #                                   of packages that use the external
     #                                   component.
+    {
-        Verbose ("Calculate external dependencies");
+        Verbose ("Calculate external dependencies on packages in build");
         %extern_deps = ();
-        foreach my $key ( keys %packages )
+        foreach my $pe (@build_order)
+        {
-                next unless ( $packages{$key}{buildActive} );
+                next unless ( $pe->{buildActive} );
-                next unless ( $packages{$key}{'edeps'} );
+                next unless ( $pe->{'edeps'} );
-                foreach ( keys %{$packages{$key}{'edeps'}} )
+                foreach ( keys %{$pe->{'edeps'}} )
+                {
-                    push @{$extern_deps{$packages{$key}{'edeps'}{$_}} {$_} }, $key;
+                    push @{$extern_deps{$pe->{'edeps'}{$_}} {$_} }, $pe->{tag};
+                }
+        }
+    }
-    #
-    #   Just to be sure to be sure
-    #
-    if ( keys %depends )
-    {
-        #DebugDumpData ("depends", \%depends );
-        Error( "Internal algorithm error: Bad dependancy walk",
-               "Possible circular dependency");
-    }
 #   DebugDumpData("Packages", \%packages);
 #   DebugDumpData ("Order", \@build_order);
 #   DebugDumpData("External Depends", \%extern_deps );
+}
 #-------------------------------------------------------------------------------
+# Function        : calc_rootFingerPrint
+#
+# Description     : Calculate a finger print of all the directories in the
+#                   sandbox root.
+#
+#                   Used to determine if the user has added or remove a package
+#                   from the sandbox
+#
+# Inputs          : None
+#
+# Returns         : SHA1 hash
+#
+sub calc_rootFingerPrint
+{
+    my $fpSha1 = Digest->new("SHA-1");
+    foreach my $pname ( glob("*") )
+    {
+        next if ( $pname =~ m~^\.~ );
+        next if ( $pname =~ m~dpkg_archive$~ );
+        next if ( $pname =~ m~^CVS$~ );
+        next unless ( -d $pname );
+        $fpSha1->add($pname);
+        #
+        #   Include stop files in fingerprint too
+        #
+        $fpSha1->add("$pname/stop" ) if ( -f "$pname/stop" );
+        $fpSha1->add("$pname/stop.$GBE_MACHTYPE" ) if ( -f "$pname/stop.$GBE_MACHTYPE" );
+    }
+    return $fpSha1->hexdigest;
+}
+#-------------------------------------------------------------------------------
 # Function        : cmd
+#
 # Description     : Execute a command in all the sandboxes
 #                       Locate the base of the sandbox
 #                       Locate all packages in the sandbox
 # Returns         : Will exit
+#
 sub cmd
+{
     my ($hcmd, @cmd_opts ) = @_;
-    my $opt_keepgoing;
     Getopt::Long::Configure('pass_through');
-    getOptionsFromArray ( \@cmd_opts,
-                           'keepgoing!'  => \$opt_keepgoing,
-                        ) || Error ("Invalid command line" );
+    getOptionsFromArray ( \@cmd_opts ) || Error ("Invalid command line" );
     SubCommandHelp( $opt_help, $hcmd) if ($opt_help  );
+    #
     #   Determine Sandbox information
     #   Populate global variables
+    #
     calc_sandbox_info();
     foreach my $fe ( @build_order )
+    {
-        my $dir = $fe->{dir};
-        Message( "Level:" . $fe->{level} . " Name: " . $fe->{dname} ,
-                  DisplayPath ("        Path: $fe->{dir}" ));
+        my $active = displayHeader($fe, { showPath => 1 });
+        if ($active)
+        {
+            my $dir = $fe->{dir};
-        my $result = JatsCmd( "-cd=$dir", @cmd_opts);
+            my $result = JatsCmd( "-cd=$dir", @cmd_opts);
-        if ( $result ) {
+            if ( $result ) {
-            if ( $opt_keepgoing ) {
+                if ( $opt_keepgoing ) {
-                Warning ("Cmd failure");
+                    Warning ("Cmd failure");
-            } else {
+                } else {
-                Error   ("Cmd failure");
+                    Error   ("Cmd failure");
+                }
+            }
+        }
+    }
     exit 0;
 sub buildcmd
+{
     my ($cmd, @cmd_opts) = @_;
     my @build_opts;
     my @make_opts;
+    my $opt_skip = 1;
+    my $opt_clean = 0;
+    #
     #   Extract and options
+    #
     Getopt::Long::Configure('pass_through');
+    getOptionsFromArray ( \@cmd_opts,
+                          'skip!' => \$opt_skip,
+                          'clean!' => \$opt_clean,
-    getOptionsFromArray ( \@cmd_opts ) || Error ("Invalid command line" );
+    ) || Error ("Invalid command line" );
     SubCommandHelp( $opt_help, "Command $cmd") if ($opt_help );
+    #
     #   Insert default options
+    #
     push @build_opts, '-noforce' if ( $cmd eq 'all' );
-    push @build_opts, '-force' if ( $cmd ne 'all' );
+    push @build_opts, '-force'   if ( $cmd ne 'all' );
+    #
     #   Attempt to split the options into build and make options
     #   Only handle the often used options to build.
+    #
         } else {
             push @make_opts, $_;
+        }
+    }
-    push @make_opts, 'all'  unless ( @make_opts  );
+    push @make_opts, 'all'  unless ( @make_opts );
+    #
     #   Determine Sandbox information
     #   Populate global variables
+    #
     calc_sandbox_info();
     foreach my $fe ( @build_order )
+    {
+        my $active = displayHeader($fe, { showPath => 1 });
+        if ($active) {
+            #
+            #   Determine build success tag file
+            #   If the tag file exists, then see if any files in the files in the package source are more
+            #   recent than the tag file
+            #
+            my $mustBuild = 1;
+            my $sigMatch = 0;
+            my $tagFile = getPkgFingerPrintFile($fe);
+            if ( -e $tagFile ) {
+                if ( TagFileMatch($tagFile, genPkgFingerPrint($fe, 'Test')) ) {
+                    $sigMatch = 1;
+                    if ($opt_skip) {
+                        $mustBuild = 0;
+                    } else {
+                        $mustBuild = 2;
+                    }
+                } else {
+                }
+            } else {
+                    $mustBuild = 2;
+                    $sigMatch = -1;
+            }
+#Debug0("Skip: $opt_skip, sigMatch: $sigMatch, Build: $mustBuild, Opts: @make_opts",);
+            if ($mustBuild)
+            {
+                if (1)
+                {
+                    unlink $tagFile;
-        my $dir = $fe->{dir};
+                    my $dir = $fe->{dir};
+                    my $result;
+                    $result = JatsCmd( "-cd=$dir", 'build', @build_opts);
+                    if ($result)
+                    {
+                        if ($opt_keepgoing)
+                        {
-        Message( "Level:" . $fe->{level} . " Name: " . $fe->{dname} ,
+                            Warning( "Build Cmd failure - Keep going");
+                            next;
+                        }
-                  DisplayPath ("        Path: $fe->{dir}" ));
+                        Error ("Build Cmd failure");
+                    }
+                    #
+                    #   Skip make if we have a prebuilt package
+                    #
+                    my $mustMake = 1;
+                    if ($mustMake)
+                    {
+                        JatsCmd( "-cd=$dir", 'make', 'clean') if $opt_clean;
+                        $result = JatsCmd( "-cd=$dir", 'make',  @make_opts);
+                        if ($result)
+                        {
+                            if ($opt_keepgoing)
+                            {
-        JatsCmd( "-cd=$dir", 'build', @build_opts) && Error ("Build Cmd failure") if ( $result );
+                                Warning( "Make Cmd failure - Keep going");
+                                next;
+                            }
-        JatsCmd( "-cd=$dir", 'make',  @make_opts)  && Error ("Make Cmd failure")  if ( $result );
+                            Error ("Make Cmd failure");
+                        }
+                    }
+                }
+                FileCreate( $tagFile, genPkgFingerPrint($fe,'Generation') );
+            }
+            else
+            {
+                Message ("No file changes since last build. Skipping")
+            }
+        }
+    }
     exit 0;
+}
+    #
     #   Clobber and clean need to be done in the reverse order
+    #
     foreach my $fe ( reverse @build_order )
+    {
+        my $active = displayHeader($fe, { showPath => 1 });
+        if ($active)
+        {
-        my $dir = $fe->{dir};
+            my $dir = $fe->{dir};
-        Message( "Level:" . $fe->{level} . " Name: " . $fe->{dname} ,
+            my $result = JatsCmd( "-cd=$dir", @cmd, @cmd_opts);
+            if ($result)
+            {
-                  DisplayPath ("        Path: $fe->{dir}" ));
+                if ($opt_keepgoing)
+                {
-        my $result = JatsCmd( "-cd=$dir", @cmd, @cmd_opts);
+                    Warning("Command Failure");
+                }
+                else
+                {
-        Error ("Cmd failure") if ( $result );
+                    Error ("Cmd failure") if ( $result );
+                }
+            }
+        }
+    }
     exit 0;
+}
+    #
     #   Determine Sandbox information
     #   Populate global variables
+    #
     Message("Cache External Dependencies");
+    Error ("GBE_DPKG_CACHE not defined") unless $GBE_DPKG_CACHE;
     calc_sandbox_info();
+    JatsTool ('cache_dpkg', "core_devl/jats2_current" );
+    #
     #   Walk the list of external dependencies and cache each one
+    #
     foreach my $de ( sort keys %extern_deps )
+    {
         'verbose:+'         => \$opt_verbose,
         'topackage:s'       => \$opt_toPackage,
         'frompackage:s'     => \$opt_fromPackage,
         'justpackage:s'     => sub{ opts_add2List( \@opt_justPackage, @_ )},
         'ignorepackage:s'   => sub{ opts_add2List( \@opt_ignorePackage, @_ )},
+        'entireSandBox!'    => \$opt_allSandbox,
+        'users!'            => \$opt_processUsedBy,
+        'keepgoing!'        => \$opt_keepgoing,
+        'rescan!'           => \$opt_reScan,
         );
+    #
     #   Merge in the user options
+    #
     ErrorConfig('verbose' => $opt_verbose );
     return $rv;
+}
 #-------------------------------------------------------------------------------
+# Function        : displayHeader
+#
+# Description     : Display a build header
+#
+# Inputs          : $fe             - Build entry
+#                   $indent         - Indent text
+#                   $showPath       - Boolean
+#
+# Returns         : True if this entry is to be fully process
+#                   False if its being skipped
+#
+sub displayHeader
+{
+    my $fe = shift @_;
+    my $args = pop @_ if (@_ > 0 and UNIVERSAL::isa($_[-1],'HASH'));
+    #    my ($fe, %args) = @_;
+    my $indent = $args->{indent} || '';
+    my $showPath = $args->{showPath};
+    my ($status, $estatus) = addBuildInfo($fe, $args);
+    my $msg1 = $indent . 'Level:' . $fe->{level} . " [$status]" . ' Name: ' . $fe->{dname} . $estatus;
+    if ( $showPath) {
+        my $msg1Len = length($msg1);
+        if ($msg1Len < 80) {
+            $msg1 .= ' ' . '=' x (79 - $msg1Len);
+        }
+    }
+    Message( $msg1 ,  $showPath ? DisplayPath ("        Path: $fe->{dir}" ) : undef);
+   return $fe->{buildActive};
+}
+#-------------------------------------------------------------------------------
+# Function        : addBuildInfo
+#
+# Description     : Add some build info status
+#                   It will have a .sig file if its been sucessfully built
+#
+# Inputs          : $fe     - Package info
+#
+# Returns         : True - sig file present
+#
+sub addBuildInfo
+{
+    my ($fe, $args) = @_;
+    my $txt = '';
+    my $statusB = ' ';
+    my $statusF = ' ';
+    my $statusS = ' ';
+    unless ($fe->{buildActive}) {
+        $txt .= ($fe->{buildSkip}) ? ' (Build Skipped)' : ' (Build Suppressed)';
+        $statusS = ($fe->{buildSkip}) ? 'S' : 's';
+    }
+    if ($fe->{buildCurrent})
+    {
+        $statusB = '*';
+        $txt .= ' (Current Package)';
+    }
+    my $sigFile = getPkgFingerPrintFile($fe);
+    my $tagFile = $sigFile;
+    if (-f $sigFile)
+    {
+        $sigFile =~ s~ffp$~nob~;
+        if (-f $sigFile) {
+            $txt .= ' [NoBuild]';
+            $statusB = '-';
+#        } elsif (locatePreBuiltPackage($fe)) {
+#            $txt .= ' [PreBuilt]';
+#            $statusB = 'P';
+        } else {
+            $txt .= ' [Built]';
+            $statusB = 'B';
+        }
+        if ($args->{testFingerPrint})
+        {
+            if ( TagFileMatch($tagFile, genPkgFingerPrint($fe, 'Test')) )
+            {
+                $txt .= ' [GoodFinger]';
+                $statusF = 'G';
+            } else {
+                $txt .= ' [BadFinger]';
+                $statusF = 'b';
+            }
+        }
+    }
+    return "$statusS$statusB$statusF", $txt ;
+}
+#-------------------------------------------------------------------------------
 # Function        : opts_add2List
+#
 # Description     : Option processing helper
 #                   Add comma separated options to an array
 #                   User can then add items one at a time, or several at once
+        }
+    }
+}
 #-------------------------------------------------------------------------------
+# Function        : genPkgFingerPrint
+#
+# Description     : Generate a fingerprint over all files in the packages tree as
+#                   well as the package dependencies
+#
+#                   Only used to detect changes to files in the subdir
+#
+#                   This version does not actually generate a fingerprint over
+#                   the data file, rather the metadata of the file. This is much (much)
+#                   faster as there is no file i/o.
+#
+#                   It does assume that the file metadata will change if the file is changed
+#                   Will also detect the addition / deletion of files
+#
+#                   Note: This siganture is not machine - type safe
+#                         It will vary between machines (windows/Linux/...)
+#
+# Inputs          : $fe            - Package entry of the package to process
+#                   $mode          - Diagnostic: mode
+#
+# Returns         : A SHA1 hash over all the files
+#
+#
+sub genPkgFingerPrint
+{
+    my ($fe, $mode) = @_;
+    my $genPkgFingerPrintSha1;
+    my $genPkgFingerPrintCount;
+    my @fpdata;
+    #
+    #   Get the package GbeFiles.cfg file
+    #       This is held in the interface directory and is created during the build
+    #       Since the fingerprint is only genertated AFTER a successful build the file will always
+    #       be available
+    #
+    #       All we need from this file is a list of Src directories that were discovered during
+    #       the build. Unfortuanatley they are not always below the root of the package.
+    #
+    my $ifaceDir = getpkgInterface($fe);
+    return 0 unless defined $ifaceDir;
+    return 0 unless ToolsetFiles::GetDataFile($ifaceDir);
+    #
+    #   Generate a list of directories in the package
+    #   This is the root directory and all other Src directories discovered
+    #
+    my @dirList = ToolsetFiles::GetSubTrees($ifaceDir);
+    Error ("Internal:ToolsetFiles::GetDirList for $fe->{dname} not populated" ) unless @dirList;
+    #
+    #   Create the hash
+    #
+    $genPkgFingerPrintSha1 = Digest->new("SHA-1");
+    push @fpdata, $mode;
+    #
+    #   Include all dependent packages in the fingerprint
+    #       We are using the sandbox fingerprint of dependent packages
+    #       This will ensure that a change in a package will ripple through
+    #
+    foreach my $idep ( sort keys %{$fe->{ideps}})
+    {
+        my $ipkg = $packages{$idep};
+        my $tagFile = getPkgFingerPrintFile($ipkg);
+        my $tag = TagFileRead($tagFile);
+        my $text = "$tagFile: $tag";
+        $genPkgFingerPrintSha1->add($text);
+#Debug0("genPkgFingerPrint: $text, ", $genPkgFingerPrintSha1->clone->hexdigest() );
+        push @fpdata, $text . ':' . $genPkgFingerPrintSha1->clone->hexdigest();
+    }
+    #
+    #   Anonymous sub: findFile wanted function
+    #   Unlike the generation of the package signature, we don't need to
+    #   exclude any files.
+    #
+    my $wanted = sub {
+        my $item = $File::Find::name;
+        #
+        #   Get file info
+        #       Kill of the last access time - not useful
+        #
+        #       Need to exclude files that change during a null build
+        #           /interface/GbeFiles.cfg
+        #           /build.log
+        #
+        #       Symlinks present problems.
+        #       Some packages generate symlinks as they create file system images. The
+        #       links are not designed to be interpreted in the context of the current
+        #       computer. As a result.
+        #           Some may be broken - on the current machine
+        #           Some may address files that change - ie: /proc, /var, /dev
+        #           Some may address files that such as /afc, /root
+        #       Don't want to discard all symlinks. Many of them will address package
+        #       dependencies and we do want to detect changes, but those changes will
+        #       be picked up by the packages fingerprint.
+        #
+        #       Directories also appear to be a problem
+        #       The created and modified date-times appear to be modified for no good reason
+        #
+        #       Current solution: Do not include 'stat' data for ANY symlink or directory
+        #
+        my @data = stat($item);
+        my $text;
+        if ( $item =~ m~/build.log$~ || $item =~ m~/GbeFiles.cfg$~) {
+            $text = "$item : SKIPPED FILE : ";
+        }  elsif (-d $item ) {
+                $text = "$item : DIRECTORY"
+        }  elsif (-l $item ) {
+            if ( ! @data) {
+                $text = "$item : BROKEN SYMLINK : ";
+            } else {
+                my $linkTarget = readlink($item) || 'Read Error';
+                $text = "$item :SYMLINK: $linkTarget";
+            }
+        } else {
+            $data[8] = 0;               # atime - will change
+            $data[12] = '-';            # blocks - seen to change for unknown reasons
+            $text = "$item : @data";
+        }
+        $genPkgFingerPrintCount++;
+        $genPkgFingerPrintSha1->add($text);
+#Debug0("genPkgFingerPrint: $text, ", $genPkgFingerPrintSha1->clone->hexdigest() );
+        push @fpdata, $text . ':' . $genPkgFingerPrintSha1->clone->hexdigest();
+    };
+    #
+    #   Process all files in the package
+    #
+    $genPkgFingerPrintCount = 0;
+    my $dir = $fe->{dir};
+    File::Find::find( { wanted => $wanted , no_chdir => 1}, @dirList );
+#Debug0("genPkgFingerPrint: $dir, $genPkgFingerPrintCount, ", $genPkgFingerPrintSha1->clone->hexdigest() );
+    push @fpdata, $dir . ':'. $genPkgFingerPrintCount . ':' . $genPkgFingerPrintSha1->clone->hexdigest();
+    #
+    #   Debugging - delete later
+    #   Save FP data to a file
+    #
+#   my $fpDebugFile = catdir($GBE_SANDBOX, 'sandbox_dpkg_archive', $fe->{name} . '.' . $fe->{prj} . '_' . time() . '.fpd');
+#   Debug0("fpDebugFile: $fpDebugFile");
+#   FileCreate($fpDebugFile, @fpdata);
+    return $genPkgFingerPrintSha1->hexdigest;
+}
+#-------------------------------------------------------------------------------
+# Function        : getPkgFingerPrintFile
+#
+# Description     : Return the package file that contains the packages Fast Finger Print
+#
+# Inputs          : $fe     - Package entry
+#
+# Returns         : Full path to the packages fingerprint tag file
+#
+sub getPkgFingerPrintFile
+{
+    my ($fe) = @_;
+    my $tagFile = catdir($GBE_SANDBOX, 'sandbox_dpkg_archive', $fe->{name}, 'sandbox.' . $fe->{prj} . '.ffp');
+    return $tagFile;
+}
+#-------------------------------------------------------------------------------
 # Function        : SubCommandHelp
+#
 # Description     : Provide help on a subcommand
+#
 # Inputs          : $help_level             - Help Level 1,2,3
  Options for recursion control:
     -toPackage=name            - Stop building after package
     -fromPackage=name          - Start building from package
     -justPackage=name[,name]   - Build named packages
     -ignorePackage=name[,name] - Do not build named packages
+    -entireSandbox             - Process the entire sandbox
+    -users                     - Process package users, not dependencies
+    -[no]keepgoing             - Ignore errors
+    -[no]reScan                - Recalculate and cache sandbox structure
  Commands:
     help                - Same as -help
     create              - Create a sandbox in the current directory
     populate            - Populate the sandbox with packages
     delete              - Delete the sandbox
     info [[-v]-v]       - Sandbox information. -v: Be more verbose
     buildfilter         - Modify and display sandbox buildfilter
+    [un]skip            - Mark a package to be skipped during the build
+    fingerprint         - Various fingerprint operations
     cmd                 - Do commands in all sandbox components
     all                 - Do 'build', if required, then a make in all components
     build               - Force 'build and make' in all sandbox components
     make                - Do 'make' in all sandbox components
     clean               - Do 'make clean' in all sandbox components
 The exclusion of a package takes precedence over its inclusion.
 The package names can be specified as a mix of the three forms described under the '-toPackage' option.
+=item B<-[no]entireSandbox>
+This option will override the automatic package localisation that will occur if the user starts the comamnd
+within a subdirectory of a package within the sandbox and will process the entire sabdbox.
+If the user start the command within a subdirectory of a package then the sandbox commands will be localised
+to the current package and the dependencies of the package.
+=item B<-[no]users>
+This option will completely change the packages considered to be built. The normal operation is to consider
+the current package and all packages that it depends upon.
+This option will consider all packages that 'use' the current package, either directly or indirectly. It does not
+include the 'current' pakage in this list. The assumption is that the current package has been sucessfully built
+and needs to tested.
+This option will work when they is a current package to be processed and not the entire sandbox.
+The intended purpose of this option is to simplify regression testing.
+=item B<-[no]keepgoing>
+This options controls the behaviour of the command when an error is encountered.
+The default operation is to terminate the command on the package with the
+error. This can be modified so that errors are ignored.
+=item B<-[no]reScan>
+This option controls the process of locating build files within the sandbox.
+The default operation is to scan the sandbox and to cache the location of the build files.
+If a package is added or removed from the sandbox, then the sandbox will need to be rescanned.
+Jats will detect when a package has been added or removed, but if the internal structure of the
+packages has changed the cached data may be incorrect.
 =back
 =head1 DESCRIPTION
 This program is the primary tool for the maintenance of Development Sandboxes.
 The sandbox directory contains sub directories, each should contain a single
 package. Sub directories may be created with the 'jats extract' command or with the
 'jats sandbox populate' command.
-Note: Symbolic links are not supported. They cannot work as he sandbox mechanism
+Note: Symbolic links are not supported. They cannot work as the sandbox mechanism
 requires that all the packages be contained within a sub directory tree so
 that the root of the sandbox can be located by a simple scan of the directory
 tree.
 If a package subdirectory contains a file called 'stop' or 'stop.
 <GBE_MACHTYPE>', then that package will not be considered as a part of the
-build-set. A 'stop' file will prevent consideration all build platforms. The 'stop.
+build-set. A 'stop' file will prevent consideration for all build platforms. The 'stop.
 <GBE_MACHTYPE>' will only prevent consideration if being built on a GBE_MACHTYPE
 type of computer.
 If the sandbox contains a file called 'buildfilter', then the contents of the
 file will be read and used a buildfilter. The file is processed by reading each
     -help[=n]                  - Command specific help, [n=1,2,3]
     -toPackage=name            - Stop building after package
     -fromPackage=name          - Start building from package
     -justPackage=name[,name]   - Build named packages
     -ignorePackage=name[,name] - Do not build named packages
+    -entireSandbox             - Process the entire sandbox
+    -users                     - Process package users, not dependencies
     -excludePackage=name[,name]- Do not extract named package
     -recurse[=n]               - Locate dependencies within packages
     -all                       - Populate with all dependencies
     -missing                   - Locate missing packages
     -show                      - Show packages that would be extracted
 jats sandbox info [command options]
  Command Options
     -help[=n]                  - Command specific help, [n=1,2,3]
     -verbose[=n]               - Display more information
+    -usedby                    - Display package usage information
     -toPackage=name            - Stop building after package
     -fromPackage=name          - Start building from package
     -justPackage=name[,name]   - Build named packages
     -ignorePackage=name[,name] - Do not build named packages
+    -entireSandbox             - Process the entire sandbox
+    -users                     - Process package users, not dependencies
+    -fingerprint               - Display fingerprint information
 =head2 OPTIONS
 =over
 This options will increase the verbosity of the information being displayed.
 Values 1 and 2 are described in the detailed 'DESCRIPTION'. Other values are
 reserved for diagnostic use.
+=item B<-usedby>
+This option will list all packages that use the current package, both directly and
+indirectly. These are packages that should be tested whan changes are made to the
+package.
+=item B<-fingerprint>
+This option will cause the information display to include that status of each packages fingerprint.
+This will slow down the display as the calculation can be time consuming.
 =back
 =head2 DESCRIPTION
 The 'info' command will display information about the build order and the
 =item *
 Verbosity of 2
+Usage information will also be displayed. This is the same as invoking the
-Reserved for future use
+'-usedby' option.
 =item *
 Verbosity over 2
     jats sandbox buildfilter COBRA +PPC_603E
  or jats sandbox buildfilter COBRA PPC_603E
 will set the buildfilter to be COBRA and PPC_603E
+=head1 Skip Build
+=head2 NAME
+Mark a package to be skipped during the build
+=head2 SYNOPSIS
+jats sandbox [un]skip [command options] [PackageName]+
+ Command Options
+    -help[=n]               - Command specific help, [n=1,2,3]
+    -man                    - Same as -help=3
+    -[no]machine            - Skip on on this type of machine
+=head2 ARGUMENTS
+Arguments to the 'skip' command are the names of packages to be marked.
+If no packages are named then the command will display all packages that are marked to be skipped.
+If the named package is '.', then the current package will be excluded.
+=head2 OPTIONS
+The 'skip' command takes the following options:
+=over 8
+=item -[no]machine
+This option will flag that the package will be skipped only on this type of build machine.
+=back
+=head2 DESCRIPTION
+The 'skip' command marked the named packages to be skipped during the build, or the mark will be removed.
+=head2 EXAMPLES
+The command
+    jats sandbox skip package1
+will mark package1 to be skipped during the following builds.
+=head1 Sandbox Finger Print
+=head2 NAME
+Various fingerprint operations
+=head2 SYNOPSIS
+jats sandbox finger[print] [options]
+ Command Options
+    -help[=n]               - Command specific help, [n=1,2,3]
+    -man                    - Same as -help=3
+    -[no]generate           - Generate a fingerprint over a package
+    -[no]delete             - Delete the fingerprint information
+=head2 ARGUMENTS
+Arguments to the 'fingerprint' command are the names of packages to be processed.
+If no packages are named then the command will process the current package, if any.
+=head2 OPTIONS
+The 'fingerprint' command takes the following options:
+=over 8
+=item -[no]generate
+This option will cause the fingerprint of the package to be regenerated.
+=item -[no]delete
+This option will delete the fingerprint information associated wit a package.
+=back
+=head2 DESCRIPTION
+The 'fingerprint' command, will by default, examine the packages fingerprint and report
+if the package has been modified since the fingerprint was created.
+Options allow different modes of operation.
+A fingerprint may only be created after the 'build.pl' file has been created. It requires the
+build process to generate metadata about the package.
+=head2 EXAMPLES
+The command
+    jats sandbox fingerprint -generate
+will regenerate the fingerprint of the current package. Useful after trivial edits to
+enable the sandbox builder to bypass the package and not to rebuild it and all of its dependents.
 =head1 Command all
 =head2 NAME
 Build packages in the sandbox
     -help[=n]                  - Command specific help, [n=1,2,3]
     -toPackage=name            - Stop building after package
     -fromPackage=name          - Start building from package
     -justPackage=name[,name]   - Build named packages
     -ignorePackage=name[,name] - Do not build named packages
+    -entireSandbox             - Process the entire sandbox
+    -users                     - Process package users, not dependencies
+    -[no]keepgoing             - Ignore errors
+    -[no]skip                  - Skip if no source change (default:skip)
 =head2 ARGUMENTS
 Arguments are passed to the 'make' phase of the process.
 =head2 OPTIONS
+=over
+=item B<-[no]skip>
-The are command specific options.
+This operation overides the default smart building mechanism.
+By default, a package will not be built if the last build was successful and
+there has not been any change to the source of the package, since the last
+succesful build.
+=back
 =head2 DESCRIPTION
 The 'all' command will perform build, if the build files are out of date,
 followed by a make in each of the packages within the sandbox, in the correct
     -help[=n]                  - Command specific help, [n=1,2,3]
     -toPackage=name            - Stop building after package
     -fromPackage=name          - Start building from package
     -justPackage=name[,name]   - Build named packages
     -ignorePackage=name[,name] - Do not build named packages
+    -entireSandbox             - Process the entire sandbox
+    -users                     - Process package users, not dependencies
+    -[no]keepgoing             - Ignore errors
+    -[no]skip                  - Skip if no source change (default:skip)
 =head2 ARGUMENTS
 Arguments are passed to the 'make' phase of the process.
 =head2 OPTIONS
+=over
+=item B<-[no]skip>
-The are no command specific options.
+This operation overides the default smart building mechanism.
+By default, a package will not be built if the last build was successful and
+there has not been any change to the source of the package, since the last
+succesful build.
+=back
 =head2 DESCRIPTION
 The 'build' command will force a build followed by a make in each of the packages
 within the sandbox, in the correct build order.
     -help[=n]                  - Command specific help, [n=1,2,3]
     -toPackage=name            - Stop building after package
     -fromPackage=name          - Start building from package
     -justPackage=name[,name]   - Build named packages
     -ignorePackage=name[,name] - Do not build named packages
+    -entireSandbox             - Process the entire sandbox
+    -users                     - Process package users, not dependencies
+    -[no]keepgoing             - Ignore errors
 =head2 ARGUMENTS
 None
 =head2 OPTIONS
+=over
-No command specific options
+=item B<-[no]keepgoing>
+This options controls the behaviour of the command when an error is encountered.
+The default operation is to terminate the command on the package with the
+error. This can be modified so that errors are ignored.
+=back
 =head2 DESCRIPTION
 The 'clean' command will perform a 'jats make clean' in all components in the
 sandbox.
     -help[=n]                  - Command specific help, [n=1,2,3]
     -toPackage=name            - Stop building after package
     -fromPackage=name          - Start building from package
     -justPackage=name[,name]   - Build named packages
     -ignorePackage=name[,name] - Do not build named packages
+    -entireSandbox             - Process the entire sandbox
+    -users                     - Process package users, not dependencies
 =head2 ARGUMENTS
 Arguments are passed to the 'make' phase of the process.
     -[no]keepgoing             - Ignore errors
     -toPackage=name            - Stop building after package
     -fromPackage=name          - Start building from package
     -justPackage=name[,name]   - Build named packages
     -ignorePackage=name[,name] - Do not build named packages
+    -entireSandbox             - Process the entire sandbox
+    -users                     - Process package users, not dependencies
 =head2 ARGUMENTS
 Arguments are passed to a JATS command.

Subversion Repositories DevTools

(root)/core_devl/trunk/TOOLS/jats_sandbox.pl – Rev 5709 → 6133