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

                 //  Force this package to be marked as having a circular dependency - even if its been excluded
                 p.mBuildFile = 0;
                 // exclude all dependent packages
                 // max 50 chars
-                rippleBuildExclude(p, p.mId, "Package has circular dependency", null, null, true);
+                rippleBuildExclude(p, p.mId, "Package has circular dependency", null, null, true, false);
                 // 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);
                 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", null, null, true, true);
                     // 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);
                 // 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);
                     // max 50 chars
-                    rippleBuildExclude(p, p.mId, "Package has no build environment", null, null, false);
+                    rippleBuildExclude(p, p.mId, "Package has no build environment", null, null, false, true);
                     // package is not reproducible, discard
                     p.mBuildFile = -1;
                     mLogger.info("planRelease set mBuildFile to -1 for package {}", p.mAlias );
                     standardOut(mAnyBuildPlatforms, p.mAlias, mAnyBuildPlatformsFlag);
         //    ie: Package: Win32:Production and we have a BM with a class of 'Win32'
         //
         //    Only exclude the failing package and not its dependents
         //    May be legitimate in the release
         //
-//TODO - verify this code. I'm not sure it can be reached. I think that the "Package has no build environment" test above is detecting all these packages
         mLogger.debug("planRelease process packages which are not reproducible2");
         for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
                 if ( !reproduce )
+                {
                     mLogger.info("planRelease package not reproducible on the build platforms configured for this baseline {}", p.mName);
                     // max 50 chars
-                    rippleBuildExclude(p, p.mId, "Package not built for configured platforms", null, null, false);
+                    rippleBuildExclude(p, p.mId, "Package not built for configured platforms", null, null, false, true);
                     // 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);
         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 = mPackageCollection.iterator(); it1.hasNext(); )
+                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 );
+                        rippleBuildExclude( p, p.mId, null, it, be, true, true );
                         p.mBuildFile = -3;
                         mLogger.info("planRelease set mBuildFile to -3 for package {}", p.mAlias );
                         break;
+                    }
+                }
                                 //
                                 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);
+                                    rippleBuildExclude(p, -2, "Ripple Required." + " Waiting for user", null, null, false, true);
                                     // package is unBuildable, mark reason and discard
                                     p.mBuildFile = -11;
                                     if (p.mRippleStop == 's' ) {
+                                {
                                     //  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", null, null, true, true);
                                     // package is unBuildable, mark reason and discard
                                     p.mBuildFile = -10;
+                                }
                                     //  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", null, null, true, true);
                                     // package is not reproducible, mark reason and discard
                                     p.mBuildFile = -7;
+                                }
                                             // 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", null, null, true, true);
                                             // package is not reproducible, mark reason and discard
                                             p.mBuildFile = -4;
                                             break;
+                                        }
  *      [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
+ *
- *      Need more test cases
+ *      [Being Done] Need more test cases
+ *
- *      Need to report all build options, not just the selected one
+ *      [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
+ *
- *      If a WIP on a package that has circular dependencies is added, then the WIP will be excluded. This prevents the problem being fixed.
+ *      [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
+ *              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:
+            }
             //  Examine the build candidates and verify that a new version number can be calculated for each
             //  version that we need to build.
             //
-//TODO If we find WIP/TEST/RIPPLE with invalid nextVersion, then we could email the submitter and treat it as a fail.
+            //  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
+            //
             for (Iterator<Package> it = buildCandidates.iterator(); it.hasNext(); )
+            {
                 Package p = it.next();
                 if ( p.mBuildFile >= 0 )
                     int pvApplied = p.applyPV(mReleaseManager);
                     if ( pvApplied == 1 )
+                    {
                         // max 50 chars
-                        rippleBuildExclude(p, p.mId, "Package has non standard versioning", null, null, true);
+                        rippleBuildExclude(p, p.mId, "Package has non standard versioning", null, null, true, true);
+                    }
                     else if ( pvApplied == 2 )
+                    {
                         // max 50 chars
-                        rippleBuildExclude(p, p.mId, "Package has reached ripple field limitations", null, null, true);
+                        rippleBuildExclude(p, p.mId, "Package has reached ripple field limitations", null, null, true, true);
+                    }
                     else if ( pvApplied == 3 )
+                    {
                         // max 50 chars
-                        rippleBuildExclude(p, p.mId, "Package has invalid change type", null, null, true);
+                        rippleBuildExclude(p, p.mId, "Package has invalid change type", null, null, true, true);
+                    }
                     if ( pvApplied != 0)
+                    {
                         // If this package is not a WIP/TEST/RIPPLE, then remove it from this collection
                         else
+                        {
                             //  Calculate the time to build the package AND all of the packages that depend on it
                             //  Calculate the build plan for the package
                             //
-                            calcBuildPlan(p, mPackageCollection, true);
+                            calcBuildPlan(p, mPackageCollection);
+                        }
+                    }
+                }
+            }
                 //      We can get the lowest first
                 //      We can generate the complete plan in a nice order
                 //
                 Collections.sort(buildNext, Package.RippleTimeComparator);
-                //  At the moment extract the first one - this is the fastedt
+                //  At the moment extract the first one - this is the fastest
+                //  Allowing for a 20% extension.
+                //
-                //  TODO - could build another candidate as long as it does't extend the time by (say) 10%
+                //  TODO - what if two build sets don't overlap. Do we build the longer one first ?
-                //         Would need to rejigger the collection - for the next step
+                //  TODO - what if two build sets do overlay. Can we merge them somehow
                 //
                 build = buildNext.get(0);
                 //  Determine the amount of time we would allow the 'best' plan to be extended
                 //      Allow for a 20% extension in time
-                //      Min of 10 minutes
+                //      Minimum of 10 minutes
                 int baseTime = build.mRippleTime;
                 baseTime = ( baseTime * 1200) / 1000;
                 if ( baseTime < 10 * 60) {
                     baseTime = (10 * 60);
+                }
                     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. Unless doing a test build
+                //      Claim the version number to prevent other builds from using it. Even if doing a test build
                 //
-                if (build.mTestBuildInstruction == 0 && build.mNextVersion != null)
+                if (build.mNextVersion != null)
+                {
                     mReleaseManager.claimVersion(build.mPid, build.mNextVersion + build.mExtension, mBaseline);
                     build.mVersion = build.mNextVersion;
+                }
+            }
      *      Only include a package once.
      *      Only include packages that can/need to be built at the moment
+     *
      * @param p                 - Package to process
      * @param pkgCollection     - Package Collection to scan
-     * @param processAll        - True: Order all packages discovered
      */
-    private void calcBuildPlan(Package p, ArrayList<Package> pkgCollection, boolean processAll) {
+    private void calcBuildPlan(Package p, ArrayList<Package> pkgCollection) {
-        mLogger.error("calcBuildPlan Add {}", p.mAlias);
-        p.mRipplePlan = usedByPackages(p, pkgCollection);
-        p.mRippleTime = p.mBuildTime;
-        //  Use a ListIterator so that we can add elements to the end of the list while processing
+        p.mRipplePlan = new ArrayList<Package>();
-        //  Sum the buildTimes of the packages that we add to the list
+        p.mRippleTime = p.mBuildTime;
+        //  Need to add elements to the end of the list while processing
+        //  Sum the buildTimes of the packages that we add to the list
-        for (ListIterator<Package> it = p.mRipplePlan.listIterator(); it.hasNext(); )
+        ArrayList<Package> toProcess = usedByPackages(p, pkgCollection, 1);
+        while ( ! toProcess.isEmpty())
+        {
-            Package pkg = it.next();
+            Package pkg = toProcess.remove(0);
-            mLogger.error("calc process {}", pkg.mAlias);
-            pkg.mRippleOrder++;
-            p.mRippleTime += pkg.mBuildTime;
+            if ( ! p.mRipplePlan.contains( pkg ))
-            ArrayList<Package> usedBy = usedByPackages(pkg, pkgCollection);
-            for (Iterator<Package> it1 = usedBy.iterator(); it1.hasNext(); )
+            {
-                Package uPkg = it1.next();
-                uPkg.mRippleOrder = pkg.mRippleOrder + 1;
-                if ( ! p.mRipplePlan.contains( uPkg ))
-                {
-                    it.add(uPkg);
+                p.mRipplePlan.add(pkg);
-                    it.previous();
-                    p.mRippleTime += uPkg.mBuildTime;
+                p.mRippleTime += pkg.mBuildTime;
-                    mLogger.error("calc Add {}", uPkg.mAlias);
-                }
+            }
+            ArrayList<Package> usedBy = usedByPackages(pkg, pkgCollection, pkg.mRippleOrder + 1);
+            toProcess.addAll(usedBy);
+        }
         //
         //  Need to determine the rippleTime for each package in the plan
-        //      Have a much smaller set of packages to process
+        //      Have a much smaller set of packages to process (need only scan those in p.mRipplePlan)
+        //  Similar to the above code, but
-        //  Don't care about the mRipplePlan item in the packages
+        //      Don't care about the mRipplePlan item in the packages
-        //  Don't modify the mRippleOrder
+        //      Don't modify the mRippleOrder
         //
         for (ListIterator<Package> it = p.mRipplePlan.listIterator(); it.hasNext(); )
+        {
-            Package pkg = it.next();
+            Package p1 = it.next();
-            pkg.mRipplePlan = usedByPackages(pkg, pkgCollection);
-            pkg.mRippleTime = pkg.mBuildTime;
+            int rippleTime = 0;
-            //  Use a ListIterator so that we can add elements to the end of the list while processing
+            ArrayList<Package> ripplePlan = new ArrayList<Package>();
-            //  Sum the buildTimes of the packages that we add to the list
+            ArrayList<Package> toProcess1 = new ArrayList<Package>();
+            toProcess1.add(p1);
-            for (ListIterator<Package> it0 = pkg.mRipplePlan.listIterator(); it0.hasNext(); )
+            while ( ! toProcess1.isEmpty())
+            {
-                Package pkg1 = it0.next();
+                Package pkg = toProcess1.remove(0);
-                pkg.mRippleTime += pkg1.mBuildTime;
+                if ( ! ripplePlan.contains( pkg ))
-                ArrayList<Package> usedBy = usedByPackages(pkg1, pkgCollection);
-                for (Iterator<Package> it1 = usedBy.iterator(); it1.hasNext(); )
+                {
-                    Package uPkg = it1.next();
-                    if ( ! pkg.mRipplePlan.contains( uPkg ))
-                    {
-                        it0.add(uPkg);
+                    ripplePlan.add(pkg);
-                        it0.previous();
-                        pkg.mRippleTime += uPkg.mBuildTime;
+                    rippleTime += pkg.mBuildTime;
-                    }
+                }
+                ArrayList<Package> usedBy = usedByPackages(pkg, p.mRipplePlan, -1);
+                toProcess1.addAll(usedBy);
+            }
+            p1.mRippleTime = rippleTime;
+        }
         //
         //  Sort the ripplePlan so that we build the fastest elements first
         //  Only care about the ripplePlan for the main Package
         //
         Collections.sort(p.mRipplePlan, Package.PlanComparator);
      *      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) {
+    private ArrayList<Package> usedByPackages(Package pkg, ArrayList<Package> pkgCollection, int rippleOrder) {
         ArrayList<Package> usedBy = new ArrayList<Package>();
         for (Iterator<Package> it = pkgCollection.iterator(); it.hasNext(); )
+        {
+                {
                     String alias = it2.next();
                     if (  pkg.mAlias.compareTo( alias ) == 0  ) {
                         //  Have found a consumer of 'pkg'
                         usedBy.add(p);
+                        if (rippleOrder >= 0)
+                            p.mRippleOrder = rippleOrder;
                         break;
+                    }
+                }
+            }
+        }
                     buildExclusion.includeToBuild(mReleaseManager, mBaseline);
                     mLogger.error("reportChange remove unused exclusion: {}", buildExclusion.info());
                 } else {
                     // Exclude and notify
                     buildExclusion.excludeFromBuild(mReleaseManager, mBaseline);
-                    buildExclusion.email(this, mPackageCollection);
+                    buildExclusion.email(this, mPackageCollectionAll);
                     counter++;
+                }
+            }
+        }
         mLogger.error("reportChange exclusion count: {}", counter);
      * for the package and all dependent packages that are a part of the release set.
+     *
      * @param p             The package being excluded
      * @param rootPvId      The PVID of the package that is causing the exclusion. Null or -ve values are special
      *                      This package is the root cause, -2: Excluded by Ripple Stop
-     *
      * @param rootCause     Text message. Max 50 characters imposed by RM database
      * @param 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
      */
-    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, ListIterator<BuildExclusion> list, BuildExclusion be, boolean dependentToo, boolean depWipsToo )
+    {
         mLogger.debug("rippleBuildExclude");
         if ( p.mBuildFile == 0 || p.mBuildFile == 1 )
+        {
             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)
-                    if ( pkg != p )
+                        continue;
+                    for (Iterator<Package> it2 = pkg.mPackageDependencyCollection.iterator(); it2.hasNext(); )
+                    {
-                        for (Iterator<Package> it2 = pkg.mPackageDependencyCollection.iterator(); it2.hasNext(); )
-                        {
-                            Package dependency = it2.next();
+                        Package dependency = it2.next();
-                            if ( dependency == p )
+                        if ( dependency == p )
-                            {
+                        {
-                                rippleBuildExclude( pkg, rootPvId, null, list, null, dependentToo );
+                            rippleBuildExclude( pkg, rootPvId, null, list, null, dependentToo, depWipsToo );
-                                break;
+                            break;
-                            }
+                        }
+                    }
+                }
+            }
+        }
         mLogger.info("rippleBuildExclude set {} {}", p.mName, p.mBuildFile);
+    }
      * @param xml	- An xml element to append data to
      * @param p	- Package to process
      */
     private void generatePackageInfo (XmlBuilder xml, Package p)
+    {
-        String joiner = "";
-        String comment =
+        StringBuilder comment = new StringBuilder();
-                "pvid="+ p.mId +
-                " name=\"" + p.mAlias + "\""+
-                " reason=" + p.mNoBuildReason +" "+
-                " buildFile=" + p.mBuildFile + " "+
+        StringBuilder deps = new StringBuilder();
-                " directlyPlanned=" + p.mDirectlyPlanned + " "+
-                " indirectlyPlanned=" + p.mIndirectlyPlanned + " depends=[" ;
+        String joiner = "";
         for (Iterator<String> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )
+        {
             String alias = it2.next();
-            comment += joiner + alias;
+            deps.append(joiner).append(alias);
             joiner = ",";
+        }
-        comment += "]";
+        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("]");
-        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:

Subversion Repositories DevTools

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