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

import java.sql.SQLException;

import org.apache.log4j.Logger;

/**Slave Thread sub component

 */

public class SlaveThread

  extends BuildThread

{

  /**Logger

   * @attribute

   */

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

  /**constructor

   */

  public SlaveThread(int rtag_id, int rcon_id, String unitTest)

  {

    mLogger.warn("SlaveThread rtag_id " + rtag_id + " rcon_id " + rcon_id);

    mRtagId = rtag_id;

    mRconId = rcon_id;

    if ( unitTest == null )

    {

      unitTest = new String();

    }

    mUnitTest = unitTest;

  }

  /**implements the sequence diagrams consume 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);

    MutableString buildFileContent = new MutableString();

    while(!exit)

    {

      try

      {

        mLogger.fatal("run calling sleepCheck");

        sleepCheck();

        mLogger.fatal("run calling rippleEngine.collectMetaData");

        rippleEngine.collectMetaData();

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

        {

          mLogger.warn("run is interrupted");

          // unit test technique

          throw new ExitException();

        }

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

        {

          throw new Exception();

        }

        // allowed to proceed

        if ( mUnitTest.compareTo("unit test consume build files") != 0)

        {

          mRunLevel = RunLevel.IDLE;

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

          mLogger.fatal("run calling rmRunLevel.persistNew to set IDLE");

          mRunLevel.persistNew(mReleaseManager, mRconId);

          mLogger.warn("run checking allowedToProceed");

          mLogger.fatal("run calling allowedToProceed");

          allowedToProceed(false);

          mLogger.info("run allowedToProceed returned");

        }

        mRunLevel = RunLevel.WAITING;

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

        mLogger.fatal("run calling rmRunLevel.persist to set WAITING");

        mRunLevel.persist(mReleaseManager, mRconId);

        // consume build files

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

        buildFileContent.value = "";

        boolean logWarning = true;

        // additional handshake

        // Master waits for Slave to be in state waiting

        // wait for the Master to signal we are active

        MutableInt rconId = new MutableInt();

        MutableInt current_run_level = new MutableInt();

        do

        {

          mLogger.fatal("run calling mReleaseManager.querySingleRunLevel");

          mReleaseManager.querySingleRunLevel(mRconId);

          mLogger.fatal("run calling mReleaseManager.getFirstRunLevel");

          if ( !mReleaseManager.getFirstRunLevel(rconId, current_run_level) )

          {

            mLogger.warn("run no longer configured 1");

            throw new ExitException();

          }

          if (current_run_level.value != ReleaseManager.DB_ACTIVE)

          {

            try

            {

              if ( logWarning )

              {

                mLogger.warn("run sleep 3 secs waiting for Master to set Slave run level ACTIVE");

                logWarning = false;

              }

              else

              {

                mLogger.info("run sleep 3 secs waiting for Master to set Slave run level ACTIVE");

              }

              // to do, sleep for periodicMs

              mLogger.fatal("run calling Thread.sleep for 3 secs");

              Thread.sleep(3000);

              mLogger.info("run sleep returned");

            }

            catch (InterruptedException e)

            {

              mLogger.warn("run caught InterruptedException");

            }

          }

        } while (current_run_level.value != ReleaseManager.DB_ACTIVE);

        mLogger.fatal("run calling mReleaseManager.queryRunLevel");

        mReleaseManager.queryRunLevel(mRconId, buildFileContent);

        if ( buildFileContent.value.compareTo("") == 0)

        {

          mLogger.warn("run no longer configured 2");

          throw new ExitException();

        }

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

        if ( mUnitTest.compareTo("unit test consume build files") == 0 )

        {

          throw new ExitException();

        }

        // set CURRENT_BUILD_FILES to null

        mLogger.fatal("run calling mReleaseManager.clearBuildFile");

        mReleaseManager.clearBuildFile(mRconId);

        // check environment

        mLogger.warn("run checkEnvironment");

        mLogger.fatal("run calling checkEnvironment");

        checkEnvironment();

        mLogger.info("run checkEnvironment returned");

        mSleep = true;

        if ( buildFileContent.value.compareTo(mDummyBuildFileContent) != 0 )

        {

          // deliver change to product baseline

          mLogger.warn("run deliverChange");

          mLogger.fatal("run calling setViewUp");

          setViewUp(buildFileContent.value, false);

          if ( mGbeGatherMetricsOnly != null )

          {

            // special for metrics

            // deliverChange on a benign target to get mReportingPackageName and mReportingPackageVersion set up

            // nb in the metrics gathering world the <rtagid>build.xml is provided by the master thread

            mLogger.fatal("run calling deliverChange on fullstart");

            deliverChange(null, "fullstart", false);

            String archive = Package.mGbeDpkg;

            if (archive != null)

            {

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

              String destination = archive + fs + mReportingPackageName + fs + mReportingPackageVersion;

              // do this for all unix based platforms

              new File( destination ).mkdirs();

              new File( destination, "built.sparc" ).createNewFile();

              new File( destination, "built.solaris10_sparc32" ).createNewFile();

              new File( destination, "built.solaris10_x86" ).createNewFile();

              new File( destination, "built.linux_i386" ).createNewFile();

            }

          }

          else

          {

            mLogger.fatal("run calling deliverChange - the actual build");

            deliverChange(null, null, false);

            mLogger.fatal("run calling deliverChange on AbtTearDown");

            deliverChange(null, "AbtTearDown", false);

          }

          if ( mReportingBuildFailureLogFile != null )

          {

            // tweak the build failure log file in the database

            Integer rtagId = mRtagId;

            // force exclusion by default

            int testBuildInstruction = 0;

            try

            {

              testBuildInstruction = Integer.parseInt( mReportingTestBuild );

            }

            catch( NumberFormatException nfe )

            {

            }

            mLogger.fatal("run calling excludeFromBuild");

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

          }

          mLogger.info("run deliverChange returned");

          mSleep = false;

        }

      }

      catch( SQLException e )

      {

        // oracle connection issues        

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

         mException = 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

            mRecoverable = false;

            if ( cause.compareTo(Package.mRecoverable) == 0 )

            {

              mRecoverable = true;

            }

            indefinitePause(rippleEngine, cause);

            mReleaseManager.indefinitePause();

            // DEVI 51366 force sleep at beginning of while loop

            mException = true;

          }

          catch( Exception f )

          {

            mLogger.error("run indefinitePause failed");

          }

        }

      }

    }

  }

  /**returns 'S'

   */

  protected char getMode()

  {

    mLogger.debug("getMode");

    return 'S';

  }

}