WebSVN – DevTools – Diff – /buildtool/branches/planMetrics/src/main/java/com/erggroup/buildtool/ripple/RippleEngine.java

     /**name associated with the baseline
      * @attribute
      */
     public String mBaselineName = "";
-    /**collection of released pv_ids associated with the release
-     * @attribute
-     */
-    public List<Integer> mReleasedPvIDCollection = new ArrayList<Integer>();
     /**Collection of build exceptions associated with the baseline
      * Used to determine (and report) what change in build exceptions happens as part of planRelease
      * Daemon centric
      * @aggregation shared
      * @attribute
     /** Escrow information - Raw data (May not be used)
      * @attribute
      */
     private String mEscrowRawData;
-    /**package versions representing the baseline
-     * escrow centric
-     * @aggregation shared
+    /** Collections of packages
-     * @attribute
      */
     private ArrayList<Package> mPackageCollection = new ArrayList<Package>();
+    private ArrayList<Package> mPackageCollectionWip = new ArrayList<Package>();
+    private ArrayList<Package> mPackageCollectionTest = new ArrayList<Package>();
+    private ArrayList<Package> mPackageCollectionRipple = new ArrayList<Package>();
+    private ArrayList<Package> mPackageCollectionAll = new ArrayList<Package>();
     /**index to current String item
      * @attribute
      */
     private int mBuildIndex;
      * @param rtagId         - Release Identifier
      * @param isDaemon        - Mode of operation. False: Escrow, True: Daemon
      */
     public RippleEngine(ReleaseManager releaseManager, int rtagId, boolean isDaemon)
+    {
-        mLogger.debug("RippleEngine rtag_id " + rtagId + " isDaemon " + isDaemon);
+        mLogger.debug("RippleEngine rtag_id {} isDaemon {}", rtagId, isDaemon);
         mReleaseManager = releaseManager;
         mBaseline = rtagId;
         mRtagId = rtagId;
         mDaemon = isDaemon;
         mReleaseManager.setDaemonMode(mDaemon);
+    }
     /**
      * getRtagId
+     * @return The rtagId of the Release attached to this instance of the RippleEngine
      */
     public int getRtagId()
+    {
         return mRtagId;
+    }
      *                                will result in a build, so it is given priority to connect
      *                                to the database.
      */
     public void planRelease(final boolean lastBuildActive) throws SQLException, Exception
+    {
-        mLogger.warn("planRelease mDaemon " + mDaemon);
+        mLogger.warn("planRelease mDaemon {}", mDaemon);
         mBuildCollection.clear();
         mPackageCollection.clear();
+        mPackageCollectionRipple.clear();
+        mPackageCollectionTest.clear();
-        mReleasedPvIDCollection.clear();
+        mPackageCollectionWip.clear();
         mBuildOrder.clear();
         mEscrowRawData = "";
         mEscrowSetup = "";
         Phase phase = new Phase("Plan");
             //	Query package versions
             //
             phase.setPhase("queryPackageVersions");
             mLogger.debug("planRelease queryPackageVersions");
             mReleaseManager.queryPackageVersions(this, mPackageCollection, mBaseline);
+            mReleaseManager.queryWips(this, mPackageCollectionWip, mBaseline);
+            mReleaseManager.queryTest(this, mPackageCollectionTest, mBaseline);
+            mReleaseManager.queryRipples(this, mPackageCollectionRipple, mBaseline);
+            mPackageCollectionAll.addAll(mPackageCollection);
+            mPackageCollectionAll.addAll(mPackageCollectionWip);
+            mPackageCollectionAll.addAll(mPackageCollectionTest);
+            mPackageCollectionAll.addAll(mPackageCollectionRipple);
+            // Sort the collection by PVID
+            //      Unit Test output order is known
+            //      May assist in creating repeatable build orders
+            //
+            Collections.sort(mPackageCollectionAll, Package.SeqComparator);
             //------------------------------------------------------------------------
             //    Process packages collected
             //    Determine and tag those we can't build
             phase.setPhase("processPackages");
                 phase.setPhase("disconnectForPlanning");
                 mReleaseManager.disconnectForPlanning(lastBuildActive);
+            }
+        }
-        mLogger.warn("planRelease mDaemon " + mDaemon + " returned");
+        mLogger.warn("planRelease mDaemon {} returned", mDaemon);
         phase.setPhase("EndPlan");
+    }
     /** Process packages that have been collected as a part of the plan
      * @param phase
      * @throws Exception
      */
     private void processPackages() throws SQLException, Exception {
         // Deal with test builds here as they may impact upon package attributes
-        //    eg dependency collection and build standard differences
+        //    eg: dependency collection and build standard differences
-        //    This gives test builds preferential treatment
         //    Note: Done before mPackageDependencyCollection is setup
         //
         if ( mDaemon )
+        {
-            // process test builds
+            // Process test builds - they are in their own collection
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionTest.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
+                mLogger.info("planRelease package test build {}", p.mAlias);
+                //
+                //    Cannot test build an SDK based package or a Pegged Package
+                //        Remove the test build request from the database
+                //        Send a warning email
+                //
-                if (p.mBuildFile == 0)
+                if(p.mIsPegged || p.mIsSdk)
+                {
-                    // package has yet to be processed
-                    if (  p.mTestBuildInstruction > 0 )
-                    {
-                        mLogger.info("planRelease package test build " + p.mName);
-                        //
-                        //    Cannot test build an SDK based package or a Pegged Package
-                        //        Remove the test build request from the database
-                        //        Send a warning email
-                        //
-                        if(p.mIsPegged || p.mIsSdk)
-                        {
-                            String reason;
+                    String reason;
-                            reason = (p.mIsPegged) ? "Pegged" : "SDK Based";
+                    reason = (p.mIsPegged) ? "Pegged" : "SDK Based";
-                            mLogger.error("planRelease Daemon Instruction of " + reason + " package deleted: " + p.mName);
+                    mLogger.error("planRelease Daemon Instruction (testBuild) of {} package deleted: {}", reason, p.mAlias);
-                            mReleaseManager.markDaemonInstCompleted( p.mTestBuildInstruction );
+                    mReleaseManager.markDaemonInstCompleted( p.mTestBuildInstruction );
-                            emailRejectedDaemonInstruction("Cannot 'Test Build' a " + reason + " package",p);
+                    emailRejectedDaemonInstruction("Cannot 'Test Build' a " + reason + " package",p);
-                        }
+                }
-                        // force patch for test build numbering
+                // force patch for test build numbering
-                        p.mDirectlyPlanned = true;
+                p.mDirectlyPlanned = true;
-                        p.mChangeType.setPatch();
+                p.mChangeType.setPatch();
-                        p.mRequiresSourceControlInteraction = false;
+                p.mRequiresSourceControlInteraction = false;
-                        p.mBuildReason = BuildReason.Test;
+                p.mBuildReason = BuildReason.Test;
-                        rippleIndirectlyPlanned(p);
+                p.mIndirectlyPlanned = true;
-                        // put the mTestBuildAttributes to work
-                        p.mVcsTag = p.mTestBuildVcsTag;
-                        p.mId = p.mTestBuildPvId;
-                        p.setTestEmail();
-                        p.setTestDependencyCollection();
-                        p.setTestBuildStandardCollection();
-                        p.mHasAutomatedUnitTests = p.mTestBuildHasAutomatedUnitTests;
-                    }
-                }
+            }
+        }
         // Set up mPackageDependencyCollection on each package
         //    Examine the dependencies by alias and convert this to a 'package' selected from the released package set
-        mLogger.debug("planRelease setup mPackageDependencyCollection");
+        mLogger.debug("planRelease setup setPackageDependencyCollection");
-        for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+        for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
             for (Iterator<String> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )
+            {
                 String alias = it2.next();
                 Package dependency = findPackage(alias);
                 p.mPackageDependencyCollection.add(dependency);
+            }
         }
-        // DEVI 56479 detect and deal with circular dependencies
+        // Detect and deal with circular dependencies
+        // Examine all packages under consideration
+        //
         mLogger.debug("planRelease deal with circular dependencies");
-        for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+        for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
             if ( p.hasCircularDependency( this ) )
+            {
-                mLogger.info("planRelease circular dependency detected " + p.mAlias);
+                mLogger.info("planRelease circular dependency detected {}", p.mAlias);
                 //  Force this package to be marked as having a circular dependency - even if its been excluded
                 p.mBuildFile = 0;
                 // exclude all dependent packages
                 // max 50 chars
                 rippleBuildExclude(p, p.mId, "Package has circular dependency", null, null, true);
                 // take the package out of the build
                 p.mBuildFile = -6;
-                mLogger.info("planRelease set mBuildFile to -6 for package " + p.mAlias );
+                mLogger.info("planRelease set mBuildFile to -6 for package {}", p.mAlias );
                 standardOut(mCircularDependency, p.mAlias, mCircularDependencyFlag);
                 mCircularDependencyFlag = false;
+            }
+        }
         // Scan for packages with missing dependencies
         //    ie: The dependent package is not in the package Collection
         //        DEVI 55483 now use the fully built mPackageDependencyCollection (in rippleBuildExclude)
         mLogger.debug("planRelease use the fully built mPackageDependencyCollection");
-        for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+        for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
             if ( mDaemon )
+            {
                 String alias = it2.next();
                 Package dependency = findPackage(alias);
                 if (dependency == ReleaseManager.NULL_PACKAGE)
+                {
-                    mLogger.info("planRelease dependency is not in the baseline " + alias);
+                    mLogger.info("planRelease dependency is not in the baseline {}", alias);
                     // exclude all dependent packages
                     // max 50 chars
                     rippleBuildExclude(p, p.mId, "Package build dependency not in the release", null, null, true);
                     // take the package out of the build
                     p.mBuildFile = -4;
-                    mLogger.info("planRelease set mBuildFile to -4 for package " + p.mAlias );
+                    mLogger.info("planRelease set mBuildFile to -4 for package {}", p.mAlias );
                     standardOut(mNotInBaseline, p.mAlias, mNotInBaselineFlag);
                     mNotInBaselineFlag = false;
                     break;
+                }
+            }
+        }
-        // Process packages which are not reproducible, and all packages dependent upon them
+        // Detect packages with no build standard and exclude them from the build
-        //    ie: Have no build standard
         mLogger.debug("planRelease process packages which are not reproducible");
-        for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+        for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
             if (p.mBuildFile == 0)
+            {
+                    {
                         continue;
+                    }
+                }
+                // Does the package have a build standard. If not then we can't reproduce it.
-                // package has yet to be processed
+                // Escrow - Assume the package is provided
+                // Daemon - Exclude this package, but not its consumers. If the package is available then we can use it.
                 if (!p.isReproducible())
+                {
-                    // for escrow build purposes, exclude all dependent package versions
-                    mLogger.info("planRelease package not reproducible " + p.mName);
+                    mLogger.info("planRelease package not reproducible {}" ,p.mName);
                     // max 50 chars
-                    rippleBuildExclude(p, p.mId, "Package has no build environment", null, null, true);
+                    rippleBuildExclude(p, p.mId, "Package has no build environment", null, null, false);
                     // package is not reproducible, discard
                     p.mBuildFile = -1;
-                    mLogger.info("planRelease set mBuildFile to -1 for package " + p.mAlias );
+                    mLogger.info("planRelease set mBuildFile to -1 for package {}", p.mAlias );
                     standardOut(mAnyBuildPlatforms, p.mAlias, mAnyBuildPlatformsFlag);
                     mAnyBuildPlatformsFlag = false;
+                }
+            }
+        }
-        //    Process packages which are not reproducible on the configured set of  build machines.
+        //    Process packages which are not reproducible on the configured set of build machines.
         //
         //    Test each package and determine if the package contains a buildStandard that
         //    can be processed by one of the machines in the build set
         //
         //    ie: Package: Win32:Production and we have a BM with a class of 'Win32'
         //
-        //    July-2014
         //    Only exclude the failing package and not its dependents
         //    May be legitimate in the release
         //
+//TODO - verify this code. I'm not sure it can be reached. I think that the "Package has no build environment" test above is detecting all these packages
         mLogger.debug("planRelease process packages which are not reproducible2");
-        for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+        for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
             if (p.mBuildFile == 0)
+            {
                     String machineClass = it2.next();
                     if ( p.canBeBuildby(machineClass))
+                    {
                         reproduce = true;
-                        mLogger.info("planRelease package built on " + machineClass + " " + p.mAlias );
+                        mLogger.info("planRelease package built on {} {}", machineClass, p.mAlias );
                         break;
+                    }
+                }
                 if ( !reproduce )
+                {
-                    mLogger.info("planRelease package not reproducible on the build platforms configured for this baseline " + p.mName);
+                    mLogger.info("planRelease package not reproducible on the build platforms configured for this baseline {}", p.mName);
-                    if (mDaemon)
-                    {
-                        // DEVI 54816
-                        // for escrow build purposes, do not exclude all dependent package versions
-                        // max 50 chars
+                    // max 50 chars
-                        rippleBuildExclude(p, p.mId, "Package not built for configured platforms", null, null, false);
+                    rippleBuildExclude(p, p.mId, "Package not built for configured platforms", null, null, false);
-                    }
                     // package is not reproducible on the build platforms configured for this baseline, discard
                     p.mBuildFile = -2;
-                    mLogger.info("planRelease set mBuildFile to -2 for package " + p.mAlias );
+                    mLogger.info("planRelease set mBuildFile to -2 for package {}", p.mAlias );
                     standardOut(mAssocBuildPlatforms, p.mAlias, mAssocBuildPlatformsFlag);
                     mAssocBuildPlatformsFlag = false;
+                }
+            }
+        }
                     // mBuildExclusionCollection is at this point based on
                     // relevant (direct and indirect) excluded pv's in the database
                     if ( be.compare(p.mId) && be.isARootCause() && p.mTestBuildInstruction == 0 && p.mForcedRippleInstruction == 0 )
+                    {
                         // package is not reproducible, discard
                         rippleBuildExclude( p, p.mId, null, it, be, true );
                         p.mBuildFile = -3;
-                        mLogger.info("planRelease set mBuildFile to -3 for package " + p.mAlias );
+                        mLogger.info("planRelease set mBuildFile to -3 for package {}", p.mAlias );
                         break;
+                    }
+                }
+            }
                     if (p.mIsPegged || p.mIsSdk)
+                    {
                         continue;
+                    }
-                    // package has yet to be processed
+                    //    Examine this packages dependencies
-                    if (p.mDirectlyPlanned)
-                    {
-                        // a WIP exists on the package, or it is a Test Build
+                    //    If one of them does not exist in the 'official release' set then
-                        // exclude all dependent package versions
+                    //    the package needs to be built against the official release set
-                        mLogger.info("planRelease package has WIP " + p.mName);
+                    //    and we can't build any of its dependent packages
-                        if ( p.mBuildReason == null)
+                    Iterator<Integer> it2 = p.mDependencyIDCollection.iterator();
-                            p.mBuildReason = BuildReason.NewVersion;
+                    Iterator<Package> it3 = p.mPackageDependencyCollection.iterator();
-                        rippleIndirectlyPlanned(p);
+                    while ( it2.hasNext() && it3.hasNext() )
-                    }
-                    else
+                    {
-                        //    Examine this packages dependencies
-                        //    If one of them does not exist in the 'official release' set then
-                        //    the package needs to be built against the official release set
-                        //    and we can't build any of its dependent packages
-                        Iterator<Integer> it2 = p.mDependencyIDCollection.iterator();
-                        Iterator<Package> it3 = p.mPackageDependencyCollection.iterator();
-                        while ( it2.hasNext() && it3.hasNext() )
-                        {
-                            Integer dpvId = it2.next();
+                        Integer dpvId = it2.next();
-                            Package dependency = it3.next();
+                        Package dependency = it3.next();
-                            if ( !dependency.mAdvisoryRipple )
+                        if ( !dependency.mAdvisoryRipple )
+                        {
+                            // not advisory, ie: has ripple build impact
+                            if ( !isInRelease(dpvId) )
+                            {
-                                // not advisory, ie: has ripple build impact
+                                // the package is out of date
+                                // exclude all dependent package versions
+                                mLogger.info("planRelease package out of date {}", p.mName);
+                                p.mBuildReason = BuildReason.Ripple;
-                                if ( !isInRelease(dpvId) )
+                                rippleIndirectlyPlanned(p);
+                                //  This package needs to be rippled
+                                //  If this package has a rippleStop marker of 's', then we cannot
+                                //  build this package at the moment.
+                                //  Packages that depend on this package have been excluded
+                                //  We need to exclude this one too
+                                //
+                                if (p.mRippleStop == 's' || p.mRippleStop == 'w')
+                                {
-                                    // the package is out of date
+                                    // Package marked as a rippleStop
-                                    // exclude all dependent package versions
+                                    // max 50 chars
-                                    mLogger.info("planRelease package out of date " + p.mName);
+                                    rippleBuildExclude(p, -2, "Ripple Required." + " Waiting for user", null, null, false);
-                                    p.mBuildReason = BuildReason.Ripple;
+                                    // package is unBuildable, mark reason and discard
-                                    rippleIndirectlyPlanned(p);
+                                    p.mBuildFile = -11;
-                                    //  This package needs to be rippled
-                                    //  If this package has a rippleStop marker of 's', then we cannot
-                                    //  build this package at the moment.
-                                    //  Packages that depend on this package have been excluded
-                                    //  We need to exclude this one too
-                                    //
-                                    if (p.mRippleStop == 's' || p.mRippleStop == 'w')
-                                    {
-                                        // Package marked as a rippleStop
-                                        // max 50 chars
-                                        rippleBuildExclude(p, -2, "Ripple Required." + " Waiting for user", null, null, false);
-                                        // package is unBuildable, mark reason and discard
-                                        p.mBuildFile = -11;
-                                        if (p.mRippleStop == 's' ) {
+                                    if (p.mRippleStop == 's' ) {
-                                            // Need to flag to users that the package build is waiting user action
+                                        // Need to flag to users that the package build is waiting user action
-                                            mLogger.info("planRelease " + "Ripple Required." + " Stopped by flag" + p.mName);
+                                        mLogger.info("planRelease Ripple Required. Stopped by flag {}", p.mName);
-                                            mReleaseManager.setRippleStopWait(mRtagId,p);
+                                        mReleaseManager.setRippleStopWait(mRtagId,p);
-                                        }
+                                    }
-                                    break;
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
             //  Daemon Mode Only
             //  Process packages which do not exist in the archive
             //  For unit test purposes, assume all packages exist in the archive if released
             mLogger.debug("planRelease process packages which do not exist in the archive");
-            if ( ReleaseManager.mUseDatabase )
+            if ( mReleaseManager.mUseDatabase )
+            {
                 for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+                {
                     Package p = it.next();
+                            {
                                 if (! p.mIsBuildable)
+                                {
                                     //  Package does not exist in dpkg_archive and it has been flagged as unbuildable
                                     //  This may be because is Unbuildable or Manually built
-                                    mLogger.info("planRelease " + "Unbuildable" + " package not found in archive " + p.mName);
+                                    mLogger.info("planRelease Unbuildable package not found in archive {}", p.mName);
                                     // max 50 chars
                                     rippleBuildExclude(p, p.mId, "Unbuildable" + " package not found in archive", null, null, true);
                                     // package is unBuildable, mark reason and discard
                                     p.mBuildFile = -10;
                                     reason = (p.mIsPegged) ? "Pegged" : "SDK";
                                     //  Pegged packages or packages provided from an SDK MUST exist in dpkg_archive
                                     //  They will not be built within the context of this release. It is the responsibility
                                     //  of another release to build them.
-                                    mLogger.info("planRelease " + reason + " package not found in archive " + p.mName);
+                                    mLogger.info("planRelease {} package not found in archive {}", reason, p.mName);
                                     // max 50 chars
                                     rippleBuildExclude(p, p.mId, reason + " package not found in archive", null, null, true);
                                     // package is not reproducible, mark reason and discard
                                     p.mBuildFile = -7;
                                         if ( !isInRelease(dpvId) )
+                                        {
                                             // This package cannot be rebuilt as one of its dependents is NOT in this release
                                             // exclude all dependent package versions
-                                            mLogger.info("planRelease package not found in archive. Cannot be rebuilt du to  " + p.mName);
+                                            mLogger.info("planRelease package not found in archive. Cannot be rebuilt due to {}", p.mName);
                                             // max 50 chars
                                             rippleBuildExclude(p, p.mId, "Package cannot be rebuilt in this release", null, null, true);
                                             // package is not reproducible, mark reason and discard
                                             p.mBuildFile = -4;
+                                    }
                                     //  The package has not been excluded from the build
                                     if (p.mBuildFile == 0)
+                                    {
-                                        mLogger.info("planRelease package not found in archive " + p.mName);
+                                        mLogger.info("planRelease package not found in archive {}", p.mName);
                                         // DEVI 47395 the cause of this build is not WIP or ripple induced,
                                         // it simply does not exist in the archive (has been removed)
                                         // prevent source control interaction
                                         p.mRequiresSourceControlInteraction = false;
                                         p.mBuildReason = BuildReason.Restore;
+                    }
+                }
+            }
             //  Daemon Mode Only
-            //  Process forced ripples
+            //  Detect bad forced ripples requests and reject them
             mLogger.debug("planRelease process forced ripples");
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionRipple.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
                 if (p.mBuildFile == 0)
+                {
+                    //
+                    //    Cannot force a ripple on an SDK based package or a Pegged Package
+                    //        Remove the daemon instruction from the database
-                    // package has yet to be processed
+                    //        Send a warning email
+                    //
-                    if ( p.mForcedRippleInstruction > 0 )
+                    if(p.mIsPegged || p.mIsSdk)
+                    {
-                        //
-                        //    Cannot force a ripple on an SDK based package or a Pegged Package
-                        //        Remove the daemon instruction from the database
-                        //        Send a warning email
-                        //
-                        if(p.mIsPegged || p.mIsSdk)
-                        {
-                            String reason;
+                        String reason;
-                            reason = (p.mIsPegged) ? "Pegged" : "SDK Based";
+                        reason = (p.mIsPegged) ? "Pegged" : "SDK Based";
-                            mLogger.error("planRelease Daemon Instruction of " + reason + " package deleted: " + p.mName);
+                        mLogger.error("planRelease Daemon Instruction of {} package deleted: {}", reason, p.mName);
-                            mReleaseManager.markDaemonInstCompleted( p.mForcedRippleInstruction );
+                        mReleaseManager.markDaemonInstCompleted( p.mForcedRippleInstruction );
-                            emailRejectedDaemonInstruction("Cannot 'Ripple' a " + reason + " package",p);
+                        emailRejectedDaemonInstruction("Cannot 'Ripple' a " + reason + " package",p);
-                            p.mBuildFile = -8;
+                        p.mBuildFile = -8;
-                        }
-                        else
-                        {
-                            mLogger.info("planRelease package forced ripple " + p.mName);
-                            p.mBuildReason = BuildReason.Ripple;
-                            rippleIndirectlyPlanned(p);
-                        }
+                    }
+                }
+            }
             //  Daemon Mode Only
                     if (p.mIsPegged || p.mIsSdk)
+                    {
                         String reason;
                         reason = (p.mIsPegged) ? "Pegged" : "SDK";
-                        mLogger.info("planRelease " + reason + " not built in this release " + p.mName);
+                        mLogger.info("planRelease {} not built in this release {}", reason, p.mName);
                         p.mBuildFile = -8;
+                    }
+                }
+            }
             //  Daemon Mode Only
             //  Locate Test Build Requests that cannot be satisfied - will not be built due to
             //  errors in dependent packages. Report the error to the user and remove the request
             //
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionTest.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
-                if (p.mTestBuildInstruction > 0)
+                if (p.mBuildFile < 0)
+                {
+                    String reason;
-                    if (p.mBuildFile < 0)
+                    switch (p.mBuildFile)
+                    {
-                        String reason;
-                        switch (p.mBuildFile)
-                        {
-                        case -1: reason = "Not reproducible"; break;
+                    case -1:  reason = "Not reproducible"; break;
-                        case -2: reason = "Not reproducible on configured build platforms"; break;
+                    case -2:  reason = "Not reproducible on configured build platforms"; break;
-                        case -3: reason = "Marked as 'Do not ripple'"; break;
+                    case -3:  reason = "Marked as 'Do not ripple'"; break;
-                        case -4: reason = "Dependent on a package not in the release"; break;
+                    case -4:  reason = "Dependent on a package not in the release"; break;
-                        case -5: reason = "Indirectly dependent on a package not reproducible in the release"; break;
+                    case -5:  reason = "Indirectly dependent on a package not reproducible in the release"; break;
-                        case -6: reason = "Has a circular dependency"; break;
+                    case -6:  reason = "Has a circular dependency"; break;
-                        case -7: reason = "Pegged or SDK package not in dpkg_archive"; break;
+                    case -7:  reason = "Pegged or SDK package not in dpkg_archive"; break;
-                        case -8: reason = "Is a Pegged or SDK package"; break;
+                    case -8:  reason = "Is a Pegged or SDK package"; break;
-                        case -9: reason = "Rejected Daemon Instruction"; break;
+                    case -9:  reason = "Rejected Daemon Instruction"; break;
-                        case -10: reason = "Unbuildable package not in dpkg_archive"; break;
+                    case -10: reason = "Unbuildable package not in dpkg_archive"; break;
-                        case -11: reason = "Marked as 'RippleStop'"; break;
+                    case -11: reason = "Marked as 'RippleStop'"; break;
-                        default: reason = "Unknown reason. Code:" + p.mBuildFile; break;
+                    default:  reason = "Unknown reason. Code:" + p.mBuildFile; break;
-                        }
+                    }
-                        mLogger.error("planRelease Test Build of an unbuildable of package deleted: " + p.mName);
+                    mLogger.error("planRelease Test Build of an unbuildable of package deleted: {}", p.mName);
-                        mReleaseManager.markDaemonInstCompleted( p.mTestBuildInstruction );
+                    mReleaseManager.markDaemonInstCompleted( p.mTestBuildInstruction );
-                        emailRejectedDaemonInstruction(reason,p);
+                    emailRejectedDaemonInstruction(reason,p);
-                    }
+                }
+            }
+        }
         else
+        {
             // escrow reporting only
             // Report packages that are not reproducible
     private void planBuildOrder() throws Exception, SQLException {
         // Process remaining packages which are need to be reproduced for this baseline.
         //    Determine the build file for each package
         //    For daemon builds:
-        //      Determine the first package that can be built now, this means the first package
+        //      Determine the next package that can be built now
-        //      not dependent upon packages also to be built.
+        //          Sounds simple - doesn't it
         //      Set its mBuildNumber to 1, all remaining reproducible packages to 2
-        //      Add buildable packages to mBuildableCollection
         //    For escrow builds:
         //      Determine the package versions that can be built in the build iteration
         //      Set their mBuildNumber to the build iteration
         //      Increment the build iteration and repeat until all package versions
         //      that need to be reproduced have been assigned a build iteration
-        if ( mDaemon )
-        {
-            // Sort the build order such that the unit tests are sorted by instruction id
-            //  and placed at the head of the list. This is an attempt to have the oldest
-            //  unit tests at the head of the list.
-            //
-            //  The order of all other elements is preserved
-            //  The order of the other elements is basically
-            //      planned - ordered by modified date-time
-            //      others  - order by pv_id
-            //
-            Package.setSequence(mPackageCollection);
-            Collections.sort(mPackageCollection, Package.UnitTestComparator);
-        }
         boolean allProcessed = false;
         int buildFile = 1;
         do
+        {
+            //
+            //  Create the mBuildOrder collection
+            //      Same for both Daemon and Escrow modes
+            //      Will have package build order and build level
             boolean allDependenciesProcessed = true;
             do
+            {
-                // assume all dependencies have been processed
                 allDependenciesProcessed = true;
                 for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+                {
                     Package p = it.next();
-                    if ( (  mDaemon && ( ( !p.mDirectlyPlanned && !p.mIndirectlyPlanned ) || p.mBuildFile < 0 ) ) ||
-                         ( !mDaemon && p.mBuildFile == -2 ) )
+                    if ( p.mBuildFile < 0  )
+                    {
-                        // Daemon: Flag packages with no build requirement as processed
+                        // Daemon: Flag packages that cannot be built
                         // Escrow: Flag packages with a foreign build environment as processed
                         p.mProcessed = true;
-                        mLogger.info("planRelease package has no build requirement " + p.mName);
+                        mLogger.info("planRelease package not buildable {}", p.mName);
+                    }
-                    else if ( ( p.mBuildFile == 0 ) && ( (mDaemon && ( p.mDirectlyPlanned || p.mIndirectlyPlanned ) ) || ( !mDaemon ) ) )
+                    else if ( p.mBuildFile == 0 )
+                    {
                         // package yet to be processed and
-                        //  Daemon mode: Has a build requirement
+                        //  Daemon mode: Could be built
                         //  Escrow mode: Can be reproduced
                         boolean canBeBuiltNow = true;
                         boolean allDependenciesForThisPackageProcessed = true;
                         //  Scan the packages dependencies
                                 //  If any of them have not been processed, then cannot calculate canBeBuiltNow until this
                                 //  dependency has been processed
                                 allDependenciesForThisPackageProcessed = false;
                                 allDependenciesProcessed = false;
+                            }
-                            else if (  (  mDaemon && ( dependency.mDirectlyPlanned ) || ( dependency.mIndirectlyPlanned ) )
+                            else if (  (  mDaemon && (   dependency.mBuildFile == 0 ) )
                                     || ( !mDaemon && ( ( dependency.mBuildFile == 0 ) ||
                                                            ( dependency.mBuildFile == buildFile &&
                                                            ( !p.haveSameBuildStandards(dependency)  ) ) ) ) )
+                            {
                                 // Daemon mode:
-                                //    This processed dependency has a build requirement - so can't build
+                                //    This processed dependency has not been assigned to a build iteration - so can't built yet
                                 // Escrow mode: This package cannot be built now if
                                 //    This processed dependency has not been assigned to a build iteration or
                                 //    This processed dependency has been assigned to this build iteration, but the
                                 //    build standards of the package and this dependency prevent the package being
                                 //    built in this iteration.
                                 canBeBuiltNow = false;
-                                mLogger.info("planRelease package cannot be built in this iteration " + p.mName);
+                                mLogger.info("planRelease package cannot be built in this iteration {}", p.mName);
                                 break;
+                            }
+                        }
+                        //  All dependencies have been processed. May be able to build this package
+                        //      Add the package to the build order list
+                        //
                         if (allDependenciesForThisPackageProcessed)
+                        {
                             p.mProcessed = true;
-                            if ( mDaemon )
+                            if ( canBeBuiltNow )
+                            {
                                 mBuildOrder.add(p);
-                                if ( canBeBuiltNow )
-                                {
-                                    // flag package with build requirement, may get down graded to future build requirement
-                                    p.mBuildFile = 1;
-                                    mLogger.info("planRelease set mBuildFile to 1 for package " + p.mAlias );
-                                }
-                                else
-                                {
-                                    // flag package with future build requirement
-                                    p.mBuildFile = 2;
-                                    mLogger.info("planRelease set mBuildFile to 2 for package " + p.mAlias );
-                                }
-                            }
-                            else
-                            {
-                                // Escrow Mode
-                                if ( canBeBuiltNow )
-                                {
-                                    mBuildOrder.add(p);
-                                    p.mBuildFile = buildFile;
+                                p.mBuildFile = buildFile;
-                                    mLogger.info("planRelease set mBuildFile to " + buildFile + " for package " + p.mAlias );
+                                mLogger.info("planRelease set mBuildFile to {} for package {}",buildFile, p.mAlias );
-                                }
+                            }
+                        }
+                    }
+                }
             } while( !allDependenciesProcessed );
+            //  Have process all the packages that we can at the moment
+            //      Examine all the packages in the collection to see if there are more that need to be extracted
+            //      These will be done at a different build-level
+            //
+            allProcessed = true;
+            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            {
+                Package p = it.next();
+                if ( p.mBuildFile == 0 )
+                {
+                    // more build files are required
+                    allProcessed = false;
+                    mLogger.info("planRelease more build files are required for {}", p.mName);
+                    break;
+                }
+            }
+            buildFile++;
+            if (buildFile % 500 == 0 ) {
+                mLogger.error("planRelease. Too many build levels {}", buildFile);
+            }
+        } while( !allProcessed );
+        if ( mDaemon )
+        {
             //
             //  Daemon Mode:
-            //  Locate all packages that we would like to build and
+            //  Locate all packages that we can build now
-            //      Calculate new version - report errors
-            //      Determine a package we would like to build
+            //      Packages that have a build requirement and have no reason we cannot build them
             //
+            ArrayList<Package> buildCandidates = new ArrayList<Package>();
-            if ( mDaemon )
+            for (Iterator<Package> it = mBuildOrder.iterator(); it.hasNext(); )
+            {
+                Package p = it.next();
-                for (Iterator<Package> it = mBuildOrder.iterator(); it.hasNext(); )
+                if ( p.mProcessed && p.mBuildFile > 0 )
+                {
-                    Package p = it.next();
-                    if ( p.mProcessed && p.mBuildFile == 1 )
+                    if (p.mBuildReason != null)
+                    {
-                        p.mBuildFile = buildFile;
+                        // Have a reason to build this package
-                        mLogger.info("planRelease 2 set mBuildFile to " + buildFile + " for package " + p.mAlias );
-                        if ( buildFile == 1 )
+                        buildCandidates.add(p);
-                        {
-                            int pvApplied = p.applyPV(mReleaseManager, mBaseline);
+                        mLogger.info("planRelease Candidate {}",p.mAlias);
-                            if ( pvApplied == 1 )
-                            {
+                    }
-                                // max 50 chars
+                }
-                                rippleBuildExclude(p, p.mId, "Package has non standard versioning", null, null, true);
-                            }
+            }
-                            else if ( pvApplied == 2 )
-                            {
-                                // max 50 chars
+            //  Add in the WIPs, Tests and Ripple Requests so that we can process them as one collections
-                                rippleBuildExclude(p, p.mId, "Package has reached ripple field limitations", null, null, true);
+            //  Now have a collection of packages that we would like to build right now
-                            }
+            //  See if any of them can be excluded due to issues with creating a new package version
-                            else if ( pvApplied == 3 )
+            buildCandidates.addAll(mPackageCollectionWip);
-                            {
-                                // max 50 chars
+            buildCandidates.addAll(mPackageCollectionTest);
-                                rippleBuildExclude(p, p.mId, "Package has invalid change type", null, null, true);
+            buildCandidates.addAll(mPackageCollectionRipple);
-                            }
-                            else
+            for (Iterator<Package> it = buildCandidates.iterator(); it.hasNext(); )
-                            {
+            {
-                                //    Have found a package to build
-                                //        Prevent finding others
-                                buildFile = 2;
+                Package p = it.next();
-                                if ( p.mForcedRippleInstruction > 0 )
+                if ( p.mBuildFile >= 0 )
-                                {
+                {
-                                    mReleaseManager.markDaemonInstCompleted( p.mForcedRippleInstruction );
+                    int pvApplied = p.applyPV(mReleaseManager, mBaseline);
-                                }
-                                if ( p.mTestBuildInstruction > 0 )
+                    if ( pvApplied == 1 )
+                    {
-                                {
+                        // max 50 chars
-                                    mReleaseManager.markDaemonInstInProgress( p.mTestBuildInstruction );
+                        rippleBuildExclude(p, p.mId, "Package has non standard versioning", null, null, true);
+                    }
+                    else if ( pvApplied == 2 )
+                    {
+                        // max 50 chars
+                        rippleBuildExclude(p, p.mId, "Package has reached ripple field limitations", null, null, true);
+                    }
+                    else if ( pvApplied == 3 )
+                    {
-                                }
+                        // max 50 chars
+                        rippleBuildExclude(p, p.mId, "Package has invalid change type", null, null, true);
+                    }
+                    if ( pvApplied != 0)
+                    {
+                        // If this package is not a WIP/TEST/RIPPLE, then remove it from this collection
+                        // Want to keep all WIP/TEST/RIPPLE items to simplify deporting
+                        if (! p.mIsNotReleased )
-                            }
+                        {
+                            it.remove();
+                        }
+                    }
+                    //
+                    //  Ensure that the mRippleTime is known for each package
+                    //  Collection includes: naturalRipples, ForcedRipples, TestBuilds and NewVersions
+                    if ( pvApplied == 0)
+                    {
+                        if (p.mTestBuildInstruction != 0)
+                        {
+                            // Test Build - there is no ripple effect
+                            // The time impact will be the estimated build time of this one package
+                            p.mRippleTime = p.mBuildTime;
+                        }
                         else
+                        {
-                            mLogger.info("planRelease package has future (downgraded) build requirement " + p.mName + " " + buildFile);
+                            //  Calculate the time to build the package AND all of the packages that depend on it
+                            //  Calculate the build plan for the package
+                            //
+                            calcBuildPlan(p);
+                        }
+                    }
+                }
+            }
+            //
-            // are more build files required
+            //  Determine the NON-test package the we will build next
-            allProcessed = true;
+            //
+            Package build = ReleaseManager.NULL_PACKAGE;
-            if (mDaemon)
+            for (Iterator<Package> it = buildCandidates.iterator(); it.hasNext(); )
+            {
-                //  Recalculate mBuildOrder
-                //  Remove any packages that cannot be built due to errors encountered during
-                //  the use of applyPV()
-                //
-                ArrayList<Package> mTempBuildOrder = new ArrayList<Package>();
+                Package p = it.next();
-                //  Seed mBuildOrder with packages that were prime buildable candidates
-                //  This includes test builds
+                if ( p.mBuildFile >= 0 )
-                //      Insert the active build at the head of the list - should only be one
-                //
-                for (Iterator<Package> it = mBuildOrder.iterator(); it.hasNext(); )
+                {
-                    Package p = it.next();
-                    if(p.mBuildFile > 0)
+                    if (p.mTestBuildInstruction == 0)
+                    {
+                        //  Not a Test Build
+                        if (build == ReleaseManager.NULL_PACKAGE || p.mRippleTime < build.mRippleTime)
+                        {
-                        mTempBuildOrder.add(p);
+                            build = p;
+                        }
+                    }
+                }
-                mBuildOrder = mTempBuildOrder;
+            }
+            //  Determine the first test build package
+            //  Assume the collection is in build instruction id order,
+            //      So that the first request will be built first
+            //  Add all buildable test-builds to the mBuildOrder collection
+            Package testBuild = ReleaseManager.NULL_PACKAGE;
+            mBuildOrder.clear();
-                for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = buildCandidates.iterator(); it.hasNext(); )
+            {
+                Package p = it.next();
+                if ( p.mBuildFile >= 0 )
+                {
-                    Package p = it.next();
+                    if (p.mTestBuildInstruction != 0)
-                    if ( p.mBuildFile < 0 || ( !p.mDirectlyPlanned && !p.mIndirectlyPlanned ) )
+                    {
-                        // at this point...
+                        //  Not a Test Build
-                        // only 1 package with a build requirement has a mBuildFile of 1,
+                        if (testBuild == ReleaseManager.NULL_PACKAGE)
-                        // all other packages with a build requirement have an mBuildFile of 2
+                        {
-                        // give packages with no build requirement, reproducible or not, an mBuildFile of 3
-                        p.mNoBuildReason = p.mBuildFile;
+                            build = p;
-                        p.mBuildFile = 3;
+                        }
-                        mLogger.info("planRelease 1 set mBuildFile to 3 for package " + p.mAlias );
+                        mBuildOrder.add(p);
+                    }
+                }
+            }
-            else
+            //
+            //  Extend mBuildOrder with the selected non-test build package and its build plan
+            //  Really only for display purposes
+            //
+            if (build != ReleaseManager.NULL_PACKAGE)
+            {
-                // this is escrow mode centric
+                mBuildOrder.add(build);
+                mBuildOrder.addAll(build.mRipplePlan);
+            }
+            //
-                for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            //  Mark the first package in the build order as the one to be built
+            //  This will give test builds priority
+            //
+            if (!mBuildOrder.isEmpty()) {
+                build = mBuildOrder.get(0);
+                build.mBuildFile = 1;
+                if ( build.mForcedRippleInstruction > 0 )
+                {
+                    mReleaseManager.markDaemonInstCompleted( build.mForcedRippleInstruction );
-                    Package p = it.next();
+                }
-                    if ( p.mBuildFile == 0 )
+                if ( build.mTestBuildInstruction > 0 )
-                    {
+                {
+                    mReleaseManager.markDaemonInstInProgress( build.mTestBuildInstruction );
+                }
-                        // more build files are required
+                //  Now that we know which package we are building
-                        allProcessed = false;
+                //      Set the previously calculated nextVersion as the packages version number
-                        mLogger.info("planRelease more build files are required for " + p.mName);
+                //      Claim the version number to prevent other builds from using it. Unless doing a test build
-                        break;
+                //
+                if (build.mTestBuildInstruction == 0 && build.mNextVersion != null)
-                    }
+                {
+                    mReleaseManager.claimVersion(build.mPid, build.mNextVersion + build.mExtension, mBaseline);
+                    build.mVersion = build.mNextVersion;
+                }
+            }
+            //
+            //  To fit in with the old algorithm ( ie: could be improved )
+            //  Insert marks into all packages
+            //  Not sure exactly why - Its used in the generation of the ant build file
+            //  Want to set mNoBuildReason, mBuildFile
+            //
+            //      Package we have selected to build: 0     , 1
+            //      Package we could have built      : 2     , 3
+            //      Packages we can't build          : reason, 3
+            //      Packages that are OK             : 3     , 3
+            for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+            {
+                Package p = it.next();
+                if (p == build ) {
+                    p.mNoBuildReason = 0;
+                    p.mBuildFile = 1;
+                }
+                else if ( p.mBuildFile < 0 )
+                {
+                    p.mNoBuildReason = p.mBuildFile;
+                    p.mBuildFile = 3;
+                }
+                else if (p.mBuildReason != null)
+                {
+                    p.mNoBuildReason = 2;
+                    p.mBuildFile = 3;
+                }
+                else
+                {
+                    p.mNoBuildReason = 0;
+                    p.mBuildFile = 3;
+                }
+            }
+        }
+    }
+    /**
+     * Calculate a build plan for the specified package
+     * Calculates : mRippleTime - time to build the package and the ripple effect
+     * Calculates : mBuildPlan - collection of packages in the plan that can be built at the moment
+     *
+     * Needs to determine all packages that consume the package - and all packages that consume them
+     *  Note: The package may not be in the mPackageCollection ( it may be a WIP/TEST/RIPPLE )
+     *
+     * Need to:
+     *      Only include a package once.
+     *      Only include packages that can/need to be built at the moment
+     *
+     * @param p     - Package to process
+     */
+    private void calcBuildPlan(Package p) {
+        p.mRipplePlan = usedByPackages(p);
+        //  Use a ListIterator so that we can add elements to the end of the list while processing
+        for (ListIterator<Package> it = p.mRipplePlan.listIterator(); it.hasNext(); )
+        {
+            Package pkg = it.next();
+            ArrayList<Package> usedBy = usedByPackages(pkg);
+            for (Iterator<Package> it1 = usedBy.iterator(); it1.hasNext(); )
+            {
+                Package uPkg = it1.next();
+                if ( ! p.mRipplePlan.contains( uPkg ))
+                {
-                buildFile++;
+                    it.add(uPkg);
+                }
+            }
+        }
+        //
+        //  Now have a plan on what will be affected when we build the package
+        //  Calculate the time it will take - include my time
+        //
-        } while( !allProcessed );
+        p.mRippleTime = p.mBuildTime;
+        for (ListIterator<Package> it = p.mRipplePlan.listIterator(); it.hasNext(); )
+        {
+            Package pkg = it.next();
+            p.mRippleTime += pkg.mBuildTime;
+        }
+    }
+    /**
+     *  Calculate a collection of packages that actively use the named package
+     *  A consumer package does NOT use the named package,
+     *      If the consumer is an SDK or is Pegged
+     *      If the consumer is marked as advisoryRipple
+     *      If the consumer cannot be built
+     *
+     * @param pkg - Package to process
+     * @return A collection of packages that actively 'use' the specified package
+     */
+    private ArrayList<Package> usedByPackages(Package pkg) {
+        ArrayList<Package> usedBy = new ArrayList<Package>();
+        for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+        {
+            Package p = it.next();
+            //  Is this package 'actively used' in the current build
+            if (p.mBuildFile >= 0)
+            {
+                for (Iterator<String> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )
+                {
+                    String alias = it2.next();
+                    if ( alias == pkg.mAlias) {
+                        //  Have found a consumer of 'pkg'
+                        usedBy.add(p);
+                        break;
+                    }
+                }
+            }
+        }
+        return usedBy;
+    }
     /** Determine if a given PVID is a member of the current release.
      *  Used to determine if a package dependency is out of date
+     *
      * @param dpvId
      * @return true - specified pvid is a full member of the Release
      */
     private boolean isInRelease(Integer dpvId) {
-        boolean found = false;
+        boolean inRelease = false;
-        for ( Iterator<Integer> it4 = mReleasedPvIDCollection.iterator(); it4.hasNext(); )
+        for ( Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+        {
-            Integer pvId = it4.next();
+            Package p = it.next();
-            if ( pvId.compareTo(dpvId) == 0 )
+            if ( p.mId == dpvId )
+            {
-                found = true;
+                inRelease = ! p.mIsNotReleased;
                 break;
+            }
+        }
-        return found;
+        return inRelease;
+    }
     /**reports what change in build exceptions happens as part of planRelease
      */
             if ( !buildExclusion.isProcessed() )
+            {
                 if (buildExclusion.isImported() && ! buildExclusion.isARootCause() ) {
                     // Remove from the exclusion list
                     buildExclusion.includeToBuild(mReleaseManager, mBaseline);
-                    mLogger.error("reportChange remove unused exclusion: " + buildExclusion.info());
+                    mLogger.error("reportChange remove unused exclusion: {}", buildExclusion.info());
                 } else {
                     // Exclude and notify
                     buildExclusion.excludeFromBuild(mReleaseManager, mBaseline);
                     buildExclusion.email(this, mPackageCollection);
                     counter++;
+                }
+            }
+        }
-        mLogger.error("reportChange exclusion count: " + counter);
+        mLogger.error("reportChange exclusion count: {}", counter);
+    }
     /**reports the build plan
      */
     public void reportPlan() throws SQLException, Exception
         if (retVal == null)
+        {
             retVal = new BuildFile();
+        }
-        mLogger.debug("getNextBuildFileContent returned " + retVal.state.name() );
+        mLogger.debug("getNextBuildFileContent returned {}", retVal.state.name() );
         return retVal;
+    }
     /**collects meta data associated with the baseline
      *          mBaseline is an RTAGID
      */
     public void collectMetaData() throws SQLException, Exception
+    {
         Phase phase = new Phase("cmd");
-        mLogger.debug("collectMetaData mDaemon " + mDaemon);
+        mLogger.debug("collectMetaData mDaemon {}", mDaemon);
         try
+        {
             phase.setPhase("connect");
             mReleaseManager.connect();
+    {
         mLogger.debug("findPackage");
         Package retVal = mReleaseManager.findPackage(alias, mPackageCollection);
-        mLogger.info("findPackage returned " + retVal.mName);
+        mLogger.info("findPackage returned {}", retVal.mName);
         return retVal;
+    }
     /**
      * Sets the mBuildFile to -5 (indirectly dependent on package versions which are not reproducible)
-     * for the package and all dependent packages
+     * for the package and all dependent packages that are a part of the release set.
+     *
      * @param p             The package being excluded
      * @param rootPvId      The PVID of the package that is causing the exclusion. Null or -ve values are special
      *                      This package is the root cause, -2: Excluded by Ripple Stop
+     *
      * @param rootCause     Text message. Max 50 characters imposed by RM database
      * @param dependentToo  True: Exclude all packages that depend on the excluded package
      */
     private void rippleBuildExclude(Package p, int rootPvId, String rootCause, ListIterator<BuildExclusion> list, BuildExclusion be, boolean dependentToo )
+    {
         mLogger.debug("rippleBuildExclude");
         if ( p.mBuildFile == 0 || p.mBuildFile == 1 )
+        {
             p.mBuildFile = -5;
-            mLogger.info("rippleBuildExclude set mBuildFile to -5 for package " + p.mAlias );
+            mLogger.info("rippleBuildExclude set mBuildFile to -5 for package {}", p.mAlias );
             if ( be != null )
+            {
                 be.setProcessed();
+            }
+            }
             //  Locate ALL packages that depend on this package and exclude them too
             //  This process will be recursive
             //    Not sure that this it is efficient
-            //  Only ripple a build exclusion through for non test builds
+            //  Only ripple a build exclusion through for packages that are a part of the full release set
+            //  NewWIPs, ForcedRipples and TestBuilds will not force consumer packages to be excluded
             //
-            if ( p.mTestBuildInstruction == 0 && dependentToo)
+            if ( ! p.mIsNotReleased && dependentToo)
+            {
-                for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+                for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+                {
                     Package pkg = it.next();
                     if ( pkg != p )
+                    {
+                        }
+                    }
+                }
+            }
+        }
-        mLogger.info("rippleBuildExclude set " + p.mName + " " + p.mBuildFile);
+        mLogger.info("rippleBuildExclude set {} {}", p.mName, p.mBuildFile);
+    }
     /**Simple XML string escaping
+     *
      * @param xml		- String to escape
             //	Generate properties for each package in this build level or lower build levels
             //	The properties link the packageAlias to the PackageName and PackageVersion
             //
             //	[DEVI 54816] In escrow mode all unreproducible packages are included
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
                 if ( ( ( p.mBuildFile > 0 ) && ( p.mBuildFile <= buildFile ) ) || ( !mDaemon && p.mBuildFile == -2 ) )
+                {
+            }
             //	UTF Support
             //	Insert additional info into the build file to provide extra checking
             //
-            if ( ! ReleaseManager.mUseDatabase )
+            if ( ! mReleaseManager.mUseDatabase )
+            {
                 // UTF Support
                 // Insert per-package planning information
                 //
-                xml.addComment("mPackageCollection");
+                xml.addComment("mPackageCollectionAll");
-                for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+                for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+                {
                     Package p = it.next();
                     generatePackageInfo(xml, p);
+                }
                     for (Iterator<Package> it = mBuildOrder.iterator(); it.hasNext(); )
+                    {
                         Package p = it.next();
                         String comment =
                                 "pvid="+ p.mId +
-                                " order=" +(++order) +
+                                " order=" + (++order) +
                                 " name=\"" + p.mAlias + "\"";
                         xml.addComment(comment);
+                    }
+                }
+            }
             //
             //	Generate target rules for each package to be built within the current build file
             //
             boolean daemonHasTarget = false;
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
                 if ( p.mBuildFile > 0 && p.mBuildFile <= buildFile )
+                {
             allProcessed = true;
             if (!mDaemon)
+            {
                 // this is escrow mode centric
-                for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+                for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+                {
                     Package p = it.next();
                     if ( p.mBuildFile > buildFile )
+                    {
                         // more build files are required
                         allProcessed = false;
-                        mLogger.info("planRelease reiterating package has no build requirement " + p.mName + " " + p.mBuildFile + " " + buildFile);
+                        mLogger.info("planRelease reiterating package has no build requirement {} {} {}",p.mName, p.mBuildFile,  buildFile);
                         break;
+                    }
+                }
                 buildFile++;
             element.addProperty("abt_rtag_id", mBaseline);
             element.addProperty("abt_daemon", mReleaseManager.currentTimeMillis());
             element.makePropertyTag("abt_packagetarball", true);
             element.makePropertyTag("abt_usetestarchive", !ReleaseManager.getUseMutex());
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
                 if ( p.mBuildFile == 1 )
+                {
         target.addAttribute("name", "fullstart");
         if (buildFile == 1)
+        {
             antEcho(target, "${line.separator}" + mAnyBuildPlatforms + "${line.separator}${line.separator}");
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
                 if ( p.mBuildFile == -1 )
+                {
                     antEcho(target, "${line.separator}" + p.mAlias + "${line.separator}");
+                }
+            }
             antEcho(target, "${line.separator}" + mAssocBuildPlatforms + "${line.separator}${line.separator}");
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
                 if ( p.mBuildFile == -2 )
+                {
                     antEcho(target, "${line.separator}" + p.mAlias + "${line.separator}");
+                }
+            }
             antEcho(target, "${line.separator}" + mNotInBaseline + "${line.separator}${line.separator}");
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
                 if ( p.mBuildFile == -4 )
+                {
                     antEcho(target, "${line.separator}" + p.mAlias + "${line.separator}");
+                }
+            }
             antEcho(target, "${line.separator}" + mDependent + "${line.separator}${line.separator}");
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
                 if ( p.mBuildFile == -5 )
+                {
         //      Escrow : All packages
         //      Daemon : Just the package being built
         //
         StringAppender dependList = new StringAppender(",");
         dependList.append("fullstart");
-        for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+        for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
             if ( ( p.mBuildFile > 0 ) && ( p.mBuildFile <= buildFile ) )
+            {
         mLogger.debug("rippleIndirectlyPlanned");
         if ( !p.mIndirectlyPlanned && p.mBuildFile == 0 )
+        {
             p.mIndirectlyPlanned = true;
-            for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+            {
                 Package pkg = it.next();
                 if ( pkg != p )
+                {
+                        }
+                    }
+                }
+            }
+        }
-        mLogger.info("rippleIndirectlyPlanned set " + p.mName + " " + p.mIndirectlyPlanned);
+        mLogger.info("rippleIndirectlyPlanned set {} {}", p.mName, p.mIndirectlyPlanned);
+    }
     /**accessor method
      */
     public String getEscrowSetUp()
+    {
         mLogger.debug("getEscrowSetUp");
         String retVal = mEscrowSetup;
-        mLogger.debug("getEscrowSetUp returned " + retVal);
+        mLogger.debug("getEscrowSetUp returned {}", retVal);
         return retVal;
+    }
     /**accessor method
      */
     public String getRawData()
+    {
         mLogger.debug("getRawData");
         String retVal = mEscrowRawData;
-        mLogger.debug("getRawData returned " + retVal);
+        mLogger.debug("getRawData returned {}", retVal);
         return retVal;
+    }
     /**Get the build loc (location)
      * This is package specific and will depend on the build mode (Escrow/Daemon)
                 String info = bs.getBuildStandardText();
                 result.append(info);
+            }
+        }
-        mLogger.info("buildInfoText returned " + result);
+        mLogger.info("buildInfoText returned {}", result);
         return result.toString();
+    }
     /**prints to standard out in escrow mode only
      * <br>Prints a title and information. The title is only printed once.
                 +  "<br>Package: " + p.mAlias
                 +  "<br>Rm Ref: " + CreateUrls.generateRmUrl(getRtagId(), p.mId);
         mailBody += "<p><hr>";
-        //    Generate the list of email recipients
-        //        Transfer the daemon instruction email list into the package before use
-        p.setTestEmail();
         String target = p.emailInfoNonAntTask(this);
-        mLogger.error("emailRejectedDaemonInstruction Server: " + getMailServer());
+        mLogger.error("emailRejectedDaemonInstruction Server: {}", getMailServer());
-        mLogger.error("emailRejectedDaemonInstruction Sender: " + getMailSender());
+        mLogger.error("emailRejectedDaemonInstruction Sender: {}", getMailSender());
-        mLogger.error("emailRejectedDaemonInstruction Target: " + target);
+        mLogger.error("emailRejectedDaemonInstruction Target: {}", target);
         try
+        {
             //
-            Smtpsend.send(getMailServer(), // mailServer
+            Smtpsend.send(getMailServer(),  // mailServer
-                    getMailSender(),       // source
+                    getMailSender(),        // source
-                    target,            // target
+                    target,                 // target
-                    getMailSender(),       // cc
+                    getMailSender(),        // cc
-                    null,              // bcc
+                    null,                   // bcc
-                    subject,           // subject
+                    subject,                // subject
-                    mailBody,          // body
+                    mailBody,               // body
-                    null               // attachment
+                    null                    // attachment
                     );
         } catch (Exception e)
+        {
-            mLogger.warn("Email Failure: emailRejectedDaemonInstruction:" + e.getMessage());
+            mLogger.warn("Email Failure: emailRejectedDaemonInstruction:{}", e.getMessage());
+        }
+    }
     /**
      * @return the mMailServer

Subversion Repositories DevTools

(root)/buildtool/branches/planMetrics/src/main/java/com/erggroup/buildtool/ripple/RippleEngine.java – Rev 7047 → 7048