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

    }

    // use finally block in planRelease to ensure releaseMutex is called

    try

    {

      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.info("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

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

            // package is not reproducible, discard

            p.mBuildFile = -1;

            mLogger.info("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.info("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.info("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.info("planRelease set mBuildFile to 1 for package " + p.mAlias );

                    }

                    else

                    {

                      // flag package with future build requirement

                      p.mBuildFile = 2;

                      mLogger.info("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.info("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.info("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);

          }

        }

      }

    }

    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

      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

        mReleaseManager.releaseMutex();

      }

      // ensure disconnect

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

    try

    {

      mReleaseManager.connect();

      mReleaseManager.queryMachtypes(mGbeMachtypeCollection, mDaemon, mBaseline);

      if (mDaemon)

      {

        mMailServer = mReleaseManager.queryMailServer();

        mMailSender = mReleaseManager.queryMailSender();

        mGlobalTarget = mReleaseManager.queryGlobalAddresses();

      }

      mBaselineName = mReleaseManager.queryBaselineName(mDaemon, mBaseline);

    }

    finally

    {

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

      // even if an exception is thrown

      // ensure disconnect

      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.info("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 )

  {