Subversion Repositories DevTools

package com.erggroup.buildtool.daemon;

import com.erggroup.buildtool.daemon.BuildThread;
import com.erggroup.buildtool.ripple.MutableString;
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 gbebuildfilter)
  {
    mLogger.debug("SlaveThread " + rtag_id);
    mRtagId = rtag_id;
    mRconId = rcon_id;
    mGbebuildfilter = gbebuildfilter;
  }

  /**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;
    MutableString buildFileContent = new MutableString();
    boolean runLevelSet = false;

    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
        if ( mGbebuildfilter.compareTo("unit test consume build files") != 0)
        {
          if ( !runLevelSet )
          {
            // IMPORTANT - this is done once before a Thread.sleep by design
            // In the case of an SQLException (signifying a database access issue)
            // avoid accessing the database immediately
            mRunLevel = RunLevel.IDLE;
            mRunLevel.persist(mReleaseManager, mRconId);
            runLevelSet = true;
          }

          mLogger.warn("run checking allowedToProceed");
          allowedToProceed();
          mLogger.info("run allowedToProceed returned");
        }
        
        // consume build files
        mLogger.warn("run consume build files");
        buildFileContent.value = "";
        
        do
        {
          mReleaseManager.queryRunLevel(mRconId, buildFileContent);
          
          if ( buildFileContent.value.compareTo("") == 0)
          {
            try
            {
              mLogger.warn("run sleep 3 secs waiting for build files");
              // to do, sleep for periodicMs
              Thread.sleep(3000);
              mLogger.info("run sleep returned");
            }
            catch (InterruptedException e)
            {
              mLogger.warn("run caught InterruptedException");
            }
          }
        } while ( buildFileContent.value.compareTo("") == 0);
        
        mLogger.info("run consumed build files");

        if ( mGbebuildfilter.compareTo("unit test consume build files") == 0 )
        {
          throw new ExitException();
        }

        // set CURRENT_BUILD_FILES to null
        mReleaseManager.clearBuildFile(mRconId);
        mRunLevel = RunLevel.ACTIVE;

        // check environment
        mLogger.warn("run checkEnvironment");
        checkEnvironment();
        mLogger.info("run checkEnvironment returned");
        
        mSleep = true;
        if ( buildFileContent.value.compareTo(mDummyBuildFileContent) != 0 )
        {
          // deliver change to product baseline
          mLogger.warn("run deliverChange");
          setViewUp(buildFileContent.value, false);
          deliverChange(null, null, false);
          tearViewDown();
          mLogger.info("run deliverChange returned");
          mSleep = false;
        }
        
      }
      catch( SQLException e )
      {
        // oracle connection issues        
         mLogger.warn("run oracle connection issues");
      }
      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");
        }
      }
    }
  }

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