* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*   http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied.  See the License for the

* specific language governing permissions and limitations

* under the License.

*/

        AnalysisEngineController, EventSubscriber {

  private static final Class CLASS_NAME = BaseAnalysisEngineController.class;

  public static enum ServiceState { INITIALIZING, RUNNING, DISABLED, STOPPING, FAILED };

 

  protected ServiceState currentState = ServiceState.INITIALIZING;

 

  private static final long DoNotProcessTTL = 30 * 60 * 1000; // 30 minute time to live

  protected volatile ControllerLatch latch = new ControllerLatch(this);

  protected ConcurrentHashMap statsMap = new ConcurrentHashMap();

  protected Monitor monitor = new MonitorBaseImpl();

  protected Endpoint clientEndpoint;

  private CountDownLatch inputChannelLatch = new CountDownLatch(1);

  private OutputChannel outputChannel;

  private AsynchAECasManager casManager;

  private InProcessCache inProcessCache;

  protected AnalysisEngineController parentController;

  private String endpointName;

  protected ResourceSpecifier resourceSpecifier;

  protected HashMap paramsMap;

  protected InputChannel inputChannel;

  protected ErrorHandlerChain errorHandlerChain;

  protected long errorCount = 0;

  protected List inputChannelList = new ArrayList();

  protected ConcurrentHashMap inputChannelMap = new ConcurrentHashMap();

  protected ConcurrentHashMap idleTimeMap = new ConcurrentHashMap();

  private UimaEEAdminContext adminContext;

  protected int componentCasPoolSize = 0;

  protected long replyTime = 0;

  protected long idleTime = 0;

  protected ConcurrentHashMap serviceErrorMap = new ConcurrentHashMap();

  private boolean registeredWithJMXServer = false;

  protected String jmxContext = "";

  protected ConcurrentHashMap mBeanMap = new ConcurrentHashMap();

  protected ServicePerformance servicePerformance = null;

  protected ServiceErrors serviceErrors = null;

  protected ConcurrentHashMap timeSnapshotMap = new ConcurrentHashMap();

  private String deploymentDescriptor = "";

  private JmxManagement jmxManagement = null;

  protected volatile boolean stopped = false;

  protected String delegateKey = null;

  protected List unregisteredDelegateList = new ArrayList();

  protected volatile boolean allDelegatesAreRemote = false;

  protected List controllerListeners = new ArrayList();

  protected volatile boolean serviceInitialized = false;

  protected ConcurrentHashMap perCasStatistics = new ConcurrentHashMap();

  private volatile boolean casMultiplier = false;

  protected Object syncObject = new Object();

  // Map holding outstanding CASes produced by Cas Multiplier that have to be acked

  protected ConcurrentHashMap cmOutstandingCASes = new ConcurrentHashMap();

  private Object mux = new Object();

  private Object waitmux = new Object();

  private volatile boolean waitingForCAS = false;

  private long startTime = System.nanoTime();

  private long totalWaitTimeForCAS = 0;

  private long lastCASWaitTimeUpdate = 0;

  private Map<Long, AnalysisThreadState> threadStateMap = new HashMap<Long, AnalysisThreadState>();

  protected final Object finalStepMux = new Object();

  protected ConcurrentHashMap<String, UimaTransport> transports = new ConcurrentHashMap<String, UimaTransport>();

  protected ConcurrentHashMap<String, UimaMessageListener> messageListeners = new ConcurrentHashMap<String, UimaMessageListener>();

  private Exception initException = null;

  // Local cache for this controller only. This cache stores state of

  // each CAS. The actual CAS is still stored in the global cache. The

  // local cache is used to determine when each CAS can be removed as

  // it reaches the final step. Global cache is not a good place to

  // store this information if there are collocated (delegate) controllers

  // A CAS state change made by one controller may effect another controller.

  protected LocalCache localCache;

  protected String aeDescriptor;

  // List of Delegates

  protected List<Delegate> delegates = new ArrayList<Delegate>();

  // indicates whether or not we received a callback from the InProcessCache when

  // it becomes empty

  protected volatile boolean callbackReceived = false;

  // Monitor used in stop() to await a callback from InProcessCache

  protected Object callbackMonitor = new Object();

  protected volatile boolean awaitingCacheCallbackNotification = false;

  protected ConcurrentHashMap<String, String> abortedCasesMap = new ConcurrentHashMap<String, String>();

  protected String processPid = "";

  private CountDownLatch stopLatch = new CountDownLatch(1);

  // Set to true when stopping the service

  private volatile boolean releasedAllCASes;

  protected List<DoNotProcessEntry> doNotProcessList = new ArrayList<DoNotProcessEntry>();

  private ScheduledExecutorService daemonServiceExecutor = null;

  private static final UimaAsVersion uimaAsVersion = new UimaAsVersion();

  public BaseAnalysisEngineController() {

  }

  public BaseAnalysisEngineController(AnalysisEngineController aParentController,

          int aComponentCasPoolSize, String anEndpointName, String aDescriptor,

          AsynchAECasManager aCasManager, InProcessCache anInProcessCache) throws Exception {

    this(aParentController, aComponentCasPoolSize, 0, anEndpointName, aDescriptor, aCasManager,

            anInProcessCache, null, null);

  }

  public BaseAnalysisEngineController(AnalysisEngineController aParentController,

          int aComponentCasPoolSize, String anEndpointName, String aDescriptor,

          AsynchAECasManager aCasManager, InProcessCache anInProcessCache, Map aDestinationMap)

          throws Exception {

    this(aParentController, aComponentCasPoolSize, 0, anEndpointName, aDescriptor, aCasManager,

            anInProcessCache, aDestinationMap, null);

  }

  public BaseAnalysisEngineController(AnalysisEngineController aParentController,

          int aComponentCasPoolSize, String anEndpointName, String aDescriptor,

          AsynchAECasManager aCasManager, InProcessCache anInProcessCache, Map aDestinationMap,

          JmxManagement aJmxManagement) throws Exception {

    this(aParentController, aComponentCasPoolSize, 0, anEndpointName, aDescriptor, aCasManager,

            anInProcessCache, aDestinationMap, aJmxManagement);

  }

  public BaseAnalysisEngineController(AnalysisEngineController aParentController,

          int aComponentCasPoolSize, long anInitialCasHeapSize, String anEndpointName,

          String aDescriptor, AsynchAECasManager aCasManager, InProcessCache anInProcessCache,

          Map aDestinationMap, JmxManagement aJmxManagement) throws Exception {

    casManager = aCasManager;

    inProcessCache = anInProcessCache;

    localCache = new LocalCache(this);

    aeDescriptor = aDescriptor;

    parentController = aParentController;

    componentCasPoolSize = aComponentCasPoolSize;

    if (this instanceof AggregateAnalysisEngineController) {

      // Populate a list of un-registered co-located delegates. A delegate will be taken off the

      // un-registered list

      // when it calls its parent registerChildController() method.

      Set set = aDestinationMap.entrySet();

      synchronized (unregisteredDelegateList) {

        for (Iterator it = set.iterator(); it.hasNext();) {

          Map.Entry entry = (Map.Entry) it.next();

          Endpoint endpoint = (Endpoint) entry.getValue();

          if (endpoint != null && !endpoint.isRemote()) {

            unregisteredDelegateList.add(entry.getKey());

          }

        }

        if (unregisteredDelegateList.size() == 0) // All delegates are remote

        {

          allDelegatesAreRemote = true;

        }

      }

    }

    endpointName = anEndpointName;

    delegateKey = anEndpointName;

    if (this instanceof AggregateAnalysisEngineController) {

      ConcurrentHashMap endpoints = new ConcurrentHashMap();

      endpoints.putAll(aDestinationMap);

      // Create a map containing: Endpoint-DelegateKey pairs, to enable look-up

      // of a delegate key based on delegate's endpoint

      ((AggregateAnalysisEngineController) this).mapEndpointsToKeys(endpoints);

    }

    // If not the top level, retrieve the name of the endpoint from the parent

    if (!isTopLevelComponent()) {

      Endpoint endpoint = ((AggregateAnalysisEngineController) parentController).lookUpEndpoint(

              endpointName, false);

      endpointName = endpoint.getEndpoint();

    }

    resourceSpecifier = UimaClassFactory.produceResourceSpecifier(aDescriptor);

    if (isTopLevelComponent()) {

      // Check UIMA AS version againg the UIMA Core version. If not the same throw Exception

      if (!uimaAsVersion.getVersionString().equals(UIMAFramework.getVersionString())) {

        UIMAFramework.getLogger(CLASS_NAME).logrb(

                Level.INFO,

                CLASS_NAME.getName(),

                "BaseAnalysisEngineController",

                UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,

                "UIMAEE_incompatible_version_WARNING",

                new Object[] { getComponentName(), uimaAsVersion.getVersionString(),

                    UIMAFramework.getVersionString() });

        throw new ResourceInitializationException(new AsynchAEException(

                "Version of UIMA-AS is Incompatible with a Version of UIMA Core. UIMA-AS Version:"

                        + uimaAsVersion.getVersionString() + " Core UIMA Version:"

                        + UIMAFramework.getVersionString()));

      }

      logPlatformInfo(getComponentName());

    } else {

      if (UIMAFramework.getLogger(CLASS_NAME).isLoggable(Level.INFO)) {

        UIMAFramework.getLogger(CLASS_NAME).logrb(Level.INFO, CLASS_NAME.getName(),

                "BaseAnalysisEngineController", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,

                "UIMAEE_service_id_INFO", new Object[] { endpointName });

      }

    }

    // Is this service a CAS Multiplier?

    if ((resourceSpecifier instanceof AnalysisEngineDescription && ((AnalysisEngineDescription) resourceSpecifier)

            .getAnalysisEngineMetaData().getOperationalProperties().getOutputsNewCASes())

            || resourceSpecifier instanceof CollectionReaderDescription) {

      casMultiplier = true;

    }

    paramsMap = new HashMap();

    if (aJmxManagement == null) {

      jmxManagement = new JmxManager(getJMXDomain());

    } else {

      jmxManagement = aJmxManagement;

      if (jmxManagement.getMBeanServer() != null) {

        paramsMap.put(AnalysisEngine.PARAM_MBEAN_SERVER, jmxManagement.getMBeanServer());

      }

    }

    paramsMap.put(AnalysisEngine.PARAM_MBEAN_NAME_PREFIX, jmxManagement.getJmxDomain());

    if (isTopLevelComponent() && this instanceof AggregateAnalysisEngineController) {

      if (UIMAFramework.getLogger(CLASS_NAME).isLoggable(Level.INFO)) {

        UIMAFramework.getLogger(CLASS_NAME).logrb(Level.INFO, CLASS_NAME.getName(), "C'tor",

                UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE, "UIMAEE_using_vm_transport_INFO",

                new Object[] { getComponentName() });

      }

    }

    // Top level component?

    if (parentController == null) {

      paramsMap.put(Resource.PARAM_RESOURCE_MANAGER, casManager.getResourceManager());

      initialize(resourceSpecifier, paramsMap);

      AnalysisEngineManagementImpl mbean = (AnalysisEngineManagementImpl) getUimaContextAdmin()

              .getManagementInterface();

      // Override uima core jmx domain setting

      mbean.setName(getComponentName(), getUimaContextAdmin(), jmxManagement.getJmxDomain());

      if (resourceSpecifier instanceof AnalysisEngineDescription) {

        // Is this service a CAS Multiplier?

        if (((AnalysisEngineDescription) resourceSpecifier).getAnalysisEngineMetaData()

                .getOperationalProperties().getOutputsNewCASes()) {

          System.out.println(getName() + "-Initializing CAS Pool for Context:"

                  + getUimaContextAdmin().getQualifiedContextName());

          System.out.println(getComponentName() + "-CasMultiplier Cas Pool Size="

                  + aComponentCasPoolSize + " Cas Initialial Heap Size:" + anInitialCasHeapSize);

          if (UIMAFramework.getLogger(CLASS_NAME).isLoggable(Level.INFO)) {

            UIMAFramework.getLogger(CLASS_NAME)

                    .logrb(

                            Level.INFO,

                            CLASS_NAME.getName(),

                            "C'tor",

                            UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,

                            "UIMAEE_multiplier_cas_pool_config_INFO",

                            new Object[] { getComponentName(), aComponentCasPoolSize,

                                anInitialCasHeapSize });

          }

          initializeComponentCasPool(aComponentCasPoolSize, anInitialCasHeapSize);

        }

      }

    } else {

      UimaContext childContext = parentController.getChildUimaContext(endpointName);

      paramsMap.put(Resource.PARAM_UIMA_CONTEXT, childContext);

      initialize(resourceSpecifier, paramsMap);

      initializeComponentCasPool(aComponentCasPoolSize, anInitialCasHeapSize);

      if (parentController instanceof AggregateAnalysisEngineController) {

        // Register self with the parent controller

        ((AggregateAnalysisEngineController) parentController).registerChildController(this,

                delegateKey);

      }

    }

    // Each component in the service hierarchy has its own index. The index is used

    // to construct jmx context path to which every object belongs.

    int index = getIndex();

    // Get uima ee jmx base context path

    jmxContext = getJmxContext();

    if (!isTopLevelComponent() && this instanceof PrimitiveAnalysisEngineController) {

      String thisComponentName = ((AggregateAnalysisEngineController) parentController)

              .lookUpDelegateKey(endpointName);

      jmxContext += (thisComponentName + " Uima EE Service");

    }

    // Register InProcessCache with JMX under the top level component

    if (inProcessCache != null && isTopLevelComponent()) {

      inProcessCache.setName(jmxManagement.getJmxDomain() + jmxContext + ",name="

              + inProcessCache.getName());

      ObjectName on = new ObjectName(inProcessCache.getName());

      jmxManagement.registerMBean(inProcessCache, on);

    }

    initializeServiceStats();

    // Show Serialization Strategy of each remote delegate

    if (this instanceof AggregateAnalysisEngineController) {

      Set set = aDestinationMap.entrySet();

      for (Iterator it = set.iterator(); it.hasNext();) {

        Map.Entry entry = (Map.Entry) it.next();

        Endpoint endpoint = (Endpoint) entry.getValue();

        if (endpoint != null && endpoint.isRemote()) {

          String key = ((AggregateAnalysisEngineController) this).lookUpDelegateKey(endpoint

                  .getEndpoint());

          System.out.println("Service:" + getComponentName()

                  + " Configured To Serialize CASes To Remote Delegate:" + key + " Using "

                  + endpoint.getSerializer() + " Serialization");

          if (UIMAFramework.getLogger(CLASS_NAME).isLoggable(Level.INFO)) {

            UIMAFramework.getLogger(CLASS_NAME).logrb(Level.INFO, CLASS_NAME.getName(), "C'tor",

                    UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,

                    "UIMAEE_show_remote_delegate_serialization_INFO",

                    new Object[] { getComponentName(), key, endpoint.getSerializer() });

          }

        }

      }

    }

    // Create an instance of ControllerMBean and register it with JMX Server.

    // This bean exposes service lifecycle APIs to enable remote stop

    if (isTopLevelComponent()) {

      Controller controller = new Controller(this);

      String jmxName = getManagementInterface().getJmxDomain() + "name=" + "Controller";

      registerWithAgent(controller, jmxName);

    }

  }

  /**

   * Returns resources loaded by the URLClassLoader on startup.

   *

   * @return

   */

  private String getLoadedJars() {

    StringBuffer loadedJars = new StringBuffer("");

    try {

      if ( this.getClass().getClassLoader() instanceof URLClassLoader) {

        URL[] urls = ((URLClassLoader)this.getClass().getClassLoader()).getURLs();

        for( URL url : urls ) {

          loadedJars.append(url.getFile()+File.pathSeparator);

        }

      }

    } catch( Exception e) {

      if (UIMAFramework.getLogger(CLASS_NAME).isLoggable(Level.WARNING)) {

        UIMAFramework.getLogger(CLASS_NAME).logrb(Level.WARNING, getClass().getName(),

                "getLoadedJars", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,

                "UIMAEE_exception__WARNING", new Object[] { e });

      }

    }

    return loadedJars.toString();

  }

  private void logPlatformInfo(String serviceName) {

    if (ManagementFactory.getPlatformMBeanServer() != null) {

      RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();

      // MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();

      OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();

      // bean.getName() should return a string that looks like this: PID@HOSTNAME

      // where PID is the process id and the HOSTNAME is the name of the machine

      processPid = bean.getName();

      if (processPid != null && processPid.trim().length() > 0) {

        int endPos = processPid.indexOf("@"); // find the position where the PID ends

        if (endPos > -1) {

          processPid = processPid.substring(0, endPos);

        }

      }

   

      String loadedJars = getLoadedJars(); 

      DateFormat df = new SimpleDateFormat("dd MMM yyyy HH:mm:ss ");

      StringBuffer platformInfo = new StringBuffer();

      platformInfo.append("\n+------------------------------------------------------------------");

      platformInfo.append("\n                   Starting UIMA AS Service - PID:" + processPid);

      platformInfo.append("\n+------------------------------------------------------------------");

      platformInfo.append("\n+ Service Name:" + serviceName);

      platformInfo.append("\n+ Service Queue Name:" + endpointName);

      platformInfo.append("\n+ Service Start Time:" + df.format(bean.getStartTime()));

      platformInfo.append("\n+ UIMA AS Version:" + uimaAsVersion.getVersionString());

      platformInfo.append("\n+ UIMA Core Version:" + UIMAFramework.getVersionString());

      platformInfo.append("\n+ OS Name:" + osBean.getName());

      platformInfo.append("\n+ OS Version:" + osBean.getVersion());

      platformInfo.append("\n+ OS Architecture:" + osBean.getArch());

      platformInfo.append("\n+ OS CPU Count:" + osBean.getAvailableProcessors());

      platformInfo.append("\n+ JVM Vendor:" + bean.getVmVendor());

      platformInfo.append("\n+ JVM Name:" + bean.getVmName());

      platformInfo.append("\n+ JVM Version:" + bean.getVmVersion());

      platformInfo.append("\n+ JVM Input Args:" + bean.getInputArguments());

      platformInfo.append("\n+ JVM Classpath:" + bean.getClassPath());

      if ( loadedJars != null && loadedJars.length() > 0 ) {

        platformInfo.append("\n+ JVM Loaded Jars:" + loadedJars);

      }

      platformInfo.append("\n+ JVM LIB_PATH:" + bean.getLibraryPath());

      platformInfo.append("\n+------------------------------------------------------------------");

      System.out.println(platformInfo.toString());

      UIMAFramework.getLogger(CLASS_NAME).logrb(Level.INFO, CLASS_NAME.getName(),

              "logPlatformInfo", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,

              "UIMAEE_show_platform_info__INFO", new Object[] { platformInfo.toString() });

    }

  }

  public AnalysisEngineController getParentController() {

    return parentController;

  }

  public UimaTransport getTransport(String aKey) throws Exception {

    return getTransport(null, aKey);

  }

  public UimaTransport getTransport(UimaAsContext asContext) throws Exception {

    String endpointName = getName();

    if (!isTopLevelComponent()) {

      endpointName = parentController.getName();

    }

    return getTransport(asContext, endpointName);

  }

  public UimaTransport getTransport(UimaAsContext asContext, String aKey) throws Exception {

    UimaTransport transport = null;

    if (!transports.containsKey(aKey)) {

      transport = new VmTransport(asContext, this);

      if (isStopped()) {

        throw new ServiceShutdownException();

      }

      transports.put(aKey, transport);

    } else {

      transport = (UimaTransport) transports.get(aKey);

    }

    return transport;

  }

  /**

   * Initializes transport used for internal messaging between collocated Uima AS services.

   */

  public void initializeVMTransport(int parentControllerReplyConsumerCount) throws Exception {

    // If this controller is an Aggregate Controller, force delegates to initialize

    // their internal transports.

    if (this instanceof AggregateAnalysisEngineController) {

      // Get a list of all colocated delegate controllers.

      List<AnalysisEngineController> childControllers = ((AggregateAnalysisEngineController_impl) this).childControllerList;

      synchronized( childControllers ) {

        for( AnalysisEngineController ctrl: childControllers ) {

          // Force initialization

          ctrl.initializeVMTransport(parentControllerReplyConsumerCount);

        }

      }

    }

    // Only delegate controllers execute the logic below

    if (parentController != null) {

      UimaAsContext uimaAsContext = new UimaAsContext();

      if (!registeredWithJMXServer) {

        registeredWithJMXServer = true;

        registerServiceWithJMX(jmxContext, false);

      }

      // Determine how many consumer threads to create. First though use the parent Aggregate

      // Controller

      // to lookup this delegate key. Next fetch the delegate endpoint which contains

      // concurrentConsumers property.

      String key = ((AggregateAnalysisEngineController) parentController)

              .lookUpDelegateKey(getName());

      int concurrentRequestConsumers = 1;

      int concurrentReplyConsumers = 1;

      if (key != null) {