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

     /** 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.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, false);
+                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);
                 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 = mPackageCollectionAll.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
                 Package dependency = findPackage(alias);
                 if (dependency == ReleaseManager.NULL_PACKAGE)
+                {
                     mLogger.info("planRelease dependency is not in the baseline {}", alias);
-                    // exclude all dependent packages
+                    // Exclude the package
                     // max 50 chars
-                    rippleBuildExclude(p, p.mId, "Package build dependency not in the release", null, null, true, 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);
                     mNotInBaselineFlag = false;
                     break;
+                }
+            }
                 // 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())
+                {
                     mLogger.info("planRelease package not reproducible {}" ,p.mName);
+                    // Exclude the package
                     // max 50 chars
-                    rippleBuildExclude(p, p.mId, "Package has no build environment", null, null, false, 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;
+                }
+            }
+        }
                 if ( !reproduce )
+                {
                     mLogger.info("planRelease package not reproducible on the build platforms configured for this baseline {}", p.mName);
+                    // Exclude the package
                     // max 50 chars
-                    rippleBuildExclude(p, p.mId, "Package not built for configured platforms", null, null, false, true);
+                    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
-            //      I would have thought that all consumer packages had already been excluded ??
-            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 = mPackageCollectionAll.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
-                        rippleBuildExclude( p, p.mId, null, it, be, true, true );
-                        p.mBuildFile = -3;
-                        mLogger.info("planRelease set mBuildFile to -3 for package {}", p.mAlias );
-                        break;
-                    }
-                }
-            }
             //  Daemon Mode Only
             //  Process packages which need to be ripple built
             mLogger.debug("planRelease process packages which need to be ripple built");
             for (Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
                                 //
                                 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, true);
+                                    rippleBuildExclude(p, -2, "Ripple Required." + " Waiting for user", -11);
-                                    // package is unBuildable, mark reason and discard
-                                    p.mBuildFile = -11;
                                     if (p.mRippleStop == 's' ) {
                                         // 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);
+                                    }
                                 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);
+                                    // Exclude the package
                                     // max 50 chars
-                                    rippleBuildExclude(p, p.mId, "Unbuildable" + " package not found in archive", null, null, true, 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);
+                                    // Exclude the package
                                     // max 50 chars
-                                    rippleBuildExclude(p, p.mId, reason + " package not found in archive", null, null, true, 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);
+                                            // Exclude the package
                                             // max 50 chars
-                                            rippleBuildExclude(p, p.mId, "Package cannot be rebuilt in this release", null, null, true, 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
             //  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) {
                     int pvApplied = p.applyPV(mReleaseManager);
                     if ( pvApplied == 1 )
+                    {
                         // max 50 chars
-                        rippleBuildExclude(p, p.mId, "Package has non standard versioning", null, null, true, true);
+                        rippleBuildExclude(p, p.mId, "Package has non standard versioning", -5);
+                    }
                     else if ( pvApplied == 2 )
+                    {
                         // max 50 chars
-                        rippleBuildExclude(p, p.mId, "Package has reached ripple field limitations", null, null, true, true);
+                        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", null, null, true, true);
+                        rippleBuildExclude(p, p.mId, "Package has invalid change type", -5);
+                    }
+                }
+            }
+        }
                     mDependentFlag = false;
+                }
+            }
+        }
+    }
+    /** Plan the build order.
+         *  Assumes that a great deal of work has been done.
+         *  This is a stand alone method to contain the work
+         *
+         * @throws Exception
+         * @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 = null;
+                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 != null )
+                {
+                    mLogger.error("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 != null ) {
+                    // Use the full plan, but treat it as the basic plan so that we will mark level-0 builds
+                    basicPlan = fullPlan;
+                    fullPlan = null;
+                    mBuildOrder.addAll(basicPlan.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 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.error("Excluded Package {}, {}", p.mAlias, be.mRootCause);
+                             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;
+                                         break;
+                                     }
+                                 }
+                                 if (!found)
+                                 {
+                                     BuildExclusion buildExclusion = new BuildExclusion(pkg.mId, p.mId, null, p.mTestBuildInstruction);
+                                     it.add(buildExclusion);
+                                     mLogger.error("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);
+            }
+        }
     /** Internal class to contain intermediate results
      */
     class PlanResults {
         int planTime = 0;
-        ArrayList<Package> planCollection = new ArrayList<Package>();
+        ArrayList<PlannedPackage> planCollection = new ArrayList<PlannedPackage>();
+    }
     /**
      * Process a collection of packages and generate a collection of package plans
      * A package plan is a collection of packages that can be built
+     *
      * @return
      */
     private PlanResults planCollection(String name, ArrayList<Package> packageCollection, boolean mode)
+    {
-        ArrayList<Package> ripplePlan = new ArrayList<Package>();
+        ArrayList<PlannedPackage> ripplePlan = new ArrayList<PlannedPackage>();
         PlanResults results = new PlanResults();
         //  Reset flags used in the calculations
         Package.resetProcessed(packageCollection);
                     if (allDependenciesForThisPackageProcessed)
+                    {
                         p.mProcessed = true;
                         if ( canBeBuiltNow )
+                        {
-                            results.planCollection.add(p);
+                            results.planCollection.add( new PlannedPackage(p, buildLevel));
                             p.mBuildFile = buildLevel;
                             p.mIsProcessed = true;
                             mLogger.info("planRelease set mBuildFile to {} for package {}",buildLevel, p.mAlias );
+                        }
+                    }
         //      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<Package> toBuild = new ArrayList<Package>();
+            ArrayList<PlannedPackage> toBuild = new ArrayList<PlannedPackage>();
-            for (Iterator<Package> it = results.planCollection.iterator(); it.hasNext(); )
+            for (Iterator<PlannedPackage> it = results.planCollection.iterator(); it.hasNext(); )
+            {
-                Package p = it.next();
+                PlannedPackage p = it.next();
+                p.mBuildLevel = 0;
-                if (p.mBuildReason != null) {
+                if (p.mPkg.mBuildReason != null) {
-                    if (mode || ( !mode && p.mBuildReason != BuildReason.Ripple ))
+                    if (mode || ( !mode && p.mPkg.mBuildReason != BuildReason.Ripple ))
+                    {
                         toBuild.add(p);
+                    }
+                }
+            }
                 //  Need to add elements to the end of the list while processing
                 //  Sum the buildTimes of the packages that we add to the list
                 while ( ! toBuild.isEmpty())
+                {
-                    Package pkg = toBuild.remove(0);
+                    PlannedPackage pkg = toBuild.remove(0);
-                    if (pkg.mRippleOrder > 100 ) {
+                    if (pkg.mBuildLevel > 100 ) {
                         mLogger.error("Circular dependency detected - not handled well");
                         break;
+                    }
                     if ( ! ripplePlan.contains( pkg ))
+                    {
                         ripplePlan.add(pkg);
-                        results.planTime += pkg.mBuildTime;
+                        results.planTime += pkg.mPkg.mBuildTime;
+                    }
-                    ArrayList<Package> usedBy = usedByPackages(pkg, results.planCollection, pkg.mRippleOrder + 1);
+                    ArrayList<PlannedPackage> usedBy = usedByPackages(pkg, results.planCollection, pkg.mBuildLevel + 1);
                     toBuild.addAll(usedBy);
+                }
                 //  Sort the packages by buildOrder and buildTime
-                Collections.sort(ripplePlan, Package.BuildOrderComparitor);
+                Collections.sort(ripplePlan, PlannedPackage.BuildOrderComparitor);
                 mLogger.error("Plan Build {} Time: {}", name, results.planTime);
-                for (Iterator<Package> it = ripplePlan.iterator(); it.hasNext(); )
+                for (Iterator<PlannedPackage> it = ripplePlan.iterator(); it.hasNext(); )
+                {
-                    Package p = it.next();
+                    PlannedPackage p = it.next();
-                    mLogger.error("Plan: {} {}", p.mRippleOrder, p.mAlias);
+                    mLogger.error("Plan: {} {}", p.mBuildLevel, p.mPkg.mAlias);
+                }
+            }
             //  Daemon mode: Returning calculated plan
             results.planCollection = ripplePlan;
                 if (p.mBuildFile >= 0)
+                {
                     if (!mode)
+                    {
                         //  Exclude packages that would have been processed in the basicPlan
-                        for (Iterator<Package> it1 = basicPlan.planCollection.iterator(); it1.hasNext(); )
+                        for (Iterator<PlannedPackage> it1 = basicPlan.planCollection.iterator(); it1.hasNext(); )
+                        {
-                            Package pkg = it1.next();
+                            PlannedPackage pkg = it1.next();
-                            if (pkg == p)
+                            if (pkg.mPkg == p)
+                            {
                                 mLogger.error("Test Plan without {}", p.mAlias);
                                 continue;
+                            }
+                        }
                         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, false);
+                        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 );
+                    }
+                }
+            }
+        }
         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,
-    /** Plan the build order.
+     *      If the consumer is an SDK or is Pegged
-     *  Assumes that a great deal of work has been done.
+     *      If the consumer is marked as advisoryRipple
-     *  This is a stand alone method to contain the work
+     *      If the consumer cannot be built
      *
-     * @throws Exception
+     * @param pkg - Package to process
+     * @param planCollection - collection of packages to scan
-     * @throws SQLException
+     * @param rippleOrder - Set the ripple oder, if >= 0
+     *
+     * @return A collection of packages that actively 'use' the specified package
      */
-    private void planBuildOrder() throws Exception, SQLException
+    private ArrayList<PlannedPackage> usedByPackages(PlannedPackage pkg, ArrayList<PlannedPackage> planCollection, int rippleOrder) {
-    {
-//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.
+        ArrayList<PlannedPackage> usedBy = new ArrayList<PlannedPackage>();
-        //    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
+        for (Iterator<PlannedPackage> it = planCollection.iterator(); it.hasNext(); )
-        //  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();
+            PlannedPackage p = it.next();
-                if (p.mBuildFile >= 0)
-                {
-                    mBuildOrder.add(p);
-                    p.mRippleOrder = 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 = null;
-            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 != null )
-            {
-                mLogger.error("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 != null ) {
-                // 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
+            //  Is this package 'actively used' in the current build
-            //
-            Package build = ReleaseManager.NULL_PACKAGE;
-            if (!mBuildOrder.isEmpty()) {
-                build = mBuildOrder.get(0);
-                build.mBuildFile = 1;
+            if (p.mPkg.mBuildFile >= 0)
-                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
-            //
-            //  TODO - Not sure this does anything for us. Once upon a time it might have been nice, but now it may be confusing
-            //
-            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();
+                for (Iterator<String> it2 = p.mPkg.mDependencyCollection.iterator(); it2.hasNext(); )
-                if ( p.mBuildFile >= 0 )
+                {
-                    Package pReleased = findPackage(p.mAlias);
+                    String alias = it2.next();
+                    if (  pkg.mPkg.mAlias.compareTo( alias ) == 0  ) {
-                    if ( pReleased != ReleaseManager.NULL_PACKAGE)
+                        //  Have found a consumer of 'pkg'
-                    {
+                        usedBy.add(p);
-                        int index = mReleaseManager.findPackageLastIndex;
+                        if (rippleOrder >= 0)
-                        mPackageCollection.set(index, p);
+                            p.mBuildLevel = rippleOrder;
-                        p.mIsNotReleased = false;
+                        break;
+                    }
+                }
+            }
-            //
-            //  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<Package> it = mBuildOrder.iterator(); it.hasNext(); )
-        {
-            Package p = it.next();
-            mLogger.error("Plan: {} {}", p.mRippleOrder, p.mAlias);
-        }
+        return usedBy;
+    }
     /**
-     *  Calculate a collection of packages that actively use the named package
+     *  Calculate a collection of packages that 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 pkgCollection - 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<Package> usedByPackages(Package pkg, ArrayList<Package> pkgCollection, int rippleOrder) {
+    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();
-            //  Is this package 'actively used' in the current build
+            for (Iterator<String> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )
-            if (p.mBuildFile >= 0)
+            {
-                for (Iterator<String> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )
-                {
-                    String alias = it2.next();
+                String alias = it2.next();
-                    if (  pkg.mAlias.compareTo( alias ) == 0  ) {
+                if (  pkg.mAlias.compareTo( alias ) == 0  ) {
-                        //  Have found a consumer of 'pkg'
-                        usedBy.add(p);
+                    usedBy.add(p);
-                        if (rippleOrder >= 0)
-                            p.mRippleOrder = rippleOrder;
-                        break;
+                    break;
-                    }
+                }
+            }
+        }
         return usedBy;
         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 that are a part of the release set.
+     * 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 depWipsToo    False: Don't exclude WIP 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, boolean depWipsToo )
+    private void rippleBuildExclude(Package p, int rootPvId, String rootCause, int reason )
+    {
         mLogger.debug("rippleBuildExclude");
         if ( p.mBuildFile == 0 || p.mBuildFile == 1 )
+        {
-            p.mBuildFile = -5;
+            p.mBuildFile = reason;
             mLogger.info("rippleBuildExclude set mBuildFile to -5 for package {}", p.mAlias );
+            //  Scan the complete collection looking for a matching item
+            //  If found, process it, else add it (unprocessed)
-            if ( be != null )
+            boolean found = false;
+            for (Iterator<BuildExclusion> it = mBuildExclusionCollection.iterator(); it.hasNext(); )
+            {
+                BuildExclusion buildExclusion = it.next();
+                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
-                //  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))
-                        {
-                            buildExclusion.setProcessed();
-                        }
-                    }
-                    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);
-                    }
-                    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 packages that are a part of the full release set
-            //  NewWIPs, ForcedRipples and TestBuilds will not force consumer packages to be excluded
-            //
-            if ( ! p.mIsNotReleased && dependentToo)
-            {
-                for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
-                {
-                    Package pkg = it.next();
-                    //  Skip myself
-                    if (pkg == p)
-                        continue;
-                    //  Ignore dependent WIPS if required
-                    if (!depWipsToo && pkg.mDirectlyPlanned)
-                        continue;
-                    for (Iterator<Package> it2 = pkg.mPackageDependencyCollection.iterator(); it2.hasNext(); )
-                    {
-                        Package dependency = it2.next();
-                        if ( dependency == p )
-                        {
-                            rippleBuildExclude( pkg, rootPvId, null, list, null, dependentToo, depWipsToo );
+                BuildExclusion buildExclusion = new BuildExclusion(p.mId, rootPvId, rootCause, p.mTestBuildInstruction);
-                            break;
-                        }
-                    }
-                }
+                //
+                //  Add the new build exclusion to a list
+                //    Either the default list or a user-specified list
+                mBuildExclusionCollection.add(buildExclusion);
+            }
+        }
-        mLogger.info("rippleBuildExclude set {} {}", p.mName, p.mBuildFile);
+        mLogger.info("rippleBuildExclude set {} {}", p.mAlias, p.mBuildFile);
+    }
     /**Simple XML string escaping
+     *
      * @param xml		- String to escape
                 // Insert build exclusion information
                 xml.addComment("mBuildExclusionCollection");
                 for (Iterator<BuildExclusion> it = mBuildExclusionCollection.iterator(); it.hasNext(); )
+                {
                     BuildExclusion buildExclusion = it.next();
-                    if (!buildExclusion.isProcessed())
+                    //if (!buildExclusion.isProcessed())
+                    {
                         xml.addComment(buildExclusion.info());
+                    }
+                }
                 // UTF Support
                 // Insert build Plan
                 if (mDaemon)
+                {
                     xml.addComment("mBuildOrder");
-                    int order = 0;
-                    for (Iterator<Package> it = mBuildOrder.iterator(); it.hasNext(); )
+                    for (Iterator<PlannedPackage> it = mBuildOrder.iterator(); it.hasNext(); )
+                    {
-                        Package p = it.next();
+                        PlannedPackage p = it.next();
                         String comment =
-                                "pvid="+ p.mId +
+                                "pvid="+ p.mPkg.mId +
-                                " order=" + (++order) +
+                                " order=" + p.mBuildLevel +
-                                " Rorder=" + (p.mRippleOrder) +
-                                " time=" + p.mBuildTime +
+                                " time=" + p.mPkg.mBuildTime +
-                                " name=\"" + p.mAlias + "\"";
+                                " name=\"" + p.mPkg.mAlias + "\"";
                         xml.addComment(comment);
+                    }
+                }
+            }

Subversion Repositories DevTools

(root)/buildtool/branches/planMetrics2/src/main/java/com/erggroup/buildtool/ripple/RippleEngine.java – Rev 7078 → 7079