JetstreamApplication.java

/*******************************************************************************
 *  Copyright © 2012-2015 eBay Software Foundation
 *  This program is dual licensed under the MIT and Apache 2.0 licenses.
 *  Please see LICENSE for more information.
 *******************************************************************************/
package com.ebay.jetstream.application;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jmx.export.annotation.ManagedResource;

import com.ebay.jetstream.config.Configuration;
import com.ebay.jetstream.config.RootConfiguration;
import com.ebay.jetstream.event.support.ShutDownOrchestrator;
import com.ebay.jetstream.management.Management;
import com.ebay.jetstream.util.CommonUtils;
import com.ebay.jetstream.xmlser.Hidden;

/**
 * @author shmurthy
 * 
 *         A container class for hosting Jetstream Event based applications. This class will provide a main method and
 *         shutdown hook. It will start core services like messaging, monitoring and control, logging etc. It will load
 *         the entry bean specified in configuration. The rest of the wiring will be driven by this entry bean. This
 *         class can serve as a main for applications or as a collocated container. If this container's main is used,
 *         then the following command line arguments must be specified Viz, appname, configfile name and config version.
 *         If it is collocated with another container, these 3 parameters can be programatically set.
 * 
 */

@ManagedResource(objectName = "Application")
public class JetstreamApplication {

  private static class ShutdownHook extends Thread {
    @Override
    public void run() {
      try {
        getInstance().shutdown();
      }
      catch (Throwable t) {
        throw CommonUtils.runtimeException(t);
      }
      System.out.println("Gracefully shutdown"); //KEEPME
    }
  }

  private static Class<? extends JetstreamApplication> s_applicationClass = JetstreamApplication.class;
  private static JetstreamApplication s_application;
  private static final Logger LOGGER = LoggerFactory.getLogger("com.ebay.jetstream.application");
  private ThreadPoolExecutor m_worker;
  private BlockingQueue<Runnable> m_workQueue;

  protected static Class<? extends JetstreamApplication> getApplicationClass() {
    return s_applicationClass;
  }

  public static Configuration getConfiguration() {
    return RootConfiguration.getConfiguration();
  }

  @Hidden
  public static JetstreamApplication getInstance() {
    if (s_application == null) {
      synchronized (s_applicationClass) {
        if (s_application == null) {
          try {
            s_applicationClass.newInstance();
          }
          catch (Exception e) {
            throw CommonUtils.runtimeException(e);
          }
        }
      }
    }
    return s_application;
  }

  /**
   * Every Jetstream application shares a common main(). It creates the instance of the application, configures command
   * line options, parses the command line based on the options, starts the application based on the resulting
   * configuration, and then runs the application.
   * 
   * @param args
   *          command line arguments
   */
  public static void main(String[] args) throws Exception {
    System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.Jdk14Logger");
    JetstreamApplication ta = null;
    try {
      ta = getInstance();
      // Allow JetstreamApplication option handling methods to be protected
      final JetstreamApplication optionHandler = ta;
      new CliOptions(new CliOptionHandler() {
        public Options addOptions(Options options) {
          return optionHandler.addOptions(options);
        }

        public void parseOptions(CommandLine line) {
          optionHandler.parseOptions(line);
        }
      }, args);
      
      if (System.getenv("COS") == null)
    	  System.setProperty("COS", "Dev");
      
      ta.init();
    }
    catch (Exception e) {
      LOGGER.error( "Failed to start Application" + e.getLocalizedMessage());		
      System.err.println("Failed to start application: " + e);
      e.printStackTrace(System.err);
      System.exit(1);
    }
    ta.run(); // this is the container's event loop
  }

  protected static void setApplicationClass(Class<? extends JetstreamApplication> applicationClass) {
    s_applicationClass = applicationClass;
  }

  private final Object m_monitor = new Object();
  private final AtomicBoolean m_shutdown = new AtomicBoolean(false);

  private final JetstreamApplicationInformation m_applicationInformation = new JetstreamApplicationInformation(this);

  protected JetstreamApplication() {
    if (s_application != null)
      throw new IllegalStateException(s_application.getClass().getName() + " is already running");
    s_application = this;
    RootConfiguration.applicationClass(m_applicationInformation, getClass());
    Runtime.getRuntime().addShutdownHook(new ShutdownHook());
   
  }

  /**
   * Adds options specific to this application. It may be overridden for custom application specific option
   * configuration.
   * 
   * @param options
   *          the Options to configure with new custom application command line options.
   * 
   * @return the configured options.
   */
  protected Options addOptions(Options options) {
    options.addOption("b", "beans", true, "Beans to start during initialization");
    options.addOption("c", "config", true, "Configuration URL or file path");
    options.addOption("cv", "configversion", true, "Version of configuration");
    options.addOption("n", "name", true, "Name of application");
    options.addOption("p", "port", true, "Monitoring port");
    options.addOption("z", "zone", true, "URL or path of dns zone content");
    options.addOption("nd", "nodns", false, "Not a network application");
    options.addOption("wqz", "workqueuesz", true, "work queue size");
    options.addOption("wt", "workerthreads", true, "worker threads");
    return options;
  }

  public JetstreamApplicationInformation getApplicationInformation() {
    return m_applicationInformation;
  }
  
  /**
 * @param work
 * @return true if success else false
 */
  public boolean submitWork(WorkRequest work) {
	  if (m_workQueue != null)
		  return m_workQueue.offer(work);

	  return false;
  }

  /**
   * Override this method to do initialization in a custom JetstreamApplication.
   * 
   * @throws Exception
   */
  protected void init() throws Exception {
    JetstreamApplicationInformation ai = getApplicationInformation();
    ai.selfLocate();
    
    m_workQueue = new LinkedBlockingQueue<Runnable>(ai.getWorkQeueSz());
    m_worker = new ThreadPoolExecutor(ai.getWorkerThreads(), 3, 30, TimeUnit.SECONDS, m_workQueue, new ThreadPoolExecutor.CallerRunsPolicy());
    m_worker.prestartCoreThread();
    
    Management.addBean(ai.getApplicationName(), this);
    logInfo("Starting services for " + ai);
    String[] configs = ai.getConfigRoots();
    RootConfiguration rc = configs == null ? new RootConfiguration(ai) : new RootConfiguration(ai, configs);
    rc.start();
    String[] sa = ai.getBeans();
    if (sa != null)
      for (String bean : sa)
        rc.getBean(bean);
  }

  protected void logInfo(String message) {
	  LOGGER.info( message);
  }

  protected void logSevereError(String message) {
	  LOGGER.error( message);
  }

  /**
   * Parse the options given on the command line. This method may be overridden for application specific command line
   * option handling.
   * 
   * @param commandLine
   *          the parsed command line.
   */
  protected void parseOptions(CommandLine commandLine) {
    JetstreamApplicationInformation ai = getApplicationInformation();
    if (commandLine.hasOption('b')) {
      ai.setBeans(commandLine.getOptionValues('b'));
    }
    if (commandLine.hasOption('c')) {
      ai.setConfigRoots(commandLine.getOptionValues('c'));
    }
    if (commandLine.hasOption("cv")) {
      ai.setConfigVersion(commandLine.getOptionValue("cv"));
    }
    if (commandLine.hasOption('n')) {
      ai.setApplicationName(commandLine.getOptionValue('n'));
    }
    if (commandLine.hasOption('p')) {
      ai.setManagementPort(Integer.valueOf(commandLine.getOptionValue('p')));
      System.setProperty("jetty_port",commandLine.getOptionValue('p'));
    } else{
    	 System.setProperty("jetty_port" ,  String.valueOf(9999));
    }
    if (commandLine.hasOption('z')) {
      ai.setZone(commandLine.getOptionValue('z'));
    }
    if (commandLine.hasOption("nd")) {
      ai.useDNS(false);
    }
    
    if (commandLine.hasOption("wqz")) {
    	ai.setWorkQueueSz(Integer.valueOf(commandLine.getOptionValue("wqz")));
    }
    
    if (commandLine.hasOption("wt")) {
    	ai.setWorkerThreads(Integer.valueOf(commandLine.getOptionValue("wt")));
    }

  }

  /**
   * Override this method to do work in the Jetstream application.
   */
  protected void run() throws Exception {
    // Do nothing by default
  }

  public void shutdown() throws InterruptedException, Exception {
    try {
      if (ShutDownOrchestrator.getInstance() != null) {
        ShutDownOrchestrator.getInstance().shutDown();
      }
      logInfo("Shutting down " + getApplicationInformation().getApplicationName());
    }
    finally {
      Configuration c = getConfiguration();
      if (c != null)
        c.close();
      synchronized (m_monitor) {
        m_shutdown.set(true);
        m_monitor.notifyAll();
        if (m_worker!=null)
        	m_worker.shutdown();
      }
    }
  }

  /**
   * shutdown shuts down all core services. It must be called for graceful exit, and is called automatically if
   * System.exit() is called.
   */
  // 8853 fix - do not show this link no matter what @ManagedOperation

  protected void waitForShutdown() {
    while (!m_shutdown.get()) {
      System.out.println("waiting for shutdown"); //KEEPME
      synchronized (m_monitor) {
        try {
          m_monitor.wait(10000);
        }
        catch (InterruptedException e) {
          // Ignore
        }
      }
    }
  }
}