Subversion Repositories DevTools

package com.erggroup.buildtool.daemon;

import com.erggroup.buildtool.ripple.MutableChar;

import com.erggroup.buildtool.ripple.MutableInt;

import com.erggroup.buildtool.ripple.Package;

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;

    MutableInt rtag_id = new MutableInt();

    MutableInt rcon_id = new MutableInt();

    MutableChar daemon_mode = new MutableChar();

    String hostname = new String("");

    try

    {

      InetAddress local = InetAddress.getLocalHost();

      hostname = local.getHostName();

      mHostname = hostname;

      mLogger.info("BuildDaemon set hostname " + mHostname);

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

        }

      }

      boolean firstTime = true;

      while (run)

      {

        try

        {

          if ( !firstTime )

          {

            mLogger.warn("BuildDaemon sleep for 10 mins");

            Thread.sleep(600000);

            mLogger.info("BuildDaemon sleep returned");

          }

          else

          {

            firstTime = false;    

          }

          releaseManager.queryReleaseConfig(hostname);

          rtag_id.value = 0;

          rcon_id.value = 0;

          daemon_mode.value = 'X';

          boolean moreReleasesConfigured = 

            releaseManager.getFirstReleaseConfig(rtag_id, rcon_id, 

                                                 daemon_mode);

          do

          {

            if (moreReleasesConfigured)

            {

              if (!isActive(rcon_id.value))

              {

                mLogger.warn("BuildDaemon activating " + rtag_id.value + " " + rcon_id.value + " " + daemon_mode.value);

                String utf = null;

                if ( connectionString.compareTo("unit test spawn thread") == 0 )

                {

                  utf = connectionString;

                }

                // spawn and run the BuildThread

                if (daemon_mode.value == 'M')

                {

                  MasterThread thread = new MasterThread(rtag_id.value, rcon_id.value, utf);

                  ThreadIdentifier threadIdentifier = 

                    new ThreadIdentifier(rcon_id.value, thread);

                  mThreadCollection.add(threadIdentifier);

                  // begin thread execution and invoke thread.run();

                  thread.start();

                }

                else if (daemon_mode.value == 'S')

                {

                  SlaveThread thread = new SlaveThread(rtag_id.value, rcon_id.value, utf);

                  ThreadIdentifier threadIdentifier = 

                    new ThreadIdentifier(rcon_id.value, thread);

                  mThreadCollection.add(threadIdentifier);

                  // begin thread execution and invoke thread.run();

                  thread.start();

                }

              }

              moreReleasesConfigured = 

                  releaseManager.getNextReleaseConfig(rtag_id, rcon_id, 

                                                      daemon_mode);

            }

          }

          while (moreReleasesConfigured);

          if ( connectionString.compareTo("unit test spawn thread") == 0)

          {

            run = false;

          }

        }

        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());

    }

}