Subversion Repositories DevTools

package com.erggroup.buildtool.ripple;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.erggroup.buildtool.ripple.BuildFile.BuildFileState;

import com.erggroup.buildtool.ripple.ReleaseManager.BuildReason;

import com.erggroup.buildtool.smtp.CreateUrls;

import com.erggroup.buildtool.smtp.Smtpsend;

import com.erggroup.buildtool.utilities.StringAppender;

import com.erggroup.buildtool.utilities.XmlBuilder;

/**Plans release impact by generating a set of Strings containing build file content.

 */

public class RippleEngine

{

    /**configured mail server

     * @attribute

     */

    private String mMailServer = "";

    /**configured mail sender user

     * @attribute

     */

    private String mMailSender = "";

    /**configured global email target

     * @attribute

     */

    private String mMailGlobalTarget = "";

    /** Vector of email addresses for global and project wide use

     *  Most emails will be sent to this list of email recipients

     */

    public List<String> mMailGlobalCollection = new ArrayList<String>();

    /**name associated with the baseline

     * @attribute

     */

    public String mBaselineName = "";

    /**collection of released pv_ids associated with the release

     * @attribute

     */

    public List<Integer> mReleasedPvIDCollection = new ArrayList<Integer>();

    /**Collection of build exceptions associated with the baseline

     * Used to determine (and report) what change in build exceptions happens as part of planRelease

     * Daemon centric

     * @aggregation shared

     * @attribute

     */

    ArrayList<BuildExclusion> mBuildExclusionCollection = new ArrayList<BuildExclusion>();

    /**Logger

     * @attribute

     */

    private static final Logger mLogger = LoggerFactory.getLogger(RippleEngine.class);

    /** Escrow information - commands to set up escrow

     * @attribute

     */

    private String mEscrowSetup;

    /** Escrow information - Raw data (May not be used)

     * @attribute

     */

    private String mEscrowRawData;

    /**package versions representing the baseline

     * escrow centric

     * @aggregation shared

     * @attribute

     */

    private ArrayList<Package> mPackageCollection = new ArrayList<Package>();

    /**index to current String item

     * @attribute

     */

    private int mBuildIndex;

    /**Database abstraction

     * @attribute

     */

    ReleaseManager mReleaseManager;

    /**Baseline identifier (rtag_id for a release manager baseline, bom_id for deployment manager baseline)

     * @attribute

     */

    private int mBaseline;

    /** Escrow Only: SBOM_ID

     */

    private int mSbomId;

    /** RTAG_ID

     *  Set from mBaseline

     */

    private int mRtagId;

    /**When true, mBuildCollection contains one item based on a release manager rtag_id and contains a daemon property

     * When false, mBuildCollection contains at least one item based on a deployment manager bom_id

     * Will be accessed by the Package class to calculate its mAlias

     * @attribute

     */

    public boolean mDaemon;

    /**collection of build file content in String form

     * @attribute

     */

    private ArrayList<BuildFile> mBuildCollection = new ArrayList<BuildFile>();

    /** 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>();

    /**Warning message

     * @attribute

     */

    private static final String mAnyBuildPlatforms = "Warning. The following package versions are not reproducible on any build platform: ";

    /**Flag to control output to standard out

     * @attribute

     */

    private boolean mAnyBuildPlatformsFlag = true;

    /**Warning message

     * @attribute

     */

    private static final String mAssocBuildPlatforms = "Warning. The following package versions are not reproducible on the build platforms associated with this baseline: ";

    /**Flag to control output to standard out

     * @attribute

     */

    private boolean mAssocBuildPlatformsFlag = true;

    /**Warning message

     * @attribute

     */

    private static final String mNotInBaseline = "Warning. The following package versions are not reproducible as they are directly dependent upon package versions not in the baseline: ";

    /**Flag to control output to standard out

     * @attribute

     */

    private boolean mNotInBaselineFlag = true;

    /**Warning message

     * @attribute

     */

    private static final String mDependent = "Warning. The following package versions are not reproducible as they are directly/indirectly dependent upon not reproducible package versions: ";

    /**Flag to control output to standard out

     * @attribute

     */

    private boolean mDependentFlag = true;

    /**Warning message

     * @attribute

     */

    private static final String mCircularDependency = "Warning. The following package versions are not reproducible as they have circular dependencies: ";

    /**Flag to control output to standard out

     * @attribute

     */

    private boolean mCircularDependencyFlag = true;

    /** String used to terminate lines

     * @attribute

     */

    private static final  String mlf = System.getProperty("line.separator");

    /** XML File Prefix

     */

    private static final String mXmlHeader = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>" + mlf;

    /**RippleEngine constructor

     * @param releaseManager  - Associated releaseManager instance

     * @param rtagId         - Release Identifier

     * @param isDaemon        - Mode of operation. False: Escrow, True: Daemon

     */

    public RippleEngine(ReleaseManager releaseManager, int rtagId, boolean isDaemon)

    {

        mLogger.debug("RippleEngine rtag_id " + rtagId + " isDaemon " + isDaemon);

        mReleaseManager = releaseManager;

        mBaseline = rtagId;

        mRtagId = rtagId;

        mDaemon = isDaemon;

        mReleaseManager.setDaemonMode(mDaemon);

    }

    /**

     * getRtagId

     */

    public int getRtagId()

    {

        return mRtagId;

    }

    /**Plan what is to be built

     * 	<br>Discards all build file content

     * 	<br>Generates new build file content

     * 

     * @param lastBuildActive 		- False. Daemon Mode. The last build was a dummy. 

     *                                This planning session may not result in a build

     *                              - True. Daemon Mode. The last build was not a dummy.

     *                                There is a very good chance that this planning session

     *                                will result in a build, so it is given priority to connect 

     *                                to the database.	

     */

    public void planRelease(final boolean lastBuildActive) throws SQLException, Exception

    {

        mLogger.warn("planRelease mDaemon " + mDaemon);

        mBuildCollection.clear();

        mPackageCollection.clear();

        mReleasedPvIDCollection.clear();

        mBuildOrder.clear();

        mEscrowRawData = "";

        mEscrowSetup = "";

        Phase phase = new Phase("Plan");

        // use finally block in planRelease to ensure the connection is released

        try

        {

            phase.setPhase("connectForPlanning");

            mReleaseManager.connectForPlanning(lastBuildActive);

            if ( mDaemon )

            {

                // claim the mutex

                mLogger.warn("planRelease claimMutex");

                phase.setPhase("claimMutex");

                mReleaseManager.claimMutex();

                // Populate the mBuildExclusionCollection

                //

                // Builds are either 'Directly excluded' or 'Indirectly excluded'

                // Direct excludes result from:

                //      User request

                //      Build failure

                //      Inability to build package

                // Indirectly excluded packages result from have a build dependency on a package

                // that is directly excluded.

                //  

                // In the following code we will extract from the Database all build exclusions

                // We will then add 'Relevant' entries to mBuildExclusionCollection

                // and delete, from the database those that are no longer relevant - ie indirectly excluded

                // items where the root cause is no longer in the set.

                phase.setPhase("mBuildExclusionCollection");

                mBuildExclusionCollection.clear();

                ArrayList<BuildExclusion> tempBuildExclusionCollection = new ArrayList<BuildExclusion>();

                mLogger.debug("planRelease queryBuildExclusions");

                mReleaseManager.queryBuildExclusions(tempBuildExclusionCollection, mBaseline);

                // only populate mBuildExclusionCollection with tempBuildExclusionCollection entries which have a relevant root_pv_id

                // The entry is relevant if:

                //     It is for a directly excluded package,other than a RippleStop

                //     It is for an indirectly excluded package AND the reason for exclusion still exists

                //

                for (Iterator<BuildExclusion> it = tempBuildExclusionCollection.iterator(); it.hasNext(); )

                {

                    BuildExclusion buildExclusion = it.next();

                    if ( buildExclusion.isRelevant(tempBuildExclusionCollection) )

                    {

                        mBuildExclusionCollection.add(buildExclusion);

                    }

                    else

                    {

                        // Remove the indirectly excluded entry as its root cause

                        // is no longer present.

                        buildExclusion.includeToBuild(mReleaseManager, mBaseline);

                    }

                }

            }

            //-----------------------------------------------------------------------

            //	Query package versions

            //

            phase.setPhase("queryPackageVersions");

            mLogger.debug("planRelease queryPackageVersions");

            mReleaseManager.queryPackageVersions(this, mPackageCollection, mBaseline);

            //------------------------------------------------------------------------

            //    Process packages collected

            //    Determine and tag those we can't build

            phase.setPhase("processPackages");

            processPackages();

            //-----------------------------------------------------------------------

            //    At this point we have tagged all the packages that we cannot build

            //    Now we can determine what we are building

            phase.setPhase("planBuildOrder");

            mLogger.debug("planRelease process Remaining");

            planBuildOrder();

            //  Report excluded packages and the build plan

            //  This is being done with the MUTEX being held, but the 

            //  trade off is the cost of getting a connection.

            //

            if ( mDaemon )

            {

                phase.setPhase("Report Change");

                reportChange();

                phase.setPhase("Report Plan");            

                reportPlan();

            }

            //

            //	Generate the build Files

            //

            phase.setPhase("generateBuildFiles");

            generateBuildFiles();

        }

        finally

        {

            mLogger.debug("planRelease finally");

            // this block is executed regardless of what happens in the try block

            // even if an exception is thrown

            // ensure the SELECT FOR UPDATE is released

            try

            {

                if ( mDaemon )

                {

                    // attempt to release the SELECT FOR UPDATE through a commit

                    // a commit must be done in the normal case

                    // a commit may as well be done in the Exception case

                    // in the case of a SQLException indicating database connectivity has been lost

                    // having a go at the commit is superfluous

                    // as the SELECT FOR UPDATE will have been released upon disconnection

                    phase.setPhase("releaseMutex");

                    mReleaseManager.releaseMutex();

                }

            }

            finally

            {

                // ensure disconnect under all error conditions

                phase.setPhase("disconnectForPlanning");

                mReleaseManager.disconnectForPlanning(lastBuildActive);

            }

        }

        mLogger.warn("planRelease mDaemon " + mDaemon + " returned");

        phase.setPhase("EndPlan");

    }

    /** Process packages that have been collected as a part of the plan

     * @param phase

     * @throws SQLException

     * @throws Exception

     */

    private void processPackages() throws SQLException, Exception {

        // Deal with test builds here as they may impact upon package attributes

        //    eg dependency collection and build standard differences

        //    This gives test builds preferential treatment

        //    Note: Done before mPackageDependencyCollection is setup

        //

        if ( mDaemon )

        {

            // process test builds

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

            {

                Package p = it.next();

                if (p.mBuildFile == 0)

                {

                    // package has yet to be processed

                    if (  p.mTestBuildInstruction > 0 )

                    {

                        mLogger.info("planRelease package test build " + p.mName);

                        //

                        //    Cannot test build an SDK based package or a Pegged Package

                        //        Remove the test build request from the database

                        //        Send a warning email

                        //

                        if(p.mIsPegged || p.mIsSdk)

                        {

                            String reason;

                            reason = (p.mIsPegged) ? "Pegged" : "SDK Based";

                            mLogger.error("planRelease Daemon Instruction of " + reason + " package deleted: " + p.mName);

                            mReleaseManager.markDaemonInstCompleted( p.mTestBuildInstruction );

                            emailRejectedDaemonInstruction("Cannot 'Test Build' a " + reason + " package",p);

                        }

                        // force patch for test build numbering

                        p.mDirectlyPlanned = true;

                        p.mChangeType.setPatch();

                        p.mRequiresSourceControlInteraction = false;

                        p.mBuildReason = BuildReason.Test;

                        rippleIndirectlyPlanned(p);

                        // put the mTestBuildAttributes to work

                        p.mVcsTag = p.mTestBuildVcsTag;

                        p.mId = p.mTestBuildPvId;

                        p.setTestEmail();

                        p.setTestDependencyCollection();

                        p.setTestBuildStandardCollection();

                        p.mHasAutomatedUnitTests = p.mTestBuildHasAutomatedUnitTests;

                    }

                }

            }

        }

        // Set up mPackageDependencyCollection on each package

        //    Examine the dependencies by alias and convert this to a 'package' selected from the released package set

        mLogger.debug("planRelease setup mPackageDependencyCollection");

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

        {

            Package p = it.next();

            for (Iterator<String> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )

            {

                String alias = it2.next();

                Package dependency = findPackage(alias);

                p.mPackageDependencyCollection.add(dependency);

            }

        }

        // DEVI 56479 detect and deal with circular dependencies

        mLogger.debug("planRelease deal with circular dependencies");

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

        {

            Package p = it.next();

            if ( p.hasCircularDependency( this ) )

            {

                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

                // max 50 chars

                rippleBuildExclude(p, p.mId, "Package has circular dependency", null, null, true);

                // 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 = mPackageCollection.iterator(); it.hasNext(); )

        {

            Package p = it.next();

            if ( mDaemon )

            {

                //  Daemon Mode Only

                //  Not interested in the dependencies of a pegged package or a package provided from an SDK.

                //  Such packages will be deemed to not have missing dependencies

                if (p.mIsPegged || p.mIsSdk)

                {

                    continue;

                }

            }

            for (Iterator<String> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )

            {

                String alias = it2.next();

                Package dependency = findPackage(alias);

                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);

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

                }

            }

        }

        // Process packages which are not reproducible, and all packages dependent upon them

        //    ie: Have no build standard      

        mLogger.debug("planRelease process packages which are not reproducible");

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

        {

            Package p = it.next();

            if (p.mBuildFile == 0)

            {

                if ( mDaemon )

                {

                    //  Daemon Mode Only

                    //  Not interested in the reproducibility of a pegged package or a package provided from an SDK.

                    //  Such packages will be deemed to be reproducible - but out side of this release

                    if (p.mIsPegged || p.mIsSdk)

                    {

                        continue;

                    }

                }

                // package has yet to be processed

                if (!p.isReproducible())

                {

                    // for escrow build purposes, exclude all dependent package versions

                    mLogger.info("planRelease package not reproducible " + p.mName);

                    // max 50 chars

                    rippleBuildExclude(p, p.mId, "Package has no build environment", null, null, true);

                    // package is not reproducible, discard

                    p.mBuildFile = -1;

                    mLogger.info("planRelease set mBuildFile to -1 for package " + p.mAlias );

                    standardOut(mAnyBuildPlatforms, p.mAlias, mAnyBuildPlatformsFlag);

                    mAnyBuildPlatformsFlag = false;

                }

            }

        }

        //    Process packages which are not reproducible on the configured set of  build machines.

        //

        //    Test each package and determine if the package contains a buildStandard that

        //    can be processed by one of the machines in the build set

        //

        //    ie: Package: Win32:Production and we have a BM with a class of 'Win32'

        //

        //    July-2014 

        //    Only exclude the failing package and not its dependents

        //    May be legitimate in the release

        //

        mLogger.debug("planRelease process packages which are not reproducible2");

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

        {

            Package p = it.next();

            if (p.mBuildFile == 0)

            {

                if ( mDaemon )

                {

                    //  Daemon Mode Only

                    //  Not interested in the reproducibility of a pegged package or a package provided from an SDK.

                    //  Such packages will be deemed to be reproducible - but out side of this release

                    if (p.mIsPegged || p.mIsSdk)

                    {

                        continue;

                    }

                }

                // package has yet to be processed

                // assume it does not need to be reproduced for this baseline

                //

                //    For each machineClass in the buildset

                boolean reproduce = false;

                for (Iterator<String> it2 = mReleaseManager.mReleaseConfigCollection.mMachineClasses.iterator(); it2.hasNext(); )

                {

                    String machineClass = it2.next();

                    if ( p.canBeBuildby(machineClass))

                    {

                        reproduce = true;

                        mLogger.info("planRelease package built on " + machineClass + " " + p.mAlias );

                        break;

                    }

                }

                if ( !reproduce )

                {

                    mLogger.info("planRelease package not reproducible on the build platforms configured for this baseline " + p.mName);

                    if (mDaemon)

                    {

                        // DEVI 54816

                        // for escrow build purposes, do not exclude all dependent package versions

                        // max 50 chars

                        rippleBuildExclude(p, p.mId, "Package not built for configured platforms", null, null, false);

                    }

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

        {

            // Daemon Mode Only

            // Process packages which are not ripple buildable, and all packages dependent upon them

            mLogger.debug("planRelease process packages which are not ripple buildable");

            for (ListIterator<BuildExclusion> it = mBuildExclusionCollection.listIterator(); it.hasNext(); )

            {

                BuildExclusion be = it.next();

                for (Iterator<Package> it1 = mPackageCollection.iterator(); it1.hasNext(); )

                {

                    Package p = it1.next();

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

                        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(); )

            {

                Package p = it.next();

                if (p.mBuildFile == 0)

                {

                    //  Not interested in a pegged package or a package provided from an SDK.

                    //  Such packages are not rippled

                    if (p.mIsPegged || p.mIsSdk)

                    {

                        continue;

                    }

                    // package has yet to be processed

                    if (p.mDirectlyPlanned)

                    {

                        // a WIP exists on the package, or it is a Test Build

                        // exclude all dependent package versions

                        mLogger.info("planRelease package has WIP " + p.mName);

                        if ( p.mBuildReason == null)

                            p.mBuildReason = BuildReason.NewVersion;

                        rippleIndirectlyPlanned(p);

                    }

                    else

                    {

                        //    Examine this packages dependencies

                        //    If one of them does not exist in the 'official release' set then

                        //    the package needs to be built against the official release set

                        //    and we can't build any of its dependent packages

                        Iterator<Integer> it2 = p.mDependencyIDCollection.iterator();

                        Iterator<Package> it3 = p.mPackageDependencyCollection.iterator();

                        while ( it2.hasNext() && it3.hasNext() )

                        {

                            Integer dpvId = it2.next();

                            Package dependency = it3.next();

                            if ( !dependency.mAdvisoryRipple )

                            {

                                // not advisory, ie: has ripple build impact

                                if ( !isInRelease(dpvId) )

                                {

                                    // the package is out of date

                                    // exclude all dependent package versions

                                    mLogger.info("planRelease package out of date " + p.mName);

                                    p.mBuildReason = BuildReason.Ripple;

                                    rippleIndirectlyPlanned(p);

                                    //  This package needs to be rippled

                                    //  If this package has a rippleStop marker of 's', then we cannot

                                    //  build this package at the moment.

                                    //  Packages that depend on this package have been excluded

                                    //  We need to exclude this one too

                                    //

                                    if (p.mRippleStop == 's' || p.mRippleStop == 'w') 

                                    {

                                        // Package marked as a rippleStop

                                        // max 50 chars

                                        rippleBuildExclude(p, -2, "Ripple Required." + " Waiting for user", null, null, false);

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

                                        }

                                    }

                                    break;

                                }

                            }

                        }

                    }

                }

            }

            //  Daemon Mode Only

            //  Process packages which do not exist in the archive

            //  For unit test purposes, assume all packages exist in the archive if released

            mLogger.debug("planRelease process packages which do not exist in the archive");

            if ( ReleaseManager.mUseDatabase )

            {

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

                {

                    Package p = it.next();

                    if (p.mBuildFile == 0)

                    {

                        // package has yet to be processed

                        if (!p.mDirectlyPlanned && !p.mIndirectlyPlanned && p.mForcedRippleInstruction == 0)

                        {

                            // check package version archive existence

                            if (!p.existsInDpkgArchive())

                            {

                                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);

                                    // max 50 chars

                                    rippleBuildExclude(p, p.mId, "Unbuildable" + " package not found in archive", null, null, true);

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

                                {

                                    String reason;

                                    reason = (p.mIsPegged) ? "Pegged" : "SDK";

                                    //  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 " + reason + " package not found in archive " + p.mName);

                                    // max 50 chars

                                    rippleBuildExclude(p, p.mId, reason + " package not found in archive", null, null, true);

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

                                    //    If one of them does not exist in the 'official release' set then

                                    //    the package cannot be rebuilt in this release.

                                    for (Iterator<Integer> it2 = p.mDependencyIDCollection.iterator() ; it2.hasNext() ;)

                                    {

                                        Integer dpvId = it2.next();

                                        if ( !isInRelease(dpvId) )

                                        {

                                            // 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 du to  " + p.mName);

                                            // max 50 chars

                                            rippleBuildExclude(p, p.mId, "Package cannot be rebuilt in this release", null, null, true);

                                            // package is not reproducible, mark reason and discard

                                            p.mBuildFile = -4;

                                            break;

                                        }

                                    }

                                    //  The package has not been excluded from the build

                                    if (p.mBuildFile == 0)

                                    {

                                        mLogger.info("planRelease package not found in archive " + p.mName);

                                        // DEVI 47395 the cause of this build is not WIP or ripple induced,

                                        // it simply does not exist in the archive (has been removed)

                                        // prevent source control interaction

                                        p.mRequiresSourceControlInteraction = false;

                                        p.mBuildReason = BuildReason.Restore;

                                        rippleIndirectlyPlanned(p);

                                    }

                                }

                            }

                        }

                    }

                }

            }

            //  Daemon Mode Only

            //  Process forced ripples

            mLogger.debug("planRelease process forced ripples");

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

            {

                Package p = it.next();

                if (p.mBuildFile == 0)

                {

                    // package has yet to be processed

                    if ( p.mForcedRippleInstruction > 0 )

                    {

                        //

                        //    Cannot force a ripple on an SDK based package or a Pegged Package

                        //        Remove the daemon instruction from the database

                        //        Send a warning email

                        //

                        if(p.mIsPegged || p.mIsSdk)

                        {

                            String reason;

                            reason = (p.mIsPegged) ? "Pegged" : "SDK Based";

                            mLogger.error("planRelease Daemon Instruction of " + reason + " package deleted: " + p.mName);

                            mReleaseManager.markDaemonInstCompleted( p.mForcedRippleInstruction );

                            emailRejectedDaemonInstruction("Cannot 'Ripple' a " + reason + " package",p);

                            p.mBuildFile = -8; 

                        }

                        else

                        {

                            mLogger.info("planRelease package forced ripple " + p.mName);

                            p.mBuildReason = BuildReason.Ripple;

                            rippleIndirectlyPlanned(p);

                        }

                    }

                }

            }

            //  Daemon Mode Only

            //  Mark Pegged and SDK packages as not to be built

            //  Have previously detected conflicts between pegged/sdk packages and daemon instructions

            //

            mLogger.debug("planRelease remove pegged and SDK packages from the build set");

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

            {

                Package p = it.next();

                if (p.mBuildFile == 0)

                {

                    //  Not interested in a pegged package or a package provided from an SDK.

                    //  Such packages are not built

                    if (p.mIsPegged || p.mIsSdk)

                    {

                        String reason;

                        reason = (p.mIsPegged) ? "Pegged" : "SDK";

                        mLogger.info("planRelease " + reason + " not built in this release " + p.mName);

                        p.mBuildFile = -8;

                    }

                }

            }

            //  Daemon Mode Only

            //  Locate Test Build Requests that cannot be satisfied - will not be built due to

            //  errors in dependent packages. Report the error to the user and remove the request

            //

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

            {

                Package p = it.next();

                if (p.mTestBuildInstruction > 0)

                {

                    if (p.mBuildFile < 0)

                    {

                        String reason;

                        switch (p.mBuildFile)

                        {

                        case -1: reason = "Not reproducible"; break;

                        case -2: reason = "Not reproducible on configured build platforms"; break;

                        case -3: reason = "Marked as 'Do not ripple'"; break;

                        case -4: reason = "Dependent on a package not in the release"; break;

                        case -5: reason = "Indirectly dependent on a package not reproducible in the release"; break;

                        case -6: reason = "Has a circular dependency"; break;

                        case -7: reason = "Pegged or SDK package not in dpkg_archive"; break;

                        case -8: reason = "Is a Pegged or SDK package"; break;

                        case -9: reason = "Rejected Daemon Instruction"; break;

                        case -10: reason = "Unbuildable package not in dpkg_archive"; break;

                        case -11: reason = "Marked as 'RippleStop'"; break;

                        default: reason = "Unknown reason. Code:" + p.mBuildFile; break;

                        }

                        mLogger.error("planRelease Test Build of an unbuildable of package deleted: " + p.mName);

                        mReleaseManager.markDaemonInstCompleted( p.mTestBuildInstruction );

                        emailRejectedDaemonInstruction(reason,p);

                    }

                }

            }

        }

        else

        {

            // escrow reporting only

            // Report packages that are not reproducible

            //

            //  Note: I don't believe this code can be executed

            //        The -3 is only set in daemon mode

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

            {

                Package p = it.next();

                if (p.mBuildFile == -3)

                {

                    standardOut(mDependent, p.mAlias, mDependentFlag);

                    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 {

        // Process remaining packages which are need to be reproduced for this baseline.

        //    Determine the build file for each package

        //    For daemon builds:

        //      Determine the first package that can be built now, this means the first package 

        //      not dependent upon packages also to be built.

        //      Set its mBuildNumber to 1, all remaining reproducible packages to 2

        //      Add buildable packages to mBuildableCollection

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

        if ( mDaemon )

        {

            // Sort the build order such that the unit tests are sorted by instruction id 

            //  and placed at the head of the list. This is an attempt to have the oldest 

            //  unit tests at the head of the list.

            //

            //  The order of all other elements is preserved

            //  The order of the other elements is basically

            //      planned - ordered by modified date-time

            //      others  - order by pv_id

            //

            Package.setSequence(mPackageCollection);

            Collections.sort(mPackageCollection, Package.UnitTestComparator);

        }

        boolean allProcessed = false;

        int buildFile = 1;

        do

        {

            boolean allDependenciesProcessed = true;

            do

            {

                // assume all dependencies have been processed

                allDependenciesProcessed = true;

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

                {

                    Package p = it.next();

                    if ( (  mDaemon && ( ( !p.mDirectlyPlanned && !p.mIndirectlyPlanned ) || p.mBuildFile < 0 ) ) ||

                         ( !mDaemon && p.mBuildFile == -2 ) )

                    {

                        // Daemon: Flag packages with no build requirement as processed

                        // Escrow: Flag packages with a foreign build environment as processed

                        p.mProcessed = true;

                        mLogger.info("planRelease package has no build requirement " + p.mName);            

                    }

                    else if ( ( p.mBuildFile == 0 ) && ( (mDaemon && ( p.mDirectlyPlanned || p.mIndirectlyPlanned ) ) || ( !mDaemon ) ) )

                    {

                        // package yet to be processed and

                        //  Daemon mode: Has a build requirement

                        //  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.mDirectlyPlanned ) || ( dependency.mIndirectlyPlanned ) )