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

                     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);
-                }
-            }
-            mLogger.error("Determine new version numbers");
-            for (Iterator<Package> it = testVersions.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", -5);
-                    }
-                    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
                     // Do not have a plan
                     // May have tests requests
                     mLogger.error("Use NO plan");
+                }
-                //  Now have an mBuildOrder
-                //  Mark the first package in the build order as the one to be built
                 //
-                //
+                //  Now have a build order
+                //  Allocate new version numbers
+                //      Examine packages with a buidLevel of zero
+                //  If we fail all of them then we can't build anything
                 //
+                mLogger.error("Determine new version numbers");
                 Package build = ReleaseManager.NULL_PACKAGE;
+                for (Iterator<PlannedPackage> it = mBuildOrder.iterator(); it.hasNext(); )
+                {
+                    PlannedPackage pkg = it.next();
+                    if (pkg.mBuildLevel != 0)
+                    {
+                        continue;
+                    }
+                    //
+                    //  Attempt to allocate a new version number
+                    //  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
+                    //
+                    Package p = pkg.mPkg;
+                    int pvApplied = p.applyPV(mReleaseManager);
+                    if ( pvApplied == 0)
+                    {
+                        build = p;
+                        break;
+                    }
+                    else if ( pvApplied == 1 )
+                    {
+                        // max 50 chars
+                        rippleBuildExclude(p, p.mId, "Package has non standard versioning", -12);
+                    }
+                    else if ( pvApplied == 2 )
+                    {
+                        // max 50 chars
+                        rippleBuildExclude(p, p.mId, "Package has reached ripple field limitations", -12);
+                    }
+                    else if ( pvApplied == 3 )
+                    {
+                        // max 50 chars
+                        rippleBuildExclude(p, p.mId, "Package has invalid change type", -12);
+                    }
+                    else
+                    {
+                        // max 50 chars
+                        // Bad programming - should not get here
+                        rippleBuildExclude(p, p.mId, "Unable to calculate next version", -12);
+                    }
+                }
+                //  Now have an mBuildOrder
+                //  Mark the selected package in the build order as the one to be built
+                //  May need to process its it a bit more
+                //
                 if (!mBuildOrder.isEmpty()) {
-                    build = mBuildOrder.get(0).mPkg;
                     build.mBuildFile = 1;
                     if ( build.mForcedRippleInstruction > 0 )
+                    {
                         mReleaseManager.markDaemonInstCompleted( build.mForcedRippleInstruction );
                                  if (!found)
+                                 {
                                      BuildExclusion buildExclusion = new BuildExclusion(pkg.mId, p.mId, null, p.mTestBuildInstruction);
                                      it.add(buildExclusion);
                                      mLogger.info("Indirectly Excluded Package {}", pkg.mAlias);
+                                     pkg.mBuildFile = -5;
                                      ArrayList<Package> usedBy = usedByAnyPackages(pkg, mPackageCollectionAll );
                                      toExclude.addAll(usedBy);
+                                 }
+                             }
+                         }
+                     }
+                 }
+                 //
+                 //  Examine the build order and 'delete' entries with a -ve mBuildFile
+                 //  These will be the product of pvApply errors and the packages that depend on them
+                 for (Iterator<PlannedPackage> it = mBuildOrder.iterator(); it.hasNext(); )
+                 {
+                     PlannedPackage pkg = it.next();
+                     if (pkg.mPkg.mBuildFile < 0)
+                     {
+                         it.remove();
+                         mLogger.error("Purge mBuildOrder {}", pkg.mPkg);
+                     }
+                 }
                 //
                 //  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
             //  Need (would like to) build stuff
             //  Determine the packages that we need to build and the time that it will take
             //
             if ( !toBuild.isEmpty() )
+            {
+                //  Locate the packages that we need to build
+                //  The build order cannot be correctly determined at this time
-                //  Need to add elements to the end of the list while processing
+                //      Need to add elements to the end of the list while processing
-                //  Sum the buildTimes of the packages that we add to the list
+                //      Sum the buildTimes of the packages that we add to the list
                 while ( ! toBuild.isEmpty())
+                {
                     PlannedPackage pkg = toBuild.remove(0);
-                    mLogger.error("Proccessing {}", pkg.mPkg.mAlias);
                     if (pkg.mBuildLevel > 400 ) {
                         mLogger.error("Circular dependency detected - not handled well");
                         break;
+                    }
                     if ( ! pkg.mPkg.mCheckedCircularDependency )
+                    {
                         ripplePlan.add(pkg);
                         results.planTime += pkg.mPkg.mBuildTime;
                         pkg.mPkg.mCheckedCircularDependency = true;
                         ArrayList<PlannedPackage> usedBy = usedByPackages(pkg, results.planCollection);
                         toBuild.addAll(usedBy);
+                    }
+                }
                 //
-                //  Now we have a collection of packages to build
+                //  Now we have a collection of packages to build ( and only the packages to build)
                 //  Need to determine the order in which it can be done and assign build levels
+                //  Basically:
+                //      Scan the collection looking for any package whose dependencies do not exist in the collection
+                //      or they have been allocated a build level.
+                //
+                //      Need to do this in waves so that we can correctly determine the build level.
+                //
                 //
                 for (Iterator<PlannedPackage> it = ripplePlan.iterator(); it.hasNext(); )
+                {
                     PlannedPackage p = it.next();
                     p.mPkg.mCheckedCircularDependency = true;
      */
     private void rippleBuildExclude(Package p, int rootPvId, String rootCause, int reason )
+    {
         mLogger.debug("rippleBuildExclude");
-        if ( p.mBuildFile == 0 || p.mBuildFile == 1 )
+        if ( p.mBuildFile >= 0 )
+        {
             p.mBuildFile = reason;
-            mLogger.info("rippleBuildExclude set mBuildFile to -5 for package {}", p.mAlias );
+            mLogger.info("rippleBuildExclude set mBuildFile to {} for package {}", reason, p.mAlias );
             //  Scan the complete collection looking for a matching item
             //  If found then assume that this error is a a PlanError that is still present
             //      Mark it as Processed to indicate that its still present
             //  If found, process it, else add it (unprocessed)

Subversion Repositories DevTools

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