Subversion Repositories DevTools

package com.erggroup.buildtool.ripple;

import java.io.File;

import java.sql.SQLException;

import java.util.Iterator;

import java.util.ListIterator;

import java.util.Vector;

import org.apache.log4j.Logger;

import java.util.regex.PatternSyntaxException;

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

 */

public class RippleEngine

{

  /**collection of gbemachtypes in String form associated with the baseline

   * limited to the following items "win32", "sparc", "solaris10_sparc32", "solaris10_x86", "linux_i386"

   * accessed by Package::isLinuxBuilt, isSolarisBuilt, isWin32Built

   * @attribute

   */

  Vector<String> mGbeMachtypeCollection = new Vector<String>();

  /**configured mail server

   * @attribute

   */

  public String mMailServer = new String();

  /**configured mail sender user

   * @attribute

   */

  public String mMailSender = new String();

  /**configured global email target

   * @attribute

   */

  public String mGlobalTarget = new String();

  /**name associated with the baseline

   * @attribute

   */

  public String mBaselineName = new String();

  /**collection of released pv_ids associated with the release

   * @attribute

   */

  Vector<Integer> mReleasedPvIDCollection = new Vector<Integer>();

  /**timestamp associated with build file generation

   * @attribute

   */

  long mTimestamp = 0;

  /**set to "non generic", "generic" or "dummy" to indicate the nature of the package in the build file in daemon mode

   * @attribute

   */

  String mAddendum = new String("dummy");

  /**collection of build exceptions associated with the baseline

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

   * deamon centric

   * @aggregation shared

   * @attribute

   */

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

  /**Logger

   * @attribute

   */

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

  /**collection of escrow clearcase support file content in String form, set_up

   * @attribute

   */

  private Vector<String> mEscrowClearcaseSupportCollection = new Vector<String>();

  /**package versions representing the baseline

   * escrow centric

   * @aggregation shared

   * @attribute

   */

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

  /**index to current String item

   * @attribute

   */

  private int mBuildIndex;

  /**Database abstraction

   * @attribute

   */

  private ReleaseManager mReleaseManager;

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

   * @attribute

   */

  private int mBaseline;

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

   */

  boolean mDaemon;

  /**collection of build file content in String form

   * @attribute

   */

  private Vector<String> mBuildCollection = new Vector<String>();

  /**constructor

   */

  public RippleEngine(ReleaseManager releaseManager, int rtag_id, 

                      boolean isDaemon)

  {

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

    mReleaseManager = releaseManager;

    mBaseline = rtag_id;

    mDaemon = isDaemon;

  }

  /**discards all build file content

   * plans new build file content

   */

  public void planRelease() throws SQLException, Exception

  {

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

    mAddendum = "dummy";

    mBuildCollection.removeAllElements();

    mPackageCollection.removeAllElements();

    mReleasedPvIDCollection.removeAllElements();

    if ( !mDaemon )

    {

      mEscrowClearcaseSupportCollection.removeAllElements();  

    }

    mReleaseManager.connect();

    if ( mDaemon )

    {

      // claim the mutex

      mReleaseManager.claimMutex();

      mBuildExclusionCollection.removeAllElements();

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

      mReleaseManager.queryBuildExclusions(tempBuildExclusionCollection, mBaseline);

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

      // ie the root_pv_id is ONLY relevant if it is null (-1) or it points to a pv_id in the collection

      // the package with a pv_id which is a root_pv_id may be removed ie when fixing a build issue

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

      {

        BuildExclusion buildExclusion = it.next();

        if ( buildExclusion.isRelevant(tempBuildExclusionCollection) )

        {

          mBuildExclusionCollection.add(buildExclusion);

        }

        else

        {

          // this is just a cosmetic step

          // it includes package versions which have been indirectly excluded

          // the build daemon ignores this information, but it serves to clarify this point to users

          buildExclusion.includeToBuild(mReleaseManager, mBaseline);

        }

      }

    }

    mReleaseManager.queryPackageVersions(this, mPackageCollection, mDaemon, mBaseline);

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

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

          // take the package out of the build

          p.mBuildFile = -4;

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

          break;

        }

        p.mPackageDependencyCollection.add(dependency);

      }

    }

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

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

    {

      Package p = it.next();

      if (p.mBuildFile == 0)

      {

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

          //  At the moment it will cause too much pain in daemon mode

          //  Yes, it does need to be enabled - but not today

          if ( !mDaemon )

          {

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

          }

          // package is not reproducible, discard

          p.mBuildFile = -1;

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

        }

      }

    }

    // process packages which are not reproducible on the build platforms configured for this baseline

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

    {

      Package p = it.next();

      if (p.mBuildFile == 0)

      {

        // package has yet to be processed

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

        boolean reproduce = false;

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

        {

          String machtype = it2.next();

          if ( machtype.compareTo("linux_i386") == 0 )

          {

            if ( p.isLinuxBuilt() )

            {

              reproduce = true;

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

              break;

            }

          }

          else if ( machtype.compareTo("win32") == 0 )

          {

            if ( p.isWin32Built() )

            {

              reproduce = true;

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

              break;

            }

          }

          else if ( machtype.compareTo("sparc") == 0

                 || machtype.compareTo("solaris10_x86") == 0

                 || machtype.compareTo("solaris10_sparc32") == 0 )

          {

            if ( p.isSolarisBuilt() )

            {

              reproduce = true;

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

              break;

            }

          }

        }

        if ( !reproduce )

        {

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

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

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

          p.mBuildFile = -2;

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

        }

      }

    }      

    if (mDaemon)

    {

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

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

      {

        BuildExclusion be = it.next();

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

        {

          Package p = it1.next();

          if ( be.compare(p.mId) )

          {

            if ( p.mBuildFile == 0 )

            {

              // exclude all dependent package versions

              mLogger.info("planRelease do not ripple " + p.mName);

              // provide the root id and cause as recorded in the database

              rippleBuildExclude(p, be, it);

              // package is not reproducible, discard

              p.mBuildFile = -3;

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

            }

            break;

          }

        }

      }

      // process packages which need to be ripple built

      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)

          {

            // a WIP exists on the package

            // exclude all dependent package versions

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

            rippleIndirectlyPlanned(p);

          }

          else

          {

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

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

            for ( ; it2.hasNext() && it3.hasNext(); )

            {

              Integer dpv_id = it2.next();

              Package dependency = it3.next();

              if ( !dependency.mAdvisoryRipple )

              {

                // not advisory, ie has ripple build impact

                boolean found = false;

                for ( Iterator<Integer> it4 = mReleasedPvIDCollection.iterator(); it4.hasNext(); )

                {

                  Integer pv_id = it4.next();

                  if ( pv_id.compareTo(dpv_id) == 0 )

                  {

                    found = true;

                    break;

                  }

                }

                if ( !found )

                {

                  // the package is out of date

                  // exclude all dependent package versions

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

                  rippleIndirectlyPlanned(p);                 

                  break;

                }

              }

            }

          }

        }

      }

      // process packages which do not exist in the archive

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

      {

        Package p = it.next();

        if (p.mBuildFile == 0)

        {

          // package has yet to be processed

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

          if ( ReleaseManager.mUseDatabase )

          {

            // only check existence outside the unit test

            if (!p.mDirectlyPlanned && !p.mIndirectlyPlanned)

            {

              // check package version archive existence

              if (!p.exists())

              {

                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;

                rippleIndirectlyPlanned(p);

              }

            }

          }

        }

      }

    }

    // process remaining packages which 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

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

    // delete the file <rtagId>official

    Integer rtag = new Integer(mBaseline);

    File rtagIdOfficial = new File(rtag + "official");

    if (rtagIdOfficial.exists())

    {

      boolean del = rtagIdOfficial.delete();

      if ( !del )

      {

        // the delete failed

        // some literature suggests a forced garbage collection may free up resources associated with file handles

        // nothing to lose since the file "must" be deleted

        System.gc();

        del = rtagIdOfficial.delete();

        if ( !del )

        {

          mLogger.fatal("rtagIdOfficial.delete() returned " + del);

        }

      }

    }

    String raw_data = new String("");

    String lf = new String( System.getProperty("line.separator") );

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

          {

            // flag packages with no build requirement as processed in daemon mode

            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

              // in daemon mode has a build requirement or

              // in escrow mode

              boolean canBeBuiltNow = true;

              boolean allDependenciesForThisPackageProcessed = true;

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

              {

                Package dependency = it2.next();

                if ( !dependency.mProcessed )

                {

                  // cannot determine canBeBuiltNow until this dependency has been processed

                  allDependenciesForThisPackageProcessed = false;

                  allDependenciesProcessed = false;

                }

                else if ( ( mDaemon && ( dependency.mDirectlyPlanned ) || ( dependency.mIndirectlyPlanned ) ) || 

                          ( !mDaemon &&

                            ( ( dependency.mBuildFile == 0 ) ||

                              ( dependency.mBuildFile == buildFile &&

                                ( ( p.isLinuxBuilt() && !dependency.isLinuxBuilt() ) ||

                                  ( p.isWin32Built() && !dependency.isWin32Built() ) ||

                                  ( p.isSolarisBuilt() && !dependency.isSolarisBuilt() ) ||

                                  ( !p.isLinuxBuilt() && dependency.isLinuxBuilt() ) ||

                                  ( !p.isWin32Built() && dependency.isWin32Built() ) ||

                                  ( !p.isSolarisBuilt() && dependency.isSolarisBuilt() ) ) ) ) ) )

                {

                  // in daemon mode this processed dependency has a build requirement or

                  // in escrow mode...

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

                  // this processed dependency has been assigned to this build iteration and does not build on this platform

                  canBeBuiltNow = false;

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

                  break;

                }

              }

              if (allDependenciesForThisPackageProcessed)

              {

                p.mProcessed = true;

                if ( mDaemon )

                {

                  if ( canBeBuiltNow )

                  {

                    // flag package with build requirement, may get downgraded to future build requirement

                    p.mBuildFile = 1;

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

                  }

                  else

                  {

                    // flag package with future build requirement

                    p.mBuildFile = 2;

                    mLogger.warn("planRelease set mBuildFile to 2 for package " + p.mAlias );

                  }

                }

                else

                {

                  if ( canBeBuiltNow )

                  {

                    if ( !mDaemon )

                    {

                      String isWin32Built = new String("");

                      if ( p.isWin32Built() )

                      {

                        isWin32Built = "W";

                      }

                      String isLinuxBuilt = new String("");

                      if ( p.isLinuxBuilt() )

                      {

                        isLinuxBuilt = "L";

                      }

                      String isSolarisBuilt = new String("");

                      if ( p.isSolarisBuilt() )

                      {

                        isSolarisBuilt = "S";

                      }

                      String isGeneric = new String("");

                      if ( p.isGeneric() )

                      {

                        isGeneric = "G";

                      }

                      raw_data += p.mAlias + "," +

                                  isWin32Built + "," +

                                  isLinuxBuilt + "," +

                                  isSolarisBuilt + "," +

                                  isGeneric + "," +

                                  buildFile +

                                  lf;

                    }

                    // not daemon

                    p.mBuildFile = buildFile;

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

                  }

                }

              }

            }

          }

        }

      } while( !allDependenciesProcessed );

      if ( mDaemon )

      {

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

        {

          Package p = it.next();

          if ( p.mProcessed && p.mBuildFile == 1 )

          {

            p.mBuildFile = buildFile;

            mLogger.warn("planRelease 2 set mBuildFile to " + buildFile + " for package " + p.mAlias );

            if ( buildFile == 1 )

            {

              int pvApplied = p.applyPV(mReleaseManager, mBaseline);

              if ( pvApplied == 1 )

              {

                // max 50 chars

                rippleBuildExclude(p, p.mId, "Package has non standard versioning", null);

              }

              else

              if ( pvApplied == 2 )

              {

                // max 50 chars

                rippleBuildExclude(p, p.mId, "Package has reached ripple field limitations", null);

              }

              else

              {

                buildFile = 2;

              }

            }

            else

            {

              mLogger.info("planRelease package has future (downgraded) build requirement " + p.mName + " " + buildFile);              

            }

          }

        }

      }

      // are more build files required

      allProcessed = true;

      if (mDaemon)

      {

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

        {

          Package p = it.next();

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

          {

            // at this point...

            // only 1 package with a build requirement has a mBuildFile of 1,

            // all other packages with a build requirement have an mBuildFile of 2

            // give packages with no build requirement, reproducible or not, an mBuildFile of 3

            p.mBuildFile = 3;

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

          }

        }

      }

      else

      {

        // this is escrow mode centric

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

        {

          Package p = it.next();

          if ( p.mBuildFile == 0 )

          {

            // more build files are required

            allProcessed = false;

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

            break;

          }

        }

        buildFile++;

      }

    } while( !allProcessed );

    // persist the build files

    allProcessed = false;

    buildFile = 1;

    if ( mDaemon )

    {

      // all interesting packages in daemon mode match the following filter

      buildFile = 3;

    }

    mTimestamp = System.currentTimeMillis();

    if ( !ReleaseManager.mUseDatabase )

    {

      mTimestamp = 123456789;

    }

    do

    {

      String buildFileContent = new String( generateBuildFileHeader() );

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

      {

        Package p = it.next();

        if ( ( p.mBuildFile > 0 ) && ( p.mBuildFile <= buildFile ) )

        {

          buildFileContent += generatePackageProperty(p);

        }

      }

      buildFileContent += generateTaskdef();

      String set_up = new String("");

      boolean daemonHasTarget = false;

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

      {

        Package p = it.next();

        if ( p.mBuildFile > 0 && p.mBuildFile <= buildFile )

        {

          buildFileContent += generateTarget(p, buildFile);

          if ( p.mBuildFile == 1 )

          {

            daemonHasTarget = true;

          }

        }

        if ( !mDaemon && buildFile == 1 )

        {

          // for the purposes of the set up, use /

          String loc = new String("");

          try

          {

            // The regular expression "\\\\" matches an escape character "\\" and a single backslash "\\"

            loc = p.mLocation.replaceAll("\\\\", "/");

          }

          catch( PatternSyntaxException e )

          {

          }

          set_up += "jats release -extractfiles"

                    + " \"-label=" + p.mLabel + "\""

                    + " \"-path=" + loc + "\""

                    + " \"-view=" + p.mAlias + "\""

                    + " -root=. -noprefix"

                    + lf;

        }

      }

      if ( mDaemon && !daemonHasTarget )

      {

        // must have AbtSetUp, AbtTearDown, and AbtPublish targets

        buildFileContent += "<target name=\"AbtSetUp\"/>" + lf +

                            "<target name=\"AbtTearDown\"/>" + lf +

                            "<target name=\"AbtPublish\"/>" + lf;

      }

      if ( !mDaemon && buildFile == 1 )

      {

        mEscrowClearcaseSupportCollection.add(set_up);

        mEscrowClearcaseSupportCollection.add(raw_data);

      }

      buildFileContent += generateDefaultTarget( buildFile);

      buildFileContent += generateBuildFileFooter();

      mBuildCollection.add(buildFileContent);

      // are more build files required

      allProcessed = true;

      if (!mDaemon)

      {

        // this is escrow mode centric

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

        {

          Package p = it.next();

          if ( p.mBuildFile > buildFile )

          {

            // more build files are required

            allProcessed = false;

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

            break;

          }

        } 

        buildFile++;

      }

    } while( !allProcessed );

    if ( mDaemon )

    {

      // report what change in build exceptions happens as part of planRelease

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

      {

        BuildExclusion buildExclusion = it.next();

        if ( !buildExclusion.isProcessed() )

        {

          // notify

          buildExclusion.excludeFromBuild(mReleaseManager, mBaseline);

          buildExclusion.email(mPackageCollection, mMailServer, mMailSender, mBaselineName);

        }

      }

    }

    mReleaseManager.disconnect();

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

  }

  /**returns first build file content

   * returns false if no build file content exists

   */

  public boolean getFirstBuildFileContent(MutableString content)

  {

    mLogger.debug("getFirstBuildFileContent");

    boolean retVal = true;

    try

    {

      mBuildIndex = 0;

      content.value = (String)mBuildCollection.get( mBuildIndex );

    }

    catch( ArrayIndexOutOfBoundsException e )

    {

      retVal = false;

    }

    mLogger.info("getFirstBuildFileContent returned " + retVal);

    return retVal;

  }

  /**returns next build file content

   * returns false if no next build file content exists

   */

  public boolean getNextBuildFileContent(MutableString content)

  {

    mLogger.debug("getNextBuildFileContent");

    boolean retVal = true;

    try

    {

      mBuildIndex++;

      content.value = (String)mBuildCollection.get( mBuildIndex );

    }

    catch( ArrayIndexOutOfBoundsException e )

    {

      retVal = false;

    }

    mLogger.debug("getNextBuildFileContent returned " + retVal);

    return retVal;

  }

  /**collects meta data associated with the baseline

   * this is sufficient to send an indefinite pause email notification

   */

  public void collectMetaData() throws SQLException, Exception

  {

    mLogger.debug("collectMetaData mDaemon " + mDaemon);

    mGbeMachtypeCollection.removeAllElements();

    mReleaseManager.connect();

    mReleaseManager.queryMachtypes(mGbeMachtypeCollection, mDaemon, mBaseline);

    if (mDaemon)

    {

      mMailServer = mReleaseManager.queryMailServer();

      mMailSender = mReleaseManager.queryMailSender();

      mGlobalTarget = mReleaseManager.queryGlobalAddresses();

    }

    mBaselineName = mReleaseManager.queryBaselineName(mDaemon, mBaseline);

    mReleaseManager.disconnect();

  }

  /**returns the Package with the matching mAlias or NULL_PACKAGE if no package has the mID

   */

  private Package findPackage(String alias)

  {

    mLogger.debug("findPackage");

    Package retVal = ReleaseManager.NULL_PACKAGE;

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

    {

      Package p = it.next();

      if ( p.mAlias.compareTo( alias ) == 0 )

      {

        retVal = p;

        break;

      }

    }

    mLogger.info("findPackage returned " + retVal.mName);

    return retVal;

  }

  /**sets the mBuildFile to -5 for the package and all dependent packages

   */

  private void rippleBuildExclude(Package p, int root_pv_id, String root_cause, ListIterator<BuildExclusion> list )

  {

    mLogger.debug("rippleBuildExclude");

    if ( p.mBuildFile == 0 || p.mBuildFile == 1 )

    {

      p.mBuildFile = -5;

      mLogger.warn("rippleBuildExclude set mBuildFile to -5 for package " + p.mAlias );

      // if found, process it, else add it (unprocessed)

      boolean found = false;

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

      {

        BuildExclusion buildExclusion = it.next();

        if ( buildExclusion.compare(p.mId, root_pv_id, root_cause))

        {

          found = true;

          buildExclusion.process();

          break;

        }

      }

      if (!found)

      {

        // process all occurrences for this package

        // these will be superceded by a new build exclusion entry

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

        {

          BuildExclusion buildExclusion = it.next();

          if ( buildExclusion.compare(p.mId))

          {

            buildExclusion.process();

          }

        }

        BuildExclusion buildExclusion = new BuildExclusion(p.mId, root_pv_id, root_cause);

        if ( list == null )

        {

          mBuildExclusionCollection.add(buildExclusion);

        }

        else

        {

          // must use the ListIterator interface to add to the collection whilst iterating through it

          list.add(buildExclusion);

        }

      }

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

      {

        Package pkg = it.next();

        if ( pkg != p )

        {

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

          {

            Package dependency = it2.next();

            if ( dependency == p )

            {

              rippleBuildExclude( pkg, root_pv_id, null, list );

              break;

            }

          }

        }

      }

    }

    mLogger.info("rippleBuildExclude set " + p.mName + " " + p.mBuildFile);

  }

  /**sets the mBuildFile to -5 for the package and all dependent packages

   */

  private void rippleBuildExclude(Package p, BuildExclusion buildExclusion, ListIterator<BuildExclusion> list )

  {

    mLogger.debug("rippleBuildExclude");

    if ( p.mBuildFile == 0 || p.mBuildFile == 1 )

    {

      p.mBuildFile = -5;

      mLogger.warn("rippleBuildExclude set mBuildFile to -5 for package " + p.mAlias );

      buildExclusion.process();

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

      {

        Package pkg = it.next();

        if ( pkg != p )

        {

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

          {

            Package dependency = it2.next();

            if ( dependency == p )

            {

              rippleBuildExclude( pkg, p.mId, null, list );

              break;

            }

          }

        }

      }

    }

    mLogger.info("rippleBuildExclude set " + p.mName + " " + p.mBuildFile);

  }

  /**returns a build file header for the mBaseline

   */

  private String generateBuildFileHeader()