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



 
        while(!exit)
        {
            try
            {
                mLogger.warn("run calling sleepCheck");
                mPhase.setPhase("sleepCheck");
                sleepCheck();
 
                mLogger.warn("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.warn("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.warn("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);

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

                                    FileInputStream abtmetrics = new FileInputStream( String.valueOf(mRtagId) + "abtmetrics.txt" );
                                    DataInputStream din = new DataInputStream( abtmetrics );
                                    InputStreamReader isr = new InputStreamReader( din );
                                    BufferedReader br = new BufferedReader( isr );
                                    String metrics = br.readLine();
                                    mLogger.warn( "execute read metrics string {}", metrics );
                                    br.close();
                                    isr.close();
                                    din.close();
 
                                    mLogger.warn("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.warn("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.warn("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

                                        //  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.warn("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.warn("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.warn("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.warn("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.warn("run calling planRelease");
                        mPhase.setPhase("Plan Release", 600);
                        mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_PLANNING);
                        mReleaseSeqNum =  mReleaseManager.queryReleaseSeqNum(mRtagId, mRconId, BuildDaemon.mHostname); 
                        mRippleEngine.planRelease(!mLastBuildWasBenign);
 

                //---------------------------------------------------------------
                //  Check that we are good to proceed with the build
                //      Check environment
                //      Ensure we have enough disk space
                //     
                mLogger.warn("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.warn("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.warn("run calling publishBuildFile on dummy");
                        mMasterBuildFile.content = mDummyBuildFileContent;
                    }
                    else
                    {
                     // publish the build file
                        mLogger.warn("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.warn("Build Package {}_{}", mReporting.packageName, mReporting.packageVersion);
 
                    mLogger.info("run calling setViewUp");
                    mPhase.setPhase("Setup View for build");
                    deliverChange("AbtSetUp", true, false);
 

                //  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);
 
                // DEVI 51366 force sleep at beginning of while loop
                mException = true;
 
                String cause = e.getMessage();

            }
        }
        try {
            mReleaseManager.clearCurrentPackageBeingBuilt(mRconId);
        } catch (Exception e) {
            mLogger.error("Exception in clearCurrentPackageBeingBuilt: {}", e.getMessage());
        }
        mPhase.setPhase("Exit Thread");
    }
 
    /**   Delete a specified version of a package from dpkg_archive

        cmd.add("-DeleteVersion");
        cmd.add(!ReleaseManager.getUseMutex(), "-testArchive");
        cmd.add("'-pname=" + mReporting.packageName + "'");
        cmd.add("'-pversion=" + mReporting.packageVersion + "'");
 
        mLogger.warn("run remote command to delete {}, {}", mReporting.packageName, mReporting.packageVersion);
        int rv = mRemoteExecution.execute(cmd.toString());
        mLogger.info("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.
        //
        //    Note: Need to flush NFS cache before we check existence 
 
        String dpkgArchiveEntry = utilities.catDir(Package.mGbeDpkg, mReporting.packageName, mReporting.packageVersion);
        File dpkgArchiveEntryFile = utilities.freshFile(dpkgArchiveEntry);
        mLogger.debug("run checking existence of {}",dpkgArchiveEntry);
 
        if ( dpkgArchiveEntryFile.exists() )
        {
            if ( dpkgArchiveEntryFile.isDirectory() )
            {
                mLogger.warn("run calling deleteDirectory on {}", dpkgArchiveEntryFile);                      
                deleteDirectory(dpkgArchiveEntryFile);
            }
        }
    }
 

                  + "Build Standards : " + indent + buildStandards;
       
        mailBody += "<p><hr>";
        try
        {
            mLogger.info("completeTestBuildEmail Server: {}", rippleEngine.getMailServer());
            mLogger.info("completeTestBuildEmail Sender: {}", rippleEngine.getMailSender());
            mLogger.info("completeTestBuildEmail Target: {}", mReporting.packageOwners);
 
            Smtpsend.send(rippleEngine.getMailServer(),     // mailServer
                    rippleEngine.getMailSender(),           // source
                    mReporting.packageOwners,               // target
                    rippleEngine.getMailSender(),           // cc

            mLogger.warn("Email Failure: completeTestBuild:{}", e.getMessage());
        }
 
        // Update the Release Manager Database
        mReleaseManager.markDaemonInstCompleted(mReporting.testBuildId);
        mLogger.warn("completeTest. Returning");
    }
    
 
    /**returns 'M'
     */

Subversion Repositories DevTools

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

Rev 7169		Rev 7176
Line 68...		Line 68...
68		68
69	`while(!exit)`	69	`while(!exit)`
70	`{`	70	`{`
71	`try`	71	`try`
72	`{`	72	`{`
73	`mLogger.error("run calling sleepCheck");`	73	`mLogger.warn("run calling sleepCheck");`
74	`mPhase.setPhase("sleepCheck");`	74	`mPhase.setPhase("sleepCheck");`
75	`sleepCheck();`	75	`sleepCheck();`
76		76
77	`mLogger.error("run calling rippleEngine.collectMetaData");`	77	`mLogger.warn("run calling rippleEngine.collectMetaData");`
78	`mPhase.setPhase("collectMetaData", 600);`	78	`mPhase.setPhase("collectMetaData", 600);`
79	`mRippleEngine.collectMetaData();`	79	`mRippleEngine.collectMetaData();`
80		80
81	`if ( Thread.currentThread().isInterrupted() )`	81	`if ( Thread.currentThread().isInterrupted() )`
82	`{`	82	`{`
Line 101...		Line 101...
101	`//---------------------------------------------------------------`	101	`//---------------------------------------------------------------`
102	`// Wait for all Slaves to enter waiting or paused state`	102	`// Wait for all Slaves to enter waiting or paused state`
103	`// They may be building`	103	`// They may be building`
104	`// They may be starting up`	104	`// They may be starting up`
105	`//`	105	`//`
106	`mLogger.error("run changing run level to WAITING (New) for rcon_id " + mRconId);`	106	`mLogger.warn("run changing run level to WAITING (New) for rcon_id {}", mRconId);`
107	`mPhase.setPhase("Wait for Slave Threads");`	107	`mPhase.setPhase("Wait for Slave Threads");`
108	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_WAITING);`	108	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_WAITING);`
109		109
110	`while (true)`	110	`while (true)`
111	`{`	111	`{`
Line 189...		Line 189...
189	`// Publish Package Build Results`	189	`// Publish Package Build Results`
190	`// Indicate to RM that we are publishing`	190	`// Indicate to RM that we are publishing`
191	`// Ensure that all build machines have placed a marker in dpkg_archive`	191	`// Ensure that all build machines have placed a marker in dpkg_archive`
192	`// Save updated build files into VCS`	192	`// Save updated build files into VCS`
193	`//`	193	`//`
194	`mLogger.error("run changing run level to PUBLISHING for rcon_id " + mRconId);`	194	`mLogger.warn("run changing run level to PUBLISHING for rcon_id {}", mRconId);`
195	`mPhase.setPhase("Publishing");`	195	`mPhase.setPhase("Publishing");`
196	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_PUBLISHING);`	196	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_PUBLISHING);`
197		197
198	`mLogger.info("run calling deliverChange on AbtPublish");`	198	`mLogger.info("run calling deliverChange on AbtPublish");`
199	`deliverChange("AbtPublish", true, false);`	199	`deliverChange("AbtPublish", true, false);`