Subversion Repositories DevTools

package com.erggroup.buildtool.daemon;

import com.erggroup.buildtool.ripple.Package;
import com.erggroup.buildtool.ripple.ReleaseConfig;
import com.erggroup.buildtool.ripple.ReleaseManager;
import com.erggroup.buildtool.daemon.NagiosThread;

import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.net.ServerSocket;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.Vector;

import org.apache.log4j.Logger;
import org.apache.log4j.xml.DOMConfigurator;

/**BuildDaemon sub component and entry point (main BuildDaemon thread)
 */
public class BuildDaemon
{

  /**hostname
   * @attribute
   */
  static String mHostname = new String();

  /**GBE_LOG
   * @attribute
   */
  static String mGbeLog = new String();

  /**Logger
   * @attribute
   */
  private static final Logger mLogger = Logger.getLogger(BuildDaemon.class);

  /**Collection of ThreadIdentifier objects.
   * @attribute
   */
  private Vector<ThreadIdentifier> mThreadCollection = new Vector<ThreadIdentifier>();

  /**Nagios
   * @attribute
   */
  ServerSocket nagiosSrv;
  NagiosThread nagiosChecker;

  /**mThreadCollection items
   */
  private class ThreadIdentifier
  {
    /**rcon_id associated with the thread
     * @attribute
     */
    private final int mRcon_id;

    /**thread identifier
     * @attribute
     */
    private final BuildThread mThread;

    /**constructor
     */
    ThreadIdentifier(int rcon_id, BuildThread thread)
    {
      mLogger.debug("ThreadIdentifier " + rcon_id);
      mRcon_id = rcon_id;
      mThread = thread;
    }

    /**accessor
     */
    int get_rcon_id()
    {
      mLogger.debug("get_rcon_id");
      mLogger.info("get_rcon_id returned " + mRcon_id);
      return mRcon_id;
    }

    /**accessor
     */
    BuildThread get_thread()
    {
      mLogger.debug("get_thread");
      return mThread;
    }
  }

  /**main method for the Build Daemon program
   * instantiates a BuildDaemon object
   */
  public static void main(String[] args)
  {
    String abtdXml = System.getenv("ABT_HOME");
    
    if ( abtdXml != null )
    {
      abtdXml += System.getProperty( "file.separator" ) + "abtd.xml";
    }
    else
    {
      abtdXml = new String("abtd.xml");
    }
    DOMConfigurator.configure(abtdXml);
    mLogger.debug("main");
    String antHome = System.getenv("ANT_HOME");
    
    if ( antHome == null )
    {
      mLogger.fatal("main ANT_HOME not set");
      System.exit(1);
    }

    mGbeLog = System.getenv("GBE_LOG");
    
    if ( mGbeLog == null )
    {
      mLogger.fatal("main GBE_LOG not set");
      System.exit(1);
    }
    
    File gl = new File( mGbeLog );
    
    if ( !gl.isDirectory() )
    {
      mLogger.fatal("main GBE_LOG is not a directory");
    }

    String gbeUNC = System.getenv("GBE_UNC");
    
    if ( gbeUNC == null )
    {
      mLogger.fatal("main GBE_UNC not set");
      System.exit(1);
    }

    String connectionString = System.getenv("GBE_RM_LOCATION");
    String username = System.getenv("GBE_RM_USERNAME");
    String password = System.getenv("GBE_RM_PASSWORD");

    for (int optind = 0; optind < args.length; optind++)
    {
      if (args[optind].equals("-c") && optind < (args.length - 1))
      {
        connectionString = args[++optind];
      }
      else if (args[optind].equals("-u") && optind < (args.length - 1))
      {
        username = args[++optind];
      }
      else if (args[optind].equals("-p") && optind < (args.length - 1))
      {
        password = args[++optind];
      }
    }

    if (connectionString == null ||
        connectionString.length() == 0 ||
        username == null ||
        username.length() == 0 ||
        password == null ||
        password.length() == 0)
    {
      mLogger.fatal("Usage: java -jar abtdD.jar -c connectionString -u username -p password");
      System.exit(1);
    }

    BuildDaemon buildDaemon = new BuildDaemon(connectionString, username, password);
    buildDaemon.cleanUp();
    
  }

  /**constructor, implements the sequence diagram spawn thread
   */
  public BuildDaemon(String connectionString, String username, 
                     String password)
  {
    mLogger.warn("BuildDaemon");
    ReleaseManager releaseManager = new ReleaseManager(connectionString, username + "[release_manager]", password);
    boolean run = true;
    String utf = null;
    
    try
    {
      InetAddress local = InetAddress.getLocalHost();
      mHostname = local.getHostName();
      mLogger.info("BuildDaemon set hostname " + mHostname);

      // Flag UTF in progress
      if ( connectionString.compareTo("unit test spawn thread") == 0 )
      {
        utf = connectionString;
      }
      
      if ( Package.mGenericMachtype == null )
      {
        mLogger.fatal("run GBE_MACHTYPE not set");
        throw new Exception("run GBE_MACHTYPE not set");
      }

      if ( Package.mGbeDpkg == null )
      {
        mLogger.fatal("run GBE_DPKG not set");
        throw new Exception("run GBE_DPKG not set");
      }

      //        Set the default handler invoked when a thread abruptly terminates due to an
      //        uncaught exception, and no other handler has been defined for that thread.
      //
      Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler());

      //
      //  Start the Nagios Interface Thread
      //
      if ( connectionString.compareTo("unit test spawn thread") != 0 )
      {
        try {
          nagiosSrv = new ServerSocket(1111);
          nagiosChecker = new NagiosThread(nagiosSrv, this);
          nagiosChecker.start();
        } catch ( IOException e ) {
              mLogger.fatal("Failed to start Nagios Service. Port already in use");
              throw new Exception("Nagios port in use");
        }
      }
 
      //        Discover new build daemons to be started on the current host
      //
      while (run)
      {
        try
        {
                // Create a list of all machines that are configured to run on this machine
                //
                releaseManager.queryReleaseConfig(mHostname);
          
          //
          //  Iterate over all the configured machines
          //    Start up new build threads for new machines
          //
          for (Iterator<ReleaseConfig> it = releaseManager.mReleaseConfigCollection.iterator(); it.hasNext(); )
          {
            ReleaseConfig rc = it.next();
            
            if (!isActive(rc.get_rcon_id()))
            {
              mLogger.warn("BuildDaemon activating " + rc.get_rtag_id() + " " + rc.get_rcon_id() + " " + rc.get_daemon_mode());
              
         
              // spawn and run the BuildThread
              if (rc.get_daemon_mode() == 'M')
              {
                MasterThread thread = new MasterThread(rc.get_rtag_id(), rc.get_rcon_id(), utf);
                ThreadIdentifier threadIdentifier =  new ThreadIdentifier(rc.get_rcon_id(), thread);
                mThreadCollection.add(threadIdentifier);
                // begin thread execution and invoke thread.run();
                thread.start();
              }
              else if (rc.get_daemon_mode() == 'S')
              {
                SlaveThread thread = new SlaveThread(rc.get_rtag_id(), rc.get_rcon_id(), utf);
                ThreadIdentifier threadIdentifier = new ThreadIdentifier(rc.get_rcon_id(), thread);
                mThreadCollection.add(threadIdentifier);
                // begin thread execution and invoke thread.run();
                thread.start();
              }
            }
            
          }
          
          //    In UTF mode we only execute the loop once
          if ( utf != null )
          {
            run = false;
            continue;
          }
         
          // Wait 10 minutes before we try to discover new machines
          
          mLogger.warn("BuildDaemon sleep for 10 mins");
          Thread.sleep(600000);
          mLogger.info("BuildDaemon sleep returned");
                   
        }
        catch (SQLException e)
        {
          mLogger.warn("BuildDaemon caught SQLException");
        }
        catch (InterruptedException e)
        {
          mLogger.warn("BuildDaemon caught InterruptedException");
        }
        catch (Exception e)
        {
          mLogger.warn("BuildDaemon caught Exception");
        }
      }
    }
    catch( UnknownHostException e )
    {
      mLogger.fatal("BuildDaemon caught UnknownHostException");
    }
    catch( Exception e )
    {
      mLogger.fatal("BuildDaemon caught Exception");
    }
  }

  /**calls isAlive on the Thread object associated with the rcon_id
   */
  public boolean isActive(final int rcon_id)
  {
    mLogger.debug("isActive " + rcon_id);
    boolean retVal = false;
    boolean found = false;

    for (Iterator<ThreadIdentifier> it = mThreadCollection.iterator(); it.hasNext(); )
    {
      ThreadIdentifier threadIdentifier = it.next();

      if (threadIdentifier.get_rcon_id() == rcon_id)
      {
        found = true;
        if (threadIdentifier.get_thread().isAlive())
        {
          retVal = true;
          break;
        }
        else
        {
            mLogger.warn("isActive found dead thread " + rcon_id );
        }
      }
    }

    if ( !found )
    {
        mLogger.warn("isActive thread not found " + rcon_id);
    }

    mLogger.warn("isActive returned " + retVal);
    return retVal;
  }

    /**
     *  Nagios interface
     *      Returns true if ALL the thread looks OK
     *      Must have one active thread
    */
    boolean checkThreads()
    {
      boolean retVal = false;
        mLogger.info("checkThreads called");
      for (Iterator<ThreadIdentifier> it = mThreadCollection.iterator(); it.hasNext(); )
      {
        ThreadIdentifier threadIdentifier = it.next();

        if (threadIdentifier.get_thread().checkThread())
        {
          retVal = true;
        }
        else
        {
          retVal = false;
          break;
        }
      }

      mLogger.info("checkThreads returned " + retVal);
      return retVal;
    }
  

  /**terminates all BuildThreads
   */
  public void cleanUp()
  {
    mLogger.warn("cleanUp");
    if ( nagiosChecker != null )
    {
        nagiosChecker.terminate();
    }

    for (Iterator<ThreadIdentifier> it = mThreadCollection.iterator(); it.hasNext(); )
    {
      ThreadIdentifier threadIdentifier = it.next();

      if (threadIdentifier.get_thread().isAlive())
      {
        try
        {
          threadIdentifier.get_thread().interrupt();
          threadIdentifier.get_thread().join();
        }
        catch( InterruptedException e )
        {
        }
      }
    }
  }
}

class UncaughtExceptionHandler implements Thread.UncaughtExceptionHandler
{
    private static final Logger mLogger = Logger.getLogger(UncaughtExceptionHandler.class);

    //Implements Thread.UncaughtExceptionHandler.uncaughtException()
    public void uncaughtException(Thread th, Throwable ex)
    {
        System.out.println("You crashed thread " + th.getName());
        System.out.println("Exception was: " + ex.toString());

        mLogger.fatal("UncaughtException ThreadName: " + th.getName());
        mLogger.fatal("UncaughtException was: " + ex.toString());
    }
}