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



import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Timer;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.DefaultLogger;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.ProjectHelper;
 

  protected boolean mErrorReported;
 
  /**Logger
   * @attribute
   */
  private static final Logger mLogger = LoggerFactory.getLogger(BuildThread.class);
 
  /** Data about the package that is being built
   * @attribute
   */
  protected ReportingData mReporting = new ReportingData();

   */
  Phase mPhase = new Phase();
  
 
  /**constructor
   * @param rtagId          - Identifies the Release
   * @param rconId          - Identifies the Controlling entry
   * @param releaseManager  - A ReleaseManager entry to use
   * @param unitTest        - Unit Test data 
   */
  BuildThread(int rtagId, int rconId, ReleaseManager releaseManager, String unitTest)

  protected void sleepCheck()
  {
    if (mException && ! BuildDaemon.mShutDown)
    {
        Integer sleepTime = 5 * 60;
        mLogger.warn("sleepCheck sleep {} secs", sleepTime);
        BuildDaemon.daemonSleepSecs(sleepTime);
        mLogger.info("sleepCheck sleep returned");
        
        // Force planning cycle when recovering from an exception
        mReleaseSeqNum = -1;

    //      Change the run level to IDLE
    //      Discard any reserved version numbers
    //      Reset the current package being built
    try
    {
      mLogger.error("allowedToProceed changing run level to IDLE for rcon_id {}", mRconId);
      mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_IDLE);
    }
    catch(SQLException e)
    {
      mLogger.warn("allowedToProceed caught SQLException");

            while(!BuildDaemon.mShutDown)
            {
                int masterCount = mReleaseManager.queryMasterCount( mRtagId );
                if ( masterCount != 1)
                {
                    mLogger.warn("allowedToProceed Invalid MasterCount: {}", masterCount);
                    throw new ExitException();   
                }
                
                int seqNum = mReleaseManager.queryReleaseSeqNum(mRtagId, mRconId, BuildDaemon.mHostname);
                if ( seqNum < 0 )

                }
                if ( seqNum != mReleaseSeqNum)
                {
                    //  Release Content has been modified
                    mReleaseSeqNum = seqNum;
                    mLogger.error("allowedToProceed. Release Sequence changed");
                    break;
                }
                
                //  Check daemon instructions that need to be processed
                //
                DaemonInstruction di = new DaemonInstruction(mRtagId, -1, true);
                if ( mReleaseManager.getDaemonInst( di ) )
                {
                    // At least one daemon instruction has expired
                    mLogger.error("allowedToProceed. Deamon instruction to be scheduled");
                    break;
                }
                
                //
                //    Backup plan
                //    Force a planning session every 60 minutes
                //
                if ( System.currentTimeMillis() - startMasterWait > 60 * 60 * 1000)
                {
                    mLogger.error("allowedToProceed. Force periodic plan");
                    break;
                }
                
                //  Have no reason to suspect that we need to plan a release
                //  Persist idle state to indicate the master is polling

    boolean proceed = false;
    try
    {
      while ( !proceed &&  !BuildDaemon.mShutDown )
      {
        mLogger.error("allowedToProceed calling mReleaseManager.connect");                      
        mReleaseManager.connect();
        
        //  Ensure that the machine is a part of the current build set
        mLogger.error("allowedToProceed calling mReleaseManager.queryReleaseConfig");                      
        if ( !mReleaseManager.queryReleaseConfig(mRtagId, mRconId, BuildDaemon.mHostname, getMode(), mStartTime) )
        {
            mLogger.warn("allowedToProceed queryReleaseConfig failed");
            mReleaseManager.disconnect();
            throw new ExitException();

          throw new ExitException();
        }
        
        //  Check for scheduled downtime or indefinite pause
        MutableDate resumeTime = new MutableDate();
        mLogger.error("allowedToProceed calling mReleaseManager.queryRunLevelSchedule");                      
        if ( !mReleaseManager.queryRunLevelSchedule(resumeTime) )
        {
          mLogger.info("allowedToProceed scheduled downtime");
          mReleaseManager.disconnect();
 
          mLogger.error("allowedToProceed changing run level to PAUSED for rcon_id {}", mRconId);
          mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_PAUSED);
          
          //
          //    Limit the pause to 10 minutes at a time
          //    Allows early get out for the daemons

              {
                mResumeTimerTask = new ResumeTimerTask();
                mTimer = new Timer();
                mResumeTimerTask.setTimer(mTimer);
              }
              mLogger.warn("allowedToProceed schedule passed {}", resumeTime.value.getTime());
              mTimer.schedule(mResumeTimerTask, resumeTime.value);
            }
            catch( IllegalStateException e )
            {
              // this may be thrown by schedule if already scheduled

        else
        {
            //
            //  If commanded to pause, then wait around until the command has been removed.
            //
            mLogger.error("allowedToProceed calling mReleaseManager.queryDirectedRunLevel");                      
            if ( !mReleaseManager.queryDirectedRunLevel(mRconId) && !BuildDaemon.mShutDown )
            {
                mLogger.error("allowedToProceed changing run level to PAUSED for rcon_id {}", mRconId);
                mReleaseManager.disconnect();
                mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_PAUSED);
 
                //  Sleep for periodicMs
                mLogger.warn("allowedToProceed sleep 1 mins directed downtime");

    finally
    {
      // this block is executed regardless of what happens in the try block
      // even if an exception is thrown
      // ensure disconnect
      mLogger.error("allowedToProceed calling mReleaseManager.disconnect");                      
      mReleaseManager.disconnect();
    }
    
    if (BuildDaemon.mShutDown)
    {

          }
      }
      if ( !exit )
      {
    	waitPerformed = true;
        mLogger.error("checkEnvironment changing run level to CANNOT_CONTINUE for rcon_id {}", mRconId);
        mRunLevel.persistFault(mReleaseManager, mRconId, reason);
        
        if ( !mUnitTest.startsWith("unit test check environment") )
        {
          mLogger.warn("checkEnvironment sleep 5 mins");

          mLogger.info("checkEnvironment sleep returned");
        }
      }
    }
 
    mLogger.error("checkEnvironment changing run level to ACTIVE for rcon_id {}", mRconId);
    mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_ACTIVE);
    
    return waitPerformed;
  }
 

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

    {
        
      // Filter function to process the files processed within this routine
      public boolean accept(File file, String name)
      {
        mLogger.debug("accept {}", name);
        boolean retVal = false;
        
        if ( file.isDirectory() && !name.startsWith( "." ) )
        {
          retVal = true;
        }
        
        mLogger.info("accept returned {}", retVal);
        return retVal;
      }
    };
    
    try

          // child is named uniquely to encapsulate a build
          // 5 days = 432,000,000 milliseconds
          if ( ( System.currentTimeMillis() - children[ child ].lastModified() ) > 432000000 )
          {
            // the directory is over 5 days old
            mLogger.warn("housekeep deleting directory {}", children[ child ].getName());
            deleteDirectory( children[ child ] );
          }
        }
      }
    }

      // this can be thrown by createNewFile
      retVal = false;
      mLogger.warn("touch caught IOException");
    }
    
    mLogger.info("touch returned {}", retVal);
    return retVal;
  }
  
  /**returns true if free disk space > 5G
   * this may become configurable if the need arises

          // 1G = 1073741824 bytes - useful for testing
          freeSpace = cwd.getUsableSpace();
 
          if ( freeSpace < 5368709120L )
          {
              mLogger.warn("hasSufficientDiskSpace failed: {} freespace {}", cwd.getAbsolutePath() , freeSpace);
              retVal = false;
          }
      }
      catch( SecurityException e )
      {
          // this can be thrown by getFreeSpace
          mLogger.warn("hasSufficientDiskSpace caught SecurityException");
      }
 
      mLogger.info("hasSufficientDiskSpace returned {} {}", retVal, freeSpace);
      return retVal;
  }
 
  /**abstract method
   */

   */
  FilenameFilter deleteDirectoryFilter = new FilenameFilter()
  {
    public boolean accept(File file, String name)
    {
      mLogger.debug("accept {}", name);
      boolean retVal = false;
      
      if ( name.compareTo(".") != 0 && ( name.compareTo("..") != 0 ) )
      {
        retVal = true;
      }
      
      mLogger.info("accept returned {}", retVal);
      return retVal;
    }
  };
 
  
  @SuppressWarnings("squid:S899")  
  protected void deleteDirectory(File directory)
  {
    mLogger.debug("deleteDirectory {}", directory.getName());
    try
    {
      if ( directory.exists() )
      {
      

              mProject.setProperty("ant.file", mBuildFile.getAbsolutePath());
 
              // Add listener for logging the complete build process
              // If the daemon has been restarted, then the listener will not have been
              // set up - so don't add it. Perhaps we need a way to open an existing
              // log file to append.
              if ( mBuildLogger != null )               {
                  mProject.addBuildListener(mBuildLogger);
              }
 
              // parse can throw BuildException, this is serious

                  mProject.addReference("ant.projectHelper", pH);
                  pH.parse(mProject, mBuildFile);
              }
              catch (BuildException be)
              {
                  mLogger.error("Parse Error: {}", be );
 
                  mBuildFile.delete(); //NOSONAR
                  throw new BuildToolException("Error parsing build file:"+ be.getCause());
              }
 

              //
              //  Log the abt_daemon value so that we can trace the build log
              //  Build logs from all machines are stored with this number
              //  Only do it at the start of the build
 
              mLogger.error("BuildRef: {}", mReporting.buildRef );    
 
          }
      }
  }
  

      {
 
          if ( target == null )     {
              target = mProject.getDefaultTarget();
          }
          mLogger.warn("deliverChange ant launched: {} Target: {}", mBuildFile.getAbsolutePath() , target);
 
          try {
              mProject.executeTarget(target);
              mLogger.warn("deliverChange ant returned");
          }

 
              if ( mReporting.buildFailureLogFile == null )
              {
                  mReporting.buildFailureLogFile = e.getMessage();
              }
              mLogger.debug("deliverChange caught BuildException, big deal, the build failed {}", mReporting.buildFailureLogFile);
              mErrorReported = true;
          }
 
 
          if (updateReporting )

     {
       Smtpsend.send(
       mRippleEngine.getMailServer(),       // mailServer
       mRippleEngine.getMailSender(),       // source
       mRippleEngine.getMailGlobalTarget(), // target (list)
       null,                                // cc
       null,                                // bcc
       "BUILD DAEMON Indefinite Pause",     // subject
       body,                                // body
       null                                 // attachment
       );
     }
     catch( Exception e )
     {
     }

       {
         Smtpsend.send(
         mRippleEngine.getMailServer(),                 // mailServer
         mRippleEngine.getMailSender(),                 // source
         mRippleEngine.getMailGlobalTarget(),           // target (list)
         null,                                          // cc
         null,                                          // bcc
         "BUILD DAEMON Indefinite Pause Recovery",      // subject
         body,                                          // body
         null                                           // attachment
         );
       }
       catch( Exception e )
       {
       }

          nagInfo.masterCount++;
      } else {
          nagInfo.slaveCount++;
      }
 
      mLogger.warn("checkThread[{}] returned {}",mRtagId, retVal);
      return retVal;
    }
 
    /**
     * Nagios interface extension

    {
        boolean retVal = mPhase.isHappy();
        if ( ! retVal) {
            nagInfo.extendedReason.add("[" + mRtagId + "] " + mPhase.happyText());
        }
        mLogger.info("checkThreadExtended: {}:{}",retVal, mPhase.toStringSecs() );
        return retVal;
    }
 
 
    /**

Rev 7023	Rev 7033
Line 32...	Line 32...
32	`import java.util.Date;`	32	`import java.util.Date;`
33	`import java.util.LinkedHashMap;`	33	`import java.util.LinkedHashMap;`
34	`import java.util.Map;`	34	`import java.util.Map;`
35	`import java.util.Timer;`	35	`import java.util.Timer;`
36		36
37	`import org.apache.log4j.Logger;`	37	`import org.slf4j.Logger;`
-		38	`import org.slf4j.LoggerFactory;`
38	`import org.apache.tools.ant.BuildException;`	39	`import org.apache.tools.ant.BuildException;`
39	`import org.apache.tools.ant.DefaultLogger;`	40	`import org.apache.tools.ant.DefaultLogger;`
40	`import org.apache.tools.ant.Project;`	41	`import org.apache.tools.ant.Project;`
41	`import org.apache.tools.ant.ProjectHelper;`	42	`import org.apache.tools.ant.ProjectHelper;`
42		43
Line 149...	Line 150...
149	`protected boolean mErrorReported;`	150	`protected boolean mErrorReported;`
150		151
151	`/**Logger`	152	`/**Logger`
152	`* @attribute`	153	`* @attribute`
153	`*/`	154	`*/`
154	`private static final Logger mLogger = Logger.getLogger(BuildThread.class);`	155	`private static final Logger mLogger = LoggerFactory.getLogger(BuildThread.class);`
155		156
156	`/** Data about the package that is being built`	157	`/** Data about the package that is being built`
157	`* @attribute`	158	`* @attribute`
158	`*/`	159	`*/`
159	`protected ReportingData mReporting = new ReportingData();`	160	`protected ReportingData mReporting = new ReportingData();`
Line 175...	Line 176...
175	`*/`	176	`*/`
176	`Phase mPhase = new Phase();`	177	`Phase mPhase = new Phase();`
177		178
178		179
179	`/**constructor`	180	`/**constructor`
180	`* @param rtagId - Identifes the Release`	181	`* @param rtagId - Identifies the Release`
181	`* @param rconId - Identifies the Controlling entry`	182	`* @param rconId - Identifies the Controlling entry`
182	`* @param releaseManager - A ReleaseManager entry to use`	183	`* @param releaseManager - A ReleaseManager entry to use`
183	`* @param unitTest - Unit Test data`	184	`* @param unitTest - Unit Test data`
184	`*/`	185	`*/`
185	`BuildThread(int rtagId, int rconId, ReleaseManager releaseManager, String unitTest)`	186	`BuildThread(int rtagId, int rconId, ReleaseManager releaseManager, String unitTest)`
Line 232...	Line 233...
232	`protected void sleepCheck()`	233	`protected void sleepCheck()`
233	`{`	234	`{`
234	`if (mException && ! BuildDaemon.mShutDown)`	235	`if (mException && ! BuildDaemon.mShutDown)`
235	`{`	236	`{`
236	`Integer sleepTime = 5 * 60;`	237	`Integer sleepTime = 5 * 60;`
237	`mLogger.warn("sleepCheck sleep " + sleepTime.toString() + " secs");`	238	`mLogger.warn("sleepCheck sleep {} secs", sleepTime);`
238	`BuildDaemon.daemonSleepSecs(sleepTime);`	239	`BuildDaemon.daemonSleepSecs(sleepTime);`
239	`mLogger.info("sleepCheck sleep returned");`	240	`mLogger.info("sleepCheck sleep returned");`
240		241
241	`// Force planning cycle when recovering from an exception`	242	`// Force planning cycle when recovering from an exception`
242	`mReleaseSeqNum = -1;`	243	`mReleaseSeqNum = -1;`
Line 265...	Line 266...
265	`// Change the run level to IDLE`	266	`// Change the run level to IDLE`
266	`// Discard any reserved version numbers`	267	`// Discard any reserved version numbers`
267	`// Reset the current package being built`	268	`// Reset the current package being built`
268	`try`	269	`try`
269	`{`	270	`{`
270	`mLogger.fatal("allowedToProceed changing run level to IDLE for rcon_id " + mRconId);`	271	`mLogger.error("allowedToProceed changing run level to IDLE for rcon_id {}", mRconId);`
271	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_IDLE);`	272	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_IDLE);`
272	`}`	273	`}`
273	`catch(SQLException e)`	274	`catch(SQLException e)`
274	`{`	275	`{`
275	`mLogger.warn("allowedToProceed caught SQLException");`	276	`mLogger.warn("allowedToProceed caught SQLException");`
Line 286...	Line 287...
286	`while(!BuildDaemon.mShutDown)`	287	`while(!BuildDaemon.mShutDown)`
287	`{`	288	`{`
288	`int masterCount = mReleaseManager.queryMasterCount( mRtagId );`	289	`int masterCount = mReleaseManager.queryMasterCount( mRtagId );`
289	`if ( masterCount != 1)`	290	`if ( masterCount != 1)`
290	`{`	291	`{`
291	`mLogger.warn("allowedToProceed Invalid MasterCount: " + masterCount);`	292	`mLogger.warn("allowedToProceed Invalid MasterCount: {}", masterCount);`
292	`throw new ExitException();`	293	`throw new ExitException();`
293	`}`	294	`}`
294		295
295	`int seqNum = mReleaseManager.queryReleaseSeqNum(mRtagId, mRconId, BuildDaemon.mHostname);`	296	`int seqNum = mReleaseManager.queryReleaseSeqNum(mRtagId, mRconId, BuildDaemon.mHostname);`
296	`if ( seqNum < 0 )`	297	`if ( seqNum < 0 )`
Line 300...	Line 301...
300	`}`	301	`}`
301	`if ( seqNum != mReleaseSeqNum)`	302	`if ( seqNum != mReleaseSeqNum)`
302	`{`	303	`{`
303	`// Release Content has been modified`	304	`// Release Content has been modified`
304	`mReleaseSeqNum = seqNum;`	305	`mReleaseSeqNum = seqNum;`
305	`mLogger.fatal("allowedToProceed. Release Sequence changed");`	306	`mLogger.error("allowedToProceed. Release Sequence changed");`
306	`break;`	307	`break;`
307	`}`	308	`}`
308		309
309	`// Check daemon instructions that need to be processed`	310	`// Check daemon instructions that need to be processed`
310	`//`	311	`//`
311	`DaemonInstruction di = new DaemonInstruction(mRtagId, -1, true);`	312	`DaemonInstruction di = new DaemonInstruction(mRtagId, -1, true);`
312	`if ( mReleaseManager.getDaemonInst( di ) )`	313	`if ( mReleaseManager.getDaemonInst( di ) )`
313	`{`	314	`{`
314	`// At least one daemon instruction has expired`	315	`// At least one daemon instruction has expired`
315	`mLogger.fatal("allowedToProceed. Deamon instruction to be scheduled");`	316	`mLogger.error("allowedToProceed. Deamon instruction to be scheduled");`
316	`break;`	317	`break;`
317	`}`	318	`}`
318		319
319	`//`	320	`//`
320	`// Backup plan`	321	`// Backup plan`
321	`// Force a planning session every 60 minutes`	322	`// Force a planning session every 60 minutes`
322	`//`	323	`//`
323	`if ( System.currentTimeMillis() - startMasterWait > 60 * 60 * 1000)`	324	`if ( System.currentTimeMillis() - startMasterWait > 60 * 60 * 1000)`
324	`{`	325	`{`
325	`mLogger.fatal("allowedToProceed. Force periodic plan");`	326	`mLogger.error("allowedToProceed. Force periodic plan");`
326	`break;`	327	`break;`
327	`}`	328	`}`
328		329
329	`// Have no reason to suspect that we need to plan a release`	330	`// Have no reason to suspect that we need to plan a release`
330	`// Persist idle state to indicate the master is polling`	331	`// Persist idle state to indicate the master is polling`
Line 360...	Line 361...
360	`boolean proceed = false;`	361	`boolean proceed = false;`
361	`try`	362	`try`
362	`{`	363	`{`
363	`while ( !proceed && !BuildDaemon.mShutDown )`	364	`while ( !proceed && !BuildDaemon.mShutDown )`
364	`{`	365	`{`
365	`mLogger.fatal("allowedToProceed calling mReleaseManager.connect");`	366	`mLogger.error("allowedToProceed calling mReleaseManager.connect");`
366	`mReleaseManager.connect();`	367	`mReleaseManager.connect();`
367		368
368	`// Ensure that the machine is a part of the current build set`	369	`// Ensure that the machine is a part of the current build set`
369	`mLogger.fatal("allowedToProceed calling mReleaseManager.queryReleaseConfig");`	370	`mLogger.error("allowedToProceed calling mReleaseManager.queryReleaseConfig");`
370	`if ( !mReleaseManager.queryReleaseConfig(mRtagId, mRconId, BuildDaemon.mHostname, getMode(), mStartTime) )`	371	`if ( !mReleaseManager.queryReleaseConfig(mRtagId, mRconId, BuildDaemon.mHostname, getMode(), mStartTime) )`
371	`{`	372	`{`
372	`mLogger.warn("allowedToProceed queryReleaseConfig failed");`	373	`mLogger.warn("allowedToProceed queryReleaseConfig failed");`
373	`mReleaseManager.disconnect();`	374	`mReleaseManager.disconnect();`
374	`throw new ExitException();`	375	`throw new ExitException();`
Line 394...	Line 395...
394	`throw new ExitException();`	395	`throw new ExitException();`
395	`}`	396	`}`
396		397
397	`// Check for scheduled downtime or indefinite pause`	398	`// Check for scheduled downtime or indefinite pause`
398	`MutableDate resumeTime = new MutableDate();`	399	`MutableDate resumeTime = new MutableDate();`
399	`mLogger.fatal("allowedToProceed calling mReleaseManager.queryRunLevelSchedule");`	400	`mLogger.error("allowedToProceed calling mReleaseManager.queryRunLevelSchedule");`
400	`if ( !mReleaseManager.queryRunLevelSchedule(resumeTime) )`	401	`if ( !mReleaseManager.queryRunLevelSchedule(resumeTime) )`
401	`{`	402	`{`
402	`mLogger.info("allowedToProceed scheduled downtime");`	403	`mLogger.info("allowedToProceed scheduled downtime");`
403	`mReleaseManager.disconnect();`	404	`mReleaseManager.disconnect();`
404		405
405	`mLogger.fatal("allowedToProceed changing run level to PAUSED for rcon_id " + mRconId);`	406	`mLogger.error("allowedToProceed changing run level to PAUSED for rcon_id {}", mRconId);`
406	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_PAUSED);`	407	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_PAUSED);`
407		408
408	`//`	409	`//`
409	`// Limit the pause to 10 minutes at a time`	410	`// Limit the pause to 10 minutes at a time`
410	`// Allows early get out for the daemons`	411	`// Allows early get out for the daemons`
Line 425...	Line 426...
425	`{`	426	`{`
426	`mResumeTimerTask = new ResumeTimerTask();`	427	`mResumeTimerTask = new ResumeTimerTask();`
427	`mTimer = new Timer();`	428	`mTimer = new Timer();`
428	`mResumeTimerTask.setTimer(mTimer);`	429	`mResumeTimerTask.setTimer(mTimer);`
429	`}`	430	`}`
430	`mLogger.warn("allowedToProceed schedule passed " + resumeTime.value.getTime());`	431	`mLogger.warn("allowedToProceed schedule passed {}", resumeTime.value.getTime());`
431	`mTimer.schedule(mResumeTimerTask, resumeTime.value);`	432	`mTimer.schedule(mResumeTimerTask, resumeTime.value);`
432	`}`	433	`}`
433	`catch( IllegalStateException e )`	434	`catch( IllegalStateException e )`
434	`{`	435	`{`
435	`// this may be thrown by schedule if already scheduled`	436	`// this may be thrown by schedule if already scheduled`
Line 454...	Line 455...
454	`else`	455	`else`
455	`{`	456	`{`
456	`//`	457	`//`
457	`// If commanded to pause, then wait around until the command has been removed.`	458	`// If commanded to pause, then wait around until the command has been removed.`
458	`//`	459	`//`
459	`mLogger.fatal("allowedToProceed calling mReleaseManager.queryDirectedRunLevel");`	460	`mLogger.error("allowedToProceed calling mReleaseManager.queryDirectedRunLevel");`
460	`if ( !mReleaseManager.queryDirectedRunLevel(mRconId) && !BuildDaemon.mShutDown )`	461	`if ( !mReleaseManager.queryDirectedRunLevel(mRconId) && !BuildDaemon.mShutDown )`
461	`{`	462	`{`
462	`mLogger.fatal("allowedToProceed changing run level to PAUSED for rcon_id " + mRconId);`	463	`mLogger.error("allowedToProceed changing run level to PAUSED for rcon_id {}", mRconId);`
463	`mReleaseManager.disconnect();`	464	`mReleaseManager.disconnect();`
464	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_PAUSED);`	465	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_PAUSED);`
465		466
466	`// Sleep for periodicMs`	467	`// Sleep for periodicMs`
467	`mLogger.warn("allowedToProceed sleep 1 mins directed downtime");`	468	`mLogger.warn("allowedToProceed sleep 1 mins directed downtime");`
Line 479...	Line 480...
479	`finally`	480	`finally`
480	`{`	481	`{`
481	`// this block is executed regardless of what happens in the try block`	482	`// this block is executed regardless of what happens in the try block`
482	`// even if an exception is thrown`	483	`// even if an exception is thrown`
483	`// ensure disconnect`	484	`// ensure disconnect`
484	`mLogger.fatal("allowedToProceed calling mReleaseManager.disconnect");`	485	`mLogger.error("allowedToProceed calling mReleaseManager.disconnect");`
485	`mReleaseManager.disconnect();`	486	`mReleaseManager.disconnect();`
486	`}`	487	`}`
487		488
488	`if (BuildDaemon.mShutDown)`	489	`if (BuildDaemon.mShutDown)`
489	`{`	490	`{`
Line 573...	Line 574...
573	`}`	574	`}`
574	`}`	575	`}`
575	`if ( !exit )`	576	`if ( !exit )`
576	`{`	577	`{`
577	`waitPerformed = true;`	578	`waitPerformed = true;`
578	`mLogger.fatal("checkEnvironment changing run level to CANNOT_CONTINUE for rcon_id " + mRconId);`	579	`mLogger.error("checkEnvironment changing run level to CANNOT_CONTINUE for rcon_id {}", mRconId);`
579	`mRunLevel.persistFault(mReleaseManager, mRconId, reason);`	580	`mRunLevel.persistFault(mReleaseManager, mRconId, reason);`
580		581
581	`if ( !mUnitTest.startsWith("unit test check environment") )`	582	`if ( !mUnitTest.startsWith("unit test check environment") )`
582	`{`	583	`{`
583	`mLogger.warn("checkEnvironment sleep 5 mins");`	584	`mLogger.warn("checkEnvironment sleep 5 mins");`
Line 585...	Line 586...
585	`mLogger.info("checkEnvironment sleep returned");`	586	`mLogger.info("checkEnvironment sleep returned");`
586	`}`	587	`}`
587	`}`	588	`}`
588	`}`	589	`}`
589		590
590	`mLogger.fatal("checkEnvironment changing run level to ACTIVE for rcon_id " + mRconId);`	591	`mLogger.error("checkEnvironment changing run level to ACTIVE for rcon_id {}", mRconId);`
591	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_ACTIVE);`	592	`mRunLevel.persist(mReleaseManager, mRconId, BuildState.DB_ACTIVE);`
592		593
593	`return waitPerformed;`	594	`return waitPerformed;`
594	`}`	595	`}`
595		596
Line 617...	Line 618...
617	`mLogger.info(message);`	618	`mLogger.info(message);`
618	`}`	619	`}`
619		620
620	`@Override`	621	`@Override`
621	`public void fatal(String message) {`	622	`public void fatal(String message) {`
622	`mLogger.fatal(message);`	623	`mLogger.error(message);`
623	`}`	624	`}`
624		625
625	`@Override`	626	`@Override`
626	`public void info(String message) {`	627	`public void info(String message) {`
627	`mLogger.info(message);`	628	`mLogger.info(message);`
Line 642...	Line 643...
642	`{`	643	`{`
643		644
644	`// Filter function to process the files processed within this routine`	645	`// Filter function to process the files processed within this routine`
645	`public boolean accept(File file, String name)`	646	`public boolean accept(File file, String name)`
646	`{`	647	`{`
647	`mLogger.debug("accept " + name);`	648	`mLogger.debug("accept {}", name);`
648	`boolean retVal = false;`	649	`boolean retVal = false;`
649		650
650	`if ( file.isDirectory() && !name.startsWith( "." ) )`	651	`if ( file.isDirectory() && !name.startsWith( "." ) )`
651	`{`	652	`{`
652	`retVal = true;`	653	`retVal = true;`
653	`}`	654	`}`
654		655
655	`mLogger.info("accept returned " + retVal);`	656	`mLogger.info("accept returned {}", retVal);`
656	`return retVal;`	657	`return retVal;`
657	`}`	658	`}`
658	`};`	659	`};`
659		660
660	`try`	661	`try`
Line 673...	Line 674...
673	`// child is named uniquely to encapsulate a build`	674	`// child is named uniquely to encapsulate a build`
674	`// 5 days = 432,000,000 milliseconds`	675	`// 5 days = 432,000,000 milliseconds`
675	`if ( ( System.currentTimeMillis() - children[ child ].lastModified() ) > 432000000 )`	676	`if ( ( System.currentTimeMillis() - children[ child ].lastModified() ) > 432000000 )`
676	`{`	677	`{`
677	`// the directory is over 5 days old`	678	`// the directory is over 5 days old`
678	`mLogger.warn("housekeep deleting directory " + children[ child ].getName());`	679	`mLogger.warn("housekeep deleting directory {}", children[ child ].getName());`
679	`deleteDirectory( children[ child ] );`	680	`deleteDirectory( children[ child ] );`
680	`}`	681	`}`
681	`}`	682	`}`
682	`}`	683	`}`
683	`}`	684	`}`
Line 725...	Line 726...
725	`// this can be thrown by createNewFile`	726	`// this can be thrown by createNewFile`
726	`retVal = false;`	727	`retVal = false;`
727	`mLogger.warn("touch caught IOException");`	728	`mLogger.warn("touch caught IOException");`
728	`}`	729	`}`
729		730
730	`mLogger.info("touch returned " + retVal);`	731	`mLogger.info("touch returned {}", retVal);`
731	`return retVal;`	732	`return retVal;`
732	`}`	733	`}`
733		734
734	`/**returns true if free disk space > 5G`	735	`/**returns true if free disk space > 5G`
735	`* this may become configurable if the need arises`	736	`* this may become configurable if the need arises`
Line 749...	Line 750...
749	`// 1G = 1073741824 bytes - useful for testing`	750	`// 1G = 1073741824 bytes - useful for testing`
750	`freeSpace = cwd.getUsableSpace();`	751	`freeSpace = cwd.getUsableSpace();`
751		752
752	`if ( freeSpace < 5368709120L )`	753	`if ( freeSpace < 5368709120L )`
753	`{`	754	`{`
754	`mLogger.warn("hasSufficientDiskSpace failed: " + cwd.getAbsolutePath() + " freeSpace " + freeSpace);`	755	`mLogger.warn("hasSufficientDiskSpace failed: {} freespace {}", cwd.getAbsolutePath() , freeSpace);`
755	`retVal = false;`	756	`retVal = false;`
756	`}`	757	`}`
757	`}`	758	`}`
758	`catch( SecurityException e )`	759	`catch( SecurityException e )`
759	`{`	760	`{`
760	`// this can be thrown by getFreeSpace`	761	`// this can be thrown by getFreeSpace`
761	`mLogger.warn("hasSufficientDiskSpace caught SecurityException");`	762	`mLogger.warn("hasSufficientDiskSpace caught SecurityException");`
762	`}`	763	`}`
763		764
764	`mLogger.info("hasSufficientDiskSpace returned " + retVal + " " + freeSpace);`	765	`mLogger.info("hasSufficientDiskSpace returned {} {}", retVal, freeSpace);`
765	`return retVal;`	766	`return retVal;`
766	`}`	767	`}`
767		768
768	`/**abstract method`	769	`/**abstract method`
769	`*/`	770	`*/`
Line 776...	Line 777...
776	`*/`	777	`*/`
777	`FilenameFilter deleteDirectoryFilter = new FilenameFilter()`	778	`FilenameFilter deleteDirectoryFilter = new FilenameFilter()`
778	`{`	779	`{`
779	`public boolean accept(File file, String name)`	780	`public boolean accept(File file, String name)`
780	`{`	781	`{`
781	`mLogger.debug("accept " + name);`	782	`mLogger.debug("accept {}", name);`
782	`boolean retVal = false;`	783	`boolean retVal = false;`
783		784
784	`if ( name.compareTo(".") != 0 && ( name.compareTo("..") != 0 ) )`	785	`if ( name.compareTo(".") != 0 && ( name.compareTo("..") != 0 ) )`
785	`{`	786	`{`
786	`retVal = true;`	787	`retVal = true;`
787	`}`	788	`}`
788		789
789	`mLogger.info("accept returned " + retVal);`	790	`mLogger.info("accept returned {}", retVal);`
790	`return retVal;`	791	`return retVal;`
791	`}`	792	`}`
792	`};`	793	`};`
793		794
794		795
795	`@SuppressWarnings("squid:S899")`	796	`@SuppressWarnings("squid:S899")`
796	`protected void deleteDirectory(File directory)`	797	`protected void deleteDirectory(File directory)`
797	`{`	798	`{`
798	`mLogger.debug("deleteDirectory " + directory.getName());`	799	`mLogger.debug("deleteDirectory {}", directory.getName());`
799	`try`	800	`try`
800	`{`	801	`{`
801	`if ( directory.exists() )`	802	`if ( directory.exists() )`
802	`{`	803	`{`
803		804
Line 944...	Line 945...
944	`mProject.setProperty("ant.file", mBuildFile.getAbsolutePath());`	945	`mProject.setProperty("ant.file", mBuildFile.getAbsolutePath());`
945		946
946	`// Add listener for logging the complete build process`	947	`// Add listener for logging the complete build process`
947	`// If the daemon has been restarted, then the listener will not have been`	948	`// If the daemon has been restarted, then the listener will not have been`
948	`// set up - so don't add it. Perhaps we need a way to open an existing`	949	`// set up - so don't add it. Perhaps we need a way to open an existing`
949	`// logfile to append.`	950	`// log file to append.`
950	`if ( mBuildLogger != null ) {`	951	`if ( mBuildLogger != null ) {`
951	`mProject.addBuildListener(mBuildLogger);`	952	`mProject.addBuildListener(mBuildLogger);`
952	`}`	953	`}`
953		954
954	`// parse can throw BuildException, this is serious`	955	`// parse can throw BuildException, this is serious`
Line 960...	Line 961...
960	`mProject.addReference("ant.projectHelper", pH);`	961	`mProject.addReference("ant.projectHelper", pH);`
961	`pH.parse(mProject, mBuildFile);`	962	`pH.parse(mProject, mBuildFile);`
962	`}`	963	`}`
963	`catch (BuildException be)`	964	`catch (BuildException be)`
964	`{`	965	`{`
965	`mLogger.fatal("Parse Error:" + be.toString() );`	966	`mLogger.error("Parse Error: {}", be );`
966		967
967	`mBuildFile.delete(); //NOSONAR`	968	`mBuildFile.delete(); //NOSONAR`
968	`throw new BuildToolException("Error parsing build file:"+ be.getCause());`	969	`throw new BuildToolException("Error parsing build file:"+ be.getCause());`
969	`}`	970	`}`
970		971
Line 990...	Line 991...
990	`//`	991	`//`
991	`// Log the abt_daemon value so that we can trace the build log`	992	`// Log the abt_daemon value so that we can trace the build log`
992	`// Build logs from all machines are stored with this number`	993	`// Build logs from all machines are stored with this number`
993	`// Only do it at the start of the build`	994	`// Only do it at the start of the build`
994		995
995	`mLogger.fatal("BuildRef: " + mReporting.buildRef );`	996	`mLogger.error("BuildRef: {}", mReporting.buildRef );`
996		997
997	`}`	998	`}`
998	`}`	999	`}`
999	`}`	1000	`}`
1000		1001
Line 1033...	Line 1034...
1033	`{`	1034	`{`
1034		1035
1035	`if ( target == null ) {`	1036	`if ( target == null ) {`
1036	`target = mProject.getDefaultTarget();`	1037	`target = mProject.getDefaultTarget();`
1037	`}`	1038	`}`
1038	`mLogger.warn("deliverChange ant launched: " + mBuildFile.getAbsolutePath() + " Target:" + target);`	1039	`mLogger.warn("deliverChange ant launched: {} Target: {}", mBuildFile.getAbsolutePath() , target);`
1039		1040
1040	`try {`	1041	`try {`
1041	`mProject.executeTarget(target);`	1042	`mProject.executeTarget(target);`
1042	`mLogger.warn("deliverChange ant returned");`	1043	`mLogger.warn("deliverChange ant returned");`
1043	`}`	1044	`}`
Line 1051...	Line 1052...
1051		1052
1052	`if ( mReporting.buildFailureLogFile == null )`	1053	`if ( mReporting.buildFailureLogFile == null )`
1053	`{`	1054	`{`
1054	`mReporting.buildFailureLogFile = e.getMessage();`	1055	`mReporting.buildFailureLogFile = e.getMessage();`
1055	`}`	1056	`}`
1056	`mLogger.debug("deliverChange caught BuildException, big deal, the build failed " + mReporting.buildFailureLogFile);`	1057	`mLogger.debug("deliverChange caught BuildException, big deal, the build failed {}", mReporting.buildFailureLogFile);`
1057	`mErrorReported = true;`	1058	`mErrorReported = true;`
1058	`}`	1059	`}`
1059		1060
1060		1061
1061	`if (updateReporting )`	1062	`if (updateReporting )`
Line 1090...	Line 1091...
1090	`{`	1091	`{`
1091	`Smtpsend.send(`	1092	`Smtpsend.send(`
1092	`mRippleEngine.getMailServer(), // mailServer`	1093	`mRippleEngine.getMailServer(), // mailServer`
1093	`mRippleEngine.getMailSender(), // source`	1094	`mRippleEngine.getMailSender(), // source`
1094	`mRippleEngine.getMailGlobalTarget(), // target (list)`	1095	`mRippleEngine.getMailGlobalTarget(), // target (list)`
1095	`null, // cc`	1096	`null, // cc`
1096	`null, // bcc`	1097	`null, // bcc`
1097	`"BUILD DAEMON Indefinite Pause", // subject`	1098	`"BUILD DAEMON Indefinite Pause", // subject`
1098	`body, // body`	1099	`body, // body`
1099	`null // attachment`	1100	`null // attachment`
1100	`);`	1101	`);`
1101	`}`	1102	`}`
1102	`catch( Exception e )`	1103	`catch( Exception e )`
1103	`{`	1104	`{`
1104	`}`	1105	`}`
Line 1122...	Line 1123...
1122	`{`	1123	`{`
1123	`Smtpsend.send(`	1124	`Smtpsend.send(`
1124	`mRippleEngine.getMailServer(), // mailServer`	1125	`mRippleEngine.getMailServer(), // mailServer`
1125	`mRippleEngine.getMailSender(), // source`	1126	`mRippleEngine.getMailSender(), // source`
1126	`mRippleEngine.getMailGlobalTarget(), // target (list)`	1127	`mRippleEngine.getMailGlobalTarget(), // target (list)`
1127	`null, // cc`	1128	`null, // cc`
1128	`null, // bcc`	1129	`null, // bcc`
1129	`"BUILD DAEMON Indefinite Pause Recovery", // subject`	1130	`"BUILD DAEMON Indefinite Pause Recovery", // subject`
1130	`body, // body`	1131	`body, // body`
1131	`null // attachment`	1132	`null // attachment`
1132	`);`	1133	`);`
1133	`}`	1134	`}`
1134	`catch( Exception e )`	1135	`catch( Exception e )`
1135	`{`	1136	`{`
1136	`}`	1137	`}`
Line 1157...	Line 1158...
1157	`nagInfo.masterCount++;`	1158	`nagInfo.masterCount++;`
1158	`} else {`	1159	`} else {`
1159	`nagInfo.slaveCount++;`	1160	`nagInfo.slaveCount++;`
1160	`}`	1161	`}`
1161		1162
1162	`mLogger.warn("checkThread[" + mRtagId + "] returned " + retVal);`	1163	`mLogger.warn("checkThread[{}] returned {}",mRtagId, retVal);`
1163	`return retVal;`	1164	`return retVal;`
1164	`}`	1165	`}`
1165		1166
1166	`/**`	1167	`/**`
1167	`* Nagios interface extension`	1168	`* Nagios interface extension`
Line 1174...	Line 1175...
1174	`{`	1175	`{`
1175	`boolean retVal = mPhase.isHappy();`	1176	`boolean retVal = mPhase.isHappy();`
1176	`if ( ! retVal) {`	1177	`if ( ! retVal) {`
1177	`nagInfo.extendedReason.add("[" + mRtagId + "] " + mPhase.happyText());`	1178	`nagInfo.extendedReason.add("[" + mRtagId + "] " + mPhase.happyText());`
1178	`}`	1179	`}`
1179	`mLogger.info("checkThreadExtended: " + retVal + ":" + mPhase.toStringSecs() );`	1180	`mLogger.info("checkThreadExtended: {}:{}",retVal, mPhase.toStringSecs() );`
1180	`return retVal;`	1181	`return retVal;`
1181	`}`	1182	`}`
1182		1183
1183		1184
1184	`/**`	1185	`/**`

Subversion Repositories DevTools

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