Class CPMEngine

  • All Implemented Interfaces:
    java.lang.Runnable

    public class CPMEngine
    extends java.lang.Object
    implements java.lang.Runnable
    Responsible for creating and initializing processing threads. This instance manages the life-cycle of the CPE components. It exposes API for plugging in components programmatically instead of declaratively. Running in its own thread, this components creates separate Processing Pipelines for Analysis Engines and CAS Consumers, launches configured CollectionReader and attaches all of those components to form a pipeline from source to sink. The Collection Reader feeds Processing Threads containing Analysis Engines, and Analysis Engines feed results of analysis to CAS Consumers.
    • Field Detail

      • MAX_WAIT_ON_QUEUE

        private static final int MAX_WAIT_ON_QUEUE
        The Constant MAX_WAIT_ON_QUEUE.
        See Also:
        Constant Field Values
      • CAS_PROCESSED_MSG

        private static final int CAS_PROCESSED_MSG
        The Constant CAS_PROCESSED_MSG.
        See Also:
        Constant Field Values
      • SINGLE_THREADED_MODE

        private static final java.lang.String SINGLE_THREADED_MODE
        The Constant SINGLE_THREADED_MODE.
        See Also:
        Constant Field Values
      • casPool

        public CPECasPool casPool
        The CAS pool.
      • lockForPause

        public final java.lang.Object lockForPause
        The lock for pause.
      • pause

        protected boolean pause
        The pause.
      • isRunning

        protected volatile boolean isRunning
        The is running.
      • stopped

        protected volatile boolean stopped
        The stopped.
      • killed

        protected volatile boolean killed
        The killed.
      • pauseOnException

        private boolean pauseOnException
        The pause on exception.
      • annotatorList

        private java.util.LinkedList annotatorList
        The annotator list.
      • annotatorDeployList

        private java.util.LinkedList annotatorDeployList
        The annotator deploy list.
      • consumerList

        private java.util.LinkedList consumerList
        The consumer list.
      • consumerDeployList

        private java.util.LinkedList consumerDeployList
        The consumer deploy list.
      • numToProcess

        private long numToProcess
        The num to process.
      • poolSize

        private int poolSize
        The pool size.
      • stats

        private java.util.Map stats
        The stats.
      • statusCbL

        private java.util.ArrayList statusCbL
        The status cb L.
      • readerFetchSize

        private int readerFetchSize
        The reader fetch size.
      • inputQueueSize

        private int inputQueueSize
        The input queue size.
      • outputQueueSize

        private int outputQueueSize
        The output queue size.
      • concurrentThreadCount

        private int concurrentThreadCount
        The concurrent thread count.
      • analysisEngines

        private java.util.Hashtable analysisEngines
        The analysis engines.
      • consumers

        private java.util.Hashtable consumers
        The consumers.
      • casprocessorList

        private CasProcessor[] casprocessorList
        The casprocessor list.
      • producerResult

        private java.util.concurrent.Future<?> producerResult
      • cpeFactory

        private CPEFactory cpeFactory
        The cpe factory.
      • processingUnits

        protected ProcessingUnit[] processingUnits
        The processing units.
      • processingUnitResults

        protected java.util.concurrent.Future<?>[] processingUnitResults
      • casConsumerPU

        private ProcessingUnit casConsumerPU
        The cas consumer PU.
      • casConsumerPUResult

        private java.util.concurrent.Future<?> casConsumerPUResult
      • checkpointData

        private CheckpointData checkpointData
        The checkpoint data.
      • mixedCasProcessorTypeSupport

        private boolean mixedCasProcessorTypeSupport
        The mixed cas processor type support.
      • mPerformanceTuningSettings

        private java.util.Properties mPerformanceTuningSettings
        The m performance tuning settings.
      • activeProcessingUnits

        private int activeProcessingUnits
        The active processing units.
      • hardKill

        private boolean hardKill
        The hard kill.
      • skippedDocs

        private java.util.Hashtable skippedDocs
        The skipped docs.
      • definedCapabilities

        private Capability[] definedCapabilities
        The defined capabilities.
      • needsTCas

        private boolean needsTCas
        The needs T cas.
      • crFetchTime

        private long crFetchTime
        The cr fetch time.
      • readerState

        private int readerState
        The reader state.
      • dropCasOnExceptionPolicy

        private boolean dropCasOnExceptionPolicy
        The drop cas on exception policy.
      • singleThreadedCPE

        private boolean singleThreadedCPE
        The single threaded CPE.
      • nonThreadedCasConsumerProcessingUnit

        private NonThreadedProcessingUnit nonThreadedCasConsumerProcessingUnit
        The non threaded cas consumer processing unit.
      • initial_cp_list

        private java.util.LinkedList initial_cp_list
        The initial cp list.
      • casProcessorsDeployed

        private boolean casProcessorsDeployed
        The cas processors deployed.
      • consumerThreadStarted

        private boolean consumerThreadStarted
        The consumer thread started.
      • readerThreadStarted

        private boolean readerThreadStarted
        The reader thread started.
      • processingThreadsState

        private int[] processingThreadsState
        The processing threads state.
    • Constructor Detail

      • CPMEngine

        public CPMEngine​(CPMExecutorService aExecutorService,
                         CPEFactory aCpeFactory,
                         ProcessTrace aProcTr,
                         CheckpointData aCheckpointData)
                  throws java.lang.Exception
        Initializes Collection Processing Engine. Assigns this thread and all processing threads created by this component to a common Thread Group.
        Parameters:
        aExecutorService - - contains all CPM related threads
        aCpeFactory - - CPE factory object responsible for parsing cpe descriptor and creating components
        aProcTr - - instance of the ProcessTrace where the CPM accumulates stats
        aCheckpointData - - checkpoint object facillitating restart from the last known point
        Throws:
        java.lang.Exception - the exception
    • Method Detail

      • getProcessingContainers

        public java.util.LinkedList getProcessingContainers()
        Returns a list of Processing Containers for Analysis Engines. Each CasProcessor is managed by its own container.
        Returns:
        the processing containers
      • getAllProcessingContainers

        public java.util.LinkedList getAllProcessingContainers()
        Returns a list of All Processing Containers. Each CasProcessor is managed by its own container.
        Returns:
        the all processing containers
      • setStats

        public void setStats​(java.util.Map aMap)
        Plugs in a map where the engine stores perfomance info at runtime.
        Parameters:
        aMap - - map for runtime stats and totals
      • getStats

        public java.util.Map getStats()
        Returns CPE stats.
        Returns:
        Map containing CPE stats
      • setPauseOnException

        public void setPauseOnException​(boolean aPause)
        Sets a global flag to indicate to the CPM that it should pause whenever exception occurs.
        Parameters:
        aPause - - true if pause is requested on exception, false otherwise
      • isPauseOnException

        public boolean isPauseOnException()
        Returns if the CPM should pause when exception occurs.
        Returns:
        - true if the CPM pauses when exception occurs, false otherwise
      • setInputQueueSize

        public void setInputQueueSize​(int aInputQueueSize)
        Defines the size of inputQueue. The queue stores this many entities read from the CollectionReader. Every processing pipeline thread will read its entities from this input queue. The CollectionReader is decoupled from the consumer of entities, and continuously replenishes the input queue.
        Parameters:
        aInputQueueSize - the size of the batch.
      • setOutputQueueSize

        public void setOutputQueueSize​(int aOutputQueueSize)
        Defines the size of outputQueue. The queue stores this many entities enqueued by every processing pipeline thread.The results of analysis are dumped into this queue for consumer thread to consume its contents.
        Parameters:
        aOutputQueueSize - the size of the batch.
      • setPoolSize

        public void setPoolSize​(int aPoolSize)
        Defines the size of Cas Pool.
        Parameters:
        aPoolSize - the size of the Cas pool.
      • getPoolSize

        public int getPoolSize()
        Gets the pool size.
        Returns:
        the pool size
      • setConcurrentThreadSize

        public void setConcurrentThreadSize​(int aConcurrentThreadSize)
        Defines number of threads executing the processing pipeline concurrently.
        Parameters:
        aConcurrentThreadSize - the size of the batch.
      • addStatusCallbackListener

        public void addStatusCallbackListener​(BaseStatusCallbackListener aListener)
        Adds the status callback listener.
        Parameters:
        aListener - the a listener
      • getCallbackListeners

        public java.util.ArrayList getCallbackListeners()
        Returns a list of ALL callback listeners currently registered with the CPM.
        Returns:
        -
      • isKilled

        public boolean isKilled()
        Returns true if this engine has been killed.
        Returns:
        true if this engine has been killed
      • dumpState

        private void dumpState()
        Dumps some internal state of the CPE. Used for debugging.
      • killIt

        public void killIt()
        Kill CPM the hard way. None of the entities in the queues will be processed. This methof simply empties all queues and at the end adds EOFToken to the work queue so that all threads go away.
      • isHardKilled

        public boolean isHardKilled()
        Returns if the CPE was killed hard. Soft kill allows the CPE to finish processing all in-transit CASes. Hard kill causes the CPM to stop processing and to throw away all unprocessed CASes from its queues.
        Returns:
        true if the CPE was killed hard
      • asynchStop

        @Deprecated
        public void asynchStop()
        Deprecated.
        Asynch stop.
      • stopIt

        public void stopIt()
        Stops execution of the Processing Pipeline and this thread.
      • getIndexInList

        private int getIndexInList​(java.util.List aDeployList,
                                   java.lang.String aName)
        Returns index to a CasProcessor with a given name in a given List.
        Parameters:
        aDeployList - - List of CasConsumers to be searched
        aName - - name of the CasConsumer we want to find
        Returns:
        0 - if a CasConsumer is not found in a list, else returns a position in the list where the CasConsumer can found
      • getPositionInListIfExists

        private int getPositionInListIfExists​(java.lang.String aName,
                                              java.util.List aList)
        Find the position in the list of the Cas Processor with a given name.
        Parameters:
        aName - the a name
        aList - the a list
        Returns:
        the position in the list of the Cas Processor with a given name
      • isMultipleDeploymentAllowed

        private boolean isMultipleDeploymentAllowed​(java.lang.String aDescPath,
                                                    java.lang.String aCpName,
                                                    boolean isConsumer)
                                             throws java.lang.Exception
        Parses Cas Processor descriptor and checks if it is parallelizable.
        Parameters:
        aDescPath - - fully qualified path to a CP descriptor
        aCpName - - name of the CP
        isConsumer - - true if the CP is a Cas Consumer, false otherwise
        Returns:
        - true if CP is parallelizable, false otherwise
        Throws:
        java.lang.Exception - -
      • isParallizable

        public boolean isParallizable​(CasProcessor aProcessor,
                                      java.lang.String aCpName)
                               throws java.lang.Exception
        Determines if a given Cas Processor is parallelizable. Remote Cas Processors are by default parallelizable. For integrated and managed the CPM consults Cas Processor's descriptor to determine if it is parallelizable.
        Parameters:
        aProcessor - - Cas Processor being checked
        aCpName - - name of the CP
        Returns:
        - true if CP is parallelizable, false otherwise
        Throws:
        java.lang.Exception - -
      • addCasConsumer

        private void addCasConsumer​(CasProcessor aProcessor,
                                    java.lang.String aCpName)
                             throws java.lang.Exception
        Adds Cas Processor to a single-threaded pipeline. This pipeline is fed by the output queue and typicall contains Cas Consumers. AEs can alos be part of this pipeline.
        Parameters:
        aProcessor - - Cas Processor to add to single-threaded pipeline
        aCpName - - name of the Cas Processor
        Throws:
        java.lang.Exception - -
      • addParallizableCasProcessor

        private void addParallizableCasProcessor​(CasProcessor aProcessor,
                                                 java.lang.String aCpName)
                                          throws java.lang.Exception
        Add Cas Processor to a list of CPs that are to be run in the parallelizable pipeline. The fact that the CP is in parallelizable pipeline does not mean that there will be instance per pipeline of CP. Its allowed to have a single instance, shareable CP running in multi-threaded pipeline.
        Parameters:
        aProcessor - - CP to add to parallelizable pipeline
        aCpName - - name of the CP
        Throws:
        java.lang.Exception - -
      • classifyCasProcessors

        private void classifyCasProcessors()
                                    throws java.lang.Exception
        Classify based on Cas Processor capability to run in parallel. Some Cas Processors need to run as single instance only. It scans the list of Cas Processors backwords and moves those Cas Processors that are not parallelizable to a separate single-thread pipeline. This process of moving CPs continues until the first parallelizable Cas Processor is found. Beyond this all Cas Processors are moved to a parallelizable pipeline. If the non-parallelizable CP is in the parallelizable pipeline there simply will be a single instance of it that will be shared by all processing threads.
        Throws:
        java.lang.Exception - -
      • addCasProcessor

        public void addCasProcessor​(CasProcessor aCasProcessor)
                             throws ResourceConfigurationException
        Adds a CASProcessor to the processing pipeline. If a CasProcessor already exists and its status=DISABLED this method will re-enable the CasProcesser.
        Parameters:
        aCasProcessor - CASProcessor to be added to the processing pipeline
        Throws:
        ResourceConfigurationException - the resource configuration exception
      • addCasProcessor

        public void addCasProcessor​(CasProcessor aCasProcessor,
                                    int aIndex)
                             throws ResourceConfigurationException
        Adds a CASProcessor to the processing pipeline at a given place in the processing pipeline.
        Parameters:
        aCasProcessor - CASProcessor to be added to the processing pipeline
        aIndex - - insertion point for a given CasProcessor
        Throws:
        ResourceConfigurationException - the resource configuration exception
      • removeCasProcessor

        public void removeCasProcessor​(int aCasProcessorIndex)
        Removes a CASProcessor from the processing pipeline.
        Parameters:
        aCasProcessorIndex - - CasProcessor position in processing pipeline
      • disableCasProcessor

        public void disableCasProcessor​(int aCasProcessorIndex)
        Disable a CASProcessor in the processing pipeline.
        Parameters:
        aCasProcessorIndex - CASProcessor to be added to the processing pipeline
      • disableCasProcessor

        public void disableCasProcessor​(java.lang.String aCasProcessorName)
        Disable a CASProcessor in the processing pipeline.
        Parameters:
        aCasProcessorName - CASProcessor to be added to the processing pipeline
      • enableCasProcessor

        public void enableCasProcessor​(java.lang.String aCasProcessorName)
        Disable a CASProcessor in the processing pipeline.
        Parameters:
        aCasProcessorName - CASProcessor to be added to the processing pipeline
      • getCasProcessors

        public CasProcessor[] getCasProcessors()
        Returns all CASProcesors in the processing pipeline.
        Returns:
        the cas processors
      • redeployAnalysisEngine

        public void redeployAnalysisEngine​(ProcessingContainer aProcessingContainer)
                                    throws java.lang.Exception
        Deploys CasProcessor and associates it with a ProcessingContainer.
        Parameters:
        aProcessingContainer - the a processing container
        Throws:
        java.lang.Exception - the exception
      • deployAnalysisEngines

        private void deployAnalysisEngines()
                                    throws AbortCPMException
        Deploys All Analysis Engines. Analysis Engines run in a replicated processing units seperate from Cas Consumers.
        Throws:
        AbortCPMException - -
      • deployCasProcessors

        public void deployCasProcessors()
                                 throws AbortCPMException
        Starts CASProcessor containers one a time. During this phase the container deploys a TAE as local,remote, or integrated CasProcessor.
        Throws:
        AbortCPMException - the abort CPM exception
      • restoreFromCheckpoint

        private void restoreFromCheckpoint​(java.lang.String component,
                                           java.lang.String aEvType)
        Restores named events from the checkpoint.
        Parameters:
        component - - component name to restore named event for
        aEvType - - event to restore
      • copyComponentEvents

        private void copyComponentEvents​(java.lang.String aEvType,
                                         java.util.List aList,
                                         ProcessTrace aPTr)
                                  throws java.io.IOException
        Copy given component events.
        Parameters:
        aEvType - - event type
        aList - - list of events to copy
        aPTr - -
        Throws:
        java.io.IOException - -
      • isRunning

        public boolean isRunning()
        Returns a global flag indicating if this Thread is in processing state.
        Returns:
        true, if is running
      • isPaused

        public boolean isPaused()
        Returns a global flag indicating if this Thread is in pause state.
        Returns:
        true, if is paused
      • pauseIt

        public void pauseIt()
        Pauses this thread.
      • resumeIt

        public void resumeIt()
        Resumes this thread.
      • setCollectionReader

        public void setCollectionReader​(BaseCollectionReader aCollectionReader)
        Sets CollectionReader to use during processing.
        Parameters:
        aCollectionReader - aCollectionReader
      • setNumToProcess

        public void setNumToProcess​(long aNumToProcess)
        Defines the size of the batch.
        Parameters:
        aNumToProcess - the new num to process
      • getLastProcessedDocId

        public java.lang.String getLastProcessedDocId()
        Returns Id of the last document processed.
        Returns:
        the last processed doc id
      • getLastDocRepository

        public java.lang.String getLastDocRepository()
        Gets the last doc repository.
        Returns:
        the last doc repository
      • producePU

        private ProcessingUnit producePU​(java.lang.String aClassName)
                                  throws java.lang.Exception
        Instantiate custom Processing Pipeline.
        Parameters:
        aClassName - - name of a class that extends ProcessingUnit
        Returns:
        - an instance of the ProcessingUnit
        Throws:
        java.lang.Exception - -
      • startDebugControlThread

        private void startDebugControlThread()
        Start debug control thread.
      • createOutputQueue

        private BoundedWorkQueue createOutputQueue​(int aQueueSize)
                                            throws java.lang.Exception
        Instantiate custom Output Queue.
        Parameters:
        aQueueSize - - max size of the queue
        Returns:
        - new instance of the output queue
        Throws:
        java.lang.Exception - -
      • notifyListenersWithException

        private void notifyListenersWithException​(java.lang.Exception e)
        Notify listeners of a given exception.
        Parameters:
        e - - en exception to be sent to listeners
      • pipelineKilled

        public void pipelineKilled​(java.lang.String aPipelineThreadName)
        Callback method used to notify the engine when a processing pipeline is killed due to excessive errors. This method is only called if the processing pipeline is unable to acquire a connection to remote service and when configuration indicates 'kill-pipeline' as the action to take on excessive errors. When running with multiple pipelines, routine decrements a global pipeline counter and tests if there are no more left. When all pipelines are killed as described above, the CPM needs to terminate. Since pipelines are prematurely killed, there are artifacts (CASes) in the work queue. These must be removed from the work queue and disposed of (released) back to the CAS pool so that the Collection Reader thread properly exits.
        Parameters:
        aPipelineThreadName - - name of the pipeline thread exiting from its run() method
      • run

        public void run()
        Using given configuration creates and starts CPE processing pipeline. It is either single-threaded or a multi-threaded pipeline. Which is actually used depends on the configuration defined in the CPE descriptor. In multi-threaded mode, the CPE starts number of threads: 1) ArtifactProducer Thread - this is a thread containing a Collection Reader. It runs asynchronously and it fills a WorkQueue with CASes. 2) CasConsumer Thread - this is an optional thread. It is only instantiated if there Cas Consumers in the pipeline 3) Processing Threads - one or more processing threads, configured identically, that are performing analysis How many threads are started depends on configuration in CPE descriptor All threads started here are placed in a ThreadGroup. This provides a catch-all mechanism for errors that may occur in the CPM. If error is thrown, the ThreadGroup is notified. The ThreadGroup than notifies all registers listeners to give an application a chance to report the error and do necessary cleanup. This routine manages all the threads and makes sure that all of them are cleaned up before returning. The ThreadGroup must cleanup all threads under its control otherwise a memory leak occurs. Even those threads that are not started must be cleaned as they end up in the ThreadGroup when instantiated. The code uses number of state variables to make decisions during cleanup.
        Specified by:
        run in interface java.lang.Runnable
      • forcePUShutdown

        private void forcePUShutdown()
        Place EOF Token onto a work queue to force thread exit.
      • getTimer

        private UimaTimer getTimer()
                            throws java.lang.Exception
        Return timer to measure performace of the cpm. The timer can optionally be configured in the CPE descriptor. If none defined, the method returns default timer.
        Returns:
        - customer timer or JavaTimer (default)
        Throws:
        java.lang.Exception - -
      • cleanup

        public void cleanup()
        Null out fields of this object. Call this only when this object is no longer needed.
      • registerTypeSystemsWithCasManager

        private void registerTypeSystemsWithCasManager()
                                                throws java.lang.Exception
        Registers Type Systems of all components with the CasManager.
        Throws:
        java.lang.Exception - the exception
      • stopCasProcessors

        public void stopCasProcessors​(boolean kill)
                               throws CasProcessorDeploymentException
        Stops All Cas Processors and optionally changes the status according to kill flag.
        Parameters:
        kill - - true if CPE has been stopped before completing normally
        Throws:
        CasProcessorDeploymentException - the cas processor deployment exception
      • getProgress

        public Progress[] getProgress()
        Returns collectionReader progress.
        Returns:
        the progress
      • getStatForContainer

        private java.util.HashMap getStatForContainer​(ProcessingContainer aContainer)
        Gets the stat for container.
        Parameters:
        aContainer - the a container
        Returns:
        the stat for container
      • saveStat

        private void saveStat​(java.lang.String aStatLabel,
                              java.lang.String aStatValue,
                              ProcessingContainer aContainer)
        Save stat.
        Parameters:
        aStatLabel - the a stat label
        aStatValue - the a stat value
        aContainer - the a container
      • isProcessorReady

        private boolean isProcessorReady​(int aStatus)
        Check if the CASProcessor status is available for processing.
        Parameters:
        aStatus - the a status
        Returns:
        true, if is processor ready
      • invalidateCASes

        public void invalidateCASes​(CAS[] aCASList)
        Invalidate CA ses.
        Parameters:
        aCASList - the a CAS list
      • releaseCASes

        public void releaseCASes​(CAS[] aCASList)
        Releases given cases back to pool.
        Parameters:
        aCASList - - cas list to release
      • setPerformanceTuningSettings

        public void setPerformanceTuningSettings​(java.util.Properties aPerformanceTuningSettings)
        Overrides the default performance tuning settings for this CPE. This affects things such as CAS sizing parameters.
        Parameters:
        aPerformanceTuningSettings - the new settings
        See Also:
        UIMAFramework.getDefaultPerformanceTuningProperties()
      • getPerformanceTuningSettings

        public java.util.Properties getPerformanceTuningSettings()
        Gets the performance tuning settings.
        Returns:
        Returns the PerformanceTuningSettings.
      • setProcessControllerAdapter

        public void setProcessControllerAdapter​(ProcessControllerAdapter aPca)
        Sets the process controller adapter.
        Parameters:
        aPca - the new process controller adapter
      • getCpeConfig

        protected CpeConfiguration getCpeConfig()
                                         throws java.lang.Exception
        Gets the cpe config.
        Returns:
        the cpe config
        Throws:
        java.lang.Exception - the exception
      • processingUnitShutdown

        void processingUnitShutdown​(ProcessingUnit unit)
        Called from the ProcessingUnits when they shutdown due to having received the EOFToken. When all ProcessingUnits have shut down, we put an EOFToken on the output queue so that The CAS Consumers will also shut down. -Adam
        Parameters:
        unit - the unit
      • dropCasOnException

        public boolean dropCasOnException()
        Drop cas on exception.
        Returns:
        true, if successful
      • getCasWithSOFA

        private java.lang.Object getCasWithSOFA​(java.lang.Object entity,
                                                ProcessTrace pTrTemp)
        Gets the cas with SOFA.
        Parameters:
        entity - the entity
        pTrTemp - the tr temp
        Returns:
        the cas with SOFA
      • needsView

        private boolean needsView()
        Needs view.
        Returns:
        true if needsTCas
      • bootstrapCPE

        private void bootstrapCPE()
                           throws java.lang.Exception
        Initialize the CPE.
        Throws:
        java.lang.Exception - -
      • setupProcessingPipeline

        private void setupProcessingPipeline()
                                      throws java.lang.Exception
        Setup single threaded pipeline.
        Throws:
        java.lang.Exception - -
      • setupConsumerPipeline

        private void setupConsumerPipeline()
                                    throws java.lang.Exception
        Setup Cas Consumer pipeline as single threaded.
        Throws:
        java.lang.Exception - -
      • skipDroppedDocument

        private boolean skipDroppedDocument​(java.lang.Object[] entity)
        Determines if a given CAS should be skipped.
        Parameters:
        entity - - container for CAS
        Returns:
        true if a given CAS should be skipped
      • runSingleThreaded

        public void runSingleThreaded()
                               throws java.lang.Exception
        Runs the CPE in a single thread without queues.
        Throws:
        java.lang.Exception - -
      • endOfProcessingReached

        private boolean endOfProcessingReached​(long entityCount)
        Determines if the CPM processed all documents.
        Parameters:
        entityCount - - number of documents processed so far
        Returns:
        true if all documents processed, false otherwise
      • handleException

        private void handleException​(java.lang.Throwable t,
                                     java.lang.Object[] entity,
                                     ProcessTrace aPTrace)
        Handle given exception.
        Parameters:
        t - - exception to handle
        entity - - CAS container
        aPTrace - - process trace
      • notifyListeners

        private void notifyListeners​(int aMsgType,
                                     java.lang.Object[] entity,
                                     ProcessTrace aPTrace)
        Notify listeners.
        Parameters:
        aMsgType - the a msg type
        entity - the entity
        aPTrace - the a P trace
      • notifyListeners

        private void notifyListeners​(int aMsgType,
                                     java.lang.Object[] entity,
                                     ProcessTrace aPTrace,
                                     java.lang.Throwable t)
        Notify listeners.
        Parameters:
        aMsgType - the a msg type
        entity - the entity
        aPTrace - the a P trace
        t - the t
      • callEntityProcessCompleteWithCAS

        public static void callEntityProcessCompleteWithCAS​(StatusCallbackListener statCL,
                                                            CAS cas,
                                                            EntityProcessStatus eps)
        Internal use only, public for cross package access. switches class loaders and locks cas
        Parameters:
        statCL - status call back listener
        cas - CAS
        eps - entity process status
      • getProcessTrace

        private ProcessTrace getProcessTrace()
                                      throws java.lang.Exception
        Gets the process trace.
        Returns:
        the process trace
        Throws:
        java.lang.Exception - the exception
      • tearDownCPE

        private void tearDownCPE()
        Stop and cleanup single-threaded CPE.
      • waitForCpmToResumeIfPaused

        private void waitForCpmToResumeIfPaused()
        Wait for CPM to resume if paused.