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

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStreamReader;

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.warn("MasterThread rtag_id " + rtag_id + " rcon_id " + rcon_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();

    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 )

            {

              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;

            boolean logWarning = true;

            boolean logWarning2 = true;

            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)

                  {

                    if ( logWarning )

                    {

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

                      logWarning = false;

                    }

                    else

                    {

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

                {

                  if ( logWarning2 )

                  {

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

                    logWarning2 = false;

                  }

                  else

                  {

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

            MutableString doesNotRequireSourceControlInteraction = new MutableString();

            boolean buildOccurred = retrieveLastPackage(mRtagId,

                                                        packageName, 

                                                        packageExtension, 

                                                        packageVersion, 

                                                        packageDepends, 

                                                        isRipple,

                                                        packageVersionId, 

                                                        fullyPublished,

                                                        newLabel,

                                                        doesNotRequireSourceControlInteraction);

            if ( buildOccurred )

            {

              // buildOccurred simply means a dummy build file did not apply ie the build file had attempted a build

              // by now it has been labelled

              tearViewDown();

              boolean buildErrorOccurred = true;

              try

              {

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

                {

                  buildErrorOccurred = false;

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

                  {

                    Integer rtagId = new Integer(mRtagId);

                    if ( doesNotRequireSourceControlInteraction.value.length() == 0 )

                    {

                      // requires source control interaction ie labelled in ClearCase

                      // publish to release manager

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

                    }

                    else

                    {

                      // trigger release note generation and on_make_official.wsf, which changes ownership and write access in the archive

                      // this should not be through autoMakeRelease (sledgehammer, the package is already official in release manager in this scenario)

                      // at the time of writing, calling autoMakeRelease does not help if the package was 'released' more than 24 hours ago

                      // this seems to be a business rule in the generate_release_notes package

                      // the buildtool has no option but to call autoMakeRelease at present

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

                    }

                    FileInputStream abtmetrics = new FileInputStream( rtagId.toString() + "abtmetrics.txt" );

                    DataInputStream din = new DataInputStream( abtmetrics );

                    InputStreamReader isr = new InputStreamReader( din );

                    BufferedReader br = new BufferedReader( isr );

                    String metrics = br.readLine();

                    mLogger.warn( "execute read metrics string " + metrics );

                    br.close();

                    isr.close();

                    din.close();

                    mReleaseManager.insertPackageMetrics(rtagId.toString(), packageName.value, packageExtension.value, metrics );

                  }

                  else

                  {

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

                    throw new Exception();

                  }

                }

                else

                {

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

                  throw new Exception();

                }

              }

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

                    }

                  }

                }

                Integer rtagId = new Integer(mRtagId);

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

                if ( !buildErrorOccurred )

                {

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

                  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)

            {

                mLogger.warn("run changing run level to ACTIVE for rcon_id " + rconId.value);

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

        mSleep = true;

      }

      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,

                              MutableString doesNotRequireSourceControlInteraction) 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.length == 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);

          }

          else

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

          {

            doesNotRequireSourceControlInteraction.value = keyVal[1];

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

          }

        }

      }

      rtagIdOfficialBufferedReader.close();

      rtagIdOfficialFileReader.close();

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

        }

      }

      retVal = true;

    }

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

    return retVal;

  }

}