Subversion Repositories DevTools

package com.erggroup.buildtool.daemon;

import com.erggroup.buildtool.daemon.BuildThread;

import com.erggroup.buildtool.ripple.MutableInt;

import com.erggroup.buildtool.ripple.MutableString;

import com.erggroup.buildtool.ripple.Package;

import com.erggroup.buildtool.ripple.ReleaseManager;

import com.erggroup.buildtool.ripple.RippleEngine;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.IOException;

import java.sql.SQLException;

import java.util.Iterator;

import java.util.Vector;

import org.apache.log4j.Logger;

import org.apache.tools.ant.taskdefs.Execute;

/**Master Thread sub component

 */

public class MasterThread

  extends BuildThread

{

  /**Logger

   * @attribute

   */

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

  /**

   * @attribute

   */

  private String[] command = new String[100];

  /**

   * @attribute

   */

  private int commandIndex = 0;

  /**

   * @attribute

   */

  private Execute thread = new Execute();

  /**constructor

   */

  public MasterThread(int rtag_id, int rcon_id, String gbebuildfilter)

  {

    mLogger.debug("MasterThread " + rtag_id);

    mRtagId = rtag_id;

    mRconId = rcon_id;

    mGbebuildfilter = gbebuildfilter;

  }

  /**implements the sequence diagrams coordinate slave threads, generate build files, allowed to proceed, check environment

   */

  public void run()

  {

    Integer id = new Integer(mRtagId);

    setName(id.toString());

    mLogger.debug("run");

    boolean exit = false;

    RippleEngine rippleEngine = new RippleEngine(mReleaseManager, mRtagId, true);

    MutableInt rconId = new MutableInt();

    MutableInt current_run_level = new MutableInt();

    MutableString addendum = new MutableString();

    boolean runLevelSet = false;

    while(!exit)

    {

      try

      {

        if ( Thread.currentThread().isInterrupted() )

        {

          mLogger.warn("run is interrupted");

          // unit test technique

          throw new ExitException();

        }

        if ( mGbebuildfilter.compareTo("unit test spawn thread") == 0)

        {

          throw new Exception();

        }

        // allowed to proceed

        MutableString buildFileContent = new MutableString();

        if ( mGbebuildfilter.compareTo("unit test check environment") != 0)

        {

          if ( mGbebuildfilter.compareTo("unit test generate build files") != 0)

          {

            if ( mGbebuildfilter.compareTo("unit test coordinate slave threads") != 0 )

            {

              if ( !runLevelSet )

              {

                // IMPORTANT - this is done once before a Thread.sleep by design

                // In the case of an SQLException (signifying a database access issue)

                // avoid accessing the database immediately

                mRunLevel = RunLevel.IDLE;

                mRunLevel.persist(mReleaseManager, mRconId);

                runLevelSet = true;

              }

              mLogger.warn("run checking allowedToProceed");

              allowedToProceed();

              mLogger.info("run allowedToProceed returned");

              if ( mGbebuildfilter.compareTo("unit test allowed to proceed") == 0 )            

              {

                throw new ExitException();

              }

            }

            // coordinate slave threads

            mLogger.warn("run coordinate slave threads");

            boolean allSlaveThreadsWaiting = false;

            while ( !allSlaveThreadsWaiting )

            {

              mReleaseManager.queryRunLevel(mRtagId);

              // anything but WAITING

              current_run_level.value = ReleaseManager.DB_IDLE;

              boolean moreRunLevelsConfigured = mReleaseManager.getFirstRunLevel(rconId, current_run_level);

              // attempt to exit loop

              allSlaveThreadsWaiting = true;

              do

              {

                if (moreRunLevelsConfigured)

                {

                  if (current_run_level.value != ReleaseManager.DB_WAITING)

                  {

                    mLogger.warn("run waiting for rcon id " + rconId.value);

                    allSlaveThreadsWaiting = false;

                  }

                  else

                  {

                    moreRunLevelsConfigured = mReleaseManager.getNextRunLevel(rconId, current_run_level);

                  }

                }

              }

              while (moreRunLevelsConfigured && allSlaveThreadsWaiting);

              if ( !allSlaveThreadsWaiting )

              {

                // to do, sleep for periodicMs

                if ( mGbebuildfilter.compareTo("unit test coordinate slave threads") == 0 )

                {

                  Thread.currentThread().interrupt();

                }

                else

                {

                  mLogger.warn("run sleeping 3 secs waiting for slave threads");

                  Thread.sleep(3000);

                  mLogger.info("run sleep returned");

                }

              }

            }

            if ( mGbebuildfilter.compareTo("unit test coordinate slave threads") == 0 )

            {

              throw new ExitException();

            }

            deliverChange(null, "AbtPublish", false);

            // Publishing is done outside ant by design

            // The preference is to do all release manager work outside ant

            MutableString packageName = new MutableString();

            MutableString packageExtension = new MutableString();

            MutableString packageVersion = new MutableString();

            MutableString packageDepends = new MutableString();

            MutableString isRipple = new MutableString();

            MutableString packageVersionId = new MutableString();

            MutableString fullyPublished = new MutableString();

            MutableString newLabel = new MutableString();

            boolean buildOccurred = retrieveLastPackage(mRtagId,

                                                        packageName, 

                                                        packageExtension, 

                                                        packageVersion, 

                                                        packageDepends, 

                                                        isRipple,

                                                        packageVersionId, 

                                                        fullyPublished,

                                                        newLabel);

            if ( buildOccurred )

            {

              boolean buildErrorOccurred = true;

              try

              {

                if ( fullyPublished.value.compareTo("yes") == 0 )

                {

                  buildErrorOccurred = false;

                  if ( newLabel.value.length() > 0 )

                  {

                    // labelled in ClearCase                

                    Integer rtagId = new Integer(mRtagId);

                    mReleaseManager.autoMakeRelease(rtagId.toString(), packageName.value, packageExtension.value, packageVersion.value, newLabel.value, packageDepends.value, isRipple.value);

                  }

                  else

                  {

                    mLogger.info("run package not labelled in ClearCase on " + packageName.value + packageVersion.value);

                    throw new Exception();

                  }

                }

                if ( buildErrorOccurred )

                {

                  mLogger.info("run build error occurred on " + packageName.value + packageVersion.value);

                  throw new Exception();

                }

                tearViewDown();

              }

              catch( Exception e)

              {

                // an error occurred publishing to ClearCase or Release Manager

                // take out the archive entry first

                String fs = System.getProperty( "file.separator" );

                String dpkgArchiveEntry = new String(Package.mGbeDpkg + fs + packageName.value + fs + packageVersion.value);

                File dpkgArchiveEntryFile = new File(dpkgArchiveEntry);

                mLogger.info("run checking existence of " + dpkgArchiveEntry);

                if ( dpkgArchiveEntryFile.exists() )

                {

                  if ( dpkgArchiveEntryFile.isDirectory() )

                  {

                    mLogger.warn("run deleting " + dpkgArchiveEntryFile.getName());

                    deleteDirectory(dpkgArchiveEntryFile);

                  }

                }

                else

                {

                  String dplyArchiveEntry = new String(Package.mGbeDply + fs + packageName.value + fs + packageVersion.value);

                  File dplyArchiveEntryFile = new File(dplyArchiveEntry);

                  mLogger.info("run checking existence of " + dplyArchiveEntry);

                  if ( dplyArchiveEntryFile.exists() )

                  {

                    if ( dplyArchiveEntryFile.isDirectory() )

                    {

                      mLogger.warn("run deleting " + dplyArchiveEntryFile.getName());

                      deleteDirectory(dplyArchiveEntryFile);

                    }

                  }

                }

                if ( buildErrorOccurred )

                {

                  Integer rtagId = new Integer(mRtagId);

                  mReleaseManager.excludeFromBuild(packageVersionId.value, packageVersion.value, rtagId.toString());

                }

                else

                {

                  mLogger.fatal("an error occurred publishing to ClearCase or Release Manager");

                  tearViewDown();

                  throw new Exception();

                }

              }

            }

            mLogger.info("run coordinate slave threads returned");

            // generate build files

            mLogger.warn("run generating build files");

            rippleEngine.planRelease();

            // get the build file from the ripple engine

            rippleEngine.getFirstBuildFileContent(buildFileContent, addendum);

            if ( addendum.value.compareTo("non generic") == 0 )

            {

              // publish the build file

              mLogger.warn("run publishing build file");

              mReleaseManager.publishBuildFile(mRtagId, buildFileContent.value);

            }

            else

            {

              // publish a dummy build file for either generic or dummy cases

              // this results in the slave not running ant

              mLogger.warn("run publishing dummy build file");

              mReleaseManager.publishBuildFile(mRtagId, mDummyBuildFileContent);

            }

          }

          mLogger.info("run generated build files");

          // change the run level for all threads in associated with the baseline

          mLogger.warn("run change the run level for all threads in associated with the baseline");

          mReleaseManager.queryReleaseConfig(mRtagId);

          rconId.value = -1;

          boolean moreBuildThreadsConfigured = mReleaseManager.getFirstReleaseConfig(rconId);

          mRunLevel = RunLevel.ACTIVE;

          do

          {

            if (moreBuildThreadsConfigured)

            {

                mRunLevel.persist(mReleaseManager, rconId.value);

                moreBuildThreadsConfigured = mReleaseManager.getNextReleaseConfig(rconId);

            }

          }

          while (moreBuildThreadsConfigured);

          if ( mGbebuildfilter.compareTo("unit test generate build files") == 0 )

          {

            throw new ExitException();

          }

        }

        mLogger.info("run changed run levels");

        // check environment

        mLogger.warn("run checkEnvironment");

        checkEnvironment();

        mLogger.info("run checkEnvironment returned");

        if ( mGbebuildfilter.compareTo("unit test check environment") == 0 )

        {

          throw new ExitException();

        }

        // deliver change to product baseline

        mLogger.warn("run deliverChange");

        setViewUp(buildFileContent.value, true);

        deliverChange(null, null, false);

        mLogger.info("run deliverChange returned");

      }

      catch( SQLException e )

      {

        // oracle connection issues        

        mLogger.warn("run oracle connection issues");

      }

      catch( ExitException e )

      {

        mLogger.fatal("run ExitException");

        exit = true;

      }

      catch( InterruptedException e )

      {

        mLogger.warn("run InterruptedException");

      }

      catch( Exception e )

      {

        mLogger.error("run indefinitePause");

        try

        {

          mReleaseManager.indefinitePause();

        }

        catch( Exception f )

        {

          mLogger.error("run indefinitePause failed");

        }

      }

      mSleep = false;

      if ( addendum.value.compareTo("dummy") == 0 )

      {

        // no build requirement, so let things settle

        mLogger.warn("run no build requirement, so let things settle");

        mSleep = true;

      }

    }

  }

  /**returns 'M'

   */

  protected char getMode()

  {

    mLogger.debug("getMode");

    return 'M';

  }

  /**retrieves details concerning the last package built for an rtag_id

   * isRipple = "0" (a WIP or direct change) or "1"

   * generic = "generic" or not

   * buildStandard = "JATS" or "ANT"

   */

  boolean retrieveLastPackage(int rtagId, MutableString packageName, 

                              MutableString packageExtension, 

                              MutableString packageVersion, 

                              MutableString packageDepends, 

                              MutableString isRipple, 

                              MutableString packageVersionId, 

                              MutableString fullyPublished,

                              MutableString newLabel) throws IOException

  {

    mLogger.debug("retrieveLastPackage");

    boolean retVal = false;

    Integer rtag = new Integer(rtagId);

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

    if ( rtagIdOfficial.exists() )

    {

      // read <rtagId>offical

      FileReader rtagIdOfficialFileReader = new FileReader(rtagIdOfficial);

      BufferedReader rtagIdOfficialBufferedReader = new BufferedReader(rtagIdOfficialFileReader);

      String line;

      while( ( line = rtagIdOfficialBufferedReader.readLine() ) != null)

      {

        String []keyVal = line.split("=", 2);

        if (keyVal[0].compareTo("packageName") == 0)

        {

          packageName.value = keyVal[1];

          mLogger.info("retrieveLastPackage packageName " + packageName.value);

        }

        else

        if (keyVal[0].compareTo("packageExtension") == 0)

        {

          packageExtension.value = keyVal[1];

          mLogger.info("retrieveLastPackage packageExtension " + packageExtension.value);

        }

        else

        if (keyVal[0].compareTo("packageVersion") == 0)

        {

          packageVersion.value = keyVal[1];

          mLogger.info("retrieveLastPackage packageVersion " + packageVersion.value);

        }

        else

        if (keyVal[0].compareTo("packageDepends") == 0)

        {

          packageDepends.value = keyVal[1];

          mLogger.info("retrieveLastPackage packageDepends " + packageDepends.value);

        }

        else

        if (keyVal[0].compareTo("packageRipple") == 0)

        {

          isRipple.value = keyVal[1];

          mLogger.info("retrieveLastPackage packageRipple " + isRipple.value);

        }

        else

        if (keyVal[0].compareTo("packageVersionID") == 0)

        {

          packageVersionId.value = keyVal[1];

          mLogger.info("retrieveLastPackage packageVersionID " + packageVersionId.value);

        }

        else

        if (keyVal[0].compareTo("fullyPublished") == 0)

        {

          fullyPublished.value = keyVal[1];

          mLogger.info("retrieveLastPackage fullyPublished " + fullyPublished.value);

        }

        else

        if (keyVal[0].compareTo("newLabel") == 0)

        {

          newLabel.value = keyVal[1];

          mLogger.info("retrieveLastPackage newLabel " + newLabel.value);

        }

      }

      rtagIdOfficialBufferedReader.close();

      retVal = true;

    }

    rtagIdOfficial.delete();

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

    return retVal;

  }

}