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.sql.SQLException;

import org.apache.log4j.Logger;

/**Master Thread sub component

 */

public class MasterThread

  extends BuildThread

{

  /**Logger

   * @attribute

   */

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

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

    boolean insertRunLevel = true;

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

    MutableInt rconId = new MutableInt();

    MutableInt current_run_level = new MutableInt();

    MutableString addendum = new MutableString();

    while(!exit)

    {

      try

      {

        rippleEngine.collectMetaData();

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

              {

                mRunLevel = RunLevel.IDLE;

                mLogger.warn("run changing run level to IDLE for rcon_id " + mRconId);

                mRunLevel.persistNew(mReleaseManager, mRconId);

                insertRunLevel = false;

              }

              mLogger.warn("run checking allowedToProceed");

              allowedToProceed(true);

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

            // preserve 

            String reportingFullyPublished = mReportingFullyPublished;

            String reportingNewLabel = mReportingNewLabel;

            deliverChange(null, "AbtTearDown", false);

            // DEVI 47395 delete the build file now

            // this will prevent any chance of multiply publishing a package version

            File buildFile = new File(mRtagId + "build.xml");

            if ( buildFile.exists() )

            {

              buildFile.delete();

            }

            if ( mReportingPackageName != null )

            {

              // a dummy build file did not apply

              // Publishing is done outside ant by design

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

              boolean buildErrorOccurred = true;

              try

              {

                if ( reportingFullyPublished != null && reportingFullyPublished.compareTo("yes") == 0 )

                {

                  buildErrorOccurred = false;

                  if ( reportingNewLabel.length() > 0 )

                  {

                    Integer rtagId = new Integer(mRtagId);

                    if ( mGbeGatherMetricsOnly == null )

                    {

                      if ( mReportingDoesNotRequireSourceControlInteraction.compareTo("false") == 0 )

                      {

                        // requires source control interaction ie labelled in ClearCase

                        // publish to release manager

                        mReleaseManager.autoMakeRelease(rtagId.toString(), mReportingPackageName, mReportingPackageExtension, mReportingPackageVersion, reportingNewLabel, mReportingPackageDepends, mReportingIsRipple);

                      }

                      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(), mReportingPackageName, mReportingPackageExtension, mReportingPackageVersion, reportingNewLabel, mReportingPackageDepends, mReportingIsRipple);

                      }

                    }

                    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(), mReportingPackageName, mReportingPackageExtension, metrics );

                  }

                  else

                  {

                    mLogger.info("run package not labelled in ClearCase on " + mReportingPackageName + mReportingPackageVersion);

                    throw new Exception();

                  }

                }

                else

                {

                  mLogger.info("run build error occurred on " + mReportingPackageName + mReportingPackageVersion);

                  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 + mReportingPackageName + fs + mReportingPackageVersion);

                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 + mReportingPackageName + fs + mReportingPackageVersion);

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

                // pass root file

                mReleaseManager.excludeFromBuild(mReportingPackageVersionId, mReportingPackageVersion, rtagId.toString(), null, null, mReportingBuildFailureLogFile);

                if ( !buildErrorOccurred )

                {

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

                  throw new Exception("an error occurred publishing to ClearCase or Release Manager");

                }

              }

            }

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

          if ( mGbeGatherMetricsOnly != null )

          {

            // set view up early for metrics gathering to ensure build file is fully written before letting the slave loose

            setViewUp(buildFileContent.value, true);            

          }

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

        if ( mGbeGatherMetricsOnly == null )

        {

          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.warn("run ExitException");

        exit = true;

      }

      catch( InterruptedException e )

      {

        mLogger.warn("run InterruptedException");

      }

      catch( Exception e )

      {

        mLogger.error("run indefinitePause");

        String cause = e.getMessage();

        if ( cause != null )

        {

          try

          {

            // notify first

            // many reasons for indefinite pause, including database related, so do database last

            indefinitePause(rippleEngine, cause);

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

  }

}