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<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 {} 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( 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 = 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 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;

                }

            }

        }

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

                    // max 50 chars

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

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

        //

        //    Only exclude the failing package and not its dependents

        //    May be legitimate in the release

        //

//TODO - verify this code. I'm not sure it can be reached. I think that the "Package has no build environment" test above is detecting all these packages

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

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

        {

            Package p = it.next();

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

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

                    }

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

                                    // 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 {} package not found in archive {}", reason, 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 due 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

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

            //  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 {} not built in this release {}", reason, 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 = 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);

                }

            }

        }

        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 - Planing is not working well

/**

 * Current status

 * The selection of the package to build next is deeply flawed

 * Currently it will select a ripple over a directly planned package - thus the unit tests are not working

 * 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:

 *      Need to include all packages that we can now build into the final build plan, not just the first one and its build tree

 * 

 *      Need to generate a single package set - so that WIPS and others replace those in the final build set

 *      Remove duplicates from the complete package set

 *      

 *      Need more test cases

 *      

 *      Need to report all build options, not just the selected one

 *      

 *      Cleanup the ANT build file - don't list all the release dependencies, just those needed to build the current package

 */

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

        boolean allProcessed = false;

        int buildFile = 1;

        do

        {

            //

            //  Create the mBuildOrder collection

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

                {

                    Package p = it.next();

                    if ( p.mBuildFile < 0  ) 

                    {

                        // Daemon: Flag packages that cannot be built

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

                        p.mProcessed = true;

                        mLogger.info("planRelease package not buildable {}", p.mName);            

                    }

                    else if ( p.mBuildFile == 0 )

                    {

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

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

                                                           ( dependency.mBuildFile == buildFile &&

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

                            {

                                // Daemon mode:

                                //    This processed dependency has not been assigned to a build iteration - so can't built yet

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

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