Subversion Repositories DevTools

        //  Now have a collection of packages with those that we cannot build have been marked

        //      ie: they have not been excluded, have not already been discovered and do not depend on any package in the collection

        //      Continue to do this until all packages have been extracted

        //      Allocate build levels as we go

        //

        phase.setPhase("Determine Build Order");

        boolean allProcessed = false;

        int buildLevel = 1;

        do

        {

            //

            //      Same for both Daemon and Escrow modes

            //      Will have package build order and build level

            boolean allDependenciesProcessed = true;

            do

            {

                allDependenciesProcessed = true;

                for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )

                {

                    Package p = it.next();

                    //  Skip packages that have been processed - have determined build order, or cannot build

                    if (p.mIsProcessed) {

                        continue;

                    }

                    // Package yet to be processed and

                    //      Daemon mode: Could be built

                    //      Escrow mode: Can be reproduced

                    boolean canBeBuiltNow = true;

                    boolean allDependenciesForThisPackageProcessed = true;

                    //  Scan the packages dependencies

                    for ( Iterator<Package> it2 = p.mPackageDependencyCollection.iterator(); it2.hasNext(); )

                    {

                        Package dependency = it2.next();

                        if ( !dependency.mProcessed )

                        {

                            //  If all the dependencies have been processed, then we can potentially build this package

                            //  If any of them have not been processed, then cannot calculate canBeBuiltNow until this 

                            //  dependency has been processed

                            allDependenciesForThisPackageProcessed = false;

                            allDependenciesProcessed = false;

                        }

                        else if (  (  mDaemon && (   dependency.mBuildFile == 0 ) ||  (dependency.mBuildFile == buildLevel)) 

                                || ( !mDaemon && ( ( dependency.mBuildFile == 0 ) ||

                                                       ( dependency.mBuildFile == buildLevel &&

                                                       ( !p.haveSameBuildStandards(dependency)  ) ) ) ) )

                        {

                            // Can be built - yet

                            // Daemon mode:

                            //    This processed dependency has not been assigned to a build iteration

                            //    This processed dependency has been assigned to this build iteration

                            // Escrow mode: This package cannot be built now if

                            //    This processed dependency has not been assigned to a build iteration or

                            //    This processed dependency has been assigned to this build iteration, but the 

                            //    build standards of the package and this dependency prevent the package being

                            //    built in this iteration.   

                            canBeBuiltNow = false;

                            mLogger.info("planRelease package cannot be built in this iteration {}", p.mName);

                            break;

                        }

                    }

                    //  All dependencies have been processed. May be able to build this package

                    //      Add the package to the build order list

                    //

                    if (allDependenciesForThisPackageProcessed)

                    {

                        p.mProcessed = true;

                        if ( canBeBuiltNow )

                        {

                            results.planCollection.add( new PlannedPackage(p, buildLevel));

                            p.mBuildFile = buildLevel;

                            p.mIsProcessed = true;

                            mLogger.info("planRelease set mBuildFile to {} for package {}",buildLevel, p.mAlias );

                        }

                    }

                }

            } while( !allDependenciesProcessed );

            //  Have process all the packages that we can build at the moment

            //      Examine all the packages in the collection to see if there are more that need to be extracted

            //      These will be done at a different build-level

            //  

            allProcessed = true;

            for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )

            {

                Package p = it.next();

                if ( !  p.mIsProcessed )

                {

                    // more build files are required

                    allProcessed = false;

                    mLogger.info("planRelease more build files are required for {}", p.mName);

                    break;

                }

            }

            buildLevel++;

            if (buildLevel % 500 == 0 ) {

                mLogger.error("planRelease. Too many build levels {}", buildLevel);

            }

        //  Now we have a collection packages that we can build right now

        //      The packages currently have a build level set into mBuildFile

        //

            //      Reset the calculated buildLevel - It will be calculated again

            ArrayList<PlannedPackage> toBuild = new ArrayList<PlannedPackage>();

                //  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

                //      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.

                                String alias = it2.next();

                                for (Iterator<PlannedPackage> it3 = ripplePlan.iterator(); !found && it3.hasNext(); )

                                {

                                    PlannedPackage pkg = it3.next();

                                    if (pkg.mPkg.mAlias.compareTo( alias ) == 0)

                                    {

                                        break;

                                }

                            }

                            if (!found)

                            {

                                //  None of this packages dependencies can be found in the collection of packages to build

                                //  Thus we can build it - at the current level

                                p.mBuildLevel = buildLevel;

                                thisLevel.add(p);

                    //  Mark all the packages at this level as have been processed

                    //  Cannot do this while we are determining the packages in the level 

                    for (Iterator<PlannedPackage> it = thisLevel.iterator(); it.hasNext(); )

                    {

                        PlannedPackage p = it.next();

                        p.mPkg.mCheckedCircularDependency = false;

                    }

                    more = !thisLevel.isEmpty(); 

                    buildLevel++;

                //  Sort the packages by buildOrder and buildTime

                phase.setPhase("Sort Plan");

                Collections.sort(ripplePlan, PlannedPackage.BuildOrderComparitor);

                if (mLogger.isInfoEnabled() )

                {

                    phase.setPhase("Display Build Order");

                    mLogger.info("Plan Build {} Time: {}", name, results.planTime);

                    for (Iterator<PlannedPackage> it = ripplePlan.iterator(); it.hasNext(); )