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

    /** Collections of packages

     */

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

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

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

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

    private ArrayList<Package> mPackageCollectionAll = 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<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: ";

    /**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 {} isDaemon {}", rtagId, isDaemon);

        mReleaseManager = releaseManager;

        mBaseline = rtagId;

        mRtagId = rtagId;

        mDaemon = isDaemon;

        mReleaseManager.setDaemonMode(mDaemon);

    }

    /**

     * getRtagId

     * @return The rtagId of the Release attached to this instance of the RippleEngine

     */

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

        mPackageCollectionRipple.clear();

        mPackageCollectionTest.clear();

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

            mReleaseManager.queryWips(this, mPackageCollectionWip, mBaseline);

            mReleaseManager.queryTest(this, mPackageCollectionTest, mBaseline);

            mReleaseManager.queryRipples(this, mPackageCollectionRipple, mBaseline);

            mPackageCollectionAll.addAll(mPackageCollection);

            mPackageCollectionAll.addAll(mPackageCollectionWip);

            mPackageCollectionAll.addAll(mPackageCollectionTest);

            mPackageCollectionAll.addAll(mPackageCollectionRipple);

            // Sort the collection by PVID

            //      Unit Test output order is known

            //      May assist in creating repeatable build orders

            //

            Collections.sort(mPackageCollectionAll, Package.SeqComparator);

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

            //    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 {} returned", mDaemon);

        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

        //    Note: Done before mPackageDependencyCollection is setup

        //

        if ( mDaemon )

        {

            // Process test builds - they are in their own collection

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

            {

                Package p = it.next();

                mLogger.info("planRelease package test build {}", p.mAlias);

                //

                //    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 (testBuild) of {} package deleted: {}", reason, p.mAlias);

                    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;

                p.mIndirectlyPlanned = true;

            }

        }

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

        for (Iterator<Package> it = mPackageCollectionAll.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);

            }

        }    

        // Detect and deal with circular dependencies

        // Examine all packages under consideration

        //

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

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

        {

            Package p = it.next();

            if ( p.hasCircularDependency( mPackageCollectionAll ) )

            {

                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 the package

                // max 50 chars

                rippleBuildExclude(p, p.mId, "Package has circular dependency", -6);

                // take the package out of the build

                standardOut(mCircularDependency, p.mAlias, mCircularDependencyFlag);

                mCircularDependencyFlag = false;

            }

        }

        // Scan for packages with missing dependencies

        //    ie: The dependent package is not in the package Collection

        mLogger.debug("planRelease use the fully built mPackageDependencyCollection");

        for (Iterator<Package> it = mPackageCollectionAll.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 the package

                    // max 50 chars

                    rippleBuildExclude(p, p.mId, "Package build dependency not in the release", -4);

                    // take the package out of the build

                    standardOut(mNotInBaseline, p.mAlias, mNotInBaselineFlag);

                    mNotInBaselineFlag = false;

                    break;

                }

            }

        }

        // Detect packages with no build standard and exclude them from the build

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

        for (Iterator<Package> it = mPackageCollectionAll.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;

                    }

                }

                // Does the package have a build standard. If not then we can't reproduce it.

                // 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", -1);

                    // package is not reproducible, discard

                    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'

        //

        //    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 = mPackageCollectionAll.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);

                    // Exclude the package

                    // max 50 chars

                    rippleBuildExclude(p, p.mId, "Package not built for configured platforms", -2);

                    // package is not reproducible on the build platforms configured for this baseline, discard

                    standardOut(mAssocBuildPlatforms, p.mAlias, mAssocBuildPlatformsFlag);

                    mAssocBuildPlatformsFlag = false;

                }

            }

        }      

        if (mDaemon )

        {

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

                    }

                    //    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", -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 ( mReleaseManager.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);

                                    // Exclude the package

                                    // max 50 chars

                                    rippleBuildExclude(p, p.mId, "Unbuildable" + " package not found in archive", -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 {} package not found in archive {}", reason, p.mName);

                                    // Exclude the package

                                    // max 50 chars

                                    rippleBuildExclude(p, p.mId, reason + " package not found in archive", -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 due to {}", p.mName);

                                            // Exclude the package

                                            // max 50 chars

                                            rippleBuildExclude(p, p.mId, "Package cannot be rebuilt in this release", -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

            //  Detect bad forced ripples requests and reject them

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

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

            {

                Package p = it.next();

                if (p.mBuildFile == 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 {} package deleted: {}", reason, p.mName);

                        mReleaseManager.markDaemonInstCompleted( p.mForcedRippleInstruction );

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

                        p.mBuildFile = -8; 

                    }

                }

            }

            //  Daemon Mode Only

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

            //  Mark RippleStoped packages as not to be build

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

                {

                    String reason = null;

                    //  Not interested in a pegged package or a package provided from an SDK or packages with an active RippleStop

                    //  Such packages are not built

                    if (p.mIsPegged ) {

                        reason = "Pegged";

                        p.mBuildFile = -8;

                    } else if (p.mIsSdk) {

                        reason = "SDK";

                        p.mBuildFile = -8;

                    } else if (p.mRippleStop == 's' || p.mRippleStop == 'w') {

                        reason = "RippleStop";

                        p.mBuildFile = -11;

                    }

                    if (reason != null)

                    {

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

                    }

                }

            }

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

            {

                Package p = it.next();

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

                }

            }

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

            //

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

        {

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