Subversion Repositories DevTools

package com.erggroup.buildtool.daemon;

import com.erggroup.buildtool.daemon.BuildThread;

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 com.erggroup.buildtool.ripple.RunLevelData;

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

				}

				// Indicate that the Slave is WAITING - for a job

				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;

				// Wait for Salve to be set as Active

				for (;;)

				{

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

					mReleaseManager.querySingleRunLevel(mRconId);

					// Detect this daemon has been un-configured

					if (mReleaseManager.mRunLevelCollection.isEmpty())

					{

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

						throw new ExitException();

					}

					RunLevelData rl = mReleaseManager.mRunLevelCollection.firstElement();

					if (rl.get_current_run_level() != 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");

						}

					} else

					{

						// Have been set to Active

						break;

					}

				}

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

				mReleaseManager.queryBuildFile(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)

				{

					// Start of a build cycle. Set new log file to capture

					// entire build log

					flagStartBuildCycle();

					// 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 " + e.toString());

				String cause = e.getMessage();

				if (cause == null)

				{

					cause = e.toString();

				}

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

	}

}