* 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.

*/

        MessageListener {

  private static final Class CLASS_NAME = BaseUIMAAsynchronousEngineCommon_impl.class;

  public enum ClientState {INITIALIZING, RUNNING, FAILED, RECONNECTING, STOPPING, STOPPED};

 

  protected ClientState state = ClientState.INITIALIZING;

  protected String brokerURI = null;

  protected static final String SHADOW_CAS_POOL = "ShadowCasPool";

  protected static final int MetadataTimeout = 1;

  protected static final int CpCTimeout = 2;

  protected static final int ProcessTimeout = 3;

  protected static final int PingTimeout = 4;

  protected volatile boolean initialized;

  protected List listeners = new ArrayList();

  protected AsynchAECasManager asynchManager;

  protected boolean remoteService = false;

  protected CollectionReader collectionReader = null;

  protected volatile boolean running = false;

  protected ProcessingResourceMetaData resourceMetadata;

 

  protected CAS sendAndReceiveCAS = null;

  protected UIDGenerator idGenerator = new UIDGenerator();

  protected ConcurrentHashMap<String, ClientRequest> clientCache = new ConcurrentHashMap<String, ClientRequest>();

  protected ConcurrentHashMap<Long, ThreadMonitor> threadMonitorMap = new ConcurrentHashMap<Long, ThreadMonitor>();

  // Default timeout for ProcessCas requests

  protected int processTimeout = 0;

  // Default timeout for GetMeta requests

  protected int metadataTimeout = 60000;

  // Default timeout for CpC requests is no timeout

  protected int cpcTimeout = 0;

  protected volatile boolean abort = false;

  protected static final String uniqueIdentifier = String.valueOf(System.nanoTime());

  protected Exception exc;

  // Counter maintaining a number of CASes sent to a service. The counter

  // is incremented every time a CAS is sent and decremented when the CAS

  // reply is received. It is also adjusted down in case of a timeout or

  // error.

  protected AtomicLong outstandingCasRequests = new AtomicLong();

  protected AtomicLong totalCasRequestsSentBetweenCpCs = new AtomicLong();

  protected ConcurrentHashMap springContainerRegistry = new ConcurrentHashMap();

  protected MessageConsumer consumer = null;

  protected SerialFormat serialFormat = SerialFormat.XMI;

 

  protected TypeSystemImpl remoteTypeSystem; // of the remote service, for filtered binary compression

  protected UimaASClientInfoMBean clientSideJmxStats = new UimaASClientInfo();

  private UimaSerializer uimaSerializer = new UimaSerializer();

  protected ClientServiceDelegate serviceDelegate = null;

  private Object stopMux = new Object();

  private Object sendMux = new Object();

  private BlockingQueue<CasQueueEntry> threadQueue = new LinkedBlockingQueue<CasQueueEntry>();

  private ConcurrentHashMap<Long, CasQueueEntry> threadRegistrar = new ConcurrentHashMap<Long, CasQueueEntry>();

  private volatile boolean casQueueProducerReady;

  private Object casProducerMux = new Object();

  protected BlockingQueue<PendingMessage> pendingMessageQueue = new LinkedBlockingQueue<PendingMessage>();

  // Create Semaphore that will signal when the producer object is initialized

  protected Semaphore producerSemaphore = new Semaphore(1);

  // Create Semaphore that will signal when CPC reply has been received

  protected Semaphore cpcSemaphore = new Semaphore(1);

  // Create Semaphore that will signal when GetMeta reply has been received

  protected Semaphore getMetaSemaphore = new Semaphore(0, true);

  // Signals when the client is ready to send CPC request

  protected Semaphore cpcReadySemaphore = new Semaphore(1);

  // Signals receipt of a CPC reply

  protected Semaphore cpcReplySemaphore = new Semaphore(1);

  protected volatile boolean producerInitialized;

  protected static ConcurrentHashMap<String, SharedConnection> sharedConnections =

      new ConcurrentHashMap<String, SharedConnection>();

 

  //protected static SharedConnection sharedConnection = null;

  protected Thread shutdownHookThread = null;

  private ExecutorService exec = Executors.newFixedThreadPool(1);

 

  private volatile boolean casMultiplierDelegate;

 

  abstract public String getEndPointName() throws Exception;

  abstract protected TextMessage createTextMessage() throws Exception;

  abstract protected BytesMessage createBytesMessage() throws Exception;

  abstract protected void setMetaRequestMessage(Message msg) throws Exception;

  abstract protected void setCASMessage(String casReferenceId, CAS aCAS, Message msg)

          throws Exception;

  abstract protected void setCASMessage(String casReferenceId, String aSerializedCAS, Message msg)

          throws Exception;

  abstract protected void setCASMessage(String casReferenceId, byte[] aSerializedCAS, Message msg)

          throws Exception;

  abstract public void setCPCMessage(Message msg) throws Exception;

  abstract public void initialize(Map anApplicationContext) throws ResourceInitializationException;

  abstract protected void cleanup() throws Exception;

  abstract public String deploy(String[] aDeploymentDescriptorList, Map anApplicationContext)

          throws Exception;

  abstract protected String deploySpringContainer(String[] springContextFiles)

          throws ResourceInitializationException;

  abstract protected MessageSender getDispatcher();

 

  abstract protected void initializeConsumer(String aBrokerURI, Connection connection) throws Exception;

  abstract protected SharedConnection validateConnection(String aBrokerURI) throws Exception;

  // enables/disable timer per CAS. Defaul is to use single timer for

  // all outstanding CASes

  protected volatile boolean timerPerCAS=false;

 

  //abstract protected  String getBrokerURI();

  protected void setBrokeryURI(String brokerURI ) {

    this.brokerURI = brokerURI;

  }

  protected String getBrokerURI() {

    return brokerURI;

  }

 

  public void addStatusCallbackListener(UimaAsBaseCallbackListener aListener) {

    if (running) {

     throw new UIMA_IllegalStateException(JmsConstants.JMS_LOG_RESOURCE_BUNDLE,"UIMAJMS_listener_added_after_initialize__WARNING", new Object[]{});

  }

    listeners.add(aListener);

  }

  public SerialFormat getSerialFormat() {

    return serialFormat;

  }

  protected void setSerialFormat(SerialFormat aSerialFormat) {

    serialFormat = aSerialFormat;

  }

 

  public TypeSystemImpl getRemoteTypeSystem() {

    return remoteTypeSystem;

  }

  protected void setRemoteTypeSystem(TypeSystemImpl remoteTypeSystem) {

    this.remoteTypeSystem = remoteTypeSystem;

  }

 

  /**

   * Serializes a given CAS.

   *

   * @param aCAS

   *          - CAS to serialize

   * @return - serialized CAS

   *

   * @throws Exception

   */

  protected String serializeCAS(CAS aCAS, XmiSerializationSharedData serSharedData)

          throws Exception {

    return uimaSerializer.serializeCasToXmi(aCAS, serSharedData);

  }

  protected String serializeCAS(CAS aCAS) throws Exception {

    XmiSerializationSharedData serSharedData = new XmiSerializationSharedData();

    return uimaSerializer.serializeCasToXmi(aCAS, serSharedData);

  }

  public void removeStatusCallbackListener(UimaAsBaseCallbackListener aListener) {

    listeners.remove(aListener);

  }

  public void onBeforeMessageSend(UimaASProcessStatus status) {

      try {

         for (int i = 0; listeners != null && i < listeners.size(); i++) {

             UimaAsBaseCallbackListener statCL = (UimaAsBaseCallbackListener) listeners.get(i);

             statCL.onBeforeMessageSend(status);

         }

      } catch( Throwable t) {

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

                    "onBeforeMessageSend", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,

                    "UIMAEE_exception__WARNING", t);

      }   

  }

  public void onBeforeProcessCAS(UimaASProcessStatus status, String nodeIP, String pid) {

    for (int i = 0; listeners != null && i < listeners.size(); i++) {

      UimaAsBaseCallbackListener statCL = (UimaAsBaseCallbackListener) listeners.get(i);

      try {

          statCL.onBeforeProcessCAS(status, nodeIP, pid);

       

      } catch( Throwable t) {

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

                    "onBeforeProcessCAS", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,

                    "UIMAEE_exception__WARNING", t);

      }

    }

  }

  public void onBeforeProcessMeta(String nodeIP, String pid) {

    for (int i = 0; listeners != null && i < listeners.size(); i++) {

      UimaAsBaseCallbackListener statCL = (UimaAsBaseCallbackListener) listeners

          .get(i);

      try {

        statCL.onBeforeProcessMeta(nodeIP, pid);

      } catch (Throwable t) {

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

            getClass().getName(), "onBeforeProcessMeta",

            UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,

            "UIMAEE_exception__WARNING", t);

      }

    }

  }

  public synchronized void setCollectionReader(CollectionReader aCollectionReader)

          throws ResourceInitializationException {

    if (initialized) {

      // Uima ee client has already been initialized. CR should be

      // set before calling initialize()

      throw new ResourceInitializationException();

    }

    collectionReader = aCollectionReader;

  }

  private void addMessage(PendingMessage msg) {

    pendingMessageQueue.add(msg);

  }

  protected void acquireCpcReadySemaphore() {

    try {

      // Acquire cpcReady semaphore to block sending CPC request until

      // ALL outstanding CASes are received.

      cpcReadySemaphore.acquire();

    } catch (InterruptedException e) {

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

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

                    "collectionProcessingComplete", JmsConstants.JMS_LOG_RESOURCE_BUNDLE,

                    "UIMAJMS_client_interrupted_while_acquiring_cpcReadySemaphore__WARNING", new Object[] {});

          }

    }

  }

  public synchronized void collectionProcessingComplete() throws ResourceProcessException {

    try {

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

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

                "collectionProcessingComplete", JmsConstants.JMS_LOG_RESOURCE_BUNDLE,

                "UIMAJMS_app_cpc_request_FINEST", new Object[] {});

      }

      if (outstandingCasRequests.get() > 0) {

        UIMAFramework.getLogger(CLASS_NAME)

                .logrb(

                        Level.INFO,

                        CLASS_NAME.getName(),

                        "collectionProcessingComplete",

                        JmsConstants.JMS_LOG_RESOURCE_BUNDLE,

                        "UIMAJMS_in_cpc_INFO",

                        new Object[] { outstandingCasRequests.get(),

                            totalCasRequestsSentBetweenCpCs.get() });

      }

      // If the client was initialized but never sent any CASes its cpcReadySemaphore

      // must be first explicitly released to enable the code to send CPC to a service.

      // The semaphore is initially acquired in the initialize(Map) method and typically

      // released when the number of CASes sent equals the number of CASes received. Since

      // no CASes were sent we must do the release here to be able to continue.

      if (totalCasRequestsSentBetweenCpCs.get() == 0 && !serviceDelegate.isAwaitingPingReply()) {

        cpcReadySemaphore.release();

      }

      // The cpcReadySemaphore was initially acquired in the initialize() method

      // so below we wait until ALL CASes are processed. Once all

      // CASes are received the semaphore will be released

      acquireCpcReadySemaphore();

      serviceDelegate.cancelDelegateTimer();

      if (!running) {

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