WebSVN – DevTools – Diff – //buildtool/trunk/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;
     /** List of packages that we plan to build
      * Used to provide feedback into RM
      * Only the first entry is about to be built as we re-plan every cycle
      */
-    private ArrayList<Package> mBuildOrder = new ArrayList  <Package>();
+    private ArrayList<PlannedPackage> mBuildOrder = new ArrayList  <PlannedPackage>();
     /**Warning message
      * @attribute
      */
     private static final String mAnyBuildPlatforms = "Warning. The following package versions are not reproducible on any build platform: ";
+    {
         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");
      * @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
+                    mLogger.error("planRelease Daemon Instruction (testBuild) of {} package deleted: {}", reason, p.mAlias);
-                        //        Remove the test build request from the database
+                    mReleaseManager.markDaemonInstCompleted( p.mTestBuildInstruction );
-                        //        Send a warning email
+                    emailRejectedDaemonInstruction("Cannot 'Test Build' a " + reason + " package",p);
-                        //
-                        if(p.mIsPegged || p.mIsSdk)
-                        {
+                }
-                            String reason;
-                            reason = (p.mIsPegged) ? "Pegged" : "SDK Based";
                             mLogger.error("planRelease Daemon Instruction of {} package deleted: {}", reason, p.mName);
                             mReleaseManager.markDaemonInstCompleted( p.mTestBuildInstruction );
                             emailRejectedDaemonInstruction("Cannot 'Test Build' a " + reason + " package",p);
+                        }
+            }
+        }
         // 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 ) )
+            if ( p.hasCircularDependency( mPackageCollectionAll ) )
+            {
                 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
+                // Exclude the package
                 // max 50 chars
-                rippleBuildExclude(p, p.mId, "Package has circular dependency", null, null, true);
+                rippleBuildExclude(p, p.mId, "Package has circular dependency", -6);
                 // take the package out of the build
                 p.mBuildFile = -6;
                 mLogger.info("planRelease set mBuildFile to -6 for package {}", p.mAlias );
                 standardOut(mCircularDependency, p.mAlias, mCircularDependencyFlag);
+            }
+        }
         // 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 )
+            {
                 if (dependency == ReleaseManager.NULL_PACKAGE)
+                {
                     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);
+                    rippleBuildExclude(p, p.mId, "Package build dependency not in the release", -4);
                     // take the package out of the build
                     p.mBuildFile = -4;
                     mLogger.info("planRelease set mBuildFile to -4 for package {}", p.mAlias );
                     standardOut(mNotInBaseline, p.mAlias, mNotInBaselineFlag);
                     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);
                     // max 50 chars
-                    rippleBuildExclude(p, p.mId, "Package has no build environment", null, null, true);
+                    rippleBuildExclude(p, p.mId, "Package has no build environment", -1);
                     // package is not reproducible, discard
                     p.mBuildFile = -1;
                     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
         //
         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)
+            {
                 if ( !reproduce )
+                {
                     mLogger.info("planRelease package not reproducible on the build platforms configured for this baseline {}", p.mName);
-                    if (mDaemon)
-                    {
-                        // DEVI 54816
+                    // Exclude the package
-                        // 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", -2);
-                    }
                     // 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 );
                     standardOut(mAssocBuildPlatforms, p.mAlias, mAssocBuildPlatformsFlag);
                     mAssocBuildPlatformsFlag = false;
+                }
+            }
+        }
-        if (mDaemon)
+        if (mDaemon )
+        {
-            // Daemon Mode Only
-            // Process packages which are not ripple buildable, and all packages dependent upon them
-            mLogger.debug("planRelease process packages which are not ripple buildable");
-            for (ListIterator<BuildExclusion> it = mBuildExclusionCollection.listIterator(); it.hasNext(); )
-            {
-                BuildExclusion be = it.next();
                 for (Iterator<Package> it1 = mPackageCollection.iterator(); it1.hasNext(); )
+                {
                     Package p = it1.next();
                     if (p.mIsPegged || p.mIsSdk)
+                    {
                         continue;
+                    }
-                    // package has yet to be processed
+                    //    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();
-                    if (p.mDirectlyPlanned)
+                    while ( it2.hasNext() && it3.hasNext() )
+                    {
                         // a WIP exists on the package, or it is a Test Build
                         // exclude all dependent package versions
                         mLogger.info("planRelease package has WIP {}", p.mName);
                         if ( p.mBuildReason == null)
                         //    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();
+                            // not advisory, ie: has ripple build impact
-                            Package dependency = it3.next();
-                            if ( !dependency.mAdvisoryRipple )
+                            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
                                     // exclude all dependent package versions
                                     mLogger.info("planRelease package out of date {}", p.mName);
                                     p.mBuildReason = BuildReason.Ripple;
                                             // Need to flag to users that the package build is waiting user action
                                             mLogger.info("planRelease Ripple Required. Stopped by flag {}", p.mName);
                                             mReleaseManager.setRippleStopWait(mRtagId,p);
+                                        }
+                                    }
-                                    break;
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+                                {
                                     //  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);
                                     // max 50 chars
-                                    rippleBuildExclude(p, p.mId, "Unbuildable" + " package not found in archive", null, null, true);
+                                    rippleBuildExclude(p, p.mId, "Unbuildable" + " package not found in archive", -10);
-                                    // package is unBuildable, mark reason and discard
-                                    p.mBuildFile = -10;
+                                }
                                 //  Not interested in a pegged package or a package provided from an SDK.
                                 //  Such packages are not rippled
                                 else if (p.mIsPegged || p.mIsSdk)
                                     //  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 {} package not found in archive {}", reason, p.mName);
                                     // max 50 chars
-                                    rippleBuildExclude(p, p.mId, reason + " package not found in archive", null, null, true);
+                                    rippleBuildExclude(p, p.mId, reason + " package not found in archive", -7);
-                                    // package is not reproducible, mark reason and discard
-                                    p.mBuildFile = -7;
+                                }
                                 else if (p.mForcedRippleInstruction == 0)
+                                {
                                     //  [JATS-331] Unable to rebuild package with Advisory Ripple dependencies
                                     //    Examine this packages dependencies
                                             // 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 due to {}", p.mName);
                                             // max 50 chars
-                                            rippleBuildExclude(p, p.mId, "Package cannot be rebuilt in this release", null, null, true);
+                                            rippleBuildExclude(p, p.mId, "Package cannot be rebuilt in this release", -4);
-                                            // package is not reproducible, mark reason and discard
-                                            p.mBuildFile = -4;
                                             break;
+                                        }
+                                    }
                                     //  The package has not been excluded from the build
+                    }
+                }
+            }
             //  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 {} package deleted: {}", reason, p.mName);
                             mReleaseManager.markDaemonInstCompleted( p.mForcedRippleInstruction );
                             emailRejectedDaemonInstruction("Cannot 'Ripple' a " + reason + " package",p);
+                }
+            }
             //  Daemon Mode Only
             //  Mark Pegged and SDK packages as not to be built
+            //  Mark RippleStoped packages as not to be build
             //  Have previously detected conflicts between pegged/sdk packages and daemon instructions
             //
             mLogger.debug("planRelease remove pegged and SDK packages from the build set");
             for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
                 if (p.mBuildFile == 0)
+                {
+                    String reason = null;
-                    //  Not interested in a pegged package or a package provided from an SDK.
+                    //  Not interested in a pegged package or a package provided from an SDK or packages with an active RippleStop
                     //  Such packages are not built
                     if (p.mIsPegged || p.mIsSdk)
+                    {
                         String reason;
                         reason = (p.mIsPegged) ? "Pegged" : "SDK";
                         mLogger.info("planRelease {} not built in this release {}", reason, p.mName);
                         p.mBuildFile = -8;
+                    } else if (p.mIsSdk) {
+                        reason = "SDK";
+                        p.mBuildFile = -8;
+                    } else if (p.mRippleStop == 's' || p.mRippleStop == 'w') {
+                        reason = "RippleStop";
+                        p.mBuildFile = -11;
+                    }
+                    if (reason != null)
+                    {
+                        mLogger.info("planRelease {} not built in this release {}", reason, p.mName);
+                    }
+                }
+            }
             //  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 = mPackageCollectionTest.iterator(); it.hasNext(); )
+            {
+                Package p = it.next();
+                if (p.mBuildFile < 0)
+                {
+                    String reason;
+                    switch (p.mBuildFile)
+                    {
+                    case -1:  reason = "Not reproducible"; break;
+                    case -2:  reason = "Not reproducible on configured build platforms"; break;
+                    case -3:  reason = "Marked as 'Do not ripple'"; 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 -6:  reason = "Has a circular dependency"; break;
+                    case -7:  reason = "Pegged or SDK package not in dpkg_archive"; break;
+                    case -8:  reason = "Is a Pegged or SDK package"; break;
+                    case -9:  reason = "Rejected Daemon Instruction"; break;
+                    case -10: reason = "Unbuildable package not in dpkg_archive"; break;
+                    case -11: reason = "Marked as 'RippleStop'"; break;
+                    default:  reason = "Unknown reason. Code:" + p.mBuildFile; break;
+                    }
+                    mLogger.error("planRelease Test Build of an unbuildable of package deleted: {}", p.mName);
+                    mReleaseManager.markDaemonInstCompleted( p.mTestBuildInstruction );
+                    emailRejectedDaemonInstruction(reason,p);
+                }
+            }
+            //  Daemon Mode Only
+            //  Examine the build candidates and verify that a new version number can be calculated for each
+            //  version that we need to build.
+            //
+            //  If we can't generate a new version number, then this is considered to be a build failure
+            //  The package will be excluded and the user will be emailed
+            //
+            ArrayList<Package> testVersions = new ArrayList<Package>();
+            testVersions.addAll(mPackageCollectionWip);
+            testVersions.addAll(mPackageCollectionRipple);
+            testVersions.addAll(mPackageCollectionTest);
             for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
+                if (p.mBuildFile >= 0 &&  p.mBuildReason != null) {
+                    testVersions.add(p);
+                }
+            }
+            for (Iterator<Package> it = testVersions.iterator(); it.hasNext(); )
+            {
+                Package p = it.next();
-                if (p.mTestBuildInstruction > 0)
+                if ( p.mBuildFile >= 0 )
+                {
+                    int pvApplied = p.applyPV(mReleaseManager);
-                    if (p.mBuildFile < 0)
+                    if ( pvApplied == 1 )
+                    {
                         String reason;
                         switch (p.mBuildFile)
+                        {
                         case -1: reason = "Not reproducible"; break;
+                        }
                         mLogger.error("planRelease Test Build of an unbuildable of package deleted: {}", p.mName);
                         mReleaseManager.markDaemonInstCompleted( p.mTestBuildInstruction );
                         emailRejectedDaemonInstruction(reason,p);
+                    }
+                    else if ( pvApplied == 2 )
+                    {
+                        // max 50 chars
+                        rippleBuildExclude(p, p.mId, "Package has reached ripple field limitations", -5);
+                    }
+                    else if ( pvApplied == 3 )
+                    {
+                        // max 50 chars
+                        rippleBuildExclude(p, p.mId, "Package has invalid change type", -5);
+                    }
+                }
+            }
+        }
         else
+        {
             // escrow reporting only
             // Report packages that are not reproducible
                     mDependentFlag = false;
+                }
+            }
+        }
+    }
     /** Plan the build order.
-     *  Assumes that a great deal of work has been done.
+         *  Assumes that a great deal of work has been done.
-     *  This is a stand alone method to contain the work
+         *  This is a stand alone method to contain the work
-     *
+         *
-     * @throws Exception
+         * @throws Exception
-     * @throws SQLException
+         * @throws SQLException
+         */
+        private void planBuildOrder() throws Exception, SQLException
+        {
+    //TODO - Planning is not working well
+    /**
+     * Current status
+     * The selection of the package to build next is deeply flawed
+     * Currently it will select a directly planned package over a ripple - (perhaps that is good)
+     *
+     * Currently on the buildPlan of the 'selected' package is included in the BuildOrder
+     *
+     * The current algorithm is based on time - but all packages have zero build time ( in UTF )
+     * Even if this is fixed the algorithm is broken as we will select the complete build with the shortest time
+     * which will be the ripple of a leaf package ( perhaps that is good )
+     *
+     * Also:
+     *      [Done] Need to include all packages that we can now build into the final build plan, not just the first one and its build tree
+     *
+     *      [Done-ish]Need to generate a single package set - so that WIPS and others replace those in the final build set
+     *      [Done]Remove duplicates from the complete package set
+     *
+     *      [Being Done] Need more test cases
+     *
+     *      [Done, in the UTF] Need to report all build options, not just the selected one
+     *                         Data to RM may need some more info
+     *
+     *      Cleanup the ANT build file - don't list all the release dependencies, just those needed to build the current package
+     *      Chances are - all we need is the new package version number
+     *
+     *      [Fixed] If a WIP on a package that has circular dependencies is added, then the WIP will be excluded. This prevents the problem being fixed.
+     *              Should not exclude a WIP of a package with a circular dependency
+     */
+            // Process remaining packages which are need to be reproduced for this baseline.
+            //    Determine the build file for each package
+            //    For daemon builds:
+            //      Determine the next package that can be built now
+            //          Sounds simple - doesn't it
+            //      Set its mBuildNumber to 1, all remaining reproducible packages to 2
+            //    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
+            //
+            //  Generate a plan for the packages that are in the current release
+            //  These may be the result of a ripple going through the system
+            //  or a rebuild of a missing package or the result of a merge.
+            //
+            //  This will provide our basic plan, before we consider adding new packages to the
+            //  mix, such as those from user WIPS and RIPPLE requests.
+            //
+            PlanResults basicPlan = planCollection("Basic", mPackageCollection, true);
+            //  Have not considered any of the WIP or RIPPLE packages
+            //  If any of them are in the basic plan, then we can ignore them as we will build them
+            //  when we build the basic plan
+            //
+            //  Determine a set of packages that will not be included if we build the basic plan
+            //
+            //  At the moment - lets assume there are none
+            //  What do we do ?
+            //      Select the first request
+            //      Replace the package in the released collection
+            //      Run the plan algorithm
+            //      Restore the release collection
+            //
+            if ( mDaemon )
+            {
+                //
+                //  Need to consider the TEST requests
+                //      - Valid requests will be placed first on the build order
+                //
+                mBuildOrder.clear();
+                for (Iterator<Package> it = mPackageCollectionTest.iterator(); it.hasNext(); )
+                {
+                    Package p = it.next();
+                    if (p.mBuildFile >= 0)
+                    {
+                        mBuildOrder.add( new PlannedPackage(p,0 ) );
+                    }
+                }
+                //  First attempt
+                //  Insert all the WIPs and RIPPLES into the buildset.
+                //  Generate a plan and see how much the time is extended.
+                //
+                //  Don't modify mPackageCollection, although data in the 'Package' in the underlying packages may change
+                PlanResults fullPlan = postRipplePlan("Full", basicPlan, true);
+                //  Decide with plan to use
+                //  At the moment we have, at most two.
+                //      - (basic) Current Release ripples
+                //      - (full) Current Release + All WIPS and RIPPLES
+                //
+                //  If we have both then if the full plan is < 20% longer than the basic plan, use the full plan
+                //  Otherwise we use basic plan FOLLOWED by the a MODIFIED full plan (one without the natural ripples)
+                //  Add the planned packages into the buildOrder
+                if( !basicPlan.planCollection.isEmpty() && !fullPlan.planCollection.isEmpty() )
+                {
+                    mLogger.info("Two plan selection: {} {}, {} <= {}", basicPlan.planTime,fullPlan.planTime, basicPlan.planTime * 12, fullPlan.planTime * 10);
+                    if ( (basicPlan.planTime * 12) <= (fullPlan.planTime * 10) )
+                    {
+                        //  Use the basic plan FOLLOWED by a plan that does not include
+                        //      Ripples done by the basic plan
+                        //      WIPs/RIPPLES done in the course of doing the basic plan
+                        mBuildOrder.addAll(basicPlan.planCollection);
+                        fullPlan = postRipplePlan("Full-Ripples", basicPlan, false);
+                        mBuildOrder.addAll(fullPlan.planCollection);
+                    } else {
+                        //  Use the full plan
+                        mBuildOrder.addAll(fullPlan.planCollection);
+                    }
+                } else if (!basicPlan.planCollection.isEmpty() ) {
+                    // Use the basic plan
+                    mBuildOrder.addAll(basicPlan.planCollection);
+                } else if ( !fullPlan.planCollection.isEmpty() ) {
+                    // Use the full plan
+                    mBuildOrder.addAll(fullPlan.planCollection);
+                } else {
+                    // Do not have a plan
+                    // May have tests requests
+                }
+                //  Now have an mBuildOrder
+                //  Mark the first package in the build order as the one to be built
+                //
+                Package build = ReleaseManager.NULL_PACKAGE;
+                if (!mBuildOrder.isEmpty()) {
+                    build = mBuildOrder.get(0).mPkg;
+                    build.mBuildFile = 1;
+                    if ( build.mForcedRippleInstruction > 0 )
+                    {
+                        mReleaseManager.markDaemonInstCompleted( build.mForcedRippleInstruction );
+                    }
+                    if ( build.mTestBuildInstruction > 0 )
+                    {
+                        mReleaseManager.markDaemonInstInProgress( build.mTestBuildInstruction );
+                    }
+                    //  Now that we know which package we are building
+                    //      Set the previously calculated nextVersion as the packages version number
+                    //      Claim the version number to prevent other builds from using it. Even if doing a test build
+                    //
+                    if (build.mNextVersion != null)
+                    {
+                        mReleaseManager.claimVersion(build.mPid, build.mNextVersion + build.mExtension, mBaseline);
+                        build.mVersion = build.mNextVersion;
+                    }
+                }
+                //
+                //  Massage the package collection
+                //      Replace WIP/TEST/RIPPLE so that the mPackageCollection is a collection of packages we would like in the release
+                //      Don't replace those that we can't build due to errors
+                //
+                //         Update packages in the basicPlan
+                //         Update / Add packages to the fullPlan
+                //
+                ArrayList<Package> buildCandidates = new ArrayList<Package>();
+                buildCandidates.addAll(mPackageCollectionTest);
+                buildCandidates.addAll(mPackageCollectionWip);
+                buildCandidates.addAll(mPackageCollectionRipple);
+                for (Iterator<Package> it = buildCandidates.iterator(); it.hasNext(); )
+                {
+                    Package p = it.next();
+                    if ( p.mBuildFile >= 0 )
+                    {
+                        Package pReleased = findPackage(p.mAlias);
+                        if ( pReleased != ReleaseManager.NULL_PACKAGE)
+                        {
+                            int index = mReleaseManager.findPackageLastIndex;
+                            mPackageCollection.set(index, p);
+                            p.mIsNotReleased = false;
+                        }
+                        else
+                        {
+                            mPackageCollection.add(p);
+                            p.mIsNotReleased = false;
+                        }
+                    }
+                }
+                //
+                //  Report packages that are indirectly excluded
+                //  ie: They will not be built because one, or more, of there dependents is not buildable
+                //
+                mLogger.debug("planBuildOrder process packages which are not ripple buildable");
+                 for (ListIterator<BuildExclusion> it = mBuildExclusionCollection.listIterator(); it.hasNext(); )
+                 {
+                     BuildExclusion be = it.next();
+                     for (Iterator<Package> it1 = mPackageCollection.iterator(); it1.hasNext(); )
+                     {
+                         Package p = it1.next();
+                         // ensure only root cause, non test build, build exclusions are excluded
+                         // 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 it and its consumers
+                             //
+                             mLogger.info("Excluded Package {}, {}", p.mAlias, be );
+                             ArrayList<Package> toExclude = new ArrayList<Package>();
+                             toExclude.addAll(usedByAnyPackages(p, mPackageCollection ));
+                             //  Process packages that we need to exclude indirectly
+                             //
+                             while ( ! toExclude.isEmpty())
+                             {
+                                 Package pkg = toExclude.remove(0);
+                                 // If this package has not been excluded (for whatever reason), than add it
+                                 boolean found = false;
+                                 for (Iterator<BuildExclusion> it2 = mBuildExclusionCollection.iterator(); it2.hasNext(); )
+                                 {
+                                     BuildExclusion buildExclusion = it2.next();
+                                     if (buildExclusion.compare(pkg.mId) )
+                                     {
+                                         found = true;
+                                         if  ( buildExclusion.isImported() )
+                                         {
+                                             // An exclusion for this package already exists
+                                             // If it was 'imported' from the database then
+                                             // mark it as processed so that it will be persisted
+                                             //
+                                             // Otherwise it will be a new one
+                                             //
+                                             buildExclusion.setProcessed();
+                                         }
+                                         break;
+                                     }
+                                 }
+                                 if (!found)
+                                 {
+                                     BuildExclusion buildExclusion = new BuildExclusion(pkg.mId, p.mId, null, p.mTestBuildInstruction);
+                                     it.add(buildExclusion);
+                                     mLogger.info("Indirectly Excluded Package {}", pkg.mAlias);
+                                     ArrayList<Package> usedBy = usedByAnyPackages(p, mPackageCollectionAll );
+                                     toExclude.addAll(usedBy);
+                                 }
+                             }
+                         }
+                     }
+                 }
+                //
+                //  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      : 0     , 2
+                //      Packages we can't build          : reason, 3
+                //      Packages that are OK             : 3     , 3
+                //      ????                             : 0     , 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 = 0;
+                        p.mBuildFile = 2;
+                    }
+                    else
+                    {
+                        p.mNoBuildReason = 0;
+                        p.mBuildFile = 3;
+                    }
+                }
+            }
+            else
+            {
+                //  Escrow
+                //  The basic plan is the escrow build order
+                mBuildOrder = basicPlan.planCollection;
+            }
+            mLogger.error("Final Plan");
+            for (Iterator<PlannedPackage> it = mBuildOrder.iterator(); it.hasNext(); )
+            {
+                PlannedPackage p = it.next();
+                mLogger.error("Plan: {} {} {}", p.mBuildLevel, p.mPkg.mAlias, p.mPkg.mId);
+            }
+        }
+    /** Internal class to contain intermediate results
      */
+    class PlanResults {
+        int planTime = 0;
+        ArrayList<PlannedPackage> planCollection = new ArrayList<PlannedPackage>();
+    }
+    /**
+     * Process a collection of packages and generate a collection of package plans
-    private void planBuildOrder() throws Exception, SQLException {
+     * A package plan is a collection of packages that can be built
+     *      The first item in the list is a package that can be built right now
+     *      Other items in the list will be packages that can be built now or will need to be built as the result
+     *      of a ripple
+     *
+     * The method will be called multiple times so that we can evaluate different plans
+     * The underling packages will have data and flags that will need to be rested before a calculation
+     *
+     * @param name - Name of the plan
+     * @param packageCollection - Base collection of packages to plan
+     * @param mode - true: Include 'Ripples'
+     *
+     * @return
+     */
+    private PlanResults planCollection(String name, ArrayList<Package> packageCollection, boolean mode)
+    {
+        ArrayList<PlannedPackage> ripplePlan = new ArrayList<PlannedPackage>();
+        PlanResults results = new PlanResults();
-        // Process remaining packages which are need to be reproduced for this baseline.
-        //    Determine the build file for each package
+        //  Reset flags used in the calculations
-        //    For daemon builds:
-        //      Determine the first package that can be built now, this means the first package
-        //      not dependent upon packages also to be built.
-        //      Set its mBuildNumber to 1, all remaining reproducible packages to 2
-        //      Add buildable packages to mBuildableCollection
+        Package.resetProcessed(packageCollection);
-        //    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
+        //  Exclude all packages that cannot be built and all packages that depend on them
-        if ( mDaemon )
+        //      First find packages to be directly excluded
+        ArrayList<Package>exclude = new ArrayList<Package>();
+        for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
+        {
+            Package p = it.next();
+            if ( p.mBuildFile == -8 ) {
-            // Sort the build order such that the unit tests are sorted by instruction id
+                //  Mark SDK or Pegged so that we don't build them, but can build their dependents
+                p.mProcessed = true;
+                p.mIsProcessed = true;
+                mLogger.error("SDK/Peg Exclude: {}", p);
+            } else if (p.mBuildFile < 0 ) {
+                exclude.add(p);
+                mLogger.error("Direct Exclude: {}", p);
+            }
+        }
-            //  and placed at the head of the list. This is an attempt to have the oldest
+        //  Exclude packages that have failed to be built
+        //      These are recorded in mBuildExclusionCollection
+        for (ListIterator<BuildExclusion> it = mBuildExclusionCollection.listIterator(); it.hasNext(); )
+        {
-            //  unit tests at the head of the list.
+            BuildExclusion be = it.next();
+            if ( be.isABuildError() )
-            //
+            {
+                for (Iterator<Package> it1 = packageCollection.iterator(); it1.hasNext(); )
+                {
-            //  The order of all other elements is preserved
+                    Package p = it1.next();
-            //  The order of the other elements is basically
+                    if (p.mBuildFile >= 0 && p.mId == be.mId) {
-            //      planned - ordered by modified date-time
+                        p.mBuildFile  = -3;
-            //      others  - order by pv_id
+                        exclude.add(p);
+                        break;
+                    }
+                }
-            //
+            }
+        }
+        //  Process the list of packages to be excluded
+        //  Add to the list packages that depend on the excluded package that have not already been excluded
+        while( !exclude.isEmpty() )
+        {
-            Package.setSequence(mPackageCollection);
+            Package p = exclude.remove(0);
+            p.mProcessed = true;
+            p.mIsProcessed = true;
-            Collections.sort(mPackageCollection, Package.UnitTestComparator);
+            mLogger.error("planCollection package not buildable {}", p.mName);
+            for (Iterator<Package> it1 = packageCollection.iterator(); it1.hasNext(); )
+            {
+                Package pkg = it1.next();
+                if (pkg.mProcessed) {
+                    continue;
+                }
+                for (Iterator<String> it = pkg.mDependencyCollection.iterator(); it.hasNext(); )
+                {
+                    String alias = it.next();
+                    if ( p.mAlias.compareTo( alias ) == 0 ) {
+                        exclude.add(pkg);
+                    }
+                }
+            }
+        }
+        //  Now have a collection of packages with those that we cannot build have been marked
+        //  Process the list and determine packages that we can build right now
+        //      ie: they have not been excluded, have not already been discovered and do not depend on any package in the collection
+        //      Continue to do this until all packages have been extracted
+        //      Allocate build levels as we go
+        //
         boolean allProcessed = false;
-        int buildFile = 1;
+        int buildLevel = 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(); )
+                for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
+                {
                     Package p = it.next();
+                    //  Skip packages that have been processed - have determined build order, or cannot build
+                    if (p.mIsProcessed) {
+                        continue;
+                    }
-                    if ( (  mDaemon && ( ( !p.mDirectlyPlanned && !p.mIndirectlyPlanned ) || p.mBuildFile < 0 ) ) ||
+                    // Package yet to be processed and
-                         ( !mDaemon && p.mBuildFile == -2 ) )
+                    //      Daemon mode: Could be built
+                    //      Escrow mode: Can be reproduced
+                    boolean canBeBuiltNow = true;
+                    boolean allDependenciesForThisPackageProcessed = true;
+                    //  Scan the packages dependencies
+                    for ( Iterator<Package> it2 = p.mPackageDependencyCollection.iterator(); it2.hasNext(); )
+                    {
                         // Daemon: Flag packages with no build requirement as processed
                         // Escrow: Flag packages with a foreign build environment as processed
                         p.mProcessed = true;
                         mLogger.info("planRelease package has no build requirement {}", p.mName);
                         //  Daemon mode: Has a build requirement
                         //  Escrow mode: Can be reproduced
                         boolean canBeBuiltNow = true;
                         boolean allDependenciesForThisPackageProcessed = true;
-                        //  Scan the packages dependencies
+                        if ( !dependency.mProcessed )
-                        for ( Iterator<Package> it2 = p.mPackageDependencyCollection.iterator(); it2.hasNext(); )
+                        {
                             Package dependency = it2.next();
                             if ( !dependency.mProcessed )
+                            {
                                 canBeBuiltNow = false;
                                 mLogger.info("planRelease package cannot be built in this iteration {}", p.mName);
                                 break;
+                            }
+                        }
+                        else if (  (  mDaemon && (   dependency.mBuildFile == 0 ) ||  (dependency.mBuildFile == buildLevel))
+                                || ( !mDaemon && ( ( dependency.mBuildFile == 0 ) ||
+                                                       ( dependency.mBuildFile == buildLevel &&
+                                                       ( !p.haveSameBuildStandards(dependency)  ) ) ) ) )
+                        {
+                            // Can be built - yet
+                            // Daemon mode:
+                            //    This processed dependency has not been assigned to a build iteration
+                            //    This processed dependency has been assigned to this build iteration
+                            // 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);
+                            break;
+                        }
+                    }
+                    //  All dependencies have been processed. May be able to build this package
+                    //      Add the package to the build order list
+                    //
-                        if (allDependenciesForThisPackageProcessed)
+                    if (allDependenciesForThisPackageProcessed)
+                    {
+                        p.mProcessed = true;
+                        if ( canBeBuiltNow )
+                        {
                             p.mProcessed = true;
                             if ( mDaemon )
+                            {
+                            }
+                        }
+                    }
+                }
             } while( !allDependenciesProcessed );
-            //
-            //  Daemon Mode:
-            //  Locate all packages that we would like to build and
+            //  Have process all the packages that we can at the moment
-            //      Calculate new version - report errors
+            //      Examine all the packages in the collection to see if there are more that need to be extracted
-            //      Determine a package we would like to build
+            //      These will be done at a different build-level
             //
-            if ( mDaemon )
+            allProcessed = true;
+            for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
+            {
-                for (Iterator<Package> it = mBuildOrder.iterator(); it.hasNext(); )
+                Package p = it.next();
+                if ( !  p.mIsProcessed )
+                {
+                    // more build files are required
-                    Package p = it.next();
+                    allProcessed = false;
+                    mLogger.info("planRelease more build files are required for {}", p.mName);
+                    break;
+                }
+            }
+            buildLevel++;
+            if (buildLevel % 500 == 0 ) {
+                mLogger.error("planRelease. Too many build levels {}", buildLevel);
+            }
+        } while( !allProcessed );
+        //  Now we have a collection packages that we can build right now
+        //      The packages currently have a build level set into mBuildFile
+        //
+        if (mDaemon)
+        {
+            //  Determine if we have a reason to build anything in this collection of buildable packages
+            //  Reset the calculated buildLevel - It will be calculated again
+            //
+            ArrayList<PlannedPackage> toBuild = new ArrayList<PlannedPackage>();
+            for (Iterator<PlannedPackage> it = results.planCollection.iterator(); it.hasNext(); )
+            {
+                PlannedPackage p = it.next();
+                p.mBuildLevel = 0;
-                    if ( p.mProcessed && p.mBuildFile == 1 )
+                if (p.mPkg.mBuildReason != null) {
+                    if (mode || ( !mode && p.mPkg.mBuildReason != BuildReason.Ripple ))
+                    {
                         p.mBuildFile = buildFile;
                         mLogger.info("planRelease 2 set mBuildFile to {} for package {}", buildFile, p.mAlias );
                         if ( buildFile == 1 )
                             mLogger.info("planRelease package has future (downgraded) build requirement {} {}", p.mName, buildFile);
+                        }
+                    }
+                }
+            }
-            // are more build files required
+            //  Need (would like to) build stuff
+            //  Determine the packages that we need to build and the time that it will take
-            allProcessed = true;
+            //
-            if (mDaemon)
+            if ( !toBuild.isEmpty() )
+            {
-                //  Recalculate mBuildOrder
+                results.planTime = 0;
-                //  Remove any packages that cannot be built due to errors encountered during
-                //  the use of applyPV()
-                //
-                ArrayList<Package> mTempBuildOrder = new ArrayList<Package>();
+                //  Need to add elements to the end of the list while processing
-                //  Seed mBuildOrder with packages that were prime buildable candidates
+                //  Sum the buildTimes of the packages that we add to the list
-                //  This includes test builds
+                while ( ! toBuild.isEmpty())
-                //      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();
+                    PlannedPackage pkg = toBuild.remove(0);
-                    if(p.mBuildFile > 0)
+                    if (pkg.mBuildLevel > 100 ) {
+                        mLogger.error("Circular dependency detected - not handled well");
+                        break;
+                    }
+                    if ( ! ripplePlan.contains( pkg ))
+                    {
-                        mTempBuildOrder.add(p);
+                        ripplePlan.add(pkg);
+                        results.planTime += pkg.mPkg.mBuildTime;
+                    }
+                    ArrayList<PlannedPackage> usedBy = usedByPackages(pkg, results.planCollection, pkg.mBuildLevel + 1);
+                    toBuild.addAll(usedBy);
+                }
-                mBuildOrder = mTempBuildOrder;
+                //  Sort the packages by buildOrder and buildTime
+                Collections.sort(ripplePlan, PlannedPackage.BuildOrderComparitor);
+                mLogger.info("Plan Build {} Time: {}", name, results.planTime);
-                for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+                for (Iterator<PlannedPackage> it = ripplePlan.iterator(); it.hasNext(); )
+                {
-                    Package p = it.next();
+                    PlannedPackage p = it.next();
+                    mLogger.info("Plan: {} {}", p.mBuildLevel, p.mPkg.mAlias);
+                }
+            }
+            //  Daemon mode: Returning calculated plan
+            results.planCollection = ripplePlan;
+        }
+        return results;
+    }
+    /** Generate a plan based on a modified set of packages
+     *
+     * @param name      - Name of the plan
+     * @param basicPlan - basicPlan
+     * @param mode      - True: Include natural ripples and WIPS/RIPPLES that would have been done
-                    if ( p.mBuildFile < 0 || ( !p.mDirectlyPlanned && !p.mIndirectlyPlanned ) )
+     *                          as a part of the basic plan
+     * @return
+     */
+    private PlanResults postRipplePlan(String name, PlanResults basicPlan, boolean mode) {
+        ArrayList<Package> fullPlanCollection = new ArrayList<Package>(mPackageCollection);
+        ArrayList<Package> buildCandidates = new ArrayList<Package>();
+        buildCandidates.addAll(mPackageCollectionWip);
+        buildCandidates.addAll(mPackageCollectionRipple);
+        if ( !buildCandidates.isEmpty() )
+        {
+            for (Iterator<Package> it = buildCandidates.iterator(); it.hasNext(); )
+            {
+                Package p = it.next();
+                if (p.mBuildFile >= 0)
+                {
+                    if (!mode)
+                    {
                         // at this point...
                         // only 1 package with a build requirement has a mBuildFile of 1,
                         // 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;
                         p.mBuildFile = 3;
                         mLogger.info("planRelease 1 set mBuildFile to 3 for package {}", p.mAlias );
+                    }
+                    mLogger.info("Test Plan with {}", p.mAlias);
+                    Package foundInRelease = mReleaseManager.findPackage(p.mAlias, fullPlanCollection);
+                    int foundIndex = mReleaseManager.findPackageLastIndex;
+                    if (foundInRelease == ReleaseManager.NULL_PACKAGE)
+                    {
+                        fullPlanCollection.add(p);
+                    }
+                    else
+                    {
+                        fullPlanCollection.set(foundIndex, p);
+                    }
+                    Package.resetCircularDependency (fullPlanCollection);
+                    if ( p.hasCircularDependency( fullPlanCollection ) )
+                    {
+                        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 the package
+                        // max 50 chars
+                        rippleBuildExclude(p, p.mId, "Package has circular dependency", -6);
+                    }
+                }
+            }
-            else
+        }
+        return planCollection(name, fullPlanCollection, mode);
+    }
+    /**
+     *  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
+     * @param planCollection - collection of packages to scan
+     * @param rippleOrder - Set the ripple oder, if >= 0
+     *
+     * @return A collection of packages that actively 'use' the specified package
+     */
+    private ArrayList<PlannedPackage> usedByPackages(PlannedPackage pkg, ArrayList<PlannedPackage> planCollection, int rippleOrder) {
+        ArrayList<PlannedPackage> usedBy = new ArrayList<PlannedPackage>();
+        for (Iterator<PlannedPackage> it = planCollection.iterator(); it.hasNext(); )
+        {
+            PlannedPackage p = it.next();
+            //  Is this package 'actively used' in the current build
+            if (p.mPkg.mBuildFile >= 0)
+            {
-                // this is escrow mode centric
-                for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+                for (Iterator<String> it2 = p.mPkg.mDependencyCollection.iterator(); it2.hasNext(); )
+                {
                     Package p = it.next();
                     if ( p.mBuildFile == 0 )
+                    {
                         allProcessed = false;
                         mLogger.info("planRelease more build files are required for {}", p.mName);
                         break;
+                    }
+                }
-                buildFile++;
+            }
+        }
-        } while( !allProcessed );
+        return usedBy;
+    }
+    /**
+     *  Calculate a collection of packages that use the named package
+     *
+     * @param pkg - Package to process
+     * @param pkgCollection - collection of packages to scan
+     *
+     * @return A collection of packages that actively 'use' the specified package
+     */
+    private ArrayList<Package> usedByAnyPackages(Package pkg, ArrayList<Package> pkgCollection) {
+        ArrayList<Package> usedBy = new ArrayList<Package>();
+        for (Iterator<Package> it = pkgCollection.iterator(); it.hasNext(); )
+        {
+            Package p = it.next();
+            for (Iterator<String> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )
+            {
+                String alias = it2.next();
+                if (  pkg.mAlias.compareTo( alias ) == 0  ) {
+                    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
+    /** Reports what change in build exceptions happens as part of planRelease
+     *
+     *  There are three types of exceptions
+     *      PlanError - These may be removed, if the error was not seen in the last plan
+     *      BuildErrors - These we persist
+     *      IndirectErrors - Packages that depend on a Plan or Build errors
      */
     public void reportChange() throws SQLException, Exception
+    {
         int counter = 0;
         for (Iterator<BuildExclusion> it = mBuildExclusionCollection.iterator(); it.hasNext(); )
+        {
             BuildExclusion buildExclusion = it.next();
+            //  Skip 'Processed' entries
+            //  These will be the result of a PlanError that we have seen again
+            //
+            //  PlanErrors - Add/Remove as detected
+            //  BuildErrors - Persist.
+            //  IndirectErrors - Add/Remove as detected
+            //
-            if ( !buildExclusion.isProcessed() )
+            if ( !buildExclusion.isABuildError() )
+            {
                 if (buildExclusion.isImported() && ! buildExclusion.isARootCause() ) {
                     // Remove from the exclusion list
                     buildExclusion.includeToBuild(mReleaseManager, mBaseline);
                     mLogger.error("reportChange remove unused exclusion: {}", buildExclusion.info());
+        }
+    }
     /**
      * Find Package by package alias
-     * Searches the complete package collection
+     * Searches the released package collection
      * @param   alias               - alias of package to locate
      * @return  Package with the matching mAlias or NULL_PACKAGE if no package has the mAlias
      */
     public Package findPackage(String alias)
+    {
         Package retVal = mReleaseManager.findPackage(alias, mPackageCollection);
         mLogger.info("findPackage returned {}", retVal.mName);
         return retVal;
+    }
     /**
-     * Sets the mBuildFile to -5 (indirectly dependent on package versions which are not reproducible)
+     * Sets the mBuildFile to the specified value for the package
-     * for the package and all dependent packages
+     * Does not handle dependent packages - this will be done later
+     *
      * @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 list          If not null, add build exclusion to specified list, else use default(mBuildExclusionCollection) list. Allows insertions while iterating the list.
-     * @param be            If not null, process provided BuildExclusion element, otherwise find-existing/create a BuildExclusion element
-     * @param dependentToo  True: Exclude all packages that depend on the excluded package
+     * @param reason        New value for mBuildFile
      */
-    private void rippleBuildExclude(Package p, int rootPvId, String rootCause, ListIterator<BuildExclusion> list, BuildExclusion be, boolean dependentToo )
+    private void rippleBuildExclude(Package p, int rootPvId, String rootCause, int reason )
+    {
         mLogger.debug("rippleBuildExclude");
         if ( p.mBuildFile == 0 || p.mBuildFile == 1 )
+        {
             p.mBuildFile = -5;
             mLogger.info("rippleBuildExclude set mBuildFile to -5 for package {}", p.mAlias );
-            if ( be != null )
+                if ( buildExclusion.compare(p.mId, rootPvId, rootCause))
-            {
+                {
-                be.setProcessed();
+                    buildExclusion.setProcessed();
+                    found = true;
+                    break;
+                }
+            }
-            else
+            if (!found)
+            {
-                //  If no be item has been provided, then scan the complete collection looking for a matching item
+                // Entry not found in the mBuildExclusionCollection. Its a new error
+                //
-                //  If found, process it, else add it (unprocessed)
+                // Mark all occurrences for this package as processed
-                boolean found = false;
+                // These will be superseded by a new build exclusion entry
                 for (Iterator<BuildExclusion> it = mBuildExclusionCollection.iterator(); it.hasNext(); )
+                {
                     BuildExclusion buildExclusion = it.next();
-                    if ( buildExclusion.compare(p.mId, rootPvId, rootCause))
+                    if ( buildExclusion.compare(p.mId))
+                    {
                         buildExclusion.setProcessed();
-                        found = true;
-                        break;
+                    }
+                }
-                if (!found)
-                {
-                    // Entry not found in the mBuildExclusionCollection
-                    // Mark all occurrences for this package as processed
-                    // These will be superseded by a new build exclusion entry
-                    for (Iterator<BuildExclusion> it = mBuildExclusionCollection.iterator(); it.hasNext(); )
-                    {
-                        BuildExclusion buildExclusion = it.next();
-                        if ( buildExclusion.compare(p.mId))
+                //  Add the new build exclusion to a list
-                        {
-                            buildExclusion.setProcessed();
-                        }
-                    }
-                    BuildExclusion buildExclusion = new BuildExclusion(p.mId, rootPvId, rootCause, p.mTestBuildInstruction);
+                BuildExclusion buildExclusion = new BuildExclusion(p.mId, rootPvId, rootCause, p.mTestBuildInstruction);
-                    //
-                    //  Add the new build exclusion to a list
-                    //    Either the default list or a user-specified list
-                    if ( list == null )
-                    {
-                        mBuildExclusionCollection.add(buildExclusion);
+                mBuildExclusionCollection.add(buildExclusion);
-                    }
-                    else
-                    {
-                        // must use the ListIterator interface to add to the collection whilst iterating through it
-                        list.add(buildExclusion);
-                    }
-                }
+            }
+        }
             //  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
+                {
                     Package p = it.next();
                     generatePackageInfo(xml, p);
+                }
+                xml.addComment("mPackageCollectionWip");
+                for (Iterator<Package> it = mPackageCollectionWip.iterator(); it.hasNext(); )
+                {
+                    Package p = it.next();
+                    if (p.mIsNotReleased )
+                        generatePackageInfo(xml, p);
+                }
+                xml.addComment("mPackageCollectionTest");
+                for (Iterator<Package> it = mPackageCollectionTest.iterator(); it.hasNext(); )
+                {
+                    Package p = it.next();
+                    if (p.mIsNotReleased )
+                        generatePackageInfo(xml, p);
+                }
+                xml.addComment("mPackageCollectionTestRipple");
+                for (Iterator<Package> it = mPackageCollectionRipple.iterator(); it.hasNext(); )
+                {
+                    Package p = it.next();
+                    if (p.mIsNotReleased )
+                        generatePackageInfo(xml, p);
+                }
                 // UTF Support
                 // Insert build exclusion information
                 xml.addComment("mBuildExclusionCollection");
                 for (Iterator<BuildExclusion> it = mBuildExclusionCollection.iterator(); it.hasNext(); )
+                {
                     BuildExclusion buildExclusion = it.next();
-                    if (!buildExclusion.isProcessed())
+                    {
-                        xml.addComment(buildExclusion.info());
+                        xml.addComment(buildExclusion.toString());
+                    }
+                }
+            }
-                // UTF Support
+            // UTF Support (Also while trailing the changes)
-                // Insert build Plan
+            // Insert build Plan
-                if (mDaemon)
+            if (mDaemon)
+            {
+                xml.addComment("mBuildOrder");
+                for (Iterator<PlannedPackage> it = mBuildOrder.iterator(); it.hasNext(); )
+                {
-                    xml.addComment("mBuildOrder");
+                    PlannedPackage p = it.next();
-                    int order = 0;
+                    String comment =
-                    for (Iterator<Package> it = mBuildOrder.iterator(); it.hasNext(); )
-                    {
-                        Package p = it.next();
-                        String comment =
+                            "pvid="+ p.mPkg.mId +
-                                "pvid="+ p.mId +
+                            " order=" + p.mBuildLevel +
-                                " order=" +(++order) +
+                            " time=" + p.mPkg.mBuildTime +
-                                " name=\"" + p.mAlias + "\"";
+                            " name=\"" + p.mPkg.mAlias + "\"";
-                        xml.addComment(comment);
+                    xml.addComment(comment);
-                    }
+                }
+            }
             //  Generate Taskdef information
             generateTaskdef(xml);
             //
             //	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 )
+                    {
             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 )
+                {
      * @param xml	- An xml element to append data to
      * @param p	- Package to process
      */
     private void generatePackageInfo (XmlBuilder xml, Package p)
+    {
+        StringBuilder comment = new StringBuilder();
+        StringBuilder deps = new StringBuilder();
+        String joiner = "";
+        for (Iterator<String> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )
+        {
+            String alias = it2.next();
+            deps.append(joiner).append(alias);
+            joiner = ",";
+        }
+        comment.append("pvid=").append(p.mId);
+        comment.append(" name=").append('"').append(p.mAlias).append('"');
+        comment.append(" reason=").append(p.mNoBuildReason);
+        comment.append(" buildFile=").append(p.mBuildFile);
+        comment.append(" directlyPlanned=").append(p.mDirectlyPlanned);
+        comment.append(" indirectlyPlanned=").append(p.mIndirectlyPlanned);
+        comment.append(" depends=[").append(deps).append("]");
-        String comment =
-                "pvid="+ p.mId +
-                " name=\"" + p.mAlias + "\""+
-                " reason=" + p.mNoBuildReason +" "+
-                " buildFile=" + p.mBuildFile + " "+
-                " directlyPlanned=" + p.mDirectlyPlanned + " "+
-                " indirectlyPlanned=" + p.mIndirectlyPlanned;
-        xml.addComment(comment);
+        xml.addComment(comment.toString());
+    }
     /**returns an ant target for the passed Package
      * in daemon mode:
      *  packages are categorized with one of three mBuildFile values:
         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 )
+                {
                 +  "<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 Sender: {}", getMailSender());
         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());
+        }

Subversion Repositories DevTools

(root)//buildtool/trunk/src/main/java/com/erggroup/buildtool/ripple/RippleEngine.java – Rev 7046 → 7082