WebSVN – DevTools – Diff – /buildtool/trunk/src/main/java/com/erggroup/buildtool/daemon/MasterThread.java



import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.sql.SQLException;
import java.util.Iterator;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
/**Master Thread sub component
 */
public class MasterThread extends BuildThread
{
 
    /**Logger
     * @attribute
     */
    private static final Logger mLogger = LoggerFactory.getLogger(MasterThread.class);
 
    /** Current BuildFile
     * 
     */
    private BuildFile mMasterBuildFile = new BuildFile();

 
        while(!exit)
        {
            try
            {
                mLogger.error("run calling sleepCheck");
                mPhase.setPhase("sleepCheck");
                sleepCheck();
 
                mLogger.error("run calling rippleEngine.collectMetaData");
                mPhase.setPhase("collectMetaData", 600);
                mRippleEngine.collectMetaData();
 
                if ( Thread.currentThread().isInterrupted() )
                {

                            //---------------------------------------------------------------
                            //  Wait for all Slaves to enter waiting or paused state
                            //      They may be building
                            //      They may be starting up
                            //
                            mLogger.error("run changing run level to WAITING (New) for rcon_id " + mRconId);
                            mPhase.setPhase("Wait for Slave Threads");
                            mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_WAITING);
 
                            while (true) 
                            {

                            //    Publish Package Build Results
                            //        Indicate to RM that we are publishing
                            //        Ensure that all build machines have placed a marker in dpkg_archive
                            //        Save updated build files into VCS
                            // 
                            mLogger.error("run changing run level to PUBLISHING for rcon_id " + mRconId);
                            mPhase.setPhase("Publishing");
                            mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_PUBLISHING);
 
                            mLogger.info("run calling deliverChange on AbtPublish");
                            deliverChange("AbtPublish", true, false);

                                        mLogger.info("run completing test build on " + mReporting.packageName + mReporting.packageExtension);
                                        mPhase.setPhase("Report Test Build Complete");
                                        Package p = mRippleEngine.findPackage(mReporting.packageName + mReporting.packageExtension);
                                        if (p != ReleaseManager.NULL_PACKAGE)
                                        {
                                            mLogger.error("run calling p.completeTestBuild");                      
                                            p.completeTestBuild(mRippleEngine, mReporting.isFullyPublished);
                                        }
 
                                        //
                                        //  Determine the total time taken by the build

                                        //      Only record for successful tests. Don't want to record short build times on failure
                                        //      in particular if the package has been released. Would be OK for a WIP, but how to identify these
                                        if ( mReporting.isFullyPublished)
                                        {
                                            int buildDuration = mBuildDuration.toIntSecs();
                                            mLogger.error("Build Duration:" + buildDuration);
                                            mReleaseManager.updateBuildDuration(mReporting.packageVersionId, buildDuration);
                                        }
 
                                        mPhase.setPhase("Update Build Instance for Test");
                                        mReleaseManager.updateBuildInstance(mReporting.buildId, 0, mReporting.isFullyPublished ? BuildResult.Complete :BuildResult.BuildError );

                                    //      Have had zero length values returned
                                    //      Treat as a publishing error
                                    //
                                    if ( mReporting.newVcsTag == null || mReporting.newVcsTag.isEmpty() )
                                    {
                                        mLogger.error("run package not labelled in Version Control on " + mReporting.packageName + mReporting.packageVersion);
                                        mReporting.errMsg = "Error publishing to Version Control System";     // Max 50 Characters
                                        throw new Exception();
                                    }
 
 
                                    // Publish to release manager
                                    //    On error mReporting.errMsg will contain error string
                                    //    Publishing errors only affect the current package
                                    //
                                    mLogger.error("run calling mReleaseManager.autoMakeRelease");
                                    mPhase.setPhase("autoMakeRelease");
                                    publishError =  mReleaseManager.autoMakeRelease(mReporting);
                                    if ( publishError )
                                    {
                                        mLogger.error("autoMakeRelease publishError: " + mReporting.errMsg);
                                        throw new Exception();
                                    }
 
                                    //
                                    //  Determine the total time taken by the build
                                    //      Done as late a possible in the process
                                    //      Does not include planning time
                                    //      Does not handle case where build cycle is broken
                                    //
                                    int buildDuration = mBuildDuration.toIntSecs();
                                    mLogger.error("Build Duration:" + buildDuration);
                                    mReleaseManager.updateBuildDuration(mReporting.packageVersionId, buildDuration);
 
                                    //
                                    //    Update the Build Instance information
                                    //    If this has been a ripple then the pv_id of the build needs to be associated with

                                    mLogger.warn( "execute read metrics string " + metrics );
                                    br.close();
                                    isr.close();
                                    din.close();
 
                                    mLogger.error("run calling mReleaseManager.insertPackageMetrics");                      
                                    mReleaseManager.insertPackageMetrics(mRtagId, mReporting.packageName, mReporting.packageExtension, metrics );
 
                                    //
                                    //    Info reporting
                                    //    Send an email to track build system usage - may be noise
                                    //
                                    mReporting.errMsg = null;
                                    mLogger.error("run calling emailBuildComplete");
                                    mPhase.setPhase("Post Build Email");
                                    emailPostBuild(mRippleEngine, false);
 
                                    //---------------------------------------------------------------
                                    //    All done

 
                                    // 
                                    // Delete the dpkg_archive entry - the package is a dud
                                    //
                                    mPhase.setPhase("Delete package from archive");
                                    mLogger.error("Delete package from archive");
                                    deletePackageVersion();
 
                                    //    A publishing error. The error occurred, after the build, in the RM publishing
                                    //        We won't have a log file, but we will have a rootCause
                                    //    Exclude package from the build
                                    //        Unless its a test build (handled within mReleaseManager.excludeFromBuild) 
                                    //
                                    if ( publishError  )
                                    {
                                        mLogger.error("an error occurred publishing to Version Control or Release Manager");
 
                                        //  Post Build Error
                                        //  eMails have not been sent by the ABT class as the error has occurred outside of that process
                                        mPhase.setPhase("Post Build Failure Email");
                                        emailPostBuild(mRippleEngine, true);
 
                                        mLogger.error("run calling excludeFromBuild");
                                        mPhase.setPhase("Excluded from build");
                                        mReleaseManager.excludeFromBuild(false, 
                                                mReporting.packageVersionId, 
                                                null, 
                                                mReporting.rtagId, 

 
                                        //    If we have a log file, then provide it to the user, else insert a generic message
 
                                        mReporting.errMsg = (mReporting.buildFailureLogFile == null) ? "Buildtool env error occurred. Attempt build again" : null;
 
                                        mLogger.error("run calling excludeFromBuild"); 
                                        mPhase.setPhase("Excluded from build");
                                        mReleaseManager.excludeFromBuild(false, 
                                                mReporting.packageVersionId, 
                                                mReporting.packageVersion,
                                                mReporting.rtagId, 

                        //---------------------------------------------------------------
                        //  Start of a new build cycle
                        //      Determine if the daemon has been paused.
                        //      Set RunLevel.IDLE (within allowedToProceed)
                        //
                        mLogger.error("run calling allowedToProceed");
                        mPhase.setPhase("allowedToProceed");
                        mReleaseManager.discardVersion();
                        mReleaseManager.clearCurrentPackageBeingBuilt(mRconId);
                        allowedToProceed(true);
                        mLogger.info("run allowedToProceed returned");

                            throw new ExitException();
                        }
 
                        //  Set up mReleaseConfigCollection
                        //  This will be used when creating a build file
                        mLogger.error("Collect fresh MetaData");
                        mPhase.setPhase("collectMetaData");
                        mRippleEngine.collectMetaData();
 
                        //---------------------------------------------------------------
                        //  Plan the next build
                        //      Snap current Release Sequence Number
                        //      Determine what is to be built
                        //      Generate build files
                        mLogger.error("run calling planRelease");
                        mPhase.setPhase("Plan Release", 600);
                        mReleaseSeqNum =  mReleaseManager.queryReleaseSeqNum(mRtagId, mRconId, BuildDaemon.mHostname); 
                        mRippleEngine.planRelease(!mLastBuildWasBenign);
 
                        // get the build file from the ripple engine

                //---------------------------------------------------------------
                //  Check that we are good to proceed with the build
                //      Check environment
                //      Ensure we have enough disk space
                //     
                mLogger.error("run calling checkEnvironment"); 
                mPhase.setPhase("checkEnvironment");
                checkEnvironment();
                mLogger.info("run checkEnvironment returned");
 
                if ( mUnitTest.startsWith("unit test check environment") ) 

                mReporting.resetData();
                mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_ACTIVE);
                mReleaseManager.setCurrentPackageBeingBuilt(mRconId, mMasterBuildFile.mPkgId, mMasterBuildFile.mPvId);
 
                // Save the buildfile
                mLogger.error("Save buildfile");
                mPhase.setPhase("Save buildfile");
                saveBuildFile(mMasterBuildFile.content);
 
                // Quick Test to validate the provided Version Control tag/label
                mPhase.setPhase("Validate Version Tag");

                    mPhase.setPhase("Notify slaves of work", 10);
                    if ( mMasterBuildFile.state != BuildFileState.NonGeneric)
                    {
                        // publish a dummy build file for either generic or dummy cases
                        // this results in the slave not running ant
                        mLogger.error("run calling publishBuildFile on dummy");
                        mMasterBuildFile.content = mDummyBuildFileContent;
                    }
                    else
                    {
                     // publish the build file
                        mLogger.error("run calling publishBuildFile");    
                    }
                    mReleaseManager.publishBuildFile(mRtagId, mMasterBuildFile);                    
                    
 
                    if ( mUnitTest.compareTo("unit test generate build files") == 0 )

                    //---------------------------------------------------------------
                    //  Build the package
                    //      Setup the workspace
                    //      Build the package - deliver change to product baseline
                    //
                    mLogger.error("Build Package "  + mReporting.packageName + "_" + mReporting.packageVersion);
 
                    mLogger.info("run calling setViewUp");
                    mPhase.setPhase("Setup View for build");
                    deliverChange("AbtSetUp", true, false);
 

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

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

                mLogger.info(message);
            }
 
            @Override
            public void fatal(String message) {
                mLogger.error(message);
            }
 
            @Override
            public void info(String message) {
                mLogger.info(message);

        cmd.add("-DeleteVersion");
        cmd.add(!ReleaseManager.getUseMutex(), "-testArchive");
        cmd.add("'-pname=" + mReporting.packageName + "'");
        cmd.add("'-pversion=" + mReporting.packageVersion + "'");
 
        mLogger.error("run remote command to delete " + mReporting.packageName +", "+ mReporting.packageVersion);
        int rv = mRemoteExecution.execute(cmd.toString());
        mLogger.error("run remote command to delete. Returned " + rv);
 
        //    Belt and Braces
        //    Ensure that the package-version has been deleted, 
        //    and if not then try to delete it the slow way.
        //

 
        if ( dpkgArchiveEntryFile.exists() )
        {
            if ( dpkgArchiveEntryFile.isDirectory() )
            {
                mLogger.error("run calling deleteDirectory on " + dpkgArchiveEntryFile);                      
                deleteDirectory(dpkgArchiveEntryFile);
            }
        }
    }
 
Subversion Repositories DevTools

(root)/buildtool/trunk/src/main/java/com/erggroup/buildtool/daemon/MasterThread.java – Rev 6914 → 7033

Rev 6914		Rev 7033
Line 19...		Line 19...
19	`import java.io.FileInputStream;`	19	`import java.io.FileInputStream;`
20	`import java.io.InputStreamReader;`	20	`import java.io.InputStreamReader;`
21	`import java.sql.SQLException;`	21	`import java.sql.SQLException;`
22	`import java.util.Iterator;`	22	`import java.util.Iterator;`
23		23
24	`import org.apache.log4j.Logger;`	24	`import org.slf4j.Logger;`
-		25	`import org.slf4j.LoggerFactory;`
25		26
26	`/**Master Thread sub component`	27	`/**Master Thread sub component`
27	`*/`	28	`*/`
28	`public class MasterThread extends BuildThread`	29	`public class MasterThread extends BuildThread`
29	`{`	30	`{`
30		31
31	`/**Logger`	32	`/**Logger`
32	`* @attribute`	33	`* @attribute`
33	`*/`	34	`*/`
34	`private static final Logger mLogger = Logger.getLogger(MasterThread.class);`	35	`private static final Logger mLogger = LoggerFactory.getLogger(MasterThread.class);`
35		36
36	`/** Current BuildFile`	37	`/** Current BuildFile`
37	`*`	38	`*`
38	`*/`	39	`*/`
39	`private BuildFile mMasterBuildFile = new BuildFile();`	40	`private BuildFile mMasterBuildFile = new BuildFile();`
Line 67...		Line 68...
67		68
68	`while(!exit)`	69	`while(!exit)`
69	`{`	70	`{`
70	`try`	71	`try`
71	`{`	72	`{`
72	`mLogger.fatal("run calling sleepCheck");`	73	`mLogger.error("run calling sleepCheck");`
73	`mPhase.setPhase("sleepCheck");`	74	`mPhase.setPhase("sleepCheck");`
74	`sleepCheck();`	75	`sleepCheck();`
75		76
76	`mLogger.fatal("run calling rippleEngine.collectMetaData");`	77	`mLogger.error("run calling rippleEngine.collectMetaData");`
77	`mPhase.setPhase("collectMetaData", 600);`	78	`mPhase.setPhase("collectMetaData", 600);`
78	`mRippleEngine.collectMetaData();`	79	`mRippleEngine.collectMetaData();`
79		80
80	`if ( Thread.currentThread().isInterrupted() )`	81	`if ( Thread.currentThread().isInterrupted() )`
81	`{`	82	`{`
Line 100...		Line 101...