Subversion Repositories DevTools

package com.erggroup.buildtool.daemon;

import com.erggroup.buildtool.abt.BuildToolException;
import com.erggroup.buildtool.daemon.BuildThread;
import com.erggroup.buildtool.ripple.Package;
import com.erggroup.buildtool.ripple.ReleaseManager;
import com.erggroup.buildtool.ripple.RippleEngine;
import com.erggroup.buildtool.ripple.RunLevel.BuildState;
import com.erggroup.buildtool.utilities.MutableDate;

import java.sql.SQLException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Slave Thread sub component
 */
public class SlaveThread extends BuildThread
{

    /**
     * Logger
     * 
     * @attribute
     */
    private static final Logger mLogger = LoggerFactory.getLogger(SlaveThread.class);
    
    /** Holds the buildFile content
     * 
     */
    protected String mBuildFileContent = null;

    /**constructor
     * @param rtagId          - Identifies the Release
     * @param rconId          - Identifies the Controlling entry
     * @param releaseManager  - A ReleaseManager entry to use
     * @param unitTest        - Unit Test data 
     */
    public SlaveThread(int rtagId, int rconId, ReleaseManager releaseManager, String unitTest)
    {
        super(rtagId, rconId, releaseManager, unitTest);
        mLogger.warn("SlaveThread rtag_id " + rtagId + " rcon_id " + rconId);
    }

    /**
     * implements the sequence diagrams consume build files, allowed to proceed,
     * check environment
     */
    public void run()
    {
        Integer id = Integer.valueOf(mRtagId);
        setName(id.toString());
        mLogger.warn("run");
        boolean exit = false;
        mRippleEngine = new RippleEngine(mReleaseManager, mRtagId, true);

        while (!exit)
        {
            try
            {
                mLogger.error("run calling sleepCheck");
                mPhase.setPhase("sleepCheck");
                sleepCheck();
                
                mLogger.error("run calling rippleEngine.collectMetaData");
                mPhase.setPhase("collectMetaData");
                mRippleEngine.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)
                {
                    mLogger.error("run calling allowedToProceed");
                    mPhase.setPhase("allowedToProceed");
                    allowedToProceed(false);
                    mLogger.info("run allowedToProceed returned");
                }

                // Indicate that the Slave is WAITING - for a job
                mPhase.setPhase("Waiting for work");
                mLogger.error("run changing run level to WAITING for rcon_id " + mRconId);


                // Wait for Slave to be set as Active
                while (!BuildDaemon.mShutDown)
                {
                    // Periodically indicate, to Release Manager, that the slave is still alive
                    // A warning will be raised after 10 minutes, so it must be less than that
                    mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_WAITING);
                    
                    //
                    //  Wait to be notified that a build request is present
                    //  Have a timeout just to be sure to be sure
                    //
                    if (mUnitTest.length() == 0) {
                        synchronized (mActiveBuildMonitor) {
                            try {
                                mActiveBuildMonitor.wait(120 * 1000L);
                            }
                            catch ( InterruptedException e  ) {
                                Thread.currentThread().interrupt();
                                mLogger.error("InterruptedException in Wait for Active Build");
                            }
                        }
                    }
                    
                    //
                    //  Determine if the build cycle can proceed
                    //      May be a shutdown request
                    //      May be no longer configured
                    //      May be stopped
                    //      May be paused
                    //      May be indefinite pause
                    //  Will throw exception if we shouldn't continue on this cycle
                    //  
                    mLogger.info("run allowedToContinue");
                    allowedToContinue(false);

                    // Detect build Request
                    //  A non-null buildfile published in the database
                    mLogger.info("run calling mReleaseManager.queryBuildFile");
                    mBuildFileContent =  mReleaseManager.queryBuildFile(mRconId);
                    if (mBuildFileContent != null )
                    {
                        // Build request detected
                        mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_ACTIVE);
                        break;
                    }
                   
                }

                //
                //  Build Request detected
                //      Buildfile has been extracted from the database, but not yet saved
                //
                if (BuildDaemon.mShutDown)
                {
                    mLogger.warn("Slave run ShutDown requested");
                    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
                //  Indicates that we have taken the file and will prevent multiple builds
                mLogger.info("run calling mReleaseManager.clearBuildFile");
                mPhase.setPhase("clearBuildFile");
                mReleaseManager.clearBuildFile(mRconId);

                // check environment
                mLogger.warn("run checkEnvironment");
                mPhase.setPhase("checkEnvironment");
                checkEnvironment();
                mLogger.info("run checkEnvironment returned");

                mLastBuildWasBenign = true;
                if (mBuildFileContent.compareTo(mDummyBuildFileContent) != 0)
                {
                    mLastBuildWasBenign = false;
                    
                    // Start of a build cycle. Set new log file to capture
                    // entire build log
                    mPhase.setPhase("flagStartBuildCycle");
                    flagStartBuildCycle();
                    mReporting.resetData();
                    
                    mLogger.error("Collect fresh MetaData");
                    mPhase.setPhase("collectMetaData");
                    mRippleEngine.collectMetaData();
                    
                    // Save the build file
                    mLogger.error("Save buildfile");
                    mPhase.setPhase("Save buildfile");
                    saveBuildFile(mBuildFileContent);

                    // deliver change to product baseline
                    mLogger.error("run calling setViewUp");
                    mPhase.setPhase("Setup View for build");
                    deliverChange("AbtSetUp", true, true);

                    mLogger.error("run calling deliverChange - the actual build");
                    mPhase.setPhase("deliverChange for Build");
                    deliverChange(null, true, false);
                    
                    mLogger.error("run calling deliverChange on AbtTearDown");
                    mPhase.setPhase("AbtTearDown");
                    deliverChange("AbtTearDown", false, true);

                    if (mReporting.buildFailureLogFile != null)
                    {
                        mLogger.error("run calling excludeFromBuild");
                        mPhase.setPhase("excludeFromBuild");
                        mReleaseManager.excludeFromBuild(false, 
                                                         mReporting.packageVersionId,
                                                         mReporting.packageVersion, 
                                                         mRtagId, 
                                                         null, 
                                                         null, 
                                                         mReporting.buildFailureLogFile,
                                                         false, mReporting.isaTestBuild);
                    }

                    mLogger.info("run deliverChange returned");
                    mPhase.setPhase("End of Build Cycle");
                }
                mReleaseManager.clearCurrentPackageBeingBuilt(mRconId);
            } 
            //---------------------------------------------------------------
            //    Build loop exception handling (only)
            //
            catch (ShouldNotContinueExpection e)
            {
                mLogger.error("ShouldNotContinueExpection:" + e.getMessage());
            }
            catch (SQLException e)
            {
                // oracle connection issues
                //  Request a prolonged sleep at the start of the build loop
                mLogger.error("run oracle connection issues");
                mException = true;
            } 
            catch (ExitException e)
            {
                mLogger.warn("run ExitException");
                exit = true;
            } 
            catch (InterruptedException e)
            {
                mLogger.warn("run InterruptedException");
                Thread.currentThread().interrupt();
            }
            catch (BuildSystemException e) {
                // BuildSystem exception - a (possibly) correctable error
                // Flag as recoverable
                //    - Can't create XML build file
                //    - 
                // 
                mLogger.error("run BuildSystemException");
                mPhase.setPhase("BuildSystemException indefinitePause");
                notifyIndefinitePause(e.getMessage());
                mReleaseManager.indefinitePause(false);
                mException = true;
                mRecoverable = true;
                
            }
            catch( BuildToolException e)
            {
                // Buildtool exception - an uncorrectable error
                //    - Can't parse XML build file
                //    - 
                // 
                mLogger.error("run BuildToolException");
                mPhase.setPhase("BuildToolException indefinitePause");
                notifyIndefinitePause(e.getMessage());
                mReleaseManager.indefinitePause(false);
                mException = true;
            }
            catch (Exception e)
            {
                //  Uncaptured exception
                //  These are not good. Current mechanism to handle this condition is:
                //      1) Email build system administrator
                //      2) Pause the build system
                //  
                mLogger.error("run indefinitePause " + e.toString());
                
                // DEVI 51366 force sleep at beginning of while loop
                mException = true;
                
                String cause = e.getMessage();
                if ( cause == null || cause.compareTo("null") == 0 )
                {
                  cause = "Internal Error: " + 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;
                    }

                    mPhase.setPhase("Notify indefinitePause");
                    notifyIndefinitePause(cause);
                    mReleaseManager.indefinitePause(mRecoverable);
                }
                catch( Exception f )
                {
                    mLogger.error("run indefinitePause failed");
                }
            }
        }
        try {
            mReleaseManager.clearCurrentPackageBeingBuilt(mRconId);
        } catch (Exception e) {
            mLogger.error("Exception in clearCurrentPackageBeingBuilt:" + e.getMessage());
        }
        mPhase.setPhase("Exit Thread");
    }

    /** Determine if we are allowed to continue in this build cycle
     *      May be no longer configured
     *      May be stopped
     *      May be paused
     *      May be indefinite pause
     *  Will throw exceptions if we shouldn't continue on this cycle
     *  Does not hang around waiting for condition to clear - thats done elsewhere
     *  
     * @param master - is a master machine making this call
     * @throws ExitException 
     * @throws ShouldNotContinueExpection 
     * @throws SQLException 
     */
    private void allowedToContinue(boolean master) throws ExitException, ShouldNotContinueExpection, SQLException, Exception {
        
        if (BuildDaemon.mShutDown)
        {
            mLogger.warn("allowedToContinue. ShutDown requested");
            throw new ExitException();
        }
        
        try
        {
            mLogger.error("allowedToContinue calling mReleaseManager.connect");                      
            mReleaseManager.connect();
            
            //  Ensure that the machine is a part of the current build set
            mLogger.error("allowedToContinue calling mReleaseManager.queryReleaseConfig");                      
            if ( !mReleaseManager.queryReleaseConfig(mRtagId, mRconId, BuildDaemon.mHostname, getMode(), mStartTime) )
            {
                mLogger.warn("allowedToContinue queryReleaseConfig failed");
                mReleaseManager.disconnect();
                throw new ExitException();
            }
            
            
            //  Check for scheduled downtime or indefinite pause
            MutableDate resumeTime = new MutableDate();
            mLogger.error("allowedToContinue calling mReleaseManager.queryRunLevelSchedule");                      
            if ( !mReleaseManager.queryRunLevelSchedule(resumeTime) )
            {
              mLogger.info("allowedToContinue scheduled downtime");
              mReleaseManager.disconnect();
              throw new ShouldNotContinueExpection("Scheduled downtime");
            }
            
            //
            //  If commanded to pause, then wait around until the command has been removed.
            //
            mLogger.error("allowedToContinue calling mReleaseManager.queryDirectedRunLevel");                      
            if ( !mReleaseManager.queryDirectedRunLevel(mRconId) )
            {
                mLogger.error("allowedToContinue Pause Detected");
                throw new ShouldNotContinueExpection("Pause Detected");
            }
          
        }
        finally
        {
          // this block is executed regardless of what happens in the try block
          // even if an exception is thrown
          // ensure disconnect
          mLogger.error("allowedToContinue calling mReleaseManager.disconnect");                      
          mReleaseManager.disconnect();
        }

        // One last test for a shut down request
        if (BuildDaemon.mShutDown)
        {
            mLogger.warn("allowedToContinue. ShutDown requested");
            throw new ExitException();
        }
        
    }

    /**
     * returns 'S'
     */
    protected char getMode()
    {
        mLogger.debug("getMode");
        return 'S';
    }
}